Haz una pregunta
  Foros de Electrónica » Diseño analógico » Diseño de circuitos en general
Foros Registrarse ¿Olvidaste tu contraseña?

Temas similares

18/01/2014 #1


Problema sincronizacion de teclado PS/2 con PIC 16F628
Hola amigos, estoy tratando de que el un pic (cualquiera) reciba datos de un teclado ps2,
he urgado bastante en google y me e cargado par de 16f84 (por descuidos tontos), pero bueno el asunto es que no soy capaz de que funcione, como se puede observar no he escrito yo el codigo.

La parte Rs232 funciona perfectamente, lo se porque al ordenador llega perfectamente el mensaje de bienida al conectar el teclado. Que seria un envio PIC->PC.

Miro el clock del reloj que deberia llegar del ps2 y va a 7,4khz, y data jamas cambia de estado.
Sabe alguien donde puedo conseguir ayuda o algunos ejemplos?

PD tambien tengo uno que en el proteus funciona pero no en la realidad, este esta en mikroC , un interesante programa. libstock. com/projects/ download/661/2014/1388650403_pc_keyboard_in_p_mikroc_pic. rar
[TIENEN QUE QUITAR LOS ESPACIOS]

Espero vuestra ayda y gracias por la atencion.

A continuacion el programa que mencione primero

Código:
//-----------------------------------------------------------------------------
// 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 "16F628.h"
#fuses HS,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP
#use Delay(Clock=16000000)
#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);

   //--------

   output_low(PIN_B5);

   //-------- 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("Rs232 ok");
 
}


//-----------------------------------------------------------------------------
// 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
         }
}
20/01/2014 #2

Avatar de Scooter

Revisa el conexionado, si has roto algún pic no debería de ser por problemas con el ptorgrama
20/01/2014 #3


El conexionado está recontra revisado, ya dije que la rotura de los pics fue producida por descuidos tontos ajenos a la obra.

A que frecuencia hay que poner el pic?
Existe alguna libreria standard?

Gracias un saludo
Respuesta
¿Tienes una mejor respuesta a este tema? ¿Quieres hacerle una pregunta a nuestra comunidad y sus expertos? Registrate

Buscar más temas sobre:
Lupa Diseño de circuitos en general

Alarmas, temporizadores, acondicionadores de señal...

Cerrar
Foros de Electrónica » Diseño analógico » Diseño de circuitos en general

Powered by vBulletin® Version 3.8.4
Copyright ©2000 - 2017, Jelsoft Enterprises Ltd.
Search Engine Optimization by vBSEO ©2011, Crawlability, Inc.