Desarrollo De un teclaDo programable para computaDora

UNIVERSIDAD AUTÓNOMA DE CIUDAD JUÁREZ

Ricardo Duarte JáquezRector

David Ramírez PereaSecretario General

Manuel Loera de la RosaSecretario Académico

Juan Ignacio Camargo NassarDirector del Instituto de Ciencias Sociales y Administración

Luis Enrique Gutiérrez CasasCoordinador General de Investigación y Posgrado

Ramón Chavira ChaviraDirector General de Difusión Cultural y Divulgación Científica

Desarrollo De un teclaDo programable para computaDora

Universidad Autónoma de Ciudad Juárez

Jenaro carlos paz gutiérrez

Jesús roDarte Dávila

saúl gonzález campos

ingeniería y tecnología

CoordinaCión General de investiGaCión y PosGrado

Lisbeily Domínguez Ruvalcaba Coordinadora de la ColeCCión

Paz Gutiérrez, Jenaro Carlos; Rodarte Dávila, Jesús; González Cam-pos, Saúl.

Desarrollo de un teclado programable para computadora / Jenaro Carlos Paz Gutiérrez, Jesús Rodarte Dávila, Saúl González Campos. Ciudad Juárez, Chih. : Universidad Autónoma de Ciudad Juárez, 2013. (Colección Textos Universitarios, Serie Investigación)

44 p.; 30 cm.

Incluye bibliografía Colección Reportes Técnicos de Investigación ISbN: 978-607-7953-80-7Serie IIT, Vol. 9. ISbN: 978-607-520-018-7

Contenido:

1.– Introducción. 1.1.– Planteamiento del problema. 2.– Decodificador de UART. 3.– Interfaz con la PC. 4.– Implementación del teclado pro-gramable. 5.– Conclusiones.

D. R. © Paz Gutiérrez, Jenaro Carlos; Rodarte Dávila, Jesús; González Campos, Saúl.

La edición, diseño y producción editorial de este documento estuvo a cargo de la Direc-ción General de Difusión Cultural y Divulgación Científica, a través de la Subdirección de Publicaciones.

ínDiceResumen 7Abstract 9Palabras clave 10Usuarios potenciales 10Reconocimientos 10

i. introDucción

1.1 Planteamiento del problema 111.2 Antecedentes y justificación 111.3 Objetivo general 141.4 Hipótesis 14

2. Decodificador de UART 152.1 Arduino Duemilenove 162.1.1 Configuración de pines 162.1.2 Elementos de la placa USB 162.1.3. Especificaciones 172.1.4 Bibliotecas 172.1.5 Programación 182.2 El conector PS2 192.3 El driver para el teclado PS2 20

3. Interfaz con la PC 213.1 Construcción de interfaz USB 213.2 El driver para el teclado virtual USB 22

4. Implementación del teclado programable 244.1 Código requerido a generar 244.1.1 Generación de proyecto, cabeceras y main 244.1.2 Generación del bloque if-else 264.1.3 Generación del bloque if-else anidado 264.1.4 Generación del bloque switch 274.1.5 Generación del ciclo for 28

4.1.6 Generación de la instrucción de ciclo do-while 284.1.7 Generación de la instrucción de ciclo while 294.1.8 Generación de declaración de clase 304.1.9 Generación de la declaración de estructura 304.1.10 Generación de case Ctrl-C Ctrl-V 31

conclusiones

bibliografía

anexo

7

resumen

Muchas herramientas de Software que utilizamos hoy en día, surgieron a finales de la década de los 80’s y principios de los 90’s. Las primeras versiones de Lotus o WordPerfect estaban desarrolladas para ejecutar-se en el sistema operativo MSDOS, muchas de ellas eran textuales (no

graficas) y estaban limitadas por el hecho de que las computadoras donde se ejecu-taban contaban con muy poca memoria de almacenamiento. Sin embargo el llegar a realizar un programa como los dos mencionados involucraba un gran conocimiento de algoritmos computacionales muy sofisticados así como el tiempo suficiente para codificar miles de líneas de instrucciones para llevar a cabo las tareas específicas que debía realizar el programa.

Para aligerar el trabajo de los programadores, durante los primeros años de la última década del siglo pasado, se desarrollaron Teclados Programables y con ello se facilitó la tarea de tener que teclear en forma repetida diferentes bloques de código (de algún lenguaje específico de programación) para ir integrando las aplicaciones que el mercado, industria u organizaciones iban demandando.

En aquellos tiempos nos tocó participar en el desarrollo de Complejos Sistemas de Cómputo que requirieron teclear miles de líneas de código en lenguajes de programa-ción como Pascal, dbase o C y por supuesto tuvimos la fortuna de contar con alguna primera versión de un teclado programable.

Al paso del tiempo las computadoras fueron cambiando en su diseño y la entrada para la conexión del teclado también, razón que hizo que los teclados programables dejaran de usarse en las nuevas computadoras y al no diseñarse nuevas interfaces para el teclado programable, prácticamente dejó de producirse.

Para un Instructor de Lenguajes de Programación como hay muchos en la UACJ, el problema es el mismo que para un profesional en el desarrollo de Software, tener que teclear rápidamente bloques de instrucciones en algún lenguaje como pudiera ser C, C++, C#, Java, JavaScript, PHP u otro.

Cuando el desarrollador de software ha tomado también el papel de docente, debe de hacer que su instrucción, que involucra el teclear segmento de código ante sus alumnos en los laboratorios de Computo, un proceso rápido, confiable y bien estructu-rado. Una de las tareas que como docentes llevamos a cabo, es el utilizar plataformas

8

Desarrollo de un teclado programable para computadora

de instrucción como UACJ Online y Aula Virtual donde se pueden poner materiales y cursos en línea que alumnos inscritos en cursos presenciales o a distancia pueden acceder, los primeros desde cualquier laboratorio, sala de computo o laptop inalám-brica y los segundos desde cualquier parte del mundo. En estas plataformas uno de los materiales didácticos es el Video o películas generadas directamente de la pantalla del instructor, donde este debe de contar con una velocidad de escritura de aproximadamente 200 palabras por minuto para que el video no muestre retrasos o pausas, por lo tanto si a la hora de generar un video en computadora se cuenta con un teclado programable se evitará tener que editar el video una vez terminado o por lo menos eliminar un sobre procesamiento no necesario.


9

abstract

Many software tools we use today, emerged in the late 80’s and early 90’s. The first Lotus or WordPerfect versions were developed to run on MS-DOS operating system, many of them were text (no graphics) and were limited by the fact that computers have had very little memory storage.

but getting to do a program like the two mentioned involved a great knowledge of sophisticated computer algorithms and to encode thousands of lines of instructions to carry out specific tasks to be performed by the program.

To lighten programmers’ work, during the early nineties, mankind developed Pro-grammable Keyboards and thereby facilitated the task of repeatedly typing different code blocks (of a specific programming language) to integrate the applications that the market, industry or organizations were demanding.

In those days we had to participate in the development of Complex Computer Systems requiring thousands of lines of code in languages like Pascal, dbase or C and of course we were fortunate to have one of the firsts versions of a programmable keyboard.

Over time computers were changing in design and that was the reason to stop manufacturing programmable keyboards.

For programming language Instructors like many in the UACJ, the problem is the same as for a professional in software development, having to type rapidly blocks of instructions in a language as it could be C, C + +, C #, Java, JavaScript, PHP or another.

When the software developer has also taken the role of a teacher, he must make his teaching, which involves typing code segments to their students in computer labs, a fast, reliable and well structured. One of the tasks we do as teachers is to use instruc-tion platforms like UACJ Online or Aula Virtual where you can place online materials to students enrolled in face to face courses or distance courses, so they can access them from any computer laboratory, wireless or from anywhere in the world. In one of those virtual platforms the video training materials or films are derived directly from the instructor’s screen, where he must have to write at a speed of about 200 words per min-ute in a way that the video shows no delays or pauses, thus if at the time of generating a computer video a programmable keyboard can be used that will avoid having to edit the video once finished or at least eliminate unnecessary processing time.

10


Palabras claveTeclado, Arduino, Programable, Instrucción

Usuarios potencialesProgramadores, Desarrolladores de Software, Instructores, Encargados de labo-

ratorios de Cómputo, Alumnos de carreras con materias de Programación de Com-putadoras

ReconocimientosPor tratarse de un proyecto autofinanciable, el principal reconocimiento es a los

participantes del mismo equipo de investigación


11

i. introDucción

1.1 Planteamiento del problema

Dentro de la labor educativa de un profesional en Sistemas Computacionales que se dedica a la instrucción de Lenguajes de Programación, existe el pro-blema de tener que teclear rápidamente bloques de código (cascarones) en algún lenguaje como pudiera ser Java, JavaScript, C++, C# o algún otro. Es-

tos bloques de código (que pudieran ser aproximadamente de 10 a 15 dependiendo del lenguaje de programación) van integrando los Programas para Computadora que pue-den llegar a tener desde unas cuantas líneas hasta miles o cientos de miles de ellas.

1.2 Antecedentes y justificación

Durante los primeros años de la última década del siglo pasado se desarrollaron Teclados Programables con la finalidad de facilitarle el trabajo a un desarrollador de Software que tenía que teclear en forma repetida diferentes bloques de código (de algún lenguaje específico de programación) para ir integrando las aplicaciones que el mercado, industria u organizaciones iban demandando.

Figura 1. Teclado programable de la compañía XKeys

12


i. introDucción

En aquellos tiempos nos tocó participar en el desarrollo de Complejos Sistemas de Cómputo que requirieron teclear miles de líneas de código en lenguajes de programa-ción como Pascal, dbase o C y por supuesto tuvimos la fortuna de contar con alguna primera versión de un teclado programable.

Al paso del tiempo las computadoras fueron cambiando en su diseño y la interface física para la conexión del teclado también, razón que hizo que los teclados programa-bles dejaran de usarse en las nuevas computadoras y al no diseñarse nuevas interfa-ces para el teclado programable, prácticamente dejó de producirse.

Figura 2. Segmentos de código fuente en C++

Un teclado programable en aquel entonces tenía un precio en el mercado de aproxi-madamente $100.00 dólares y este precio, en una época donde los compiladores para el desarrollo de software costaban entre $100.00 y $400.00 dólares era un precio elevado. En la actualidad los compiladores oscilan entre $600.00 y $4000.00 dólares, han evolucionado considerablemente pues nos permiten desarrollar aplicaciones de escritorio (como entonces), pero también aplicaciones Web (para la red Internet) así como para dispositivos móviles, consolas de juegos y multimedia.


13

i. introDucción

Al ampliarse la posibilidad de desarrollo de diferente tipo de aplicaciones (más de 50 diferentes tipos en Visual Studio Ultimate 2010) las necesidades de un desarrolla-dor de Software se incrementaron pues dependiendo del Lenguaje seleccionado y el tipo de aplicación, es el set de instrucciones y por consiguiente los bloques de progra-ma o segmentos que tiene que ingresar mediante un teclado convencional.

Figura 3. Desarrollador de aplicaciones Visual Studio 2010 Ultimate

Cuando el desarrollador de software ha tomado también el papel de docente, debe de hacer que su instrucción, que involucra el teclear segmentos de código ante sus alum-nos, en los laboratorios de Computo, un proceso rápido, confiable y bien estructurado.

Una de las tareas que como docentes llevamos a cabo, es el utilizar platafor-mas de instrucción como UACJ Online y Aula Virtual donde se pueden poner mate-riales y cursos en línea que alumnos inscritos en cursos presenciales o a distancia pueden acceder, los primeros desde cualquier laboratorio, sala de computo o laptop inalámbrica y los segundos desde cualquier parte del mundo.

Figura 4. Plataforma en línea para distribución de contenidos

14


i. introDucción

El desarrollo de materiales didácticos puede ser de diferente naturaleza, entre otras Videos o películas generadas directamente de la pantalla del instructor me-diante programas de software como Camtasia Studio (www.techsmith.com). Al usar estas herramientas, el instructor debe contar con una velocidad de escritura con el teclado de aproximadamente 200 palabras por minuto para que el video no muestre retrasos o pausas no justificadas; recordemos que trabajar en línea y con video en demanda cada segundo es oro y hay que ser muy eficiente. Por lo tanto si a la hora de generar un video en computadora se cuenta con un teclado programable se evitará tener que editar el video una vez terminado o por lo menos eliminar un sobreprocesa-miento no necesario.

Figura 5. Software para la captura de la pantalla

El poder contar con un teclado programable moderno, que se adapte a las nece-sidades del Hardware existente y que pueda reconfigurarse para cada lenguaje con el que se quiera trabajar o instruir a grupos de estudiantes seria el objetivo de esta investigación de Desarrollo tecnológico, donde el trabajo sistemático basado en co-nocimientos existentes, obtenidos mediante investigación y/o experiencia práctica, permitirán la fabricación de un nuevo dispositivo, sistemas y servicios.

1.3 Objetivo general

Diseño y construcción de un teclado programable de uso general para ser usado en las clases de programación que se imparten en el Laboratorio de Cómputo Avanzado del IIT.

1.4 Hipótesis

Es factible construir un teclado programable haciendo uso del Arduino Duemi-lanove, módulos electrónicos de interface fabricados exprofeso y programación C++


15

i. introDucción

2. Decodificador de UART

La primera fase del desarrollo del proyecto, inicia con la elaboración de un progra-ma en lenguaje C++ que estará embebido en una placa Arduino Duemilenove, este software será el encargado de decodificar las señales enviadas por el UART (Univer-sal asynchronous receiver/transmiter) de un teclado PS2 cada vez que un usuario del mismo oprima una tecla.

Un UART usualmente es un circuito integrado usado para comunicaciones seria-les por el puerto de una computadora. El UART toma los bytes de datos (generados por la matriz de contactos físicos del teclado) y los transmite como bits de manera secuencial. En el destino un microprocesador, que puede ser la misma PC o una placa Arduino, es el encargado de re ensamblar los bits en bytes completos para ser pro-cesados o manipulados. En el caso de una PC, son los drivers del teclado los que se encargan de esta función y en el caso de una placa Arduino deberá ser un programa embebido que tenga la misma funcionalidad de un driver.

La transmisión serial de la información digital por un alambre u otro medio es eco-nómicamente más eficiente que hacerlo paralelamente por varios alambres, lo que tie-ne que cuidarse en la conexión entre el teclado PS2 y la placa Arduino es que los cuatro alambres requeridos por el teclado estén conectados de manera específica al Arduino.

Para probar el código será necesario utilizar una Hiperterminal conectada a él para monitorear las teclas que son pulsadas.

A continuación se detallan las características de la placa Arduino Duemilenove, al puerto PS2 del teclado y a la creación de un driver para la decodificación de bytes procedentes del mismo.

Figura 6. Placa Arduino a usarse en el teclado programable

16


i. introDucción

2.1 Arduino Duemilenove

Arduino es una plataforma de hardware libre basada en una sencilla placa de entradas y salidas simple y un entorno de desarrollo que implementa el lenguaje de programación Processing/Wiring. Arduino se puede utilizar para desarrollar objetos interactivos autónomos o puede ser conectado a software ejecutándose en una compu-tadora (por ejemplo: Macromedia Flash, Processing, Max/MSP, Pure Data). El entor-no de desarrollo integrado es libre y gratuito y se puede descargar gratuitamente.

Las plataformas Arduino están basadas en los microcontroladores Atmega328, Atmega168 o en el ATmega8, chips sencillos y de bajo costo que permiten el desarro-llo de múltiples diseños.

Al ser open-hardware, tanto su diseño como su distribución es libre. Es decir, pue-de utilizarse libremente para el desarrollo de cualquier tipo de proyecto sin haber adquirido ninguna licencia.

2.1.1 Configuración de pines

Arduino Duemilenove consta de 14 pins digitales configurables como entradas y/o salidas que operan a 5 volts. Cada pin puede proporcionar o recibir como máximo 40 mA. Los pines 3, 5, 6, 8, 10 y 11 pueden proporcionar una salida PWM (Pulse Width Modulation). Si se conecta cualquier circuito a los pines 0 y 1, eso interferirá con la comunicación USb que de manera estándar se lleva a cabo por ellos. También tiene 6 entradas analógicas que proporcionan una resolución de 10 bits. Por defecto miden de 0 a 5 volts, aunque es posible cambiar el nivel más alto, utilizando el pin AREF y algún código de bajo nivel.

2.1.2 Elementos de la placa USB

Figura 7. Esquema descriptivo del Arduino


17

i. introDucción

Empezando en el sentido de las agujas del reloj desde el centro de la parte superior:

Pin de referencia analógica (naranja) ɶSeñal de tierra digital (verde claro) ɶPines digitales 2-13 (verde) ɶPines digitales 0-1 / entrada y salida del puerto serie: TX/RX (verde oscuro) ɶbotón de reset (azul obscuro) ɶEntrada del circuito del programador serie (azul turquesa) ɶPines de entrada analógica 0-5 (azul claro) ɶPines de alimentación y tierra (voltaje: naranja, tierra: naranja claro) ɶEntrada de la fuente de alimentación externa (9-12V DC) - X1 (rosa) ɶSwitch entre alimentación externa o por puerto USb - SV1 (violeta) ɶPuerto USb serie (amarillo) para poderlo conectar a la computadora. Si conec- ɶtamos un aparato que siga la interfaz USb no funcionará pues en realidad es un puerto serie, no USb.

2.1.3. Especificaciones

Los microcontroladores Arduino Diecimila y Arduino Duemilanove están basados en Atmega168 y Atmega328.

Tabla 1. Especificación de Arduino

Caracteristica Atmega168 Atmega328

Voltaje Operativo 5V 5V

Voltaje de entrada recomendado

7-12V 7-12V

Voltaje de entrada límite 6-20V 6-20V

Pines de entrada y salida digital

14 (6 proporcionan PWM) 14 (6 proporcionan PWM)

Pines de entrada analógica 6 6

Intensidad de corriente 40mA 40mA

Memoria Flash16KB (2KB reservados para el

bootloader)32KB (2KB reservados para el bootloader)

SRAM 1KB 2KB

EEPROM 512 bytes 1MB

Frecuencia de reloj 16Mhz 16Mhz

2.1.4 Bibliotecas

Para utilizar una biblioteca existente en un programa, vaya al menú Sketch, elija “Importar la biblioteca”, y seleccione de las disponibles, teniendo en cuenta que las bibliotecas se cargan al mismo tiempo que su programa y disminuirán la cantidad de espacio para programación (Memoria Flash).

18


i. introDucción

EEPRO ɶ M - lee y escribe a la "memoria permanente" Etherne ɶ t - para conectar a internet usando el Escudo Ethernet Arduino Firmat ɶ a - para comunicarse con aplicaciones en la computadora mediante un protocolo serie estándar. LiquidCrysta ɶ l - para el control de pantallas de cristal líquido (LCD) Serv ɶ o - para el control de los servomotores SoftwareSeria ɶ l - para la comunicación serie en cualquiera de los pines digitales Steppe ɶ r - para el control de motores paso a paso Wir ɶ e - Interfaz de cable (TWI/I2C) para enviar y recibir datos a través de una red de dispositivos o sensores. PS2Keyboard – para sincronizar el reloj del teclado mediante un interrupt del ɶArduino y leer serialmente la información del teclado.UsbKeyboard – para identificar a un Arduino como si se tratara de un teclado ɶtipo USb.

2.1.5 Programación

Para programar un Arduino se cuenta con un editor especial desarrollado en Java y que permite, usando lenguaje C++ embeber código en el micro controlador Atmega

Figura 8. Editor para programar el Arduino

Para monitorear las interacciones del código embebido con el Hardware se puede usar una Hiperterminal conectada la puerto serie


19

i. introDucción

Figura 9. Monitoreo del código embebido

2.2 El conector PS2

Este conector contiene 6 pins usados para conectar algunos teclados y ratones a una computadora personal que cuente con este tipo de interfaces, su nombre proviene de las computadoras IbM Personal System/2 y se introdujo en 1987. El alambrado de un conector de este tipo se muestra en la siguiente figura:

Figura 10. Conector PS2 femenino

El pin 1 se usa para la transferencia de datos (+DATA)El pin 2 no se conectaEl pin 3 se conecta a tierraEl pin 4 se conecta a +5V DC (Vcc)El pin 5 se conecta a una fuente de oscilación (+CLK)Pin 6 no se conecta

Por lo tanto para procesar los bytes que provienen de un teclado haciendo uso de un Arduino solo se necesitan hacer 4 conexiones y lo haremos de la siguiente manera:

20


i. introDucción

Tabla 2. Conexión entre teclado PS2 y Placa ArduinoTeclado PS2 Placa Arduino

Pin 1 +Data Digital 6

Pin 3 Tierra POWER Gnd

Pin 4 Vcc +5 POWER 5V

Pin 5 +CLK Digital 3

2.3 El Driver para el Teclado PS2

El siguiente código es un segmento de la programación que hay que embeber en el Arduino para que puedan identificarse los bytes provenientes del teclado por el Ar-duino, la configuración dependerá de cada teclado PS2 de manera particular debido a que hay una gran cantidad de fabricantes y hay variantes.

#include <PS2Keyboard.h>const int DataPin = 6;const int IRQpin = 3;PS2Keyboard keyboard;void setup() { delay(1000); keyboard.begin(DataPin, IRQpin); Serial.begin(9600); Serial.println(“Keyboard Test:”);}void loop() { if (keyboard.available()) { // read the next key char c = keyboard.read(); // check for some of the special keys if (c == PS2_ENTER) { Serial.println(); } else if (c == PS2_TAB) { Serial.print(“[Tab]”); } else if (c == PS2_ESC) { Serial.print(“[ESC]”); } else if (c == PS2_PAGEDOWN) { Serial.print(“[PgDn]”); } else if (c == PS2_PAGEUP) { Serial.print(“[PgUp]”); } else if (c == PS2_LEFTARROW) { Serial.print(“[Left]”); } else if (c == PS2_RIGHTARROW) { Serial.print(“[Right]”); } else if (c == PS2_UPARROW) { Serial.print(“[Up]”); } else if (c == PS2_DOWNARROW) { Serial.print(“[Down]”); } else if (c == PS2_DELETE) { Serial.print(“[Del]”); } else { // otherwise, just print all normal characters Serial.print(c); } }}

El código final puede encontrarse en el Anexo al final del documento.


21

i. introDucción

3. Interfaz con la PC

La segunda fase del desarrollo del proyecto consiste en la construcción de una interfaz entre el Arduino y la Computadora, para que el primero se auto identifique ante el segundo y así quede registrado como un dispositivo de entrada de datos USb. En esta etapa también será necesario hacer un segundo módulo (embebido en el Ar-duino) que interactúe con la interfaz física para permitir la auto identificación.

3.1 Construcción de interfaz USB

Del libro Practical Arduino Cool Projects for Open Source Hardware, en el capítulo 4 Virtual USb Keyboard, se encuentra el siguiente diagrama de un circuito que es necesario contruir como interfaz entre el Arduino y la PC para que mediante progra-mación la placa pueda autoidentificarse como un Teclado USb genérico.

Figura 11. Diagrama para un teclado USB virtual

El listado de partes necesario es:

1 Conector USb hembra tipo “b” (puede ser de otro tipo) ɶ1 Cable USb A a b (del tipo seleccionado arriba) ɶ2 Diodos Zener de 3.6 Volts de 0.5 Watts ɶ1 Resistencia de 2.2 K 0.25 a 0.5 Watts ɶ2 Resistencias de 68R 0.25 a 0.5 Watts ɶ

Como puede observarse del diagrama de la Figura 11, los pines digitales que se usarán del Arduino son:

El pin 2 para hacer uso de interrupciones y manejar la sincronización y detección de eventos en la conexión USb y los pins 4 y 5 para transferencia de información.

22


i. introDucción

Figura 12. Circuito interfaz USB cara posterior

Figura 13. Circuito interfaz USB cara anterior

3.2 El Driver para el teclado virtual USB

El siguiente código es un segmento de la programación que hay que embeber en el Arduino para que el circuito pueda autoidentificarse como un teclado virtual USb, se encuentra incluida la bibluioteca PS2Keyboard para poder probar binomio Arduino / teclado PS2 como uno USb real.


23

i. introDucción

#include <PS2Keyboard.h>#include “UsbKeyboard.h”#define BYPASS_TIMER_ISR 1//////////////////////////////////////////////////////////////////****************** PINS usados por Arduino *******************//*******nterface para emular un teclado USB con Arduino *******// el pin 2 D+ usa interrupciones de la biblioteca UsbKeyboard// el pin 4 D- UsbKeyboard// el pin 5 UsbKeyboard // Ground UsbKeyboard y PS2Keyboard// Vcc +5V UsbKeyboard y PS2Keyboard// el pin 3 usa interrupciones para la biblioteca de PS2Keyboard// el pin 6 datos del teclado PS2Keyboard#define KBD_DATA_PIN 6 // Codigo leido del teclado (alambre Rojo)#define KBD_IRQ_PIN 3 // Pin para usar IRQ, para manejo del // Clocking del teclado (alambre Amarillo)//Crear una instancia PS2KeyboardPS2Keyboard keyboard;////////////////////// Setup//////////////////////////////void setup() {#if BYPASS_TIMER_ISR TIMSK0&=!(1<<TOIE0); // ++#endif

keyboard.begin(KBD_DATA_PIN);// Velocidad de comunicacion con la consola//Serial.begin(9600);delay(1000);}////////////////////// Setup//////////////////////////////#if BYPASS_TIMER_ISRvoid delayMs(unsigned int ms) { for (int i = 0; i < ms; i++) { delayMicroseconds(1000); }}#endif////////////////////// loop //////////////////////////////void loop() { UsbKeyboard.update(); if(keyboard.available()) { byte extra =keyboard.read_extra(); byte dat = keyboard.read(); byte val = dat - ‘0’; boolean ctrl =extra & 1; boolean alt = extra & 2; switch (dat) { case 8:UsbKeyboard.sendKeyStroke(KEY_BS); break; case 9:UsbKeyboard.sendKeyStroke(KEY_TAB); break; case 16:UsbKeyboard.sendKeyStroke(KEY_ARROW_RIGHT); break; case 17:UsbKeyboard.sendKeyStroke(KEY_ARROW_LEFT); break; case 19:UsbKeyboard.sendKeyStroke(KEY_DELETE); break; case 30:UsbKeyboard.sendKeyStroke(KEY_UP_ARROW); break; case 31:UsbKeyboard.sendKeyStroke(KEY_DOWN_ARROW); break;

//continua codigo

24


i. introDucción

Figura 14. Teclado integrado a módulo decodificador

4. Implementación del teclado programable

La tercera y última fase del proyecto consiste en adecuar las bibliotecas PS2Key-board y UsbKeyboard para que sean funcionales para todas las teclas de uno del tipo PS2,eliminando todas las incompatibilidades entre códigos ASCII que ambas mane-jan y luego determinar cuáles son los bloque de instrucciones del lenguaje de progra-mación “C” que es conveniente programar en el Arduino para que mediante una serie de teclas y comandos que se alimenten desde el sean identificados y reproducidos de manera certera y veloz.

4.1 Código requerido a generar

Todo teclado PS2 tiene una serie de teclas conocidas como F1, F2, F3, …, F12Que son las que se han programado con la finalidad de mostrar su utilidad

4.1.1 Generación de proyecto, cabeceras y main

La tecla F1 estará relacionada con la generación del siguiente código:


25

i. introDucción

Que se logra mediante la programación:

Que puede consultarse en el anexo.

26


i. introDucción

4.1.2 Generación del bloque if-else



Que también puede consultarse en el anexo

4.1.3 Generación del bloque if-else anidado

La tecla F3 estará relacionada con la generación del siguiente código.



27

i. introDucción

Que también puede consultarse en el anexo.

4.1.4 Generación del bloque switch



28


i. introDucción


4.1.5 Generación del ciclo for




4.1.6 Generación de la instrucción de ciclo do-while




29

i. introDucción


4.1.7 Generación de la instrucción de ciclo while




30


i. introDucción

4.1.8 Generación de declaración de clase




4.1.9 Generación de la declaración de estructura



31

i. introDucción



4.1.10 Generación de case Ctrl-C Ctrl-V

Las teclas F10, F11 y F12 estarán relacionadas con el case, comando para copiar y comando para pegar que se logra mediante la programación:


33

conclusiones

Como se planteó desde el inicio del proyecto, se deseaba desarrollar un pro-totipo de Hardware que permitiera desarrollar programas de computadora (software) de una manera ordenada, fácil y rápida. Todo esto se logró, sin embargo debe mencionarse que aunque las bibliotecas de software PS2Ke-

yboard y UsbKeyboard ya existían, fue necesario implementarlas para que realmente fueran funcionales para el propósito que se perseguía. El haberlas hecho convivir fue otro reto pues ambas utilizan interrupciones sobre el mismo pin lo cual las hacia incompatibles, fue necesario deshabilitar algunos segmentos del código original e im-plementar otras para que ambas trabajando de manera simultánea pudieran mani-pular el interrupt del teclado PS2 y del puerto USb de la computadora.

Otro de los retos que hubo que superar fue el hecho de que el Arduino Duemi-lenove solo cuenta con una memoria de 16Kb de almacenamiento para programas embebidos razón por la cual fue necesario crear muchas funciones para optimizar el almacenamiento y su funcionalidad.

Por ultimo cabe mencionar que una vez terminado el prototipo de teclado progra-mable. fue puesto en práctica y esto permitió desarrollar aplicaciones en las materias de programación I y II (C y C++) al interior de los programas del Instituto de Inge-niería y Tecnología de la UACJ.

El impacto del proyecto es tecnológico y académico pues permitirá desarrollar equipo de cómputo de uso general que puede ayudar a docentes a realizar su tarea educativa de manera más eficiente y a profesionales en el desarrollo de software a trabajar de manera mejor y mas estructurada.

35

bibliografía

Reporte técnico de investigación: La casa inteligente y segura; Paz J.C., Rodarte J., UACJ-IIT; 2009.

Practical Arduino cool projects for open source hardware, Jonathan Oxer, Hugh ble-mings, Apress; 2009.

http://www.arduino.cchttp://www.techsmith.comhttp://www.piengineering.com/xkeys/xkstick.php

37

anexo

Listado complete del código fuente del proyecto

//////////////////Proyecto Teclado programable//////////////////////// Ver 3 /////// ////// Desarrollado por Dr. Jenaro Carlos Paz Gutierrez ///////////// Fecha de Término: 14 octubre del 2011 ///////////// Haciendo uso de las dos bibliotecas /////// #include <PS2Keyboard.h>#include “UsbKeyboard.h”////// con varias modificaciones y adiciones que las hacen ////////// compatibles entre ellas y las habilitan a procesar ////////// la mayoria de las teclas de uno del tipo PS2 ///////// Solicitar a [email protected] //// ////////////////////////////////////////////////////////////////#define BYPASS_TIMER_ISR 1////////////////////////////////////////////////////////////////// Para emular un teclado USB usando el Arduino Duemilanove ///// se utiliza un circuito descrito en el libro: ///// Practical Arduino - Jonathan Oxer,Hugh Blemings - Apress ///// ISBN - 978-1-4302-2477-8 (2009) ///// Capitulo 4 (pag 51) Virtual USB Keyboard /////****************** PINS usados por Arduino *******************//****** Interface para emular un teclado USB con Arduino ******// el pin 2 D+ usa interrupciones biblioteca UsbKeyboard// el pin 4 D- UsbKeyboard// el pin 5 UsbKeyboard // Ground UsbKeyboard y PS2Keyboard// Vcc +5V UsbKeyboard y PS2Keyboard// el pin 3 usa interrupciones biblioteca PS2Keyboard// el pin 6 datos del teclado PS2Keyboard#define KBD_DATA_PIN 6 // Codigo leido del teclado(alambre Rojo)//#define KBD_IRQ_PIN 3 Pin para usar IRQ, para manejo del // Clocking del teclado (alambre Amarillo)//Crear una instancia PS2KeyboardPS2Keyboard keyboard;////////////////////// Setup//////////////////////////////void setup() {#if BYPASS_TIMER_ISR TIMSK0&=!(1<<TOIE0); // ++#endif

keyboard.begin(KBD_DATA_PIN);// Velocidad de comunicacion con la consola

38


anexo

//Serial.begin(9600);delay(1000);}////////////////////// Setup//////////////////////////////#if BYPASS_TIMER_ISRvoid delayMs(unsigned int ms) { for (int i = 0; i < ms; i++) { delayMicroseconds(1000); }}#endif////////////////////// loop //////////////////////////////void loop() { UsbKeyboard.update(); if(keyboard.available()) { byte extra =keyboard.read_extra(); byte dat = keyboard.read(); byte val = dat - ‘0’; boolean ctrl = extra & 1; // <ctrl> tiene bit 0 boolean alt = extra & 2; // <alt> tiene bit 1 boolean notaltctrl=1;

if (ctrl) { switch (dat) { case ‘z’: UsbKeyboard.sendKeyStroke(KEY_Z,MOD_CONTROL_LEFT); break; case ‘x’: UsbKeyboard.sendKeyStroke(KEY_X,MOD_CONTROL_LEFT); break; case ‘c’: UsbKeyboard.sendKeyStroke(KEY_C,MOD_CONTROL_LEFT); break; case ‘v’: UsbKeyboard.sendKeyStroke(KEY_V,MOD_CONTROL_LEFT); break; case ‘a’: UsbKeyboard.sendKeyStroke(KEY_A,MOD_CONTROL_LEFT); break; case ‘f’: UsbKeyboard.sendKeyStroke(KEY_F,MOD_CONTROL_LEFT); break; case ‘h’: UsbKeyboard.sendKeyStroke(KEY_H,MOD_CONTROL_LEFT); break; case ‘s’: UsbKeyboard.sendKeyStroke(KEY_S,MOD_CONTROL_LEFT); break; case ‘p’: UsbKeyboard.sendKeyStroke(KEY_P,MOD_CONTROL_LEFT); break; } notaltctrl = 0; } if (alt) { switch (dat) { case ‘f’: UsbKeyboard.sendKeyStroke(KEY_F,MOD_ALT_LEFT); break; case ‘e’: UsbKeyboard.sendKeyStroke(KEY_E,MOD_ALT_LEFT); break; case ‘v’: UsbKeyboard.sendKeyStroke(KEY_V,MOD_ALT_LEFT); break; case ‘d’: UsbKeyboard.sendKeyStroke(KEY_D,MOD_ALT_LEFT); break; case ‘t’: UsbKeyboard.sendKeyStroke(KEY_T,MOD_ALT_LEFT); break; case ‘w’: UsbKeyboard.sendKeyStroke(KEY_W,MOD_ALT_LEFT); break; case ‘h’: UsbKeyboard.sendKeyStroke(KEY_H,MOD_ALT_LEFT); break; } notaltctrl = 0; } boolean control=((32 <=dat && dat <=95)||(97 <=dat && dat <=125)) && notaltctrl; if(control) char_print(dat); else


39

anexo

switch (dat) { //case 1 KEY_KC_F9 Ver programacion de funcionalidad mas abajo +++++ //case 2 KEY_KC_F11 //case 3 KEY_KC_F5 //case 4 KEY_KC_F3 //case 5 KEY_KC_F1 //case 6 KEY_KC_F2 //case 7 KEY_KC_F12 case 8:UsbKeyboard.sendKeyStroke(KEY_BS); break; case 9:UsbKeyboard.sendKeyStroke(KEY_TAB); break; //case 10 KEY_KC_F8 //case 11 KEY_KC_F6 //case 12 KEY_KC_F4 //case 14 KEY_KC_F10 case 16:UsbKeyboard.sendKeyStroke(KEY_ARROW_RIGHT); break; case 17:UsbKeyboard.sendKeyStroke(KEY_ARROW_LEFT); break; case 19:UsbKeyboard.sendKeyStroke(KEY_DELETE); break; case 30:UsbKeyboard.sendKeyStroke(KEY_UP_ARROW); break; case 31:UsbKeyboard.sendKeyStroke(KEY_DOWN_ARROW); break; // case 131 KEY_KC_F7 case 132:UsbKeyboard.sendKeyStroke(KEY_ENTER); break; case 133: UsbKeyboard.sendKeyStroke(KEY_ESCAPE);break; // case PS2_KC_F1 **** MAIN FUNCTION AND HEADERS **** case 5: tag(“// ProgramaXX.cpp : fecha “);newLine(1); tag(“// Dr. Jenaro C. Paz.”);newLine(1); tag(“// Programacion de Computadoras -C- /////”);newLine(2); tag(“#include “); UsbKeyboard.sendKeyStroke(KEY_APOSTROPHE,MOD_SHIFT_LEFT); tag(“stdafx.h”); UsbKeyboard.sendKeyStroke(KEY_APOSTROPHE,MOD_SHIFT_LEFT); newLine(1); tag(“#include <iostream>”); newLine(1); tag(“#include <fstream>”); newLine(1); tag(“#include <stdio.h>”); newLine(1); tag(“#include <conio.h>”); newLine(1); tag(“using namespace std;”);newLine(2); tag(“void main”); drawPtesis(); drawBlock(); arrowUp(1);break; // case PS2_KC_F2: **** IF-ELSE BLOCK **** case 6: tag(“if”); drawPtesis(); drawBlock(); tag(“else”); drawBlock(); arrowUp(4); arrowRight(3); break;// case PS2_KC_F3 **** IF-ELSE IF BLOCK **** case 4: tag(“if”); drawPtesis(); drawBlock(); tag(“else if”); drawPtesis(); drawBlock(); tag(“else”); drawBlock();

40


anexo

arrowUp(6); arrowRight(3); break;//case PS2_KC_F4 **** SWITCH BLOCK **** case 12: tag(“switch”); drawPtesis(); drawBlock(); arrowUp(1); tag(“case : break;”); newLine(1); tag(“default: ;”); arrowUp(2); arrowLeft(2); break;//case PS2_KC_F5 **** FOR LOOP **** case 3: tag(“for”); UsbKeyboard.sendKeyStroke(KEY_9,MOD_SHIFT_LEFT); tag(“ ; ; “); UsbKeyboard.sendKeyStroke(KEY_0,MOD_SHIFT_LEFT); drawBlock(); arrowUp(2); arrowRight(4); break;// case PS2_KC_F6 **** DO - WHILE LOOP **** case 11: tag(“do “); drawBlock(); tag(“while”); drawPtesis(); tag(“;”); arrowLeft(2); break;//case PS2_KC_F7 **** WHILE LOOP **** case 131: tag(“while”); drawPtesis(); drawBlock(); arrowUp(2); arrowRight(6); break; // case PS2_KC_F8 **** CLASS DECLARATION **** case 10 : tag(“class “); drawBlock();tag(“;”); arrowUp(1); tag(“private: “); newLine(2); tag(“public: “); newLine(1); arrowUp(5); arrowRight(8); break;//case PS2_KC_F9 **** STRUCT **** case 1 : tag(“struct “); drawBlock();tag(“;”); arrowUp(1); break;////////////////// CASE ////////////// case PS2_KC_F10:


41

anexo

tag(“case : break;”); break; ////////////////// Ctrl C Copy ////////////// case PS2_KC_F11: UsbKeyboard.sendKeyStroke(KEY_C,MOD_CONTROL_LEFT); break; ////////////////// Ctrl V Paste ////////////// case PS2_KC_F12: UsbKeyboard.sendKeyStroke(KEY_V,MOD_CONTROL_LEFT); break; // default: Serial.print(dat,DEC); } notaltctrl=1;#if BYPASS_TIMER_ISR // check if timer isr fixed. delayMs(20);#else delay(20);#endif } }////////////////////// loop //////////////////////////////////////////////////////////////////////////////////////////void drawBlock(){ UsbKeyboard.sendKeyStroke(KEY_LSQB,MOD_SHIFT_LEFT); UsbKeyboard.sendKeyStroke(KEY_ENTER); UsbKeyboard.sendKeyStroke(KEY_ENTER); UsbKeyboard.sendKeyStroke(KEY_RSQB,MOD_SHIFT_LEFT); }///////////////////////////////////////////////////////////void drawPtesis(){ UsbKeyboard.sendKeyStroke(KEY_9,MOD_SHIFT_LEFT); UsbKeyboard.sendKeyStroke(KEY_SPACE); UsbKeyboard.sendKeyStroke(KEY_0,MOD_SHIFT_LEFT);}///////////////////////////////////////////////////////////void arrowLeft(char k){ for(char i=0; i < k; i++) UsbKeyboard.sendKeyStroke(KEY_ARROW_LEFT);}///////////////////////////////////////////////////////////void arrowRight(char k){ for(char i=0; i < k; i++) UsbKeyboard.sendKeyStroke(KEY_ARROW_RIGHT);}///////////////////////////////////////////////////////////void arrowUp(char k){ for(char i=0; i < k; i++)UsbKeyboard.sendKeyStroke(KEY_UP_ARROW);}///////////////////////////////////////////////////////////void newLine(char k){

42


anexo

for(char i=0; i < k; i++) UsbKeyboard.sendKeyStroke(KEY_ENTER);}///////////////////////////////////////////////////////////void tag(char * seq){ byte num; char count= strlen(seq); for( char j=0; j < count;j++ ){ num=seq[j]; char_print(num); }}///////////////////////////////////////////////////////////void char_print(byte j){ switch(j){ case ‘ ‘:UsbKeyboard.sendKeyStroke(KEY_SPACE); break; //32 case ‘!’:UsbKeyboard.sendKeyStroke(KEY_1,MOD_SHIFT_LEFT); break; //33 case ‘”’: UsbKeyboard.sendKeyStroke(KEY_APOSTROPHE,MOD_SHIFT_LEFT); break; //34 case ‘#’:UsbKeyboard.sendKeyStroke(KEY_3,MOD_SHIFT_LEFT); break; //35 case ‘$’:UsbKeyboard.sendKeyStroke(KEY_4,MOD_SHIFT_LEFT); break; //36 case ‘%’:UsbKeyboard.sendKeyStroke(KEY_5,MOD_SHIFT_LEFT); break; //37 case ‘&’:UsbKeyboard.sendKeyStroke(KEY_7,MOD_SHIFT_LEFT); break; //38 case ‘\’’:UsbKeyboard.sendKeyStroke(KEY_APOSTROPHE); break; //39 case ‘(‘:UsbKeyboard.sendKeyStroke(KEY_9,MOD_SHIFT_LEFT); break; //40 case ‘)’:UsbKeyboard.sendKeyStroke(KEY_0,MOD_SHIFT_LEFT); break; //41 case ‘*’:UsbKeyboard.sendKeyStroke(KEY_8,MOD_SHIFT_LEFT); break; //42 case ‘+’:UsbKeyboard.sendKeyStroke(KEY_EQUAL,MOD_SHIFT_LEFT); break; //43 case ‘,’:UsbKeyboard.sendKeyStroke(KEY_SEMIC); break; //44 case ‘-’:UsbKeyboard.sendKeyStroke(KEY_MINUS); break; //45 case ‘.’:UsbKeyboard.sendKeyStroke(KEY_DOT); break; //46 case ‘/’:UsbKeyboard.sendKeyStroke(KEY_SLASH); break; //47 case ‘0’:UsbKeyboard.sendKeyStroke(KEY_0); break; //48 case ‘1’:UsbKeyboard.sendKeyStroke(KEY_1); break; //49 case ‘2’:UsbKeyboard.sendKeyStroke(KEY_2); break; //50 case ‘3’:UsbKeyboard.sendKeyStroke(KEY_3); break; //51 case ‘4’:UsbKeyboard.sendKeyStroke(KEY_4); break; //52 case ‘5’:UsbKeyboard.sendKeyStroke(KEY_5); break; //53 case ‘6’:UsbKeyboard.sendKeyStroke(KEY_6); break; //54 case ‘7’:UsbKeyboard.sendKeyStroke(KEY_7); break; //55 case ‘8’:UsbKeyboard.sendKeyStroke(KEY_8); break; //56 case ‘9’:UsbKeyboard.sendKeyStroke(KEY_9); break; //57 case ‘:’:UsbKeyboard.sendKeyStroke(KEY_COLON,MOD_SHIFT_LEFT); break; //58 case ‘;’:UsbKeyboard.sendKeyStroke(KEY_COLON); break; //59 case ‘<’:UsbKeyboard.sendKeyStroke(KEY_SEMIC,MOD_SHIFT_LEFT); break; //60 case ‘=’:UsbKeyboard.sendKeyStroke(KEY_EQUAL); break; //61 case ‘>’:UsbKeyboard.sendKeyStroke(KEY_DOT,MOD_SHIFT_LEFT); break; //62 case ‘?’:UsbKeyboard.sendKeyStroke(KEY_SLASH,MOD_SHIFT_LEFT); break; //63 case ‘@’:UsbKeyboard.sendKeyStroke(KEY_2,MOD_SHIFT_LEFT); break; //64 case ‘A’:UsbKeyboard.sendKeyStroke(KEY_A,MOD_SHIFT_LEFT); break; //65 case ‘B’:UsbKeyboard.sendKeyStroke(KEY_B,MOD_SHIFT_LEFT); break; //66 case ‘C’:UsbKeyboard.sendKeyStroke(KEY_C,MOD_SHIFT_LEFT); break; //67 case ‘D’:UsbKeyboard.sendKeyStroke(KEY_D,MOD_SHIFT_LEFT); break; //68 case ‘E’:UsbKeyboard.sendKeyStroke(KEY_E,MOD_SHIFT_LEFT); break; //69 case ‘F’:UsbKeyboard.sendKeyStroke(KEY_F,MOD_SHIFT_LEFT); break; //70 case ‘G’:UsbKeyboard.sendKeyStroke(KEY_G,MOD_SHIFT_LEFT); break; //71 case ‘H’:UsbKeyboard.sendKeyStroke(KEY_H,MOD_SHIFT_LEFT); break; //72 case ‘I’:UsbKeyboard.sendKeyStroke(KEY_I,MOD_SHIFT_LEFT); break; //73 case ‘J’:UsbKeyboard.sendKeyStroke(KEY_J,MOD_SHIFT_LEFT); break; //74


43

anexo

case ‘K’:UsbKeyboard.sendKeyStroke(KEY_K,MOD_SHIFT_LEFT); break; //75 case ‘L’:UsbKeyboard.sendKeyStroke(KEY_L,MOD_SHIFT_LEFT); break; //76 case ‘M’:UsbKeyboard.sendKeyStroke(KEY_M,MOD_SHIFT_LEFT); break; //77 case ‘N’:UsbKeyboard.sendKeyStroke(KEY_N,MOD_SHIFT_LEFT); break; //78 case ‘O’:UsbKeyboard.sendKeyStroke(KEY_O,MOD_SHIFT_LEFT); break; //79 case ‘P’:UsbKeyboard.sendKeyStroke(KEY_P,MOD_SHIFT_LEFT); break; //80 case ‘Q’:UsbKeyboard.sendKeyStroke(KEY_Q,MOD_SHIFT_LEFT); break; //81 case ‘R’:UsbKeyboard.sendKeyStroke(KEY_R,MOD_SHIFT_LEFT); break; //82 case ‘S’:UsbKeyboard.sendKeyStroke(KEY_S,MOD_SHIFT_LEFT); break; //83 case ‘T’:UsbKeyboard.sendKeyStroke(KEY_T,MOD_SHIFT_LEFT); break; //84 case ‘U’:UsbKeyboard.sendKeyStroke(KEY_U,MOD_SHIFT_LEFT); break; //85 case ‘V’:UsbKeyboard.sendKeyStroke(KEY_V,MOD_SHIFT_LEFT); break; //86 case ‘W’:UsbKeyboard.sendKeyStroke(KEY_W,MOD_SHIFT_LEFT); break; //87 case ‘X’:UsbKeyboard.sendKeyStroke(KEY_X,MOD_SHIFT_LEFT); break; //88 case ‘Y’:UsbKeyboard.sendKeyStroke(KEY_Y,MOD_SHIFT_LEFT); break; //89 case ‘Z’:UsbKeyboard.sendKeyStroke(KEY_Z,MOD_SHIFT_LEFT); break; //90 case ‘[‘:UsbKeyboard.sendKeyStroke(KEY_LSQB); break; //91 case ‘\\’:UsbKeyboard.sendKeyStroke(KEY_BSLASH); break; //92 case ‘]’:UsbKeyboard.sendKeyStroke(KEY_RSQB); break; //93 case ‘^’:UsbKeyboard.sendKeyStroke(KEY_6,MOD_SHIFT_LEFT); break; //94 case ‘_’:UsbKeyboard.sendKeyStroke(KEY_MINUS,MOD_SHIFT_LEFT);break; //95 case ‘a’:UsbKeyboard.sendKeyStroke(KEY_A); break; //97 case ‘b’:UsbKeyboard.sendKeyStroke(KEY_B); break; //98 case ‘c’:UsbKeyboard.sendKeyStroke(KEY_C); break; //99 case ‘d’:UsbKeyboard.sendKeyStroke(KEY_D); break; //100 case ‘e’:UsbKeyboard.sendKeyStroke(KEY_E); break; //101 case ‘f’:UsbKeyboard.sendKeyStroke(KEY_F); break; //102 case ‘g’:UsbKeyboard.sendKeyStroke(KEY_G); break; //103 case ‘h’:UsbKeyboard.sendKeyStroke(KEY_H); break; //104 case ‘i’:UsbKeyboard.sendKeyStroke(KEY_I); break; //105 case ‘j’:UsbKeyboard.sendKeyStroke(KEY_J); break; //106 case ‘k’:UsbKeyboard.sendKeyStroke(KEY_K); break; //107 case ‘l’:UsbKeyboard.sendKeyStroke(KEY_L); break; //108 case ‘m’:UsbKeyboard.sendKeyStroke(KEY_M); break; //109 case ‘n’:UsbKeyboard.sendKeyStroke(KEY_N); break; //110 case ‘o’:UsbKeyboard.sendKeyStroke(KEY_O); break; //111 case ‘p’:UsbKeyboard.sendKeyStroke(KEY_P); break; //112 case ‘q’:UsbKeyboard.sendKeyStroke(KEY_Q); break; //113 case ‘r’:UsbKeyboard.sendKeyStroke(KEY_R); break; //114 case ‘s’:UsbKeyboard.sendKeyStroke(KEY_S); break; //115 case ‘t’:UsbKeyboard.sendKeyStroke(KEY_T); break; //116 case ‘u’:UsbKeyboard.sendKeyStroke(KEY_U); break; //117 case ‘v’:UsbKeyboard.sendKeyStroke(KEY_V); break; //118 case ‘w’:UsbKeyboard.sendKeyStroke(KEY_W); break; //119 case ‘x’:UsbKeyboard.sendKeyStroke(KEY_X); break; //120 case ‘y’:UsbKeyboard.sendKeyStroke(KEY_Y); break; //121 case ‘z’:UsbKeyboard.sendKeyStroke(KEY_Z); break; //122 case ‘{‘:UsbKeyboard.sendKeyStroke(KEY_LSQB,MOD_SHIFT_LEFT); break; //123 case ‘|’:UsbKeyboard.sendKeyStroke(KEY_BSLASH,MOD_SHIFT_LEFT); break; //124 case ‘}’: UsbKeyboard.sendKeyStroke(KEY_RSQB,MOD_SHIFT_LEFT);break; //125 } }

Desarrollo De un teclaDo programable para computaDora - … de un teclado… · Paz Gutiérrez,...

Documents

Transcript of Desarrollo De un teclaDo programable para computaDora - … de un teclado… · Paz Gutiérrez,...