miércoles, 22 de agosto de 2012

MAnejo de Protocolo de Control Remoto IR Infrarrojo JVC analizador lógico

http://www.jmnlab.com/receptorir/receptorir.html

Receptor IR.               





Buscando programas en el pc he encontrado uno de los primeros que hice para un pic en ensamblador para parte de un robot que nunca llegó a andar.

Una forma sencilla y barata de controlar un robot o circuito a distancia es usar un mando infrarrojo, como puede ser el de la televisión, cadena etc.. de los muchos que hay por casa. Barato porque sólo necesitaremos un receptor y una resistencia que conectar al microcontrolador, es decir entre uno y dos euros. Como receptor he utilizado un TSOP1738, que se encarga de demodular la señal enviada por el mando y nos la da en una línea en serie. Tiene 3 patas, dos de alimentación y la salida, en la que debemos colocar una resistencia de pull-up y conectarla al microcontrolador. Su montaje es el siguiente:

Circuito TSOP1738



Cada fabricante suele usar sus propios protocolos, por lo que primero tenemos que saber que es lo que buscamos en esa salida que nos proporciona el TSOP.  Para esto yo he usado un analizador lógico de  pc, que nos permite ver los unos y ceros que tienen lugar durante un tiempo, su precio está sobre los 150, 200 euros y nos será útil a la hora de trabajar con microcontroladores para comprobar su correcto funcionamiento. Es recomendable hacerse con uno que su soft tenga un analizador de protocolos. El que yo uso de 8 canales lo compre por unos 180 euros (lo más barato que encontre en su día) .

Analizador lógico.


Para ver los datos que recibimos del mando conectamos un canal del analizador lógico a la salida del TSOP, y procedemos a  pulsar botones. En este caso se está usando un mando de JVC y al pulsar un botón nos manda lo siguiente.

Mando JVC


Esa señal es la que sale del mando cuando pulsamos un botón. Como se puede ver la señal comienza cuando baja la línea, con un pulso de 8.4 ms seguido de uno de 4.2 ms, esto sólo se realiza una vez para indicar que se ha pulsado el botón y diferenciar de cuando se mantiene pulsado, la señal se repite cada 50 ms esta vez sin el pulso de inicio de 8 y 4 ms. Para diferenciar entre 1 y 0 se mide el tiempo que pasa entre dos flancos de bajada, 1 ms corresponde a un 0 y 2.1 ms a un 1, en este ejemplo se mandan 16 bits (8 de dirección y 8 de dato según el protocolo de JVC).  En este caso tenemos 11000101 (197) y 01111000 (120).

Por cada botón nuestro micro va a recibir dos bytes, el primer byte es de dirección, dice para que componente del equipo receptor es el segundo byte que sale del mando, por lo que en el mando nos encontraremos con unos cuántos botones que mandan el mismo primer byte. En este caso en el mando sólo había dos bytes de dirección, es decir todos los botones mandaban uno u otro.

Una vez que sabemos lo que sale del mando tenemos que capturarlo, interpretarlo y usarlo.

Para capturarlo se puede hacer de varias maneras, usando algún periférico del micro para protocolos serie, o en mi caso de la forma larga mediante una interrupción activada por el flanco de bajada de la línea del TSOP y contando tiempos entre flancos de bajada. La ventaja de programar en ensamblador es que en todo momento sabemos lo que está haciendo el microcontrolador y podemos tener un control del tiempo exacto.

Cada instrucción de nuestro programa en ensamblador del microcontrolador tarda una cantidad de ciclos de reloj en ejecutarse, el reloj es el cristal que conectamos externo que puede ser de varios KHz, MHz, o un oscilador interno propio del microcontrolador del orden de KHz a MHz.

Por ejemplo si tenemos el siguiente código para pic:

***************************************************
***************************************************
    org 0
    goto Start
    org 5
Start
    bsf STATUS,RP0        ; select Register Page 1
    bcf TRISC,0                ; make IO Pin C.0 an output
    bcf STATUS,RP0        ; back to Register Page 0
MainLoop

    bcf PORTC,0              ; turn on LED C0
    bsf PORTC,0              ; Turn off LED C0
    goto MainLoop            ; Do it again...
    end

***************************************************
***************************************************

Nuestro programa hace lo que tenemos dentro del  Mainloop de forma repetida, es decir haríamos 3 instrucciones en bucle: 
"bcf PORTC,0" y " bsf PORTC,0" instrucciones de 4 ciclos de reloj, y "goto MainLoop"  instrucción de 8 ciclos de reloj. Es decir cada iteracción del bucle serían 4+4+8 = 16 ciclos de reloj.

Si colocamos el osciloscopio en el puerto C0 tendremos una señal cuyo período es función del valor del oscilador. Por ejemplo si nuestro oscilado funciona a 16 MHz, en el port c tendremos una señal de 16 MHz/ 16 ciclos de reloj, es decir 1 MHz. Nuestro bucle de 3 instrucciones se realizaría en 1 microsegundo.

Cristal de 16 MHz


Primero se realiza la instrucción que pone a cero el pin C0, 0.25 uS a cero la salida. Después ponemos el pin del puerto a 1 0.25 uS y luego con este pin a 1 volvemos a la primera instrucción, esto tarda 0.5 uS, por lo que nos encontramos con una señal con un duty del 75%.

Si por ejemplo utilizamos el oscilador interno del pic a 4 MHz, tendríamos la siguiente salida:

Oscilador 4 MHz


La frecuencia de la señal es 4 MHz / 16 ciclos de reloj = 250 Khz, es decir el bucle de 3 instrucciones se realizaría en 1/250KHz = 4 microsegundos. Luego la primera instrucción tarda 1 uS, la siguiente otro uS y el goto 2 uS, en todal los 4 uS.

De esta forma podemos calcular lo que tarda en realizarse un trozo de código de nuestro programa, que usaremos para capturar los unos y los ceros mandados por el TSOP17.

Nuestro código para capturar la señal salta mediante una interrupción en RB0, cuando se detecta un flanco de bajada en este puerto salta nuestra interrupción y pasamos a ejecutar su código (repito que hay formas más adecuadas de hacerlo), por lo que tenemos que medir el tiempo que pasa entre flancos de bajada para saber si nos llega un uno y un cero, y esto lo hacemos incrementado un contador cada 0.1 ms en un registro del pic, para ello debemos conocer cuánto tarda en ejecutarse cada instrucción.

Si entre dos flancos de bajada nuestro contador vale menos de un valor mínimo o más de uno máximo nos salimos de la interrupción con una condición de error, ya que ningún valor de 1 o 0 se corresponde con estos tiempos, estamos ante un ruido. Si vale más de 0.8 ms estamos ante un 0, y si vale más de 1.7 ms ante un uno. De esta forma capturamos los 1 y 0 y los almacenamos en dos registros del pic.

Una vez que tenemos un montón de unos y ceros debemos de saber que hacer con ellos. Si queremos que nuestro circuito realice una función con cada botón, sólo debemos comparar el valor de cada registro con un valor en otro registro perteneciente a ese botón, y ejecutar cierta acción cuando los registros sean iguales.

En este caso lo que se ha hecho es convertir esos registros en binario a decimal, y sacar este valor convertido por un LCD para comprobar que el valor leído es el mismo que el visto en el analizador lógico, y de esta forma comprobar que nuestro programa funciona. Sobre el tema del LCD pongo un link en español de ionitron donde explica bien el tema http://www.x-robotics.com/rutinas.htm#LCD. Se podía haber sacado en unos y ceros sin convertir a decimal, pero un valor decimal siempre es más fácil de identificar que 16 unos y ceros seguidos.

En el analizador lógico teníamos el 197 y el 120 (tecla + del mando) recibidos por el TSOP1738, se puede ver como esos unos y ceros son capturados, convertidos a decimal y llevados al LCD.

Foto conjunto.



El circuito del pic es un circuito de pruebas con un 16F877A orientado hacía robótica, se puede ver un L298 y algunos componentes más. A la izquierda el receptor de infrarrojos y abajo el LCD con los valores recibidos por el receptor.

Agrego todo el programa al final, fue uno de los primero que hice en ensamblador para probar las interrupciones y tiempos del pic, todos los botones vistos en el analizador lógico se corresponden con los leídos en el LCD, así que supongo que funciona. De todas formas para implementar esto lo mejor es usar un periférico del microcontrolador para tal fin.

Video de funcionamiento. El color azul del led indica que recibe dato.


Para cualquier duda, comentario, corrección etc...

Gracias por pasar por aquí. Saludos.





Código Pic.

;    Designed to run at 20MHz
    list p=16F877a
    #include p16F877a.inc


    __CONFIG _CP_OFF & _WDT_OFF & _HS_OSC & _LVP_OFF & _BODEN_OFF

;******************************* DEFINICIONES***************************************************

#DEFINE LED1 PORTA,3 ;Rojo
#DEFINE LED2 PORTA,5 ;Azul
#DEFINE LED3 PORTC,5 ;Verde
#DEFINE PULSADOR2 PORTA,1
#DEFINE DATO0 PORTD,0
#DEFINE DATO1 PORTD,1
#DEFINE DATO2 PORTD,2
#DEFINE DATO3 PORTD,3
#DEFINE DATO4 PORTD,4
#DEFINE DATO5 PORTD,5
#DEFINE DATO6 PORTD,6
#DEFINE DATO7 PORTD,7
#DEFINE ENABLE PORTE,2
#DEFINE RS PORTE,0
#DEFINE W_R PORTE,1
#DEFINE LCD_DATOS PORTD
#DEFINE LCD_CTRL PORTE
#DEFINE IR PORTB,0
#DEFINE PIN_PRUEBA PORTA,0
#DEFINE PIN_PRUEBA2 PORTA,2
#DEFINE PIN_PRUEBA3 PORTC,0

;****************************** REGISTROS RAM ***************************************************

    cblock 0x20
Delay0                    ; Assign an address to label Delay1
Delay1
Delay2
Delay3
DELAY4
DELAY5   
W_TEMP
STATUS_TEMP
CUENTA
UNIDADES
DECENAS
CENTENAS
DATO1IR
DATO2IR
TICTAC
INT_CONTROL   
INT_CONTROL_OLD   
CONTADOR1       

    endc

;**************************** POSICIONES *********************************************************

    ORG 0                ; Posición de memoria donde se coloca la instrucción.
    GOTO Start            ; Salto a Start, se ejecutará la instrucción debajo de Start.
   
    ORG 4
    GOTO ISR

    ORG 5                ; Salta el vector de interrupción

;***************************** CONFIGURAR REGISTROS ************************************************

Start                    ; Inicio del programa
   
;        ****************** BANCO 0 **************************************************************
    BCF STATUS, RP0    
    BCF STATUS, RP1     ; Seleciona el Bank0

    CLRF PORTA             ; Initialize poerts by clearing output                   
    CLRF PORTB            ; data latches
    CLRF PORTC
    CLRF PORTD
    CLRF PORTE

    MOVLW B'10010000'
    MOVWF INTCON        ;GIE e INTE, bit 1 flag de INTE


;        ******************** BANCO 1 **************************************************************

    BSF    STATUS,RP0        ; select Register Page 1

    BCF OPTION_REG,INTEDG    ;Flanco de bajada

    MOVLW B'00000000'    ;Interruptores son entradas
    MOVWF TRISA       
    MOVLW B'00000001'
    MOVWF TRISB
    CLRF TRISC
    CLRF TRISD
    CLRF TRISE

    MOVLW 0X06            ;Configurar los pin de A
    MOVWF ADCON1        ;como entradas digitales.

    BCF STATUS, RP0        ;Bank0


;************************ INICIO PROGRAMA ****************************************************************
           
    BSF LED2            ;Parpadeo de Reset
    CALL Delay_2
    BCF LED2

    CALL INICIALIZA_LCD
    MOVLW B'00000001'    ;Clear Display
    CALL LCD_COMANDO
    MOVLW B'00000110'    ;Entry mode set
    CALL LCD_COMANDO
    MOVLW B'00001110'    ;Activa lcd y cursor
    CALL LCD_COMANDO

    BCF PIN_PRUEBA2
    BCF PIN_PRUEBA


;************************** PROGRAMA PRINCIPAL ********************************************************   

MAIN_LOOP
    BSF LED1
    CALL Delay_2
    BCF LED1
    CALL Delay_2

    GOTO MAIN_LOOP

;*************************** INTERRUPCIONES*************************************************************

ISR

    MOVWF W_TEMP            ;Salva W y Status
    SWAPF STATUS,0
    MOVWF STATUS_TEMP
    BSF LED2
    BCF LED1
    BCF LED3
    CLRF TICTAC
    CLRF DATO1IR
    CLRF DATO2IR
    CLRF CONTADOR1
    CLRF INT_CONTROL        ;bit 7 entrada IR, bit 3 y 4 cambio de byte y salida, bit 0:2 contador
    CLRF INT_CONTROL_OLD
    BCF PIN_PRUEBA
    BCF PIN_PRUEBA2
    BCF PIN_PRUEBA3


ISR_LOOP


;            ********* Se mira el pin de entrada, si no cambia se va a SUBIR_TIC ************************


    BTFSS IR                ;Si es cero se ejecuta la siguiente,PORTB,0 ;0.2
    GOTO PONER_A_CERO                                                    ;---->0.6
    BSF INT_CONTROL,7                                                    ;0.6
    GOTO COMP_ENTRADA                                                    ;---->1
PONER_A_CERO                                                            ;<----0.6
    NOP                                                                    ;0.8
    BCF INT_CONTROL,7                                                    ;1
COMP_ENTRADA                                                            ;<----1
    MOVFW INT_CONTROL_OLD                                                ;1.2
    XORWF INT_CONTROL,W        ;Si son iguales Z=1                            ;1.4
    BTFSS STATUS,Z            ;Si es 0 se ejecuta la siguiente            ;1.6                                   
    GOTO COMPARAR_TIC                                                    ;--->2

;************************** Incrementar el TIC **********************************************************

    NOP                                                                                 ;2
    NOP                                                                                 ;2.2
    NOP                                                                                 ;2.4
    NOP                                                                                 ;2.6

SUBIR_TIC                                                                                ;<--2.6
    NOP                                                                                    ;2.8
    MOVLW D'140'            ;1 Tics = 0.1 mS                                            ;3
    SUBWF TICTAC,W                                                                        ;3.2
    BTFSC STATUS,C            ;Si TICTAC-W mayor que 0, ejecuta la siguiente                ;3.6
    GOTO  ERROR_IR                                                                        ;
    INCF TICTAC,F                                                                        ;3.8

                                                                                ;
    MOVLW D'158'                                                                        ;4
    MOVWF DELAY5                                                                        ;4.2
Delay_5loop                                                                                ;3*0.2*158=94.8
    DECFSZ DELAY5,f                                                                        ;
    GOTO Delay_5loop                                                                    ;
    MOVFW INT_CONTROL                                                                    ;99.2                                                           
    MOVWF INT_CONTROL_OLD                                                                ;99.4
    NOP                                                                                    ;99.6
    GOTO ISR_LOOP                                                                        ;100                                                                           
   


;          ********* El pin de entrada a cambiado, en función de los tics damos 1 o 0 *****************
;          ********* TIC menos 0.8 mS error, mayor de 0.8 mS escribir cero, mayor 1.7 mS escribir uno *
;           **********   Si es el flanco de subida no comparamos ***************************************

COMPARAR_TIC                                                                           
    BTFSC IR                                                                                               
    GOTO SUBIR_TIC                                                                       
   
                                                                       
    MOVLW D'26'                ;1 Tics = 0.1 mS                                       
    SUBWF TICTAC,W                                                                       
    BTFSC STATUS,C            ;Si TICTAC-W mayor que 0, ejecuta la siguiente           
    GOTO COMPARAR_SALIDA         
                                                   
    MOVLW D'17'                ;1 Tics = 0.1 mS                                   
    SUBWF TICTAC,W                                                               
    BTFSC STATUS,C            ;Si TICTAC-W mayor que 0, ejecuta la siguiente   
    GOTO ALMACENAR_UNO                                                       
                                                                           
    MOVLW D'8'                ;1 Tics = 0.1 mS                               
    SUBWF TICTAC,W                                                           
    BTFSC STATUS,C            ;Si TICTAC-W mayor que 0, ejecuta la siguiente   
    GOTO ALMACENAR_CERO                                                           
                                                                           

   
ERROR_IR                                                                                                                                                                                                                               
    BCF LED2                                                                           
    GOTO POP                                                   

COMPARAR_SALIDA
    MOVFW INT_CONTROL                                                                                                                           
    MOVWF INT_CONTROL_OLD                                                               
    CLRF TICTAC                                                                                                                                               
    GOTO ISR_LOOP
                                                                       
   
                                                                       
                                                                                                                                                                                                                                                                                                                                                   
ALMACENAR_CERO                                                                           
    BTFSC INT_CONTROL,3    ;Si el bit 3 es uno se ejecuta la siguiente, vale 8 o mas.   
    GOTO ALMACENAR_DATO2                                                               
    BCF STATUS,C
    RLF DATO1IR,F                                                                                                                                               
    GOTO ALMACENAR_SALIDA                                                               
ALMACENAR_DATO2   
    BCF STATUS,C                                                                   
    RLF DATO2IR,F                                                                                                                                       
    GOTO ALMACENAR_SALIDA                                                               
                                                                                       
ALMACENAR_UNO                                                                           
    BTFSC INT_CONTROL,3    ;Si el bit 3 es uno se ejecuta la siguiente, vale 8 o mas.   
    GOTO ALMACENAR_DATO2_1   
    BCF STATUS,C                                                           
    RLF DATO1IR,F                                                                       
    INCF DATO1IR,F                                                                                                                                       
    GOTO ALMACENAR_SALIDA                                                               
ALMACENAR_DATO2_1   
    BCF STATUS,C                                                                   
    RLF DATO2IR,F                                                                       
    INCF DATO2IR,F                                                                                                                                       
    GOTO ALMACENAR_SALIDA                                                               
                                                                                       

ALMACENAR_SALIDA                                                                       
    INCF INT_CONTROL,F   
    BTFSC INT_CONTROL,4    ;Si el bit 4 es uno se ejecuta la siguiente, vale 16 o mas.   
    GOTO DATOS_A_LCD                                                                                                                                   
    GOTO COMPARAR_SALIDA                                                               
   

DATOS_A_LCD
   

    MOVLW B'10000000'   
    CALL LCD_COMANDO

    MOVFW DATO1IR
    CALL BINARIO_LCD
    MOVFW CENTENAS
    CALL LCD_ESCRIBIR
    MOVFW DECENAS
    CALL LCD_ESCRIBIR
    MOVFW UNIDADES
    CALL LCD_ESCRIBIR
   
    MOVLW B'11000000'
    CALL LCD_COMANDO

    MOVFW DATO2IR
    CALL BINARIO_LCD
    MOVFW CENTENAS
    CALL LCD_ESCRIBIR
    MOVFW DECENAS
    CALL LCD_ESCRIBIR
    MOVFW UNIDADES
    CALL LCD_ESCRIBIR


POP
    SWAPF STATUS_TEMP,0
    MOVWF STATUS
    MOVFW W_TEMP
    BCF INTCON,INTF
    BCF LED2
    RETFIE

;********************************** LCD ****************************************************************

INICIALIZA_LCD
    CALL Delay
    CLRF LCD_CTRL
    MOVLW B'00111000'    ;8 bits, 2 líneas y 5x8 puntos
    MOVWF LCD_DATOS
    CALL LCD_E
    CALL Delay
    RETURN

LCD_E
    BSF ENABLE
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    NOP
    BCF ENABLE
    RETURN

LCD_COMANDO   
    CLRF LCD_CTRL
    MOVWF LCD_DATOS
    CALL LCD_E
    CALL Delay   
    RETURN

LCD_ESCRIBIR
    CLRF LCD_CTRL
    BSF RS
    MOVWF LCD_DATOS
    CALL LCD_E
    CALL Delay
    RETURN

;********************************** BINARIO A LCD *****************************************************

BINARIO_LCD            ;Para registros de 8 bits, convierte a centenas, decenas y unidades.

    MOVWF CUENTA
    CLRF UNIDADES
    CLRF DECENAS
    CLRF CENTENAS

CENT_LOOP
    MOVLW D'100'
    SUBWF CUENTA,W
    BTFSS STATUS,C
    GOTO DEC_LOOP
    INCF CENTENAS,F
    MOVWF CUENTA
    GOTO CENT_LOOP
DEC_LOOP
    MOVLW D'10'
    SUBWF CUENTA,W
    BTFSS STATUS,C
    GOTO UNIDAD
    INCF DECENAS,F
    MOVWF CUENTA
    GOTO DEC_LOOP
UNIDAD
    MOVF CUENTA,W
    MOVWF UNIDADES

    MOVLW B'00110000'
    ADDWF CENTENAS,1
    ADDWF DECENAS,1
    ADDWF UNIDADES,1

    RETURN

;********************************** DELAYS *************************************************************

Delay                    ;20 mS   
    MOVLW D'65'
    MOVWF Delay1
Delay_loop
    decfsz    Delay0,f    ; Waste time. 
    goto    Delay_loop    ; The Inner loop takes 3 instructions per loop * 256 loopss = 768 instructions
    decfsz    Delay1,f    ; The outer loop takes and additional 3 instructions per lap * 256 loops
    goto    Delay_loop    ; (768+3) * 256 = 197376 instructions / 1M instructions per second = 0.197 sec.
                        ; call it a two-tenths of a second.
    RETURN

Delay_2                    ;0.86 s
    MOVLW D'22'
    MOVWF Delay2
Delay_2loop
    decfsz    Delay0,f    ; Waste time. 
    goto    Delay_2loop    ; The Inner loop takes 3 instructions per loop * 256 loopss = 768 instructions
    decfsz    Delay1,f    ; The outer loop takes and additional 3 instructions per lap * 256 loops
    goto    Delay_2loop    ; (768+3) * 256 = 197376 instructions / 1M instructions per second = 0.197 sec.
                        ; call it a two-tenths of a second.
    decfsz     Delay2,f
    goto     Delay_2loop
    return

Delay_3                ;50.2 uS
    MOVLW D'82'
    MOVWF Delay3
Delay_3loop
    DECFSZ Delay3,f
    GOTO Delay_3loop
    RETURN

    end





No hay comentarios:

Publicar un comentario