Autor Tema: Proyecto: Emulación Teclado PS/2 con PIC (Engañe a su PC y dele gato por liebre)  (Leído 70684 veces)

0 Usuarios y 1 Visitante están viendo este tema.

Desconectado camarohero

  • PIC10
  • *
  • Mensajes: 3
Emulación Teclado PS/2 con PIC (Engañe a su PC y dele gato por liebre)
« Respuesta #60 en: 20 de Julio de 2012, 13:49:56 »
Siento tener que revivir el tema, pero esto me viene como anillo al dedo y no lo encuentro en ningun otro lado
lo que necesito hacer es básicamente enviar un caracter por el puerto COM" de una PC y que lo reciba otra PC por el puerto PS/2 como si de un teclado se tratase
ya tengo el programa hecho, imprime correctamente en el puerto COM y con el hypertermina puedo ver los caracteres que envio, ahora falta la conversion a PS/2

Ya lei todo el post, agradezco a RedPic por compartirlo pero todas las fotos y diagramas estan caidos
Agradeceria eternamente cualquier actualizacion en la documentacion

Gracias y saludos de Juarez, Mexico
« Última modificación: 20 de Julio de 2012, 14:03:00 por camarohero »

Desconectado AcoranTf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1099
Precisamente eso me ocurrio hace unos dias que anduve intentando bajar el codigo, para un mini proyecto que estoy tratando de realizar y me vendria muy bien la rutina que envia los datos por PS2. Si no aparece tendre que hacerla desde cero, pero estaria muy bien aprovechar esata que ya esta hecha.

Saludos.

Desconectado Suky

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 6758
No contesto mensajes privados, las consultas en el foro

Desconectado AcoranTf

  • Colaborador
  • PIC24H
  • *****
  • Mensajes: 1099
Busquen por aquí: http://picmania.garcia-cuervo.net/proyectos.php


Saludos!

Gracias Suky, ya habia localizado esa rutina en el hilo original de nostrico. De todos modos lo que yo necesito es solo el secuenciador para el envio d elos codigos de scan, asi que tendre que "filtrarlo" y eliminar todo lo que no me va a hacer falta.

Saludos.

Desconectado camarohero

  • PIC10
  • *
  • Mensajes: 3
Código: [Seleccionar]
// Original de Nostrico del foro Todopic
// adaptado al 18f1320 por redpic
//

#include <18f1320.h>
#fuses HS,MCLR,NOWDT,NOPROTECT,NOPUT,NOBROWNOUT,NOLVP,NOCPD,NODEBUG,NOWRT
#use delay(OUT_CLOCK=20000000)
#use rs232(baud=9600, xmit=PIN_B1, rcv=PIN_B4)

#define CONTROL_A PIN_A0
#define CONTROL_B PIN_A1
#define CONTROL_C PIN_A2
#define CONTROL_INH PIN_A4

#define OUT_CLOCK PIN_B3
#define OUT_DATA PIN_B5

unsigned int8 rec_char;

unsigned char convert_ascci_to_scancode(unsigned char c){

  unsigned char scancode;

       if (c == 'a' || c == 'A') {scancode = 0x1c;}
  else if (c == 'b' || c == 'B') {scancode = 0x32;}
  else if (c == 'c' || c == 'C') {scancode = 0x21;}
  else if (c == 'd' || c == 'D') {scancode = 0x23;}
  else if (c == 'e' || c == 'E') {scancode = 0x24;}
  else if (c == 'f' || c == 'F') {scancode = 0x2b;}
  else if (c == 'g' || c == 'G') {scancode = 0x34;}
  else if (c == 'h' || c == 'H') {scancode = 0x33;}
  else if (c == 'i' || c == 'I') {scancode = 0x43;}
  else if (c == 'j' || c == 'J') {scancode = 0x3b;}
  else if (c == 'k' || c == 'K') {scancode = 0x42;}
  else if (c == 'l' || c == 'L') {scancode = 0x4b;}
  else if (c == 'm' || c == 'M') {scancode = 0x3a;}
  else if (c == 'n' || c == 'N') {scancode = 0x31;}
  else if (c == 'o' || c == 'O') {scancode = 0x44;}
  else if (c == 'p' || c == 'P') {scancode = 0x4d;}
  else if (c == 'q' || c == 'Q') {scancode = 0x15;}
  else if (c == 'r' || c == 'R') {scancode = 0x2d;}
  else if (c == 's' || c == 'S') {scancode = 0x1b;}
  else if (c == 't' || c == 't') {scancode = 0x2c;}
  else if (c == 'u' || c == 'U') {scancode = 0x3c;}
  else if (c == 'v' || c == 'V') {scancode = 0x2a;}
  else if (c == 'w' || c == 'W') {scancode = 0x1d;}
  else if (c == 'x' || c == 'X') {scancode = 0x22;}
  else if (c == 'y' || c == 'Y') {scancode = 0x35;}
  else if (c == 'z' || c == 'Z') {scancode = 0x1a;}

  else if (c == '0') {scancode = 0x45;}
  else if (c == '1') {scancode = 0x16;}
  else if (c == '2') {scancode = 0x1e;}
  else if (c == '3') {scancode = 0x26;}
  else if (c == '4') {scancode = 0x25;}
  else if (c == '5') {scancode = 0x2e;}
  else if (c == '6') {scancode = 0x36;}
  else if (c == '7') {scancode = 0x3d;}
  else if (c == '8') {scancode = 0x3e;}
  else if (c == '9') {scancode = 0x46;}

  else if (c == '/') {scancode = 0x5a;} // ENTER
  else if (c == ' ') {scancode = 0x29;} // ESPACIO
  else if (c == '>') {scancode = 0x0d;} // TABULADOR
  else if (c == '<') {scancode = 0x66;} // BORRADOR
  else if (c == '$') {scancode = 0x58;} // TAG DE MAYUSCULA $m$yuscula
  else if (c == '-') {scancode = 0x4a;} // -_

  else {scancode = 0x29;} // Cualquier otra cosa ESPACIO

  return scancode;
}


void output_scancode_ps2(unsigned char scancode){

  int contador;
  int salida, unos=1;
  boolean paridad=true;

  output_high(OUT_CLOCK); // START -------------------------------
  output_high(OUT_DATA);
  delay_us(40);

  output_high(OUT_CLOCK);
  output_low(OUT_DATA);
  delay_us(40);

  output_low(OUT_CLOCK);
  output_low(OUT_DATA);
  delay_us(40);

  salida =1;

  do{
    output_high(OUT_CLOCK);
    output_bit(OUT_DATA, scancode&0x01);
    delay_us(40);
    output_low(OUT_CLOCK);
    output_bit(OUT_DATA, scancode&0x01);
    delay_us(40);

    if ((scancode & 0x01) == 0x01) {unos++;}

    scancode = scancode>>1;
    salida++;

  }while(salida < 9);

  output_high(OUT_CLOCK); // PARITY ------------------------------
  output_bit(OUT_DATA, unos&0x01);
  delay_us(40);
  output_low(OUT_CLOCK);
  output_bit(OUT_DATA, unos&0x01);
  delay_us(40);

  output_high(OUT_CLOCK); // STOP --------------------------------
  output_high(OUT_DATA);
  delay_us(40);
  output_low(OUT_CLOCK);
  output_high(OUT_DATA);
  delay_us(40);

  output_high(OUT_CLOCK); // FIN ---------------------------------
  output_high(OUT_DATA);

  delay_ms(175);
}


void main(){

  delay_ms(300);
  printf("\r\nKBDEMUL with a 18F1320\r\nInject signal for PS/2\r\n\n");
  delay_ms(500);

  output_high(CONTROL_A); // Conmuta CD4053 a salida PIC->PC
  output_high(CONTROL_B);
  output_high(CONTROL_C);

  do{
    rec_char=getch();
    putc(rec_char;);
    output_scancode_ps2(convert_ascci_to_scancode(valor));
  }while(true);

}   
Por el momento no he podido programar un solo PIC :/
todo me falla no le encuentro el modo y ni siquiera se como empezar un proyecto en mplab con C porque no le entiendo nada al assembler
tengo mi picKit 3 sin hacer nada :( :( :(
entonces quisera convertir el codigo a arduino (ese si se deja)
pero no estoy seguro como traducir
Código: [Seleccionar]
rec_char = getch(); a lenguaje arduino
y
Código: [Seleccionar]
puct(rec_char;); como se haria?
tampoco se como podria hacer
Código: [Seleccionar]
output_bit(OUT_DATA, unos&0x01);especificamente que significa la rutina "unos&0x01"?? lo entiendo como una comparacion en pic? de la cantidad de "1's" en el scancode comparndo con "1"???
basicamente tengo esas dudas
buscare un tutorial en el foro sobre "programacion de un pic para dummies con pickit 3" jaja
gracias por sus respuestas

Desconectado camarohero

  • PIC10
  • *
  • Mensajes: 3
a todo aquel que le interese les comparto mi codigo en lenguaje arduino
extraje algunas partes del codigo de Redpic y de Nostrico AGRADEZCO SUS GANAS DE COOPERAR
ahora quiero que me ayuden con unas pequenas preguntas:
1.-que compilador usaron para los codigos posteados??
2.- como hacer que la computadora detecte en un inicio que tiene conectado un teclado en el puerto ps/2???
se ve muy facil y entendible, creo que por alli puedo empezar a usar PIC's (estrenar mi picKit 3 debbug express)
bueno sin mas rodeos aquiles baeza  :D

Código: [Seleccionar]
int clock = 10;
int data = 11;
char lectura;
byte peticion;
boolean bit_paridad = 0;
int delay_inicio = 20;
int delay_micro = 40;

void setup(){
  pinMode(clock, OUTPUT);
  digitalWrite(clock, HIGH);
  pinMode(data, OUTPUT);
  digitalWrite(data, HIGH);
  Serial.begin(9600);
}

void loop(){
  if(Serial.available()){
    lectura = Serial.read();
         if(lectura == 'A'){mayuscula(0x1c);}
    else if(lectura == 'B'){mayuscula(0x32);}
    else if(lectura == 'C'){mayuscula(0x21);}
    else if(lectura == 'D'){mayuscula(0x23);}
    else if(lectura == 'E'){mayuscula(0x24);}
    else if(lectura == 'F'){mayuscula(0x2b);}
    else if(lectura == 'G'){mayuscula(0x34);}
    else if(lectura == 'H'){mayuscula(0x33);}
    else if(lectura == 'I'){mayuscula(0x43);}
    else if(lectura == 'J'){mayuscula(0x3b);}
    else if(lectura == 'K'){mayuscula(0x42);}
    else if(lectura == 'L'){mayuscula(0x4b);}
    else if(lectura == 'M'){mayuscula(0x3a);}
    else if(lectura == 'N'){mayuscula(0x31);}
    else if(lectura == 'O'){mayuscula(0x44);}
    else if(lectura == 'P'){mayuscula(0x4d);}
    else if(lectura == 'Q'){mayuscula(0x15);}
    else if(lectura == 'R'){mayuscula(0x2d);}
    else if(lectura == 'S'){mayuscula(0x1b);}
    else if(lectura == 'T'){mayuscula(0x2c);}
    else if(lectura == 'U'){mayuscula(0x3c);}
    else if(lectura == 'V'){mayuscula(0x2a);}
    else if(lectura == 'W'){mayuscula(0x1d);}
    else if(lectura == 'X'){mayuscula(0x22);}
    else if(lectura == 'Y'){mayuscula(0x35);}
    else if(lectura == 'Z'){mayuscula(0x1a);}
    else if(lectura == 'a'){caracter(0x1c);}
    else if(lectura == 'b'){caracter(0x32);}
    else if(lectura == 'c'){caracter(0x21);}
    else if(lectura == 'd'){caracter(0x23);}
    else if(lectura == 'e'){caracter(0x24);}
    else if(lectura == 'f'){caracter(0x2b);}
    else if(lectura == 'g'){caracter(0x34);}
    else if(lectura == 'h'){caracter(0x33);}
    else if(lectura == 'i'){caracter(0x43);}
    else if(lectura == 'j'){caracter(0x3b);}
    else if(lectura == 'k'){caracter(0x42);}
    else if(lectura == 'l'){caracter(0x4b);}
    else if(lectura == 'm'){caracter(0x3a);}
    else if(lectura == 'n'){caracter(0x31);}
    else if(lectura == 'o'){caracter(0x44);}
    else if(lectura == 'p'){caracter(0x4d);}
    else if(lectura == 'q'){caracter(0x15);}
    else if(lectura == 'r'){caracter(0x2d);}
    else if(lectura == 's'){caracter(0x1b);}
    else if(lectura == 't'){caracter(0x2c);}
    else if(lectura == 'u'){caracter(0x3c);}
    else if(lectura == 'v'){caracter(0x2a);}
    else if(lectura == 'w'){caracter(0x1d);}
    else if(lectura == 'x'){caracter(0x22);}
    else if(lectura == 'y'){caracter(0x35);}
    else if(lectura == 'z'){caracter(0x1a);}
    else if(lectura == '0'){caracter(0x45);}
/*  else if(lectura == '1'){caracter(0x16);}
    else if(lectura == '2'){caracter(0x1e);}
    else if(lectura == '3'){caracter(0x26);}
    else if(lectura == '4'){caracter(0x25);}
    else if(lectura == '5'){caracter(0x2e);}
    else if(lectura == '6'){caracter(0x36);}
    else if(lectura == '7'){caracter(0x3d);}
    else if(lectura == '8'){caracter(0x3e);}
    else if(lectura == '9'){caracter(0x46);}    
    else if(lectura == '0'){caracter(0x45);}  */            //esto se usa en caso de querer pulsar las teclas de arriba,
    else if(lectura == '1'){caracter(0x69);}
    else if(lectura == '2'){caracter(0x72);}                 //estas otras para usar el num pad
    else if(lectura == '3'){caracter(0x7a);}
    else if(lectura == '4'){caracter(0x6b);}
    else if(lectura == '5'){caracter(0x73);}
    else if(lectura == '6'){caracter(0x74);}
    else if(lectura == '7'){caracter(0x6c);}
    else if(lectura == '8'){caracter(0x75);}
    else if(lectura == '9'){caracter(0x7d);}
    else if(lectura == '0'){caracter(0x70);}
    else if(lectura == ' '){mayuscula(0x29);}                          //Espacio!!
    else if(lectura == '>'){caracter(0x5a);}                           //Enter!!!!
    else if(lectura == '<'){caracter(0x66);}                           //Borrar!!!
    else if(lectura == '*'){ctrl();caracter(0x1c);F0();ctrl();}        //Seleccionar todo!!!
    else if(lectura == '+'){ctrl();caracter(0x76);F0();ctrl();}        //Ctrl + Esc (inicio)
    else if(lectura == '$'){caracter(0x0d);}                           //Tab!!!
    else if(lectura == '|'){alt();caracter(0x0c);F0();alt();}          //Cerrar!!!
    else if(lectura == '.'){caracter(0x49);}
    else if(lectura == ','){caracter(0x41);}
    else if(lectura == '@'){alt();caracter(0x1c);caracter(0x74);caracter(0x6b);F0();alt();}
    else if(lectura == '?'){alt();caracter(0x74);caracter(0x7a);F0();alt();}
  }
}

void mayuscula(byte peticion){
  shift();
  bit_paridad = HIGH;
  iniciar();
  for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    if(bitRead(peticion, contador) ==1){bit_paridad = !bit_paridad;}  
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
  
  finalizar();
  F0();
  shift();
  
  F0();
  bit_paridad = HIGH;
  iniciar();
  for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    if(bitRead(peticion, contador) ==1){bit_paridad = !bit_paridad;}  
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
  
  finalizar();

}

void caracter(byte peticion){
  bit_paridad = HIGH;
  iniciar();
  for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    if(bitRead(peticion, contador) ==1){bit_paridad = !bit_paridad;}  
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
  
  finalizar();
  
  F0();                                                                       //Se suelta la tecla
  bit_paridad = HIGH;
  iniciar();
  for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(peticion, contador));
    delayMicroseconds(delay_micro);
    if(bitRead(peticion, contador) ==1){bit_paridad = !bit_paridad;}  
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, bit_paridad);
  delayMicroseconds(delay_micro);
  
  finalizar();
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////Rutina de inicio///////////////////////////////////////////////////////////

void iniciar(){
  delay(delay_inicio);
  Serial.flush();
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);

  digitalWrite(clock, HIGH);
  digitalWrite(data, LOW);
  delayMicroseconds(delay_micro);

  digitalWrite(clock, LOW);
  digitalWrite(data, LOW);
  delayMicroseconds(delay_micro);

}

void finalizar(){
  digitalWrite(clock, HIGH); ////// STOP
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);  ////// FIN
  delay(delay_inicio);
}


void shift(){
  iniciar();
    for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(0x12, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(0x12, contador));
    delayMicroseconds(delay_micro);
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
  finalizar();
}

void F0(){
  iniciar();
    for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(0xf0, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(0xf0, contador));
    delayMicroseconds(delay_micro);
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
  finalizar();
}

void ctrl(){
  iniciar();
    for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(0x14, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(0x14, contador));
    delayMicroseconds(delay_micro);
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
  finalizar();
}


void alt(){
  iniciar();
    for(int contador = 0; contador <= 7; contador++){
    digitalWrite(clock, HIGH);
    digitalWrite(data, bitRead(0x11, contador));
    delayMicroseconds(delay_micro);
    
    digitalWrite(clock, LOW);
    digitalWrite(data, bitRead(0x11, contador));
    delayMicroseconds(delay_micro);
  }
  digitalWrite(clock, HIGH);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
    
  digitalWrite(clock, LOW);
  digitalWrite(data, HIGH);
  delayMicroseconds(delay_micro);
  finalizar();
}
« Última modificación: 01 de Agosto de 2012, 04:46:42 por camarohero »

Desconectado Suky

  • Moderadores
  • DsPIC33
  • *****
  • Mensajes: 6758
No contesto mensajes privados, las consultas en el foro

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5552
    • Picmania by Redraven
Listo. Gracias a la indicación del amigo pajaro todos mis posts en este hilo estaban rotos (cosas del cambio de dominio) y ya los he reparado. Si véis alguno que siga mal no dudéis en decírmelo.  :mrgreen:
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado cosmic

  • PIC16
  • ***
  • Mensajes: 175
Hola amigo Suky. ((:-))
Me gustaria saber como implementar las rutinas PS2 que subiste en este post, lo que requiero es enviar
dos letras A,B y C por el puerto PS2 desde un pic 873 sin usar un teclado de por medio..
Si tienes un ejemplo te lo agradezco.. :-/
Te dejo la imagen de mi circuito.

Desconectado aderregibus

  • PIC10
  • *
  • Mensajes: 1
Hola RedPic,

Primero que nada, felicitaciones por el proyecto.
En uno de los posts vi que el proyecto se convirtió en un producto comercial, y me interesaría saber si actualmente lo estás produciendo y vendiendo porque me interesa mucho.

Gracias.

Desconectado RedPic

  • Administrador
  • DsPIC33
  • *******
  • Mensajes: 5552
    • Picmania by Redraven
Hola aderregibus, muchas gracias por tu comentario.

Desgraciadamente este proyecto duró muy poco comercialmente ya que se realizó cuando los PC's abandonaban el PS/2 y venían exclusivamente con USB. De hecho solo se instalaron unas pocas unidades y ya hubo que pasarse a los diseños basados en los 18Fxx50. Además la empresa para la que se hicieron estos diseños ya no existe siquiera.  :?

Así que toma lo que desees de lo publicado en este foro a modo de experimento o proyecto pedagógico y haz con él lo que mejor te parezca.  :mrgreen:

Un saludo.
Contra la estupidez los propios dioses luchan en vano. Schiller
Mi Güeb : Picmania

Desconectado jnf

  • PIC10
  • *
  • Mensajes: 1
Estimados colegas, les comento que logre implementar exitosamente el codigo.
Tengo el problema de que en algunas maquinas puedo enviar sin problema los scan codes, y en otras no. Supongo que es por el problema de hacer la comunicacion bidireccional.

En mi caso, use un PIC16F628a, pero lamentablemente la entrada de interrupcion externa las estoy usando para leer pulsos de sensores, y dichos pulsos son enviados hacia la PC a traves de PS2.

Como dije anteriormente, funciona correctamente sin la comunicacion bidireccional, pero como hago para leer lo que envia el host si no tengo acceso a la interrupcion.

Muchos saludos!
1. CCS
2. http://www.todopic.com.ar/foros/index.php?topic=11910.msg252813#msg252813 (Probado en Win y Linux)

este es el mismo problema de las minas, alguna solución
« Última modificación: 07 de Abril de 2016, 22:36:49 por jnf »

Desconectado rod232

  • PIC10
  • *
  • Mensajes: 3
Re:Proyecto: Emulación Teclado PS/2 con PIC (Engañe a su PC y dele gato por liebre)
« Respuesta #72 en: 19 de Octubre de 2016, 19:36:28 »
Tengo el mismo problema, en la inicialización del teclado ps2, funciona si reinicio la pc con un teclado ps2, pero a la hora de reiniciarlo con la placa no me levanta...
He probado con el código que proporcionó suky, pero no funciona mi pic al iniciar la pc con el pic conectado a ella, les pego el código por si hay algún error en el cual no me fijé
Código: [Seleccionar]
#include <16F628A.h>     // Definiciones del PIC 16F628a
#fuses INTRC,NOWDT,NOPROTECT,NOLVP,PUT,BROWNOUT // Los Fuses de siempre
#use delay(internal=4000000) // Oscilador a 4 Mhz


#define T_CLOCK PIN_B2
#define T_DATA  PIN_B1
unsigned int8 valor;
char miletra;

/* ****************************************************************************************** */
void vEnvia_Byte(char Data){
char k=0,Unos=1;
 
   while(input(T_CLOCK)==0);
   output_high(T_CLOCK);
   output_high(T_DATA);
   output_drive(T_DATA);
   output_drive(T_CLOCK);
   /* ** Enviamos Bit Start ** */
   output_high(T_CLOCK);
   output_high(T_DATA);
   delay_us(40);
   output_low(T_DATA);
   delay_us(40);
   output_low(T_CLOCK); 
   delay_us(40);
   /* ** Enviamos 8 bits de datos ** */
   for(k=0;k<8;k++){
      output_high(T_CLOCK);
      delay_us(5);
      output_bit(T_DATA,Data & 0x01);
      delay_us(35);
      output_low(T_CLOCK);
      delay_us(40);
      if(bit_test(Data,0)==1){Unos++;}
      Data>>=1;   
   }
   /* ** Enviamos bit de paridad ** */
   output_high(T_CLOCK);
   delay_us(5);
   output_bit(T_DATA,Unos&0x01);
   delay_us(35);
   output_low(T_CLOCK);
   delay_us(40);
   /* ** Enviamos bit Stop ** */
   output_high(T_CLOCK);
   delay_us(5);
   output_high(T_DATA);
   delay_us(35);
   output_low(T_CLOCK);
   delay_us(40);
 
   output_float(T_CLOCK);
   output_float(T_DATA);
 
   delay_us(100);
}
/* ****************************************************************************************** */
char cLee_Byte(void){
char k;
char Data=0xEC;
 
   /* ** Condicion RTS ** */
   delay_us(100);
   if(input(T_DATA)==0){
      /* ** Esperamos a que el Host este listo para enviar datos ** */
      while(input(T_CLOCK)==0);
      output_high(T_CLOCK);
      output_drive(T_CLOCK);
      output_high(T_CLOCK);
      delay_us(200);
      output_low(T_CLOCK);
      if(input(T_DATA)==0){
         /* ** Se recibe los 8 bits de datos ** */
         for(k=0;k<8;k++){
            delay_us(40);
            output_high(T_CLOCK);
            delay_us(20);
            shift_right(&Data,1,input(T_DATA));
            delay_us(20);
            output_low(T_CLOCK);
         }
         /* ** Se ignora bit de paridad ** */
         delay_us(40);
         output_high(T_CLOCK);
         delay_us(40);
         output_low(T_CLOCK);
         /* ** Se testea bit Stop ** */
         delay_us(40);
         output_high(T_CLOCK);
         delay_us(20);
         if(input(T_DATA)==1){
         delay_us(15);
         /* ** Se envia Ack ** */
         output_drive(T_DATA);
         output_low(T_DATA);
         delay_us(5);
         output_low(T_CLOCK);
         delay_us(40);
         output_high(T_CLOCK);
         delay_us(10);
         }
      }
   }
   output_float(T_CLOCK);
   output_float(T_DATA);
   delay_us(100);
   return(Data);
}
/* ****************************************************************************************** */
#int_EXT
void Leer_Host(){
static char Dato_Host;
 
   Dato_Host=cLee_Byte();
   if(Dato_Host!=0xEC){
      if(Dato_Host==0xEE){
         vEnvia_Byte(0xEE);
      }else{
         vEnvia_Byte(0xFA);
         if(Dato_Host==0xF2){
            vEnvia_Byte(0xAB);
            vEnvia_Byte(0x83);
         }
         if(Dato_Host==0xFF){
            delay_ms(1);
            vEnvia_Byte(0xAA);
         }
      }
   }
}
/* ****************************************************************************************** */

void main()
{
   delay_ms(800);
   vEnvia_Byte(0xAA); 
   ext_int_edge(H_TO_L);
   clear_interrupt(INT_EXT);
   enable_interrupts(INT_EXT);
   enable_interrupts(GLOBAL);   
   do{
     
      vEnvia_Byte(0x44); //O
      delay_ms(100);
      vEnvia_Byte(0x4b); //L
      delay_ms(100);
      vEnvia_Byte(0x1c); //A
      delay_ms(100);
      vEnvia_Byte(0x29); //ESPACIO
      delay_ms(100);//
      vEnvia_Byte(0x42); //K
      delay_ms(100);//
      vEnvia_Byte(0x24); //E
      delay_ms(100);
      vEnvia_Byte(0x29); //ESPACIO
      delay_ms(100);//
      vEnvia_Byte(0x1c); //A
      delay_ms(100);//
      vEnvia_Byte(0x1b); //S
      delay_ms(100);//
      vEnvia_Byte(0x24); //E
      delay_ms(100);//
      vEnvia_Byte(0x29); //ESPACIO
      delay_ms(100);//
      vEnvia_Byte(0x29); //ESPACIO
      delay_ms(100);//
      vEnvia_Byte(0x29); //ESPACIO
      delay_ms(100);// 
      output_toggle(PIN_B3);
      delay_ms(500);
   }
   while(true);
}
Le coloqué un led piloto en el pin B3 para ver si funcionaba, como dije, solamente al conectar otro teclado ps2 cuando la pc inicia, al sacar el teclado y conectar el pic al puerto ps2 me escribe..si conecto el pic al puerto ps2 al iniciar la pc, no escribe nada...disculpen las molestias...
« Última modificación: 20 de Octubre de 2016, 13:32:05 por rod232 »

Desconectado germanmkurylo

  • PIC10
  • *
  • Mensajes: 1
buenas tardes
bueno este codigo funciona correctamente y esta echo en principio para cajas de musicas pero falta implementar el inicio con la pc lo cual me quede trancado asi que recurro a ustedes para terminarlo
la interrupcion externa esta sin escribir


//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
#include <16F628A.h>                       
#fuses INTRC_IO,NOWDT,NOPROTECT,NOLVP,NOBROWNOUT,NOMCLR,PUT     
#use delay(clock=4000000)                     

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                             Defino Variables                              *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
#zero_ram
unsigned char   cont_pulsos;                  // Contador de Pulsos Recibidos
unsigned char   pulsos_rx;                     // Contador de pulsos del Monedero
unsigned char   filtro_monedero;
unsigned long   tiempo_monedero;
unsigned long   filtro_10;
unsigned long   filtro_20;
unsigned long   filtro_30;
unsigned long   filtro_40;
unsigned long   filtro_50;
unsigned long   filtro_60;
unsigned long   filtro_70;
unsigned long   filtro_80;
unsigned long   filtro_90;
unsigned long   filtro_100;
unsigned long   filtro_200;
unsigned long   filtro_300;
unsigned long   filtro_400;
unsigned long   filtro_500;
unsigned long   filtro_600;
unsigned long   filtro_700;
unsigned long   filtro_800;
unsigned long   filtro_900;
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                              Defino Flags                                 *//
//*                                                                           *//
//*                                                                           *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
int1         busy_contador;                  // Indica que el Contador está en Operacion

int1         moneda_recibida;                  // Indica a Recepcion de una Moneda

int1         tiempo_10ms;

int1         monedero_st;

int1         bt_1;

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                                 Entrada                                   *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                                 Salidas                                   *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
#define OUT_CLOCK          PIN_B1               // Salida de Clock
#define OUT_DATA          PIN_A3               // Salida de Datos
#define inibidor_monedero   PIN_A2               // Inibidor monedero
                                                // 0-> Monedero Normal
                                                // 1-> Monedero trabado
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                              Interrupcion Externa                         *//
//*                                                                           *//
//*                                                                           *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
#INT_EXT
{
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                              Interrupcion Timer 1                          *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
#INT_TIMER1
void trata_int_timer1(void)
{
   tiempo_10ms = 1;

   set_timer1(65350);
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                           Configuracion de Fuses                          *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
void output_scancode_ps2(unsigned char scancode)
{
   int salida, unos=1;

   output_high(OUT_CLOCK);
   output_high(OUT_DATA);
   delay_us(10);

   output_high(OUT_CLOCK);
   output_low(OUT_DATA);
   delay_us(10);

   output_low(OUT_CLOCK);
   output_low(OUT_DATA);
   delay_us(10);

   salida = 1;

   do
   {
       output_high(OUT_CLOCK);
       output_bit(OUT_DATA, scancode&0x01);
       delay_us(10);
       output_low(OUT_CLOCK);
       output_bit(OUT_DATA, scancode&0x01);
       delay_us(10);

       if ((scancode & 0x01) == 0x01) {unos++;}

       scancode = scancode>>1;
       salida++;

   }while(salida < 9);

     output_high(OUT_CLOCK);
     output_bit(OUT_DATA, unos&0x01);
     delay_us(10);
     output_low(OUT_CLOCK);
     output_bit(OUT_DATA, unos&0x01);
     delay_us(10);

     output_high(OUT_CLOCK);
     output_high(OUT_DATA);
     delay_us(10);
     output_low(OUT_CLOCK);
     output_high(OUT_DATA);
     delay_us(10);

     output_high(OUT_CLOCK);
     output_high(OUT_DATA);

     delay_ms(5);
}

//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
//*                                   MAIN                                    *//
//* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *//
void main(void)
{
   unsigned int contador_veces;

   // ***** Inicializa IOS ***** //
      setup_comparator(NC_NC_NC_NC);

   output_a(0b00001100);                        // Mantiene portA en 0
   output_b(0b00000010);                        // Mantiene portB en 0

   // ***** Configura IOS ***** //
   // **** Bits-76543210*******//
   set_tris_a(0b11000011);                  // Configura PORTA
   set_tris_b(0b11110001);                  // Configura PORTB

   EXT_INT_EDGE(H_TO_L);

   SETUP_TIMER_1(T1_INTERNAL | T1_DIV_BY_8);
   set_timer1(64275);

   // ***** Configura INT *****//
//   enable_interrupts(INT_EXT);
   enable_interrupts(INT_TIMER1);
   enable_interrupts(GLOBAL);


   delay_ms(100);
   while(true)
   {
      if(tiempo_10ms == 1)
      {
         if(input(pin_b0) == 0)
         {
            if(monedero_st == 0)
            {
               filtro_monedero++;
               if(filtro_monedero >= 25)
               {
                  monedero_st = 1;
                  output_low(inibidor_monedero);
                  cont_pulsos++;
                  busy_contador = 1;
                  filtro_monedero = 0;
               }
            }
         }
         else
         {
            filtro_monedero = 0;
            monedero_st = 0;
            if(busy_contador == 1)
            {
               tiempo_monedero++;
               if(tiempo_monedero > 7500)
               {
               
                  pulsos_rx = cont_pulsos;
                  cont_pulsos = 0;
                  busy_contador = 0;
                  moneda_recibida = 1;
                  tiempo_monedero = 0;
                  if(moneda_recibida == 1)
                  {
                       for(contador_veces = 1; contador_veces < pulsos_rx; ++contador_veces)
                       {
                           output_low(pin_a4);
                           output_scancode_ps2(0x2D);
                           delay_ms(20);
                       }
                      moneda_recibida = 1;
                  }
                  output_high(inibidor_monedero);
                  delay_ms(2500);
               }
            }
            else
            {
               tiempo_monedero = 0;
            }
         }
         output_low(pin_b2);
         output_high(pin_b3);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_b4) == 0)
         {
            filtro_10++;
            if(filtro_10 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x03);
                  delay_ms(20);
               filtro_10 = 0;
            }   
         }
         else
         {
            filtro_10 = 0;
         }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_b6) == 0)
         {
            filtro_30++;
            if(filtro_30 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x31);
                  delay_ms(20);
               filtro_30 = 0;
            }   
         }
         else
         {
            filtro_30 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_b7) == 0)
         {
            filtro_40++;
            if(filtro_40 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x3A);
                  delay_ms(20);
               filtro_40 = 0;
            }   
         }
         else
         {
            filtro_40 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a6) == 0)
         {
            filtro_50++;
            if(filtro_50 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x33);
                  delay_ms(20);
               filtro_50 = 0;
            }   
         }
         else
         {
            filtro_50 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a7) == 0)
         {
            filtro_60++;
            if(filtro_60 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x3b);
                  delay_ms(20);
               filtro_60 = 0;
            }   
         }
         else
         {
            filtro_60 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a0) == 0)
         {
            filtro_70++;
            if(filtro_70 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x35);
                  delay_ms(20);
               filtro_70 = 0;
            }   
         }
         else
         {
            filtro_70 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a1) == 0)
         {
            filtro_80++;
            if(filtro_80 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x25);
                  delay_ms(20);
               filtro_80 = 0;
            }   
         }
         else
         {
            filtro_80 = 0;
         }

         output_high(pin_b2);
         output_low(pin_b3);

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_b5) == 0)
         {
            filtro_100++;
            if(filtro_100 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x32);
                  delay_ms(20);
               filtro_100 = 0;
            }   
         }
         else
         {
            filtro_100 = 0;
         }

/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_b7) == 0)
         {
            filtro_400++;
            if(filtro_400 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x34);
                  delay_ms(20);
               filtro_400 = 0;
            }   
         }
         else
         {
            filtro_400 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a6) == 0)
         {
            filtro_500++;
            if(filtro_500 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x2b);
                  delay_ms(20);
               filtro_500 = 0;
            }   
         }
         else
         {
            filtro_500 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a7) == 0)
         {
            filtro_600++;
            if(filtro_600 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x2a);
                  delay_ms(20);
               filtro_600 = 0;
            }   
         }
         else
         {
            filtro_600 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a0) == 0)
         {
            filtro_700++;
            if(filtro_700 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x2c);
                  delay_ms(20);
               filtro_700 = 0;
            }   
         }
         else
         {
            filtro_700 = 0;
         }
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
         if(input(pin_a1) == 0)
         {
            filtro_800++;
            if(filtro_800 >= 200)
            {         
               output_low(pin_a4);
                 output_scancode_ps2(0x25);
                  delay_ms(20);
               filtro_800 = 0;
            }   
         }
         else
         {
            filtro_800 = 0;
         }
         tiempo_10ms = 0;
      }

   }



}


 

anything