Cómo hacer un teclado inalámbrico usando Xbee con Arduino - (Parte 44/49)

 ###





 /*============================= EG LABS ================== ===================//
 
Demostración sobre cómo enviar datos del teclado ps2 de forma inalámbrica usando Xbee


 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


 XBEE:

 PIN RX DE XBEE AL PIN TX0 DE ARDUINO

 CORTO LOS PINES DE TIERRA DE ARDUINO Y XBEE

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


 #incluir "PS2Keyboard.h"

 // incluye el código de la biblioteca:

 #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;


 configuración vacía

 {

 pinMode(9, SALIDA);

 lcd.comenzar(16, 2);

 lcd.print("GARAJE PARA INGENIEROS");

 lcd.setCursor(0, 1);

 lcd.print("TECLADO a XBEE");


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


 Serie.begin(9600);

 Serial.println("GARAJE PARA INGENIEROS");

 retraso(1000);

 escritura digital (9, ALTA);

 }


 bucle vacío

 {

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

 {

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

 Serie.write(dat);

 }demás;

 }

 ###

 ###




 Archivo de cabecera

 #incluir

 #incluir

 #incluir

 #incluir "Arduino.h"

 #incluir "PS2Keyboard.h"


 #incluir "binario.h"

 typedef uint8_t booleano;

 typedef uint8_t byte;



 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;

 byte cmd_parity;

 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.

 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);

 }



 ### 

• Arduino ProMini
• CONDUJO
• Potenciómetro
• Resistor