Publicado por: RedPic en 25 de Marzo de 2006, 15:39:00
En esto estoy ahora metido .... Voy a intentar conectarle un teclado estándar PS/2 de PC
a mi <a href="http://picmania.garcia-cuervo.net/Proyectos_RRBoard1.htm" target="_blank">RRBOARD1[/url]. Abro ya el proyecto por si alguno de ustedes tiene ya experiencia y puede
ya ir haciendome amables comentarios.
Me he pasado por la página de Nocturno, <a href="http://manolo.auna.net/proyectos-raton.html" target="_blank">El Rebujito[/url], que tiene algo muy similar pero
con Dspic y un Ratón PS/2 (el 90% de lo que me hace falta ya lo ha experimentado él)
y por otros enlaces en los que está todo comido y masticado ... pero hay que hacerlo, no leerlo BR]
La conexión PS/2 es una conexión serie síncrona bidireccional (hay una línea de
datos y una de clock). Utiliza 1 bit de inicio, 8 de datos, 1 de paridad y un bit o
un byte de ACK.
La comunicación del PIC-PC al Teclado PS/2 tiene este timming:
(http://picmania.garcia-cuervo.net/images/PRJ_PS2_host2kbd.gif)
La comunicación del Teclado al PIC-PC este otro :
<img src="http://picmania.garcia-cuervo.net/images/PRJ_PS2_kbd2host.gif" border=0>
Los conectores PS/2 tienen este pinout:
<img src="http://picmania.garcia-cuervo.net/images/PRJ_PS2_Connector.GIF" border=0>
Como las líneas Data y Clock necesitan unas resistencias Pull-up voy a conectarlos
de esta forma:
<img src="http://picmania.garcia-cuervo.net/images/PRJ_PS2_Connection.GIF" border=0>
Una vez inicializado el Teclado PS/2 éste envía Scan Codes por la línea Data,
no carácters ASCII. Son códigos de rastreo de teclado, que envía uno al ser
pulsada una tecla y otro al ser soltada dicha tecla. Estos Scan Codes pueden se de
1, 2 o 3 bytes de largo:
Los códigos de rastreo de teclado son :
<img src="http://picmania.garcia-cuervo.net/images/PRJ_PS2_Scancode_01.gif" border=0>
<img src="http://picmania.garcia-cuervo.net/images/PRJ_PS2_Scancode_02.gif" border=0>
Con esto de los codigos de rastreo se produce una cosa curiosa:
Si por ejemplo queremos que nos transmita la letra "G", en mayúsculas, la secuencia
debe ser: Presionar la tecla "Shift", presionar la tecla "G", soltar la tecla "G" y soltar
la tecla "Shift". Los Scan Codes entonces serán los correspondientes a las pulsaciones
y "sueltas" de estas dos teclas : Pulsar Shift -> 12h, Pulsar "G" -> 34h, Soltar "G"
-> F0h 34h y soltar Shift -> F0h 12h por lo que la secuencia completa nos llegará
como: 12h, 34h, F0h, 34h, F0h, 12h. ( Casi ná )
Ahora voy a ponerme a publicarle a la RRBOARD1 los Pines RB0 que voy a utilizar para
detectar el Clock mediante la interrupción externa, y los pines RB3 o RB4 que voy a usar
para el Data. Los RB1 y RB2 los reservo para las comunicaciones RS232 con el PC para
poder monitorizar lo que vaya ocurriendo, Manolo Nocturno en su proyecto con el ratón
utiliza la USART para este cometido, yo creo que voy a implementar "a pelo" la
recepción de los códigos ....
En fin, os tendré al tanto.
Ya veremos cómo se me dá <img src="http://pics.miarroba.net/caretos/smokie.gif" alt="Fumador" title="Fumador" /> ....
Publicado por: RedPic en 25 de Marzo de 2006, 16:29:00
(http://picmania.garcia-cuervo.com/images/En_Espagnol.gif) Ratón PS/2 controlado por un dsPIC (http://manolo.auna.com/proyectos-raton.html)
(http://picmania.garcia-cuervo.com/images/En_Espagnol.gif) Teclado AT-PS2 Interfaz y funciones v1.2 (http://picmania.garcia-cuervo.com/recursos/Teclado AT-PS2 Interfaz y funciones v1.2.pdf)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) TECHNICAL SPECIFICATION FOR G83-6000 (http://picmania.garcia-cuervo.com/recursos/kbd_spec.pdf)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) AT Keyboard Interface V1.04 (http://www.electronic-engineering.ch/microchip/projects/keyboard/v1xx/keyboard_v1xx.html)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) The PS/2 Keyboard Interface (http://www.computer-engineering.org/ps2keyboard/)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) DIY hardware keylogger (http://www.keelog.com/diy.html)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) As to connect pic to the connector mini din (ps/2) in CCS C Forum (http://www.ccsinfo.com/forum/viewtopic.php?t=25673)
Como os digo, aquí esta T O D O ... ahora hay que darle forma ... :mrgreen:
Publicado por: migsantiago en 25 de Marzo de 2006, 16:32:00
Teclado AT-PS2 Interfaz y funciones v1.2.pdfhttp://www.4shared.com/dir/251403/ddb5213f/Todopic.html
Publicado por: RedPic en 25 de Marzo de 2006, 16:40:00
post anterior para añadirlo. Puede ser muy util e intersante tener mas información en
español. Hay muchos amigos foreros que no tienen n.p.i. de Espikinglish
Publicado por: atlasdelcarinakeel en 26 de Marzo de 2006, 11:28:00
http://www.beyondlogic.org/keyboard/keybrd.htm
Y aqui esta el codigo. Solo esta la parte de las letras en minusculas y mayusculas, asi como los numeros que estan arriba de las letras. El shift me parece que no me funciono.
;////////////AQUI TENGO CONECTADO UN TECLADO TIPO DIN DE 6 PINES AL MICROCONTROLADOR 89C51//////////////
;/////////// CON EL MICRO LEO EL DATO Y LO ENVIO SERIAL AL HIPERTERMINAL///////////////////////////////
$MOD51
VAL1 EQU 30H ;AREA NO BIT A BIT
VAL2 EQU 31H
VAL3 EQU 32H
LETRA EQU 33H
SEMAFOR EQU 23H ;AREA BIT A BIT
AUX_BIT EQU 21H
COMP EQU 22H
IN BIT P3.0
ORG 00H
JMP CONFIG
ORG 003H
JMP SERVI
CONFIG: MOV IE,#81H
MOV SP,#78H
MOV TCON,#01H
MOV SCON,#53H
MOV TMOD,#20h
MOV PCON,#80H
MOV TH1,#0FDH
MOV P1,#00H
MOV R0,#00H
CLR COMP.0
CICLO: NOP
JMP CICLO ;Espero que llegue el primer clock y se interrumpe el micro
SERVI: CALL CARGA
CLR SEMAFOR.0
LOOP0: JNB IN,START ;ESPERA BIT INICIO
JMP LOOP0
START: JB SEMAFOR.0,VISUAL ;Pregunto si la bandera es uno y salto a la etiqueta VISUAL
CALL RET_100Mseg
JNB IN,LOOP1 ;REVISA LOS BIT"S EN P3, A TRAVES DE ESTE PIN ENTRARAN LOS BITS DE DATOS
CALL UNO
JMP START
LOOP1: CALL CERO
JMP START
;////////////////AQUI LLEGO CUANDO LA BANDERA SEMAFOR.0 ES "1"////////////////
VISUAL:
;MOV P1,A ;RESPALDO EL VALOR EN EL REGISTRO LETRA
MOV LETRA,A
CALL RET1
MOV A,LETRA
;//////////////APARIR DE AQUI PREGUNTO QUE TECLA PRESIONE/////////////
ENTER: CJNE A,#5AH,BLOCK ;AQUI PUEDES SUSTITUIR BLOCK POR SHIFIZ Y PROBAR
MOV A,#0DH ;VALOR PARA PASAR A LA SIGUIENTE LINEA
CALL Trans
MOV A,#0AH
CALL Trans
MOV A,#00H
JMP SAL
;//////////////LAS RUTINAS DE SHIFT NO RECUERDO QUE ME HALLAN FUNCIONARON/////////////////
SHIFIZ: CJNE A,#12H,SHIFDE
SETB COMP.1
;MOV R1,#00h
JB COMP.0,MINUS ;JB MINUS
JNB COMP.0,MAYUS ;JB MAYUS
JMP SAL
SHIFDE: CJNE A,#59H,BLOCK
SETB COMP.1
;MOV R1,#00h
;JB COMP.0,CBLOQ
;JNB COMP.0,SBLOQ
JMP SAL
;/////////////////////////////////////////////////////////////////////
BLOCK: CJNE A,#58H,BAND
JMP GRAND
GRAND: INC R0
SETB COMP.0
CJNE R0,#02H,SAL
CLR COMP.0
MOV R0,#00H
JMP SAL
BAND: JB COMP.0,MAYUS ;AQUI PREGUNTO POR EL ESTADO DE LA BANDERA COMP.0 Y VOY A LA SUBRUTINA CORRESPONDIENTE
JNB COMP.0,MINUS
MINUS: MOV A,LETRA
MOV DPTR,#Minusculas
MOVC A,@A+DPTR
CALL Trans
JMP SAL
MAYUS: MOV A,LETRA
MOV DPTR,#Mayusculas ;CARGO EL DPTR CON LA TABLA MAYUSCULA
MOVC A,@A+DPTR ;INCREMENTO EL DPTR HASTA ENCONTRAR EL VALOR CORRESPONDIENTE EN LA TABLA Y LO CARGO EN EL ACUMULADOR
CALL Trans ;LLAMO LA RUTINA DE ENVIO
JMP SAL
;//////////////RUTINA DE ENVIO SERIAL AL PC//////////////////////////////
Trans: MOV SBUF,A
SETB TR1
CLR TI
JNB TI,$
CLR TI
CLR TR1
CALL RET1
RET
SAL: CLR IE0
RETI
UNO: SETB ACC.7 ;PONGO UN "1" EN EL ACUMULADOR SI EL PRIMER BIT DE DATO ES "1"
DJNZ AUX_BIT,ROTAR1 ;DECREMENTO AUX_BIT QUE ES EL CONTADOR DE 8 BITS QUE ME INDICA CUANDO LLEGAN TODOS LOS DATOS
JMP THEN1
ROTAR1: RR A ;ROTO EL ACUMULADOR PARA IR ACOMODANDO EL DATO
JMP SALIR1 ;sALTO PARA SALIR DE LA SUBRUTINA Y ESPERAR EL SIGUIENTE BIT DE DATOS
THEN1: SETB SEMAFOR.0 ;LEVANTO LA BANDERA PARA INDICAR QUE LLEGARON LOS 8 BITS DE DATO
SALIR1: RET
CERO: CLR ACC.7 ;IGUAL QUE LA SUBRUTINA UNO, PERO SE COLOCA "0" SEA NECESARIO
DJNZ AUX_BIT,ROTAR2
JMP THEN2
ROTAR2: RR A
JMP SALIR2
THEN2: SETB SEMAFOR.0
SALIR2: RET
CARGA: MOV AUX_BIT,#08H
MOV ACC,#00H
RET
RET_100Mseg:
MOV VAL1,#28D
DESC: DJNZ VAL1,DESC
RET
RET1:
MOV VAL1,#10D
TERC1: MOV VAL2,#10D
SEGU1: MOV VAL3,#10D
PRIM1: DJNZ VAL3,PRIM1
DJNZ VAL2,SEGU1
DJNZ VAL1,TERC1
RET
;/////////////////////////TABLAS/////////////////////
Minusculas:
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 09H ;TABULADOR(14)
DB ""
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB "q"
DB "1"
DB 00H
DB 00H
DB 00H
DB "z"
DB "s"
DB "a"
DB "w"
DB "2"
DB 00H
DB 00H
DB "c"
DB "x"
DB "d"
DB "e"
DB "4"
DB "3"
DB 00H
DB 00H
DB " "
DB "v"
DB "f"
DB "t"
DB "r"
DB "5"
DB 00H
DB 00H
DB "n"
DB "b"
DB "h"
DB "g"
DB "y"
DB "6"
DB 00H
DB 00H
DB 00H
DB "m"
DB "j"
DB "u"
DB "7"
DB "8"
DB 00H
DB 00H
DB ","
DB "k"
DB "i"
DB "o"
DB "0"
DB "9"
DB 00H
DB 00H
DB "."
DB "-"
DB "l"
DB 164 ;ñ(77)
DB "p"
DB 39 ;"(79)
DB 00H
DB 00H
DB ","
DB "{"
DB 00H
DB "["
DB 173 ;?(86)*
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H ;ENTER(91)-13
DB "]"
DB 00H
DB "}"
DB 00H
DB 00H
DB 00H
DB "<"
DB 00H
DB 00H
DB 00H
DB 00H
DB 008H ;RETROCESO(103)
DB 00H
Mayusculas:
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 09H
DB ""
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB 00H
DB "Q"
DB "1"
DB 00H
DB 00H
DB 00H
DB "Z"
DB "S"
DB "A"
DB "W"
DB "2"
DB 00H
DB 00H
DB "C"
DB "X"
DB "D"
DB "E"
DB "4"
DB "3"
DB 00H
DB 00H
DB " "
DB "V"
DB "F"
DB "T"
DB "R"
DB "5"
DB 00H
DB 00H
DB "N"
DB "B"
DB "H"
DB "G"
DB "Y"
DB "6"
DB 00H
DB 00H
DB 00H
DB "M"
DB "J"
DB "U"
DB "7"
DB "8"
DB 00H
DB 00H
DB ","
DB "K"
DB "I"
DB "O"
DB "0"
DB "9"
DB 00H
DB 00H
DB "."
DB "-"
DB "L"
DB 165
DB "P"
DB 39
DB 00H
DB 00H
DB ","
DB "{"
DB 00H
DB "["
DB 173
DB 00H
DB 00H
DB 00H
DB 00H
DB 13
DB "]"
DB 00H
DB "}"
DB 00H
DB 00H
DB 00H
DB "<"
DB 00H
DB 00H
DB 00H
DB 00H
DB 08H
DB 00H
END
Publicado por: atlasdelcarinakeel en 26 de Marzo de 2006, 11:37:00
. He querido subir el archivo pero me dicen que no hay espacio suficiente solo pesa 6,62 KB.
Publicado por: microcarsil en 26 de Marzo de 2006, 11:47:00
hago mi pequeño aporte con un enlace que hace tiempo hice acerca de una interface de teclado.aqui esta el enlace al hilo
http://miarroba.com/foros/ver.php?foroid=46840&temaid=4627644&marcar=interrupcion
Publicado por: RedPic en 26 de Marzo de 2006, 14:19:00
pero esto no es ayuda, es hacerme el proyecto completo ... así no tiene gracia ....
El camino es llano, el horizonte despejado .... ja, ja, ja .... solo tengo que copiar
y pegar .... ja, ja, ja ....
Publicado por: electronando en 26 de Marzo de 2006, 17:16:00
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=39
me refiero a las conecciones en la parte q esta conectado el pic 16f877 al teclado veo dos pull up , dos transistores y dos buffer o eso esta internamente en el teclado
por otra parte no sabia q habia tanta informacion al respecto q bien caramba q buenos enlaces
Publicado por: microcarsil en 26 de Marzo de 2006, 17:41:00
Escrito originalmente por electronando
disculpen esta interesante el proyecto pero en este enlace no se nota muy bien las conecciones
http://conket.com/modules.php?name=Sections&op=viewarticle&artid=39
me refiero a las conecciones en la parte q esta conectado el pic 16f877 al teclado veo dos pull up , dos transistores y dos buffer o eso esta internamente en el teclado
por otra parte no sabia q habia tanta informacion al respecto q bien caramba q buenos enlaces
Efectivamente electronando
las dos pull up , los dos transistores y los dos buffer esta internamente en el teclado, solo tienes que conectar los pines del teclado a los correspondientes del pic (RB0 y RB7) y alimentar el teclado (+ 5v) yo ya lo probe con el codigo anteriormente publicado en el enlace y funciona de perlas .
Publicado por: electronando en 27 de Marzo de 2006, 22:45:00
Publicado por: RedPic en 28 de Marzo de 2006, 01:56:00
Y yo voy a ponerlas .... imagino que no pasa nada por hacerlo así ya que si el teclado
las tiene internas y yo las pongo tb pues tenemos mas de lo mismo y ...
¿no?
Publicado por: microcarsil en 28 de Marzo de 2006, 04:33:00
las lineas clock y data son de colector abierto y se necesita resistencias pull-up para obtener niveles logicos altos. Una disculpa por semejante aseveracion que hice anteriormente , pero recuerdo que cuando experimente la interface conecte las lineas data y clock directamente y me funciono por cierto RedPic esto ultimo podrias checarlo para sacarme de dudas, te lo agradeceria.
Publicado por: atlasdelcarinakeel en 28 de Marzo de 2006, 08:47:00
, pero despues las coloque y tambien me funciono. Se las deje por que el clock y el dato son colector abierto. Estoy buscando mi esquematico para subirlo. Por ahi tengo otro codigo en donde se pueden teclear las teclas extendidas (valga la redundancia
), que son teclas que envian mas de un valor de dato como las teclas de direccion. Tengo un desorden, si lo consigo lo subo.
Publicado por: RedPic en 02 de Abril de 2006, 04:06:00
Hemos estado hablando de las resistencias Pull-Up que necesitamos para poder
conectar convenientemente el teclado PS/2 con el PIC ... muy cierto y muy importante.
De hecho he incluido en la conexión dichas resistencias .... y sin embargo no son
necesarias ya que si uso, como pretendo, RB0 para el Clock y RB3 para el Data ...
en un PIC 16F628 con solo usar:
Codigo:
port_b_pullups(TRUE);
Tenemos todas las Pull-Up"s que deseemos y no necesitamos añadir nada fuera
de nuestro PIC. Conectamos la alimentación del Teclado y las dos señales directamente
a nuestros pines y , voilá, ya lo tenemos todo.
Atlasdelcarinakeel, mira si en tu programa tb hacías uso de esto y por eso te
funcionó sin resistencias.
Publicado por: atlasdelcarinakeel en 02 de Abril de 2006, 04:27:00
Publicado por: RedPic en 02 de Abril de 2006, 06:40:00
(su Nick en Todopic) de un programa que empieza así :
Codigo:
//-----------------------------------------------------------------------------
// Title: KEYBOARD_PC_To_RS232.c
// Description: Interfase entre un teclado convencional tipo AT y un puerto RS232C
// Date: Abr-2005
// Ver.Rev.: V01
// Author: XP8100 (xp8100@gmail.com)
//
// #Based on the AN AVR313: Interfacing the PC AT Keyboard from ATMEL#
//
//-----------------------------------------------------------------------------
Porque funciona de maravilla. Le he hecho algunas modificaciones para adaptarlo
a mi RRBOARD1 con su PIC 16F628A y, salvo un pequeño detalle, ha salido funcionando
a la primera. (El detalle es que con un Xtal de 4Mhz no va de ninguna manera,
hay que colocarle un Xtal de 20Mhz para que funcione. Imagino que es que la
frecuencia de transmisión del Teclado es demasiado alta para el de 4 y pierde
bits por el camino, pero con el de 20 no se le escapa uno).
Gracias, gracias, gracias a mi desconocido benefactor ....
Ahora lo pondré bonito, le añadiré comentarios por doquier y lo dejaré listo para
que hasta el más novato sea capaz de entenderlo (y reproducirlo)
.... ju, jua, jua
¡¡¡ Cómo disfruto !!!
Publicado por: RaDoN en 02 de Abril de 2006, 08:24:00
Que tio!!! no paras!!! Que más quisiera tener yo tb algo de tiempo libre
Publicado por: RedPic en 02 de Abril de 2006, 10:37:00
un Keyboard PS/2 a un PIC.
Solo hago uso de dos hilos, uno debe ser RB0 para podernos aprovechar de su
función de Interrupción Externa, el otro puede ser cualquier pin de Entrada. Yo
he hecho uso del RB3. Como hace falta poner unas resistencias Pull-Up externas
a las lineas de Clock y Data he aprovechado la caracteristica de los PIC que incluye
dichas resistencias de forma programable en los pines del Puerto B, para activarlas
y evitarme así el tener de forma externa.
El teclado envia los códigos de rastreo, los fin de pulsado de tecla (break) y los de
teclas especiales mediante "bytes" de 11 bits start+codigo_8_bits+paridad+Stop
asi que la recogida de estos bits se produce en la interrupción externa, a la que está
conectada la señal de clock. Cada vez que se produce un pulso (negativo) de clock
se lee un bit. Cuando hemos leído los 11 bits en total tenemos un nuevo byte para
procesar. Este byte resulta de haber descartado los que no nos hacen falta y solo
se toman en cuenta realmente los codigo_8_bits de toda la secuencia.
Fijaos que para detectar cada uno de los bits en la Interrupción externa debemos
configurar ésta para que salte en el flaco de bajada ext_int_edge(H_TO_L);
Le dejo al programa los créditos originales de nuestro benefactor anónimo, añadiéndole
solo la modificación realizada por mi. Además he editado la tabla de conversión
poniéndola en columnas para que aparezcan mas compactas y se lea mejor el
código fuente.
]<span class="texto_mini">Codigo:</span>[hr /
//-----------------------------------------------------------------------------
// Title: KEYBOARD_PC_To_RS232.c
// Description: Interfase entre un teclado convencional tipo AT y un puerto RS232C
// Date: Abr-2005
// Ver.Rev.: V01
// Author: XP8100 (xp8100@gmail.com)
//
// #Based on the AN AVR313: Interfacing the PC AT Keyboard from ATMEL#
// #Adaptado para 16F628A por Redraven
//
//-----------------------------------------------------------------------------
//
// init_kb() Inicializa rutina y contadores
//
// decode (char) Decodifica la pulsación realizada, convirtiendola a un caracter de la tabla
//
// int_ext_isr Rutina de gestión de interrupciones. Captura los diferentes bit"s
//
//-----------------------------------------------------------------------------
// RB0 - Señal de reloj
// RB3 - Tren de impulsos (11 bit) Start+10101010+Paridad+Stop
//-----------------------------------------------------------------------------
//
// Commment : Permite conectar un teclado convencional de PC a un entorno
// gestionado por un PIC 16F877.
// El actual sistema se define como un primer prototipo, en el que no se realizan
// acciones concretas asociadas a teclas establecidas.
// Tampoco se actua sobre los indicadores luminosos del teclado, repetición de teclas, ...
//
//
//
// THIS DOCUMENT IS PROVIDED TO THE USER "AS IS"
//-----------------------------------------------------------------------------
#include "16F628a.h"
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use Delay(Clock=20000000)
#use rs232(baud=19200, xmit=PIN_B2, rcv=PIN_B1)
#zero_ram
//-----------------------------------------------------------------------------
// Definiciones globales
//-----------------------------------------------------------------------------
unsigned char edge, bitcount;
char got_interrupt;
char interrupt_count;
char status_b3;
#bit INTF_BIT = 0x0B.1 // INTCON BIT 1 = INTF RB0/INT External Interrupt Flag Bit
//-------- Tabla de caracteres correspondientes a la pulsación de la tecla
//-------- en modalidad normal (sin pulsar SHIFT)
unsigned char const unshifted[68][2] = {
0x0d,9,
0x0e,"º", 0x15,"q", 0x16,"1", 0x1a,"z", 0x1b,"s", 0x1c,"a", 0x1d,"w",
0x1e,"2", 0x21,"c", 0x22,"x", 0x23,"d", 0x24,"e", 0x25,"4", 0x26,"3",
0x29," ", 0x2a,"v", 0x2b,"f", 0x2c,"t", 0x2d,"r", 0x2e,"5", 0x31,"n",
0x32,"b", 0x33,"h", 0x34,"g", 0x35,"y", 0x36,"6", 0x39,",", 0x3a,"m",
0x3b,"j", 0x3c,"u", 0x3d,"7", 0x3e,"8", 0x41,",", 0x42,"k", 0x43,"i",
0x44,"o", 0x45,"0", 0x46,"9", 0x49,".", 0x4a,"-", 0x4b,"l", 0x4c,"ñ",
0x4d,"p", 0x4e,""", 0x52,"´", 0x54,"`", 0x55,"¡", 0x5a,13, 0x5b,"+",
0x5d,"ç", 0x61,"<", 0x66,8, 0x69,"1", 0x6b,"4", 0x6c,"7", 0x70,"0",
0x71,".", 0x72,"2", 0x73,"5", 0x74,"6", 0x75,"8", 0x79,"+", 0x7a,"3",
0x7b,"-", 0x7c,"*", 0x7d,"9",
0,0
};
//-------- Tabla de caracteres correspondientes a la pulsación de la tecla
//-------- en modalidad desplazamiento (pulsando SHIFT)
unsigned char const shifted[68][2] = {
0x0d,9,
0x0e,"ª", 0x15,"Q", 0x16,"!", 0x1a,"Z", 0x1b,"S", 0x1c,"A", 0x1d,"W",
0x1e,""", 0x21,"C", 0x22,"X", 0x23,"D", 0x24,"E", 0x25,"$", 0x26,"·",
0x29," ", 0x2a,"V", 0x2b,"F", 0x2c,"T", 0x2d,"R", 0x2e,"%", 0x31,"N",
0x32,"B", 0x33,"H", 0x34,"G", 0x35,"Y", 0x36,"&", 0x39,"L", 0x3a,"M",
0x3b,"J", 0x3c,"U", 0x3d,"/", 0x3e,"(", 0x41,";", 0x42,"K", 0x43,"I",
0x44,"O", 0x45,"=", 0x46,")", 0x49,":", 0x4a,"_", 0x4b,"L", 0x4c,"Ñ",
0x4d,"P", 0x4e,"?", 0x52,"¨", 0x54,"^", 0x55,"¿", 0x5a,13, 0x5b,"*",
0x5d,"Ç", 0x61,">", 0x66,8, 0x69,"1", 0x6b,"4", 0x6c,"7", 0x70,"0",
0x71,".", 0x72,"2", 0x73,"5", 0x74,"6", 0x75,"8", 0x79,"+", 0x7a,"3",
0x7b,"-", 0x7c,"*", 0x7d,"9",
0,0
};
//-----------------------------------------------------------------------------
// Definición de protipos
//-----------------------------------------------------------------------------
void init_kb(void);
void decode(unsigned char sc);
//-----------------------------------------------------------------------------
// Rutina de gestión de interrupciones
//-----------------------------------------------------------------------------
#int_ext
void int_ext_isr(void){
unsigned char data;
//-------- Los bit 3 a 10 se considerran datos. Paridad, start y stop
//-------- son ignorados
if(bitcount < 11 && bitcount > 2){
data = (data >> 1);
status_b3 = input(PIN_B3);
if((status_b3) == 1){
data = data | 0x80;
}
}
//-------- Todos los bits se han recibido
if(--bitcount == 0){
decode(data);
data = 0;
bitcount = 11;
got_interrupt = TRUE;
}
got_interrupt = TRUE;
interrupt_count++;
disable_interrupts(INT_EXT);
}
//-----------------------------------------------------------------------------
// Main
//-----------------------------------------------------------------------------
void main(void)
{
delay_ms(100);
init_kb();
//-------- Los pins indicados (B0 y B3) son configurados como entradas.
output_float(PIN_B0);
output_float(PIN_B3);
//-------- Activa pullups sobre todos los pins del puerto B.
port_b_pullups(TRUE);
//-------- Espera a que se activen.
delay_us(5);
//-------- Inicializa las variables usadas por la rutina de interrupción
//-------- antes de activar las interrupciones
interrupt_count = 0;
got_interrupt = FALSE;
status_b3 = 0;
//-------- Desde que se activó el modo PULLUPS del puerto B, el estado
//-------- normal del pin B0 es ALTO. La gestión de la interrupción externa
//-------- se gestiona cuando se produce un cambio de nivel ALTO a BAJO.
ext_int_edge(H_TO_L);
//-------- Asegurarse de que el el bit de flag de la interrupción externa
//-------- es borrado antes de activar la gestión de dicha interrupción
//-------- externa.
INTF_BIT = 0;
enable_interrupts(INT_EXT);
enable_interrupts(GLOBAL);
//-------- Bucle principal.
//-------- Chequear si se produce alguna interrupción (got_interrupt). Si es así, contar, borrar
//-------- el flag y esperar 50 ms, reactivando la gestión de las interrupciones
while(1){
//-------- Chequear si se produce alguna interrupción (got_interrupt).
if(got_interrupt == TRUE){
//-------- Borrar el flag global que se inicio en la rutina de servicio
//-------- de interrupciones externas.
got_interrupt = FALSE;
//-------- Esperar 50 ms para evitar rebotes en los contactos de las teclas.
//delay_ms(50);
//-------- Borrar cualquier interrupción producida durante el periodo de espera.
INTF_BIT = 0;
//-------- Reactivar interrupciones
enable_interrupts(INT_EXT);
} // --- End If ---
} // --- End While ---
} // --- End MAIN ---
//-----------------------------------------------------------------------------
// Funciones
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Inicialización de teclado.
//-----------------------------------------------------------------------------
void init_kb(void){
//-------- Longitud de la trama para cada pulsación y mensaje de bienvenida
bitcount = 11;
printf("
PC AT Keyboard Interface Ver 1.0 by XP8100" );
printf("
Adpapted for 16F628A by Redpic" );
printf("
Decoder and Monitoring for 16F628A connected ...
" );
}
//-----------------------------------------------------------------------------
// Decodificación de pulsaciones
//-----------------------------------------------------------------------------
void decode(unsigned char sc){
static unsigned char is_up=0, shift = 0, mode = 0;
unsigned char i;
printf("[%X]",sc); // Monitor de código de rastreo
//-------- El último dato recibido fue el identificador de Up-Key
if (!is_up){
switch (sc){
//-------- Identificador de Up-Key
case 0xF0 :
is_up = 1;
break;
//-------- SHIFT Izquierdo
case 0x12 :
shift = 1;
break;
//-------- SHIFT Derecho
case 0x59 :
shift = 1;
break;
//-------- ENTER
case 0x5A :
shift = 0;
printf("
" );
break;
//-------- Si no es ninguno de los identificadores especiales, procesar
//-------- pulsación, localizando caracter en tabla de caracteres.
default:
//-------- Pulsación normal
if(!shift)
{
for(i = 0; unshifted[ i ][ 0 ]!=sc && unshifted[ i ][ 0 ]; i++);
if (unshifted[ i ][ 0 ] == sc)
{
printf("<%c>", unshifted[ i ][ 1 ]);
}
}
else
//-------- Pulsación + SHIFT presionado
{
for(i = 0; shifted[ i ][ 0 ]!=sc && shifted[ i ][ 0 ]; i++);
if (shifted[ i ][ 0 ] == sc)
{
printf("<%c>", shifted[ i ][ 1 ]);
}
}
break;
} // --- End Switch
}
else
{
//-------- No se permiten 2 0xF0 en una fila
is_up = 0;
switch (sc)
{
//-------- SHIFT Izquierdo
case 0x12 :
shift = 0;
break;
//-------- SHIFT Derecho
case 0x59 :
shift = 0;
break;
} // --- End Switch
}
}
Y por último, y como siempre, os pongo un volcado de mi monitor RS232 con
los resultados de la detección de teclas y su posterior envío por el puerto serie
del PIC. En este ejemplo monitorizo la secuencia de teclas [ a ][ s ][ d ][ intro ][ f ][ g ]
Fijaos que he incluido en la transmisión tanto los códigos de rastreo como las teclas
decodificadas que dichos códigos significan:
(http://picmania.garcia-cuervo.com/images/PRJ_PS2_Dump.GIF)
Resultado plenamente satisfactorio <img src="http://pics.miarroba.com/caretos/lol.gif" alt="Muchas risas" title="Muchas risas" /> <img src="http://pics.miarroba.com/caretos/lol.gif" alt="Muchas risas" title="Muchas risas" /> <img src="http://pics.miarroba.com/caretos/lol.gif" alt="Muchas risas" title="Muchas risas" /> <img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" /> <img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" /> <img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" /> <img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" /> <img src="http://pics.miarroba.com/caretos/bounce.gif" alt="Rebotado" title="Rebotado" />
Publicado por: electronando en 02 de Abril de 2006, 14:08:00
Publicado por: migsantiago en 04 de Abril de 2006, 19:20:29
Te dejo un link al foro oficial de CCS en donde hay una librería para lo mismo...
:arrow: http://www.ccsinfo.com/forum/viewtopic.php?t=25673
:mrgreen:
Publicado por: RedPic en 05 de Abril de 2006, 01:16:46
Publicado por: RedPic en 07 de Abril de 2006, 16:54:23
Esto, ahora que lo pienso, me viene bien ya que empiezo aquí con un avance, o con mis intenciones ... voy posteando cosas, resultados, informaciones y ... me váis ayudando, colaborando, informando ... y al final tengo todo, un poco desordenado o confuso, pero todo al fin y al cabo. Y es entonces cuando lo publico en mi página, con la ventaja de que conozco el final del proyecto, así que puedo ordenar los temas, lo necesario, lo inútil ....
Si queréis ver el artículo completo, ordenado y descrito en condiciones de ser entendido podéis visitar Conectando un Teclado PS/2 a la RRBOARD1
(http://picmania.garcia-cuervo.com/Proyectos_Teclado_PS2.htm)
Publicado por: inglaof en 17 de Abril de 2006, 13:44:02
Bueno, yo pensaba colaborar jeje, pero veo que llego un poco tarde, ya hay muchas respuestas. En mi caso realize una rutina en ensablador para la recepcion de codigos del teclado. Si alguien considera conocerla, no duden en contactarme para ello..:D
no se si ya lo han comentado en este tema, pero en dado caso lo repetire:
Cuando se presiona una tecla del teclado con conector PS2, este teclado envia 1 bit de inicio, 1 byte de datos, 1 bit de paridad y un bit de stop, es el formato que utilizan.
Ahora, cada vez que presionas una tecla, se reciben al menos 3 bytes de informacion (con sus correspondientes bits de inicio, paridad y stop), donde el primer byte recibido representa el codigo de la tecla, el segundo representa el un codigo de area del teclado, si bien recuerdo ( recordemos que hay teclas repetidas como los numeros), y nuevamente el dato de la misma tecla, como confirmacion, asi lo entiendo yo. Por internet estan los codigos de las teclas. Espero sea un agregado a este tema util...
Publicado por: RedPic en 17 de Abril de 2006, 14:58:36
Así nuestros amigos Picmaníacos tendrán mas información y otras formas de hacerlo para aprender y experimentar ...
Un saludo.
Publicado por: betito_mmf en 10 de Mayo de 2006, 01:14:26
Umm.. Al pulsar una tecla del teclado PS/2 , este envia 1 bit de inicio , 8 bits de datos , 1 de paridad y 1 de stop , eso esta claro .
Y que hay de los 3 bytes de informacion como funciona esto. El host recibe la 1ra secuencia de bits y luego debe esperar la 2da y finalmente la 3ra ,y que sucede si dejo precionado una tecla bastante tiempo , no entiendo esa parte y me gustaria si no es molestia , ver un diagrama de bloques o flujo para poder entender mejor el funcionamiento Host - teclado
Saludos amigos ;-)
If you want the peace prepare for the war
Publicado por: nostrico en 31 de Mayo de 2006, 16:00:15
Publicado por: RedPic en 01 de Junio de 2006, 15:20:48
Quien busca encuentra .... :lol:
Una vez terminado este Ponga un teclado PS/2 en su PIC ya he empezado con el
Emulación Teclado PS/2 con PIC (Engañe a su PC y dele gato por liebre) (http://www.todopic.com.ar/foros/index.php?topic=11910.0) ...
aún estoy en ello, pero es el siguiente (y lógico) paso a dar. :mrgreen:
Publicado por: aitopes en 02 de Junio de 2006, 07:35:09
Acabo de llegar al foro, y me gusto el proyecto para enviar datos al PC mediante el puerto PS/2 del teclado. Supongo que para muchas aplicaciones es una forma muy sencilla de transferir informacion, simplemente como si se hubiera tipeado.
Lo que me parece raro es que se necesiten 20Mhz para no perder datos desde el teclado... Tenes informacion acerca de la velocidad con la que transmite los datos el teclado? Me llama la atencion que se haya definido una velocidad muy alta para esa interfaz, ya que nadie tipeea taaaan rapido.. :)
Suerte!
Publicado por: RedPic en 02 de Junio de 2006, 11:17:10
Enlaces donde hay de todo lo necesario para este proyecto:
(http://picmania.garcia-cuervo.com/images/En_Espagnol.gif) Ratón PS/2 controlado por un dsPIC (http://manolo.auna.com/proyectos-raton.html)
(http://picmania.garcia-cuervo.com/images/En_Espagnol.gif) Teclado AT-PS2 Interfaz y funciones v1.2 (http://picmania.garcia-cuervo.com/recursos/Teclado AT-PS2 Interfaz y funciones v1.2.pdf)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) TECHNICAL SPECIFICATION FOR G83-6000 (http://picmania.garcia-cuervo.com/recursos/kbd_spec.pdf)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) AT Keyboard Interface V1.04 (http://www.electronic-engineering.ch/microchip/projects/keyboard/v1xx/keyboard_v1xx.html)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) The PS/2 Keyboard Interface (http://www.computer-engineering.org/ps2keyboard/)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) DIY hardware keylogger (http://www.keelog.com/diy.html)
(http://picmania.garcia-cuervo.com/images/Es_Ingles.gif) As to connect pic to the connector mini din (ps/2) in CCS C Forum (http://www.ccsinfo.com/forum/viewtopic.php?t=25673)
Ahí está todo lo necesario. (La velocidad del muestreo no tiene nada que ver con la velocidad de tipeo, sino con la velocidad de transmisión del protocolo PS/2)
Publicado por: nostrico en 06 de Junio de 2006, 15:23:25
NoStRiCo
Publicado por: LABmouse en 10 de Junio de 2006, 13:46:15
Son todos unos maestros. lo probare y les cuento como me fue.
:-/ :-/ :-/ :-/ :-/
Publicado por: RedPic en 05 de Julio de 2006, 07:39:36
Asi que la solución lógica es utilizar otro PC, pero como no tengo otro no tengo mas remedio que tirar de la RRBOARD2 (http://www.todopic.com.ar/foros/index.php?topic=2300.0) haciendo las mismas funciones que en este hacía la RRBOARD1. Así mi "emisor" le hablará a la RRBOAR2 y ésta transmitirá lo que reciba vía RS232 al PC con lo que podré depurar sin problemas ... :mrgreen: :mrgreen: :mrgreen:
Aquí os pego lo que realizado para conectarle el Teclado PS/2 a la RRBOARD2 que calza un 18F4550:
Primero el Adaptador PS/2 a Cable Plano 10 pines ...
(http://picmania.garcia-cuervo.net/images/prj_ps2_adaptador_rr2_01.gif)
Despues la conexión entre el Keyboard PS/2 y la RRBOARD2 ...
(http://picmania.garcia-cuervo.net/images/prj_ps2_adaptador_rr2_02_foto.gif)
Y por último las pruebas de Lectura de Teclado y su emisión a la RS232 del PC ...
(http://picmania.garcia-cuervo.net/images/prj_ps2_dump_rr2.gif)
El código adaptado para el 18F4550 es:
Código: CSS
- //-----------------------------------------------------------------------------
- // Title: KEYBOARD_To_PC_RS232.c
- // Description: Interfase entre un teclado convencional tipo AT y un puerto RS232C
- // Date: Abr-2005
- // Ver.Rev.: V01
- // Author: XP8100 (xp8100@gmail.com)
- //
- // #Based on the AN AVR313: Interfacing the PC AT Keyboard from ATMEL#
- // #Adaptado para 18f4550 por RedPic
- //
- //-----------------------------------------------------------------------------
- //
- // init_kb() Inicializa rutina y contadores
- //
- // decode (char) Decodifica la pulsación realizada, convirtiendola a un caracter de la tabla
- //
- // int_ext_isr Rutina de gestión de interrupciones. Captura los diferentes bit's
- //
- //-----------------------------------------------------------------------------
- // RB0 - Señal de reloj
- // RB7 - Tren de impulsos (11 bit) Start+10101010+Paridad+Stop
- //-----------------------------------------------------------------------------
- //
- // Commment : Permite conectar un teclado convencional de PC a un entorno
- // gestionado por un PIC 18f4550.
- // El actual sistema se define como un primer prototipo, en el que no se realizan
- // acciones concretas asociadas a teclas establecidas.
- // Tampoco se actua sobre los indicadores luminosos del teclado, repetición de teclas, ...
- //
- //
- //
- // THIS DOCUMENT IS PROVIDED TO THE USER 'AS IS'
- //-----------------------------------------------------------------------------
- #include <18f4550.h>
- #fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOPBADEN,NOLVP,NOCPD,NODEBUG,NOWRT,NOVREGEN // Fuses
- #use delay(clock=20000000) // Clock a 20 Mhz
- #use rs232(baud=9600, xmit=PIN_C6, rcv=PIN_C7) // Canal serie con el PC
- #zero_ram
- //-----------------------------------------------------------------------------
- // Definiciones globales
- //-----------------------------------------------------------------------------
- unsigned char edge, bitcount;
- char got_interrupt;
- char interrupt_count;
- char status_b3;
- #bit INTF_BIT = 0xff2.1 // INTCON BIT 1 = INT0IF: INT0 External Interrupt Flag bit
- //-------- Tabla de caracteres correspondientes a la pulsación de la tecla
- //-------- en modalidad normal (sin pulsar SHIFT)
- unsigned char const unshifted[68][2] = {
- 0x0d,9,
- 0x0e,'º', 0x15,'q', 0x16,'1', 0x1a,'z', 0x1b,'s', 0x1c,'a', 0x1d,'w',
- 0x1e,'2', 0x21,'c', 0x22,'x', 0x23,'d', 0x24,'e', 0x25,'4', 0x26,'3',
- 0x29,' ', 0x2a,'v', 0x2b,'f', 0x2c,'t', 0x2d,'r', 0x2e,'5', 0x31,'n',
- 0x32,'b', 0x33,'h', 0x34,'g', 0x35,'y', 0x36,'6', 0x39,',', 0x3a,'m',
- 0x3b,'j', 0x3c,'u', 0x3d,'7', 0x3e,'8', 0x41,',', 0x42,'k', 0x43,'i',
- 0x44,'o', 0x45,'0', 0x46,'9', 0x49,'.', 0x4a,'-', 0x4b,'l', 0x4c,'ñ',
- 0x4d,'p', 0x4e,''', 0x52,'´', 0x54,'`', 0x55,'¡', 0x5a,13, 0x5b,'+',
- 0x5d,'ç', 0x61,'<', 0x66,8, 0x69,'1', 0x6b,'4', 0x6c,'7', 0x70,'0',
- 0x71,'.', 0x72,'2', 0x73,'5', 0x74,'6', 0x75,'8', 0x79,'+', 0x7a,'3',
- 0x7b,'-', 0x7c,'*', 0x7d,'9',
- 0,0
- };
- //-------- Tabla de caracteres correspondientes a la pulsación de la tecla
- //-------- en modalidad desplazamiento (pulsando SHIFT)
- unsigned char const shifted[68][2] = {
- 0x0d,9,
- 0x0e,'ª', 0x15,'Q', 0x16,'!', 0x1a,'Z', 0x1b,'S', 0x1c,'A', 0x1d,'W',
- 0x1e,'"', 0x21,'C', 0x22,'X', 0x23,'D', 0x24,'E', 0x25,'$', 0x26,'·',
- 0x29,' ', 0x2a,'V', 0x2b,'F', 0x2c,'T', 0x2d,'R', 0x2e,'%', 0x31,'N',
- 0x32,'B', 0x33,'H', 0x34,'G', 0x35,'Y', 0x36,'&', 0x39,'L', 0x3a,'M',
- 0x3b,'J', 0x3c,'U', 0x3d,'/', 0x3e,'(', 0x41,';', 0x42,'K', 0x43,'I',
- 0x44,'O', 0x45,'=', 0x46,')', 0x49,':', 0x4a,'_', 0x4b,'L', 0x4c,'Ñ',
- 0x4d,'P', 0x4e,'?', 0x52,'¨', 0x54,'^', 0x55,'¿', 0x5a,13, 0x5b,'*',
- 0x5d,'Ç', 0x61,'>', 0x66,8, 0x69,'1', 0x6b,'4', 0x6c,'7', 0x70,'0',
- 0x71,'.', 0x72,'2', 0x73,'5', 0x74,'6', 0x75,'8', 0x79,'+', 0x7a,'3',
- 0x7b,'-', 0x7c,'*', 0x7d,'9',
- 0,0
- };
- //-----------------------------------------------------------------------------
- // Definición de protipos
- //-----------------------------------------------------------------------------
- void init_kb(void);
- void decode(unsigned char sc);
- //-----------------------------------------------------------------------------
- // Rutina de gestión de interrupciones
- //-----------------------------------------------------------------------------
- #int_ext
- void int_ext_isr(void){
- unsigned char data;
- //-------- Los bit 3 a 10 se considerran datos. Paridad, start y stop
- //-------- son ignorados
- if(bitcount < 11 && bitcount > 2){
- data = (data >> 1);
- status_b3 = input(PIN_B7);
- if((status_b3) == 1){
- data = data | 0x80;
- }
- }
- //-------- Todos los bits se han recibido
- if(--bitcount == 0){
- decode(data);
- data = 0;
- bitcount = 11;
- got_interrupt = TRUE;
- }
- got_interrupt = TRUE;
- interrupt_count++;
- disable_interrupts(INT_EXT);
- }
- void flash_porte(void){
- int i;
- set_tris_e(0b00010000); // Prepraro PORTE para flashear, Digital y Salida
- for(i=0;i<3;i++){
- output_High(PIN_E0); // Enciendo los tres Led's de la RRBOARD2
- output_High(PIN_E1);
- output_High(PIN_E2);
- delay_ms(333); // Espero para que se vea
- output_Low(PIN_E0); // Apago los tres Led's de la RRBOARD2
- output_Low(PIN_E1);
- output_Low(PIN_E2);
- delay_ms(333); // Espero para que no se vea
- }
- }
- void on_reset(){
- disable_interrupts(global); // Deshabilito todas las interrupciones
- disable_interrupts(int_timer1); // Deshabilito ...
- disable_interrupts(int_rda);
- disable_interrupts(int_ext);
- disable_interrupts(int_ext1);
- disable_interrupts(int_ext2);
- setup_adc_ports(NO_ANALOGS); // Configuro todo lo que voy
- setup_adc(ADC_OFF); // a usar y lo que no ...
- setup_spi(FALSE);
- setup_psp(PSP_DISABLED);
- setup_counters(RTCC_INTERNAL,RTCC_DIV_2);
- setup_timer_0(RTCC_OFF);
- setup_timer_1(T1_INTERNAL | T1_DIV_BY_1);
- setup_timer_2(T2_DISABLED,0,1);
- setup_timer_3(T3_DISABLED);
- setup_comparator(NC_NC_NC_NC);
- setup_vref(FALSE);
- set_tris_c(0b10000000);
- delay_ms(333); // Espero 333 milisegundos a que todo se estabilice
- printf("\r\n"); // Me presento como deben hacer todos los PIC's de buena familia
- printf("PC AT Keyboard Interface by XP8100\r\n");
- printf("Adpapted for 18F4550 by Redpic\r\n");
- printf("Decoder and Monitor connected ...\n\r");
- printf("\r\n");
- flash_porte();
- delay_ms(100);
- init_kb();
- //-------- Los pins indicados (B0 y B7) son configurados como entradas.
- output_float(PIN_B0);
- output_float(PIN_B7);
- //-------- Activa pullups sobre todos los pins del puerto B.
- port_b_pullups(TRUE);
- //-------- Espera a que se activen.
- delay_us(5);
- //-------- Inicializa las variables usadas por la rutina de interrupción
- //-------- antes de activar las interrupciones
- interrupt_count = 0;
- got_interrupt = FALSE;
- status_b3 = 0;
- //-------- Desde que se activó el modo PULLUPS del puerto B, el estado
- //-------- normal del pin B0 es ALTO. La gestión de la interrupción externa
- //-------- se gestiona cuando se produce un cambio de nivel ALTO a BAJO.
- ext_int_edge(H_TO_L);
- //-------- Asegurarse de que el el bit de flag de la interrupción externa
- //-------- es borrado antes de activar la gestión de dicha interrupción
- //-------- externa.
- INTF_BIT = 0;
- //-------- Habilito Interrupciones
- enable_interrupts(INT_EXT);
- enable_interrupts(GLOBAL);
- }
- //-----------------------------------------------------------------------------
- // Main
- //-----------------------------------------------------------------------------
- void main(void)
- {
- //-------- Hago todo lo que tengo que hacer al resetear el micro
- On_reset();
- //-------- Bucle principal.
- //-------- Chequear si se produce alguna interrupción (got_interrupt). Si es así, contar, borrar
- //-------- el flag y esperar 50 ms, reactivando la gestión de las interrupciones
- while(1){
- //-------- Chequear si se produce alguna interrupción (got_interrupt).
- if(got_interrupt == TRUE){
- //-------- Borrar el flag global que se inicio en la rutina de servicio
- //-------- de interrupciones externas.
- got_interrupt = FALSE;
- //-------- Esperar 50 ms para evitar rebotes en los contactos de las teclas.
- //delay_ms(50);
- //-------- Borrar cualquier interrupción producida durante el periodo de espera.
- INTF_BIT = 0;
- //-------- Reactivar interrupciones
- enable_interrupts(INT_EXT);
- } // --- End If ---
- } // --- End While ---
- } // --- End MAIN ---
- //-----------------------------------------------------------------------------
- // Funciones
- //-----------------------------------------------------------------------------
- //-----------------------------------------------------------------------------
- // Inicialización de teclado.
- //-----------------------------------------------------------------------------
- void init_kb(void)
- {
- //-------- Longitud de la trama para cada pulsación
- bitcount = 11;
- }
- //-----------------------------------------------------------------------------
- // Decodificación de pulsaciones
- //-----------------------------------------------------------------------------
- void decode(unsigned char sc)
- {
- static unsigned char is_up=0, shift = 0, mode = 0;
- unsigned char i;
- // printf("[%X]",sc);
- //-------- El último dato recibido fue el identificador de Up-Key
- if (!is_up){
- switch (sc){
- //-------- Identificador de Up-Key
- case 0xF0 :
- is_up = 1;
- break;
- //-------- SHIFT Izquierdo
- case 0x12 :
- shift = 1;
- break;
- //-------- SHIFT Derecho
- case 0x59 :
- shift = 1;
- break;
- //-------- ENTER
- case 0x5A :
- shift = 0;
- printf("\n\r");
- break;
- //-------- Si no es ninguno de los identificadores especiales, procesar
- //-------- pulsación, localizando caracter en tabla de caracteres.
- default:
- //-------- Pulsación normal
- if(!shift)
- {
- for(i = 0; unshifted[i][0]!=sc && unshifted[i][0]; i++);
- if (unshifted[i][0] == sc)
- {
- printf("%c", unshifted[i][1]);
- }
- }
- else
- //-------- Pulsación + SHIFT presionado
- {
- for(i = 0; shifted[i][0]!=sc && shifted[i][0]; i++);
- if (shifted[i][0] == sc)
- {
- printf("%c", shifted[i][1]);
- }
- }
- break;
- } // --- End Switch
- }
- else
- {
- //-------- No se permiten 2 0xF0 en una fila
- is_up = 0;
- switch (sc)
- {
- //-------- SHIFT Izquierdo
- case 0x12 :
- shift = 0;
- break;
- //-------- SHIFT Derecho
- case 0x59 :
- shift = 0;
- break;
- } // --- End Switch
- }
- }
Publicado por: RedPic en 23 de Marzo de 2009, 16:11:18
El resumen y artículo publicado con estos contenidos los tenéis disponible en Conectando un Teclado PS/2 a la RRBOARD1 (http://picmania.garcia-cuervo.net/proyectos_teclado_ps2.htm) y en este otro KBDEMUL : Emulación Teclado PS/2 con un 18F1320 (http://picmania.garcia-cuervo.net/proyectos_kbdemul.php)
Publicado por: mane9999 en 05 de Mayo de 2009, 19:20:33
Sigo intendando varias cosas... si consigo algo les platico los resultados :mrgreen:
Publicado por: cevollin en 12 de Julio de 2009, 23:15:55
bueno he encontrado esta discusion de como utilizar un teclado ps/2 con un pic ya que es lo que he querido hacer desde hace un tiempo mi pregunta es como puedo simular el teclado ps/2 en el proteus ya que no tiene esa utilidad tiene para simular puertos com y usb pero no para puerto ps/2 :D :D
y como seria para recibir el scan code del teclado ya que el teclado utiliza un protocolo de comunicacion para comunicarse con la pc pic etc
Publicado por: cevollin en 21 de Julio de 2009, 17:53:28
Publicado por: betito_mmf en 07 de Septiembre de 2009, 05:02:40
Código: [Seleccionar]
for(i = 0; unshifted[ i ][ 0 ]!=sc && unshifted[ i ][ 0 ]; i++);
if (unshifted[ i ][ 0 ] == sc)
{
printf("<%c>", unshifted[ i ][ 1 ]);
}
Esta condicion
(unshifted[ i ][ 0 ]!=sc) && (unshifted[ i ][ 0 ])
es verdadera cuando la tecla presionada "sc" es diferente del dato "unshifted[ i ][ 0 ]"
entonces se incrementa i++ y luego se prosigue con el siguiente elemento del array
entonces cuando "sc" es igual a "unshifted[ i ][ 0 ]" la condicion se hace falsa ?
si es asi como es que se ejecuta el sentencia que esta dentro del IF? :?
Publicado por: KALLITOS en 01 de Abril de 2011, 14:17:28
Muchos saludos :)
Publicado por: bondadoso en 11 de Marzo de 2012, 17:36:21
ahora el ejemplo de redpic me da error en la declaracion de 0x0e,"?", dentro de unsigned char const unshifted[68][2] = {
me manda el siguiente error=
Expression must evaluate to a constant
Publicado por: jeremylf en 30 de Abril de 2012, 22:28:51
Tengo una duda, necesito poner un teclado usb a mi PIC... Deberia hacerlo con un pic con usb host? O puedo hacer de alguna manera que el teclado usb envie datos ps2 por sus lines d+ y d-??
Gracias.
Publicado por: KALLITOS en 30 de Abril de 2012, 23:30:52
saludos.
Publicado por: jcmorales82 en 07 de Noviembre de 2012, 12:13:24
Código: [Seleccionar]
#byte TRISB=0x86
#bit TRISB0=TRISB.0
#bit TRISB1=TRISB.1 //#bit TRISB3=TRISB.3 en el caso de la librería de Red
#define ClkTris TRISB0
#define DataTris TRISB1 //Hay que definir los tris, depende de que bits utilices, yo usé B0 para la interrupción y B1 para la data... (#define DataTris TRISB3 para Red)
void enviar_dato(int comando)
{
int bitcom;
disable_interrupts(global);
delay_ms(1);
ClkTris=0;
DataTris=0;
OUTPUT_BIT(PIN_B0,0);
delay_us(100); //Esto puede variar depende del teclado, pero debería estar bien para la mayoría
OUTPUT_BIT(PIN_B1,0);
PS2Key_ClkTris=1;
while(input(PIN_B0));
for(i=0;i<=7;i++){
bitcom = comando&(1<<i);
OUTPUT_BIT(PIN_B1,bitcom);
while(!input(PIN_B0));
while(input(PIN_B0));
}
OUTPUT_BIT(PIN_B1,1);//PARIDAD=1
while(!input(PIN_B0));
while(input(PIN_B0));
PS2Key_DataTris=1;
while(input(PIN_B1));
while(input(PIN_B0));
delay_ms(10); /También puede variar, espera mientras el teclado envía ACK, o Error, o Reenviar, y libera los pines de Clock y Data
}
Por ejemplo, si quieren encender las luces del teclado, el código sería:
Código: [Seleccionar]
enviar_dato(0xED);
enviar_dato(0b00000011); //ScrollLock y NumLock