Cómo hacer una llamada usando teclado, módulo GSM y Arduino - (Parte 46/49)

 ###




 /*============================= EG LABS ================== ===================//

 Demostración de cómo utilizar un teclado ps2 para realizar una llamada mediante GSM


 El circuito:

 LCD:

 * Pin LCD RS a pin digital 12

 * LCD habilita pin a pin digital 11

 * Pin LCD D4 a pin digital 7

 * Pin LCD D5 a pin digital 6

 * LCD D6 pin a digital pin 5

 * Pin LCD D7 a pin digital 4

 * LCD R/W pin a tierra
 
* Resistencia de 10K:

 * termina en +5V y tierra

 *limpiador al pin 3 del LCD

 * Ánodo LED conectado a la salida digital 9

 * Cátodo LED conectado a tierra a través de una resistencia de 1K


 TECLADO:

 FECHA PIN A PIN NÚMERO 8

 RELOJ PIN A PIN NÚMERO 3


 GSM:

 PIN RX DE GSM AL PIN TX0 DE ARDUINO

 CORTO LOS PINES DE TIERRA DE ARDUINO Y GSM

 =============================== EG LABS ================== = ==================*/


 #incluir "PS2Keyboard.h"

 #incluir

 // inicializa la biblioteca con los números de los pines de la interfaz

 LCD de cristal líquido (12, 11, 7, 6, 5, 4);


 #definir DATOS_PIN 8

 Teclado PS2Keyboard;


 // le damos un nombre al pin:

 LED int = 9;

 datos de caracteres = 0;


 configuración vacía

 {

 pinMode(9, SALIDA);

 lcd.comenzar(16, 2);

 lcd.print("GARAJE PARA INGENIEROS");

 lcd.setCursor(0, 1);

 lcd.print(" LLAMADA GSM ");

 retraso(3000);

 lcd.claro;



 teclado.begin(DATA_PIN); //inicializa el teclado de PS2



 // inicializa el pin del led como salida.

 pinMode(led, SALIDA);

 // inicia el puerto serie a 9600 bps

 Serie.begin(9600);
 
//espera un momento hasta que el puerto serie esté listo

 retraso(100);


 // Serial.print("ATD09895941988;nr");

 Serie.print("ATD");

 mientras(1)

 {

 if(keyboard.available) // comprueba si hay datos provenientes del teclado

 {

 dat = teclado.leer; // lee los datos del teclado



 si(dat == 'n')

 romper;

 demás;



 Serie.write(dat);

 lcd.write(dat);

 }demás;

 }

 Serial.print(";nº");



 lcd.setCursor(0, 1);

 lcd.print(" LLAMANDO ... ");

 }


 bucle vacío

 {

 escritura digital (led, ALTA);

 retraso(1000);

 escritura digital (led, BAJO);

 retraso(1000);

 }

 ###

 ###




 /*

 PS2Keyboard.cpp: biblioteca de PS2Keyboard

 Copyright (c) 2007 Fundación de Software Libre. Todos los derechos reservados.

 Escrito por Christian Weichel


 ** Modificado para su uso a partir de Arduino 13 por L. Abraham Smith, *


 ** Modificado para incluir: shift, alt, caps_lock, caps_lock light y conexión en caliente de un kbd *
 
** por Bill Oldfield 22/07/09 *


 Esta biblioteca es software gratuito; puedes redistribuirlo y/o

 modificarlo bajo los términos del Público General Reducido de GNU

 Licencia publicada por la Free Software Foundation; cualquiera

 versión 2.1 de la Licencia, o (a su elección) cualquier versión posterior.


 Esta biblioteca se distribuye con la esperanza de que sea útil,

 pero SIN NINGUNA GARANTÍA; sin siquiera la garantía implícita de

 COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR. Ver el GNU

 Licencia Pública General Menor para más detalles.


 Deberías haber recibido una copia del GNU Lesser General Public

 Licencia junto con esta biblioteca; si no, escribe al Software Libre

 Foundation, Inc., 51 Franklin St, quinto piso, Boston, MA 02110-1301 EE. UU.

 */


 #incluir

 #incluir

 #incluir

 #incluir "Arduino.h"

 #incluir "PS2Keyboard.h"


 #incluir "binario.h"

 typedef uint8_t booleano;

 typedef uint8_t byte;


 /*

 * Sé que esto no está bien, pero no veo la manera de evitarlo.

 * COSAS REALMENTE MALAS POR DELANTE

 *
 
* Las variables se utilizan para la gestión del estado interno del ISR. hay

 * no se mantiene en la instancia del objeto porque el ISR tiene que ser tan rápido como sea posible

 * posible. Por lo tanto, se debe evitar la sobrecarga de una llamada al método CPP.

 *

 * POR FAVOR NO CONSULTE ESTAS VARIABLES EN SU CÓDIGO YA QUE PODRÍAN DESAPARECER ALGUNAS

 * DÍA FELIZ.

 */

 int ps2Keyboard_DataPin;

 byte ps2Keyboard_CurrentBuffer;

 byte volátil ps2Keyboard_CharBuffer;

 byte volátil ps2Keyboard_BufferPos;


 // variables utilizadas para recordar información sobre las pulsaciones de teclas

 volátil bool ps2Keyboard_shift; // indica que se presionó la tecla Mayús

 bool volátil ps2Keyboard_ctrl; //indica que la tecla Ctrl está presionada

 bool volátil ps2Keyboard_alt; //indica que la tecla alt está presionada

 bool volátil ps2Keyboard_extend; // recuerda un carácter extendido del teclado recibido

 bool volátil ps2Keyboard_release; // distingue las pulsaciones de teclas de las liberaciones

 bool volátil ps2Keyboard_caps_lock; // recuerda que se ha presionado el bloqueo de mayúsculas

 
// variables utilizadas para enviar bytes de comando al teclado, por ejemplo, caps_lock light

 cmd_in_progress booleano volátil;

 volátil int cmd_count;

 byte cmd_value;

 byte volátil cmd_ack_value;

 cmd_parity byte;

 cmd_ack_byte_ok booleano volátil;


 // enviar bytes de comando al teclado necesita la paridad adecuada (de lo contrario, el teclado

 // solo te pide que repitas el byte)

 byte paridad_impar (valor de byte) {

 int i, cuenta = 1; // empezamos con 0 para paridad par

 para (i=0; i<8; i++) {

 si (val&1) cuenta++;

 valor = valor>>1;

 }

 recuento de retornos & 1; // el bit inferior del conteo es el bit de paridad

 }


 void kbd_send_command (valor de byte) {

 // evita que la rutina de interrupción reciba caracteres para que podamos usarla

 // enviar un byte

 cmd_in_progress = verdadero;

 cmd_count = 0;


 // configura el byte para desplazar e inicializar el bit de confirmación

 cmd_value = valor;

 cmd_ack_value = 1; // el kbd borrará este bit al recibir el byte

 cmd_paridad = paridad_impar(val);


 // establece el pin de datos como salida, listo para conducir
 
escritura digital (ps2Keyboard_DataPin, ALTA);

 pinMode(ps2Keyboard_DataPin, SALIDA);


 // conduce el pin del reloj bajo - esto generará el primero

 // interrupción del proceso de cambio de marcha

 pinMode(PS2_INT_PIN, SALIDA);

 escritura digital (PS2_INT_PIN, BAJA);


 // esperar al menos un ciclo de reloj (en caso de que el kbd esté a mitad de transmisión)

 retrasoMicrosegundos(60);


 // configura el bit de inicio 0

 escritura digital (ps2Keyboard_DataPin, BAJO);

 // suelta el reloj - el kbd se hace cargo de controlar el reloj desde aquí

 escritura digital (PS2_INT_PIN, ALTA);

 pinMode(PS2_INT_PIN, ENTRADA);


 // espera a que la rutina de interrupción desplace el byte, la paridad y reciba el bit de confirmación

 mientras (cmd_ack_value!=0);


 // volver a la rutina de interrupción recibiendo caracteres del kbd

 cmd_in_progress = falso;

 }


 anular el teclado de PS2::reset {

 kbd_send_command(0xFF); // envía el código de reinicio del kbd al kbd: 3 luces

 // debería parpadear brevemente en el kbd


 // restablecer todas las variables globales

 ps2Keyboard_CurrentBuffer = 0;

 ps2Keyboard_CharBuffer = 0;
 
ps2Keyboard_BufferPos = 0;

 ps2Keyboard_shift = falso;

 ps2Keyboard_ctrl = falso;

 ps2Keyboard_alt = falso;

 ps2Keyboard_extend = falso;

 ps2Keyboard_release = falso;

 ps2Keyboard_caps_lock = falso;

 cmd_in_progress = falso;

 cmd_count = 0;

 cmd_valor = 0;

 cmd_ack_value = 1;

 }


 // valor: bit_2=bloqueo_mayúsculas, bit_1=bloqueo_numérico, bit_0=bloqueo_desplazamiento

 vacío kbd_set_lights (valor de byte) {

 // Al configurar las luces con el comando 0xED el teclado responde

 // con un "byte de confirmación", 0xFA. Esto NO es lo mismo que el "bit de confirmación" que

 // sigue el cambio exitoso de cada byte de comando. Ver este sitio web

 // página para una buena descripción de todo esto:

 //

 cmd_ack_byte_ok = falso; // inicializa el indicador de byte de confirmación

 kbd_send_command(0xED); // envía el byte de comando

 mientras (!cmd_ack_byte_ok); // el byte de confirmación del teclado establece este indicador

 kbd_send_command(valor); // ahora enviamos los datos

 }


 // El ISR para la interrupción externa
 
// Esto puede parecer mucho código para una rutina de interrupción, pero el interruptor

 // las declaraciones son rápidas y el camino a través de la rutina es sólo de unos pocos

 // líneas simples de código.

 anular ps2interrupt (anular) {

 valor int = digitalRead(ps2Keyboard_DataPin);


 // Este es el código para enviar un byte al teclado. En realidad son 12 bits:

 // un bit de inicio, 8 bits de datos, 1 de paridad, 1 bit de parada, 1 bit de confirmación (del kbd)

 si (cmd_in_progress) {

 cmd_count++; // cmd_count realiza un seguimiento del cambio

 cambiar (cmd_count) {

 caso 1: // bit de inicio

 digitalWrite(ps2Keyboard_DataPin,BAJO);

 romper;

 caso 2: caso 3: caso 4: caso 5: caso 6: caso 7: caso 8: caso 9:

 // bits de datos para desplazar

 escritura digital (ps2Keyboard_DataPin, cmd_value&1);

 valor_cmd = valor_cmd>>1;

 romper;

 caso 10: // bit de paridad

 escritura digital (ps2Keyboard_DataPin, cmd_parity);

 romper;

 caso 11: // bit de parada

 // libera el pin de datos, por lo que el bit de parada realmente depende del pull-up
 
// pero esto garantiza que el pin de datos esté listo para ser controlado por el kbd para

 // para el siguiente bit.

 escritura digital (ps2Keyboard_DataPin, ALTA);

 pinMode(ps2Keyboard_DataPin, ENTRADA);

 romper;

 caso 12: // bit de confirmación: impulsado por el kbd, por lo que leemos su valor

 cmd_ack_value = digitalRead(ps2Keyboard_DataPin);

 cmd_in_progress = falso; // terminado de mudarnos

 }

 devolver; // no pases a la sección de recepción del ISR

 }


 // recibir sección del ISR

 // cambia los bits en

 si(ps2Keyboard_BufferPos > 0 && ps2Keyboard_BufferPos < 11) {

 ps2Keyboard_CurrentBuffer = (valor << (ps2Keyboard_BufferPos - 1));

 }

 ps2Keyboard_BufferPos++; // realizar un seguimiento de la posición de cambio de entrada


 if(ps2Keyboard_BufferPos == 11) { // se recibió un carácter completo

 cambiar (ps2Keyboard_CurrentBuffer) {

 caso 0xF0: { // carácter de liberación de clave

 ps2Keyboard_release = verdadero;

 ps2Keyboard_extend = falso;

 romper;

 }

 case 0xFA: { // byte de reconocimiento del comando

 cmd_ack_byte_ok = verdadero;
 
romper;

 }

 case 0xE0: { // conjunto de caracteres extendido

 ps2Keyboard_extend = verdadero;

 romper;

 }

 caso 0x12: // desplazamiento a la izquierda

 caso 0x59: { // desplazamiento a la derecha

 ps2Keyboard_shift = ps2Keyboard_release? falso verdadero;

 ps2Keyboard_release = falso;

 romper;

 }

 case 0x11: { // tecla alt (la alt derecha se extiende 0x11)

 ps2Keyboard_alt = ps2Keyboard_release? falso verdadero;

 ps2Keyboard_release = falso;

 romper;

 }

 case 0x14: { // tecla ctrl (el control derecho está extendido 0x14)

 ps2Keyboard_ctrl = ps2Keyboard_release? falso verdadero;

 ps2Keyboard_release = falso;

 romper;

 }

 caso 0x58: { // tecla de bloqueo de mayúsculas

 si (!ps2Keyboard_release) {

 ps2Keyboard_caps_lock = ps2Keyboard_caps_lock? falso verdadero;

 // permitir el bloqueo de mayúsculas para activar y desactivar la luz

 ps2Keyboard_CharBuffer = ps2Keyboard_CurrentBuffer;

 }

 demás {

 ps2Keyboard_release = falso;

 }

 romper;

 }

 predeterminado: { // la clave real

 if (ps2Keyboard_release) { // aunque ignorar si se acaba de publicar
 
ps2Keyboard_release = falso;

 }

 else { // las claves reales van a CharBuffer

 ps2Keyboard_CharBuffer = ps2Keyboard_CurrentBuffer;

 }

 }

 }

 ps2Keyboard_CurrentBuffer = 0;

 ps2Keyboard_BufferPos = 0;

 }

 }


 Teclado PS2::Teclado PS2 {

 // nada que hacer aquí 

}


 anular PS2Keyboard::begin(int dataPin) {

 //Preparar las variables globales

 ps2Keyboard_DataPin = pin de datos;

 ps2Keyboard_CurrentBuffer = 0;

 ps2Keyboard_CharBuffer = 0;

 ps2Keyboard_BufferPos = 0;

 ps2Keyboard_shift = falso;

 ps2Keyboard_ctrl = falso;

 ps2Keyboard_alt = falso;

 ps2Keyboard_extend = falso;

 ps2Keyboard_release = falso;

 ps2Keyboard_caps_lock = falso;

 cmd_in_progress = falso;

 cmd_count = 0;

 cmd_valor = 0;

 cmd_ack_value = 1;


 // inicializa los pines

 pinMode(PS2_INT_PIN, ENTRADA);

 escritura digital (PS2_INT_PIN, ALTA);

 pinMode (pin de datos, ENTRADA);

 escritura digital (pin de datos, ALTO);

 
adjuntarInterrupción(1, ps2interrupt, CAER);

 #si 0

 // Habilitación global de interrupción INT1

 EIMSK = ( 1 << INT1);

 // El flanco descendente activa la interrupción

 EICRA = (0 << ISC10) (1 << ISC11);

 #terminara si

 }


 bool Teclado PS2::disponible {

 devolver ps2Keyboard_CharBuffer! = 0;

 }


 // Esta rutina permite que un programa que llama vea si se mantienen otras claves

 // abajo cuando se recibe un carácter: es decir , , o

 // Tenga en cuenta que esta rutina debe llamarse después de que disponible haya devuelto verdadero,

 // pero ANTES de leer . La rutina de lectura borra el buffer y permite otra

 // carácter que se recibirá para que estos bits puedan cambiar en cualquier momento después de la lectura.

 byte Teclado PS2::read_extra {

 retorno (ps2Keyboard_caps_lock<<3)

 (ps2Keyboard_shift<<2)

 (ps2Keyboard_alt<<1)

 ps2Keyboard_ctrl;

 }


 byte Teclado PS2::leer {

 resultado del byte;


 // lee los datos sin procesar desde el teclado

 resultado = ps2Keyboard_CharBuffer;


 // Utilice un modificador para la conversión de código a caracteres.
 
// Esto es rápido y en realidad sólo usa 4 bytes por línea simple

 cambiar(resultado) {

 caso 0x1C: resultado="a"; romper;

 caso 0x32: resultado="b"; romper;

 caso 0x21: resultado="c"; romper;

 caso 0x23: resultado="d"; romper;

 caso 0x24: resultado="e"; romper;

 caso 0x2B: resultado="f"; romper;

 caso 0x34: resultado="g"; romper;

 caso 0x33: resultado="h"; romper;

 caso 0x43: resultado="i"; romper;

 caso 0x3B: resultado="j"; romper;

 caso 0x42: resultado="k"; romper;

 caso 0x4B: resultado="l"; romper;

 caso 0x3A: resultado="m"; romper;

 caso 0x31: resultado="n"; romper;

 caso 0x44: resultado="o"; romper;

 caso 0x4D: resultado="p"; romper;

 caso 0x15: resultado="q"; romper;

 caso 0x2D: resultado="r"; romper;

 caso 0x1B: resultado="s"; romper;

 caso 0x2C: resultado="t"; romper;

 caso 0x3C: resultado="u"; romper;

 caso 0x2A: resultado="v"; romper;

 caso 0x1D: resultado="w"; romper;

 caso 0x22: resultado="x"; romper;

 caso 0x35: resultado="y"; romper;

 caso 0x1A: resultado="z"; romper;


 // tenga en cuenta que el bloqueo de mayúsculas solo se usa en az

 caso 0x41: resultado = ps2Keyboard_shift? '<' : ','; romper;
 
caso 0x49: resultado = ps2Keyboard_shift? '>' : '.'; romper;

 caso 0x4A: resultado = ps2Keyboard_shift? '?' : '/'; romper;

 caso 0x54: resultado = ps2Keyboard_shift? '{' : '('; romper;

 caso 0x5B: resultado = ps2Keyboard_shift? '}' : ')'; romper;

 caso 0x4E: resultado = ps2Keyboard_shift? '_' : '-'; romper;

 caso 0x55: resultado = ps2Keyboard_shift? '+' : '='; romper;

 caso 0x29: resultado=" "; romper;


 caso 0x45: resultado = ps2Keyboard_shift? ')' : '0'; romper;

 caso 0x16: resultado = ps2Keyboard_shift? '!' : '1'; romper;

 caso 0x1E: resultado = ps2Keyboard_shift? '@' : 'dos'; romper;

 caso 0x26: resultado = ps2Keyboard_shift? '£' : '3'; romper;

 caso 0x25: resultado = ps2Keyboard_shift? '$' : '4'; romper;

 caso 0x2E: resultado = ps2Keyboard_shift? '%' : '5'; romper;

 caso 0x36: resultado = ps2Keyboard_shift? '^': '6'; romper;

 caso 0x3D: resultado = ps2Keyboard_shift? '&' : '7'; romper;

 caso 0x3E: resultado = ps2Keyboard_shift? '*' : '8'; romper;

 caso 0x46: resultado = ps2Keyboard_shift? '(' : '9'; descanso;


 caso 0x0D: resultado="t"; romper;
 
caso 0x5A: resultado="n"; romper;

 caso 0x66: resultado = PS2_KC_BKSP; romper;

 caso 0x69: resultado = ps2Keyboard_extend? PS2_KC_END: ​​'1'; romper;

 caso 0x6B: resultado = ps2Keyboard_extend? PS2_KC_LEFT: '4'; romper;

 caso 0x6C: resultado = ps2Keyboard_extend? PS2_KC_HOME: '7'; romper;

 caso 0x70: resultado = ps2Keyboard_extend? PS2_KC_INS: '0'; romper;

 caso 0x71: resultado = ps2Keyboard_extend? PS2_KC_DEL: '.'; romper;

 caso 0x72: resultado = ps2Keyboard_extend? PS2_KC_DOWN: '2'; romper;

 caso 0x73: resultado="5"; romper;

 caso 0x74: resultado = ps2Keyboard_extend? PS2_KC_RIGHT: '6'; romper;

 caso 0x75: resultado = ps2Keyboard_extend? PS2_KC_UP: '8'; romper;

 caso 0x76: resultado = PS2_KC_ESC; romper;

 caso 0x79: resultado="+"; romper;

 caso 0x7A: resultado = ps2Keyboard_extend? PS2_KC_PGDN: '3'; romper;

 caso 0x7B: resultado="-"; romper;

 caso 0x7C: resultado="*"; romper;

 caso 0x7D: resultado = ps2Keyboard_extend? PS2_KC_PGUP: '9'; romper;


 caso 0x58:

 // La configuración de las luces del teclado se realiza aquí. Lo ideal sería hacerlo
 
// en la propia rutina de interrupción y los códigos clave asociados con

 // Las pulsaciones de la tecla Bloq Mayús nunca se transmitirán como caracteres.

 // Sin embargo, haría que la rutina de interrupción fuera muy complicada con muchos

 // de estado extra asociado al control de un caps_lock

 // código clave que provoca que se transmita un byte cmd, lo que provoca que se transmita un ack_byte

 // se recibirá, luego se transmitirá un byte de datos. Es mucho más fácil hacerlo aquí.

 // La desventaja, sin embargo, es que la luz se enciende o apaga en el

 // el momento adecuado depende del programa que llama para verificar

 // caracteres de forma regular. Si el programa que llama se detiene

 // sondeo de caracteres en cualquier punto presionando la tecla Bloq Mayús

 // no cambiará el estado de la luz de bloqueo de mayúsculas durante el sondeo

 // no está sucediendo.

 resultado = ps2Keyboard_caps_lock? PS2_KC_CLON: PS2_KC_CLOFF;

 si (ps2Keyboard_caps_lock) kbd_set_lights(4);

 más kbd_set_lights(0);

 romper;

 
// Reinicia el contador de cambios para valores inesperados, para volver al fregadero

 // Esto permite conectar y desconectar un teclado en caliente

 predeterminado: retraso (500); // pero espera un poco en caso de que haya mitad de turno

 ps2Keyboard_BufferPos = 0;

 ps2Keyboard_shift = falso;

 ps2Keyboard_ctrl = falso;

 ps2Keyboard_alt = falso;

 ps2Keyboard_extend = falso;

 ps2Keyboard_release = falso;

 ps2Keyboard_caps_lock = falso;

 } // finalizar el cambio (resultado)


 // cambia los caracteres az aquí (menos código que en la instrucción switch)

 si (((resultado>='a') && (resultado<='z')) &&

 ((ps2Keyboard_shift &&!ps2Keyboard_caps_lock)

 (!ps2Keyboard_shift && ps2Keyboard_caps_lock))) {

 resultado = resultado + ('A'-'a');

 }


 // hecho con el personaje

 ps2Keyboard_CharBuffer = 0;


 retorno(resultado);

 }

 *******************Archivo de encabezado de teclado PS2************************
 
PS2Keyboard.h - Biblioteca de PS2Keyboard Copyright (c) 2007 Free Software Foundation.
 Todos los derechos reservados. Escrito por Christian Weichel < (correo electrónico protegido) >
 ** Modificado para uso con Arduino 13 por L. Abraham Smith, *
 ** Modificado para incluir: mayúsculas, alt, caps_lock y caps_lock light por Bill Oldfield *
 Esta biblioteca es software gratuito; usted puede redistribuirlo y/o modificarlo bajo los términos de
 la Licencia Pública General Reducida GNU publicada por la Free Software Foundation;
 versión 2.1 de la Licencia o (a su elección) cualquier versión posterior.
 Esta biblioteca se distribuye con la esperanza de que sea útil, pero SIN NINGUNA GARANTÍA;
 incluso sin la garantía implícita de COMERCIABILIDAD o IDONEIDAD PARA UN PROPÓSITO PARTICULAR.
 
Consulte la Licencia pública general reducida de GNU para obtener más detalles.
 Debería haber recibido una copia de la Licencia pública general reducida de GNU junto con esta biblioteca;
 de lo contrario, escriba a Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 EE. UU.
 */ #ifndef PS2Keyboard_h
 #definir teclado PS2_h
 #incluir
 #incluir
 #incluir
 /* * El teclado de PS2 "crea" códigos para verificar ciertas teclas. */
 // Proporciona estos códigos que no son utilizados por nada más
 // Crear todos los códigos de clave de control superiores a 0x80 simplifica la verificación
 // caracteres imprimibles a nivel de llamada.
 #definir PS2_KC_BKSP 0x80
 #definir PS2_KC_UP 0x81
 #definir PS2_KC_DOWN 0x82
 #definir PS2_KC_LEFT 0x83
 #definir PS2_KC_RIGHT 0x84
 #definir PS2_KC_PGDN0x85
 
#definir PS2_KC_PGUP 0x86
 #definir PS2_KC_END 0x87
 #definir PS2_KC_HOME 0x88
 #definir PS2_KC_INS 0x89
 #definir PS2_KC_DEL 0x8A
 #definir PS2_KC_ESC 0x8B
 #definir PS2_KC_CLON 0x8C
 //bloqueo de mayúsculas habilitado
 #definir PS2_KC_CLOFF 0x8D
 //bloqueo de mayúsculas deshabilitado
 #incluye "binary.h" typedef uint8_t boolean; typedef uint8_t byte;
 /* * Este PIN se codifica más adelante en la rutina de inicialización.
 Si cambia esto * asegúrese de cambiar también la inicialización de la interrupción.
 */ #define PS2_INT_PIN 3 /** * Propósito: Proporciona fácil acceso a los teclados de PS2
 *Autor: Christian Weichel */clase PS2Teclado
 { privado: int m_dataPin; bytes m_charBuffer; público: /**
 * Este constructor básicamente no hace nada. Por favor llame a inicio (int)
 
* antes de usar cualquier otro método en esta clase. */ Teclado PS2;
 /** * Inicia el "servicio" del teclado registrando la interrupción externa.
 * Configure los modos de pin correctamente y aumente los niveles requeridos.
 * El mejor lugar para llamar a este método es en la rutina de configuración.
 */ inicio vacío (int dataPin);
 /** * Devuelve verdadero si hay un carácter para leer, falso si no lo hay.
 */bool disponible; /** * Envía un comando de reinicio al teclado y restablece todos los controles.
 *variables dentro del código PS2Keybaord. */ reinicio nulo;
 /** * Devuelve el último carácter leído desde el teclado.
 Si el usuario presionó dos teclas * entre llamadas a este método, solo la última estará disponible.
 Tan pronto como se lea el carácter *, se borrará el búfer.
 * Si no hay ningún carácter disponible, se devolverá 0. */ byte leído;
 
/** * Devuelve el estado del clave, la clave, la clave y el estado *caps_lock.
 Tenga en cuenta que shift y caps_lock se manejan dentro del
 * Código Ps2Keyboard (y el valor de retorno de lectura ya está modificado),
 pero *poder leerlos aquí podría resultar útil.
 *Esta rutina es opcional, PERO SÓLO DEBE leerse después de la devolución de los disponibles
 * Se llama a true y BEFORE read para recuperar el carácter. Leer más tarde
 * la llamada a lectura devolverá valores impredecibles. */byte lectura_extra; }; #terminara si
 ###

• Arduino ProMini
• Condensador
• LCD
• CONDUJO
• MAX232