El teclado de PS2 utiliza un protocolo serial síncrono simple que utiliza solo dos cables para la comunicación. Debido a su simplicidad, los teclados de PS2 también se utilizan ampliamente con placas simples basadas en microcontroladores. El teclado de PS2 siempre actúa como un dispositivo esclavo que puede enviar el valor ASCII equivalente de la tecla presionada a su dispositivo maestro, que puede ser una PC o un microcontrolador.
Este proyecto explica cómo conectar un teclado y una tarjeta de memoria con la placa Arduino y, por lo tanto, escribir y almacenar texto usando el teclado de la tarjeta de memoria. Los archivos en una tarjeta de memoria SD se almacenan usando FAT32 o FAT16, y debe usar el código o la biblioteca del sistema de archivos FAT para acceder a los archivos en una tarjeta SD. La plataforma de creación sencilla de prototipos Arduino proporciona una biblioteca para acceder a tarjetas de memoria SD. Arduino también admite varias bibliotecas para interconectar dispositivos PS2 como el mouse y el teclado.
Las placas de microcontrolador AVR que cuentan con todos los circuitos básicos para el funcionamiento del microcontrolador que se ha actualizado con el gestor de arranque Arduino se denominan placas Arduino. Arduino puede comunicarse con otros dispositivos mediante E/S digitales, puerto serie, puerto I2C, puerto SPI, etc. El IDE de Arduino es tan sencillo de utilizar que cualquiera que tenga conocimientos básicos de programación en C puede empezar a utilizarlo rápidamente. El proyecto sobre cómo empezar con Arduino explica los pasos necesarios para comenzar a utilizar una placa Arduino. La placa Arduino utilizada en este proyecto es la placa Arduino Pro-Mini y la versión IDE de Arduino es 1.0.3 para Windows. La placa Arduino pro-mini lleva en su interior un microcontrolador ATMEGA328 que dispone de una memoria EEPROM interna de 1Kb.
A continuación se muestra la imagen de la placa Arduino Pro-Mini y el IDE de Arduino;
Fig. 2: Placa típica Arduino Pro-Mini
Fig. 3: Ventana del software Arduino IDE
Dado que la placa Arduino pro-mini no tiene circuitos para interactuar con el puerto serie o el puerto USB de la PC, se requiere una placa convertidora USB a TTL externa para conectarla a la PC. Este hardware ayuda a programar la placa Arduino y también ayuda en la comunicación serie con el puerto USB de la PC.
4: Placa convertidora externa de USB a TTL para programación Arduino y comunicación en serie
Se supone que el lector ha leído el proyecto sobre cómo empezar con Arduino y ha probado todo lo que se comenta allí. La tarjeta de memoria utilizada en este proyecto específico es una tarjeta SD de 2 GB de Transcend, pero el código debería funcionar con tarjetas SD de todos los proveedores. La tarjeta SD funciona con lógica de 3,3 V y, por lo tanto, para interactuar con un microcontrolador que funciona con lógica de 5 V, se debe utilizar un convertidor de nivel lógico. Dado que la tarjeta de memoria está conectada mediante el bus SPI, se pueden utilizar módulos convertidores de nivel lógico de cuatro canales que se encuentran comúnmente disponibles en el mercado. La imagen del módulo Logic Level Converter utilizado en este proyecto se muestra en la siguiente imagen;
Fig. 5: Circuito del módulo convertidor de nivel lógico
La tarjeta de memoria SD y el lado de bajo voltaje del convertidor de nivel lógico deben contar con una fuente de alimentación de 3,3 V y para ello se puede utilizar cualquier regulador IC de 3,3 V. Se sugiere conectar un LED bicolor a las líneas positivas de 3,3 V y MISO y MOSI de la tarjeta SD. La imagen de la tarjeta de memoria y los circuitos necesarios que se construyeron para este proyecto específico se muestran en la siguiente imagen. En la imagen se puede ver un potenciómetro que en realidad forma el circuito con un regulador variable SMD IC LM117 debajo. Se recomienda utilizar el LM1117, que es un regulador de 3,3 V y no requiere otros componentes para ajustar el voltaje como se muestra en el diagrama del circuito de este proyecto.
Fig. 6: Interfaz de tarjeta de memoria SD usando Level Contoller con Arduino
La placa Arduino pro-mini tiene pines digitales marcados como 2, 3, 4 hasta 13. Entre los pines digitales, cuatro pines, a saber, 10, 11, 12 y 13, se pueden configurar como SS, MOSI, MISO y SCK. MISO de la tarjeta de memoria debe conectarse al pin número 11, MOSI debe conectarse al pin número 12 y SCK debe conectarse al pin número 13 de Arduino pro-min. El SS de la tarjeta SD debe estar conectado al pin que se define como el pin SS del Arduino en el código escrito. Proyectos anteriores sobre cómo interconectar una tarjeta SD con Arduino y cómo usar la tarjeta SD para almacenar el valor del sensor analiza más sobre los detalles de la interfaz de la tarjeta SD con Arduino.
El proyecto utiliza el conector PS2 para conectar el teclado a la placa Arduino. El conector PS2 tiene un pin para Datos y otro pin para Reloj y usando solo estos dos pines el teclado se comunica con el dispositivo host. El mouse siempre tiene un conector mini-DIN macho de 6 pines para interfaz PS2, y el dispositivo host siempre tiene el pin hembra correspondiente. Las imágenes y pinouts de los conectores macho y hembra de PS2 se muestran en la siguiente imagen, la única diferencia entre los conectores de teclado y mouse de PS2 está en el color.
La imagen del pin masculino de PS2
7: conector macho mini-DIN de 6 pines para interfaz PS2
La imagen del pin femenino de PS2
Fig. 8: Conector hembra Mini DIN de 6 pines para interfaz PS2
El pinout de los conectores macho y hembra de PS2
Fig. 9: Distribución de pines de los conectores PS2 macho y hembra
Cuando se trata de conectar el conector hembra a la placa de circuito, deberías poder identificar los pines en la parte inferior del conector PS2 y la siguiente imagen te será útil.
Fig. 10: Parte inferior del conector hembra Mini DIN para interfaz PS2
El código escrito para este proyecto utiliza el archivo de biblioteca personalizado de PS2 llamado "PS2Keyboard.h", que contiene todas las rutinas necesarias para acceder a un mouse de PS2 y los detalles de cómo usar esta biblioteca para interactuar con un teclado de PS2 ya se han discutido en un proyecto anterior sobre cómo interconectar el teclado de PS2 con Arduino y cómo conectar el teclado de PS2 con LCD usando Arduino . Básicamente hay tres funciones que el usuario puede utilizar directamente en su código: “keyboard.begin”, teclado.disponible y “mouse.report(data)”.
El IDE de Arduino proporciona una biblioteca llamada
A medida que se ejecuta el código, primero abre un archivo específico para leer y muestra todo su contenido en la ventana Serial Monitor. Luego cierra el mismo archivo y lo vuelve a abrir en modo de grabación. Después de eso, el usuario puede escribir todo el texto en la tarjeta de memoria usando el teclado PS2 y se guardará en ella. La próxima vez que se ejecute el código, mostrará los mismos datos que se leyeron de la tarjeta SD junto con los datos anteriores en el mismo archivo.
Los datos se muestran en la ventana del monitor en serie con la ayuda de las funciones Serial.begin, Serial.print y Serial.println que ya se han discutido en proyectos anteriores sobre cómo realizar comunicación en serie con Arduino , cómo enviar y recibir datos en serie usando arduino y cómo hacer depuración en serie con Arduino.
Antes de compilar el código, asegúrese de que los archivos “PS2Keyboard.h” y “PS2Keyboard.cpp” se guarden en la misma carpeta donde se guardó el archivo .pde. Cuando se complete la codificación, podrá verificar y cargar el código en la placa Arduino como se explica en el proyecto Cómo comenzar con Arduino .
Código fuente del proyecto
### /*================================= EG LABS ============= ============== =========================== La demostración de lectura y escritura simple usando el teclado en la tarjeta SD. El circuito: * Tarjeta SD conectada al bus SPI de la siguiente manera: ** MOSI - pin 11 ** MISO - clavija 12 ** CLK - clavija 13 ** CS - clavija 4 Teclado: FECHA PIN A PIN NÚMERO 8 RELOJ PIN A PIN NÚMERO 3 =============================== EG LABS ================== = ==================*/ #incluir#incluir "PS2Keyboard.h" #definir DATOS_PIN 8 Teclado PS2Keyboard; Archivo miArchivo; // variable requerida para contener el descriptor del archivo const int chipSelect = 6; // el número de pin que se debe utilizar como pin SS datos de caracteres; configuración vacía { pinMode(9, SALIDA); Serie.begin(9600); // inicializa el puerto serie a una velocidad de 9600 baudios Serial.print("Inicializando tarjeta SD..."); pinMode(10, SALIDA); // Es imprescindible configurar el pin SS del hardware como salida aunque no se esté utilizando while(!SD.begin(chipSelect)); //inicializa la tarjeta SD Serial.println("tarjeta inicializada."); while(!(miArchivo = SD.open("new.txt"))); //abre el archivo para leer while (myFile.available) // lee el archivo hasta el último byte Serie.write(myFile.read); miArchivo.cerrar; //cerrar el archivo teclado.begin(DATA_PIN); //inicializa el teclado de PS2 escritura digital (9, ALTA); } bucle vacío { si (teclado.disponible) { dat = teclado.leer; // lee los datos del teclado while(!(myFile = SD.open("new.txt", FILE_WRITE))); //abre un archivo para escribir miArchivo.print(dat); //escribe la cadena en el archivo miArchivo.cerrar; Serie.write(dat); }demás; } //*************PS2.h*************// #ifndef PS2Keyboard_h #definir teclado PS2_h #incluir#incluir #incluir /* * Códigos de "creación" del teclado PS2 para verificar ciertas teclas. */ // Da estos códigos que no son usados por nada más // Hacer que todos los códigos de teclas de control sean superiores a 0x80 facilita la verificación // caracteres imprimibles en el 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_PGDN 0x85 #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 #define PS2_KC_CLON 0x8C // bloqueo de mayúsculas activado #define PS2_KC_CLOFF 0x8D // bloqueo de mayúsculas desactivado #incluir "binario.h" typedef uint8_t booleano; typedef uint8_t byte; /* * Este PIN está codificado en la rutina de inicio más adelante. Si cambias esto * asegúrese de cambiar también la inicialización de la interrupción. */ #definir PS2_INT_PIN 3 /** * Propósito: Proporciona un fácil acceso a los teclados de PS2 * Autor: Christian Weichel */ clase teclado PS2 { privado: intm_dataPin; bytes m_charBuffer; público: /** * Este constructor básicamente no hace nada. Por favor llame al inicio (int) * método antes de usar cualquier otro método de esta clase. */ Teclado PS2; /** * Inicia el "servicio" del teclado registrando la interrupción externa. * configurar los modos de pin correctamente y conducir los necesarios a alto. * Probablemente el mejor lugar para llamar a este método sea en la rutina de configuración. */ comienzo vacío (int dataPin); /** * Devuelve verdadero si hay un carácter para leer, falso en caso contrario. */ booleano disponible; /** * Envía un comando de reinicio al teclado y reinicializa todo el control. *variables dentro del código PS2Keybaord. */ reinicio nulo; /** * Devuelve el último carácter leído desde el teclado. Si el usuario ha pulsado dos * teclas entre llamadas a este método, solo la última estará disponible. Una vez * se ha leído el carácter, se borrará el búfer. * Si no hay ningún carácter disponible, se devuelve 0. */ lectura de bytes; /** * Devuelve el estado del clave, la clave, la clave y el * estado de bloqueo de mayúsculas. Tenga en cuenta que shift y caps_lock se manejan dentro del * Código Ps2Keyboard (y el valor de retorno de la lectura ya está modificado), pero *poder leerlos aquí puede resultar útil. * Esta rutina es opcional PERO SÓLO DEBE leerse después de que haya regresado la disponibilidad * verdadero y ANTES de leer se llama para recuperar el carácter. leyéndolo después * la llamada a lectura devolverá valores impredecibles. */ leer_byte extra; }; #terminara si
###
Código fuente del proyecto
### #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; booleano volátil cmd_ack_byte_ok; // 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); } ###
Diagramas de circuito
| Diagrama de circuito-usando-PS2-teclado-almacenar-texto-tarjeta-SD-usando-Arduino |  |
Componentes del proyecto
- Arduino Pro Mini
- CONDUJO
- Resistor
Vídeo del proyecto
