Archivo de la categoría: Didáctica

Algunas notas sobre programación del robot didáctico programable

En esta publicación: Robot Programable: Diagrama Básico en Bloques prometo, al final, que voy a continuar con los detalles de circuito y de programación. En la entrada: El microcontrolador “cerebro” del robot programable (básico) hay mucho de circuito (hardware), ya que el artículo contiene una descripción bastante detallada de las secciones del chip microcontrolador que utilizamos por ahora, y también detalles de configuración y uso del chip que tienen una enorme relación con la programación.

Concretamente, que algo he cumplido de la promesa.

Los artículos hasta ahora venían más o menos sincronizados con el avance de las clases, pero para esta fecha obviamente estamos en receso de verano y no hay actividad, ni la habría aunque me lo propusiera, ya que por suerte los chicos asisten a una colonia de verano. A mí tampoco el calor me favorece mucho para mover las neuronas, por eso estuve dedicando algunos artículos a la mecánica, a la búsqueda de soluciones para abaratar la construcción de la base mecánica del robot.

De eso aún falta, me quedan algunas cosas por solucionar, y me dedico casi diariamente al tema. Ya les contaré.

El robot programableRobot programable

Pero hay un programa básico ya escrito con el que hemos trabajado en clase, haciendo mover al robot. Este programa (escrito en assembler, o ASM) permite ordenar una secuencia de movimientos al robot. El programa tiene tres niveles: 1) las instrucciones básicas para mover los motores en el lenguaje del microcontrolador (son las mismas para toda la familia PIC16F, y se podrían utilizar en todos los modelos disponibles, si bien nuestro chip elegido es el PIC16F876A), 2) la inclusión posterior de las instrucciones básicas dentro de subrutinas a las que se puede llamar programando con palabras en castellano en lugar de con los mnemónicos de la programación ASM, lo cual facilita la comprensión, y finalmente 3) la conversión de estas subrutinas en macros.




Utilizando macros se programa directamente con la palabra que hemos definido para el comando; ni siquiera hace falta utilizar la instrucción CALL de ASM que se necesita para hacer correr una subrutina.

Voy a explicar poco a poco la programación, en todos los pasos.

Primero que nada: la configuración inicial del chip

Recordemos primero el diagrama en bloques, ya que hay que definir las funciones de las patas del chip teniendo en cuenta este circuito.

Diagrama básico en bloquesDiagrama en bloques
Veamos las instrucciones ASM en la parte de configuración:


        list P = 16F876a       ; indica el modelo de microprocesador a usar
        include "P16f876a.inc" ; provee declaraciones necesarias para el chip

        ERRORLEVEL 1;-302      ; para evitar los mensajes de cambio de
                               ; banco en el resultado del compilador

        ; Declaraciones que definen el funcionamiento básico del chip
        __config  _CP_OFF & _XT_OSC & _WDT_OFF & _PWRTE_ON & _LVP_OFF & _BODEN_OFF

        CBLOCK 0x20            ; Declarar las variables
          d1 ; usada en Retardos
          d2 ; usada en Retardos
          d3 ; usada en Retardos
        ENDC
;
; -----------
; INICIALIZAR
; -----------
        org 0x0000              ; Indica la dirección de origen del programa
        clrf STATUS             ; limpia el registro de estado
        movlw 0x00              ; valor cero 00
        movwf PCLATH            ; al contador de programa = comienzo 
        goto Comienzo           ; Salto a comienzo
;
Comienzo
; BANCO
        bcf STATUS,RP0          ; Prepara
        bcf STATUS,RP1          ; RAM Página 0, en pág 0 están los registros
                                ; de salida de los puertos
; ------------------------------------
; PUERTOS
        movlw 0x00      
        movwf PORTA             ; Inicializar valores del PORT A
        movlw 0x00
        movwf PORTB             ; Inicializar valores del PORT B
        movlw 0x80
        movwf PORTC             ; Inicializar valores del PORT C 
; ------------------------------------
; BANCO
        bsf STATUS,RP0          ; RAM Page 1, en pág 1 están los registros
                                ; de configuración de los puertos y
                                ; otros módulos del microcontrolador
; ---------------------------------------------------------------
; FUNCION DE LAS PATAS DE LOS PORTS
; ---------------------------------------------------------------
        movlw b'00000000'
        movwf TRISA             ; Todas las patas port A como salidas
        movlw b'00000000'
        movwf TRISB             ; Todas las patas port B como salidas
        movlw b'10111111'
        movwf TRISC             ; Todas las patas port C como entradas excepto RC6/TX
        movlw 0x06              ; Todas las patas del puerto entrada/salida digital
        movwf ADCON1            ; esto es necesario para el buen funcionamiento
                                ; de los puertos que tienen 
                                ; opciones analógicas (convertidor A/D)
;
; -----------------------------------------------------------
; BANCO
        bcf STATUS,RP0          ; Página RAM 0, la operación normal se realiza
                                ; en la página 0 de RAM
; -----------------------------------------------------------

 

Es conveniente que vayamos explicando las líneas de instrucciones por partes:


; -----------------------------------------------------------
        list P = 16F876a       ; indica el modelo de microprocesador a usar
        include "P16f876a.inc" ; provee declaraciones necesarias para el chip
; -----------------------------------------------------------

La indicación list P es muy directa, con ella se le dice al programa de compilación que vamos a trabajar en un programa para el PIC16F876A.

La indicación include incluye en el programa, en el momento de compilarlo, todo el texto que se encuentra dentro del archivo que se indica a continuación P16f876a.inc. En estos archivos (provistos por el fabricante) se definen nombres en letras para todas las partes del microcontrolador, que de otro modo deberían estar indicadas en el programa con números hexadecimales. Esta práctica evita el trabajo de estar memorizando o buscando en una tabla estos números, y facilita la comprensión al leer el programa, y permite un fácil intercambio de programas (migración) entre diferentes microprocesadores.

Por ejemplo, dentro de P16f876a.inc define así al puerto A: PORTA EQU H’0005′. Podríamos cambiar la declaración dentro de este archivo y llamar al puerto con un nombre en español, por ejemplo: PuertoA EQU H’0005′. Luego podríamos programar utilizando este nombre y funcionaría correctamente.


; -----------------------------------------------------------
        ERRORLEVEL 1;-302      ; para evitar los mensajes de cambio de
                               ; banco en el resultado del compilador
; -----------------------------------------------------------

Esta línea no es imprescindible y se utiliza para evitar molestas indicaciones de aviso cuando se cambia de banco de RAM en el programa. Las indicaciones no son necesarias si en el programa hemos realizado correctamente los cambios de banco.



; -----------------------------------------------------------
        ; Declaraciones que definen el funcionamiento básico del chip
        __config  _CP_OFF & _XT_OSC & _WDT_OFF & _PWRTE_ON & _LVP_OFF & _BODEN_OFF
; -----------------------------------------------------------

Los microcontroladores poseen una serie de configuraciones que se fijan por única vez al principio de la operación y definen ciertas partes esenciales de su funcionamiento. En el ejemplo:

_CP_OFF (Code Protection) define que no protegeremos el código de ser leído desde la memoria de programa del chip. Es posible definir _CP_ON cuando ya tenemos un programa totalmente probado en un equipo que vamos a entregar y no deseamos que alguien se lo copie leyéndolo desde la memoria de programa del microcontrolador.

_XT_OSC define el modo de oscilador de reloj del chip. En este caso, la opción _XT_OSC indica que se utilizará un cristal o resonador conectado al chip para definir la frecuencia de trabajo.

_WDT_OFF está relacionado con la función de “Despertador” (“Watchdog timer” en inglés) que se utiliza en aquellos casos en que se desea que el microcontrolador sea “despertado” de posibles estados en que haya quedado detenido, sea porque quedó esperando una señal de activación externa o porque falló su programa o porque se lo puso intencionalmente en ese estado por programa. El watchdog timer (WDT) puede producir un reinicio del microcontrolador PIC cada cierto período de tiempo, y recomenzar la ejecución del programa. Esto es para evitar que el dispositivo entre en un lazo infinito (se “cuelgue”), o se quede en una espera muy prolongada por un determinado evento que no ocurre. Durante la operación normal, el watchdog timer (en español “perro guardián” o “despertador”) genera un reinicio del microcontrolador PIC después del final de su período WDT. También cumple la función de sacar al dispositivo del modo Sleep (“Dormir”). En este caso el watchdog timer ocasiona que se despierte el microcontrolador PIC y continúe con la operación normal (sin producir reinicio), lo que se conoce como despertar WDT. No lo utilizamos en este programa en particular, de modo que fijamos _WDT_OFF, o sea, Watchdog Timer apagado.

_PWRTE_ON (Power-up Timer) Habilita un temporizador que se dispara en el encendido y permite que, durante su espera, se estabilicen todos los circuitos antes de comenzar a correr el programa.

_LVP_OFF define el modo en que se puede programar el chip. Esta definición en OFF determina que no se puede programar el chip utilizando un sistema de programación de bajo voltaje. Los programadores de PICs utilizan un voltaje de 12 volts en la pata MCLR del chip para poder escribir en su memoria de programa. Al definir el estado OFF de esta configuración se previene una programación accidental (que modificaría el programa y dejaría no operativo al microcontrolador) con los voltajes estándar de funcionamiento en sus patas.

_BODEN_OFF El bit BODEN (Brown Out Reset) en la configuración define la activación o no de una detención del microcontrolador por un descenso de voltaje de alimentación. Puede ser útil, pero no lo utilizamos en este diseño, por eso lo definimos en OFF.


; -----------------------------------------------------------
        CBLOCK 0x20            ; Declarar las variables
          d1 ; usada en Retardos
          d2 ; usada en Retardos
          d3 ; usada en Retardos
        ENDC
; -----------------------------------------------------------

En este bloque se declaran las variables que necesitaremos utilizar (y se reservan sus espacios en la memoria RAM). Por defecto, las variables son bytes (8 bits).



; -----------------------------------------------------------
; INICIALIZAR
; -----------
        org 0x0000              ; Indica la dirección de origen del programa
        clrf STATUS             ; limpia el registro de estado
        movlw 0x00              ; valor cero 00
        movwf PCLATH            ; al contador de programa = comienzo 
        goto Comienzo           ; Salto a comienzo
;
Comienzo
; BANCO
        bcf STATUS,RP0          ; Prepara
        bcf STATUS,RP1          ; RAM Página 0, en pág 0 están los registros
                                ; de salida de los puertos
; ------------------------------------
; PUERTOS
        movlw 0x00      
        movwf PORTA             ; Inicializar valores del PORT A
        movlw 0x00
        movwf PORTB             ; Inicializar valores del PORT B
        movlw 0x80
        movwf PORTC             ; Inicializar valores del PORT C 
; ------------------------------------
; BANCO
        bsf STATUS,RP0          ; RAM Page 1, en pág 1 están los registros
                                ; de configuración de los puertos y
                                ; otros módulos del microcontrolador
; ---------------------------------------------------------------
; FUNCION DE LAS PATAS DE LOS PORTS
; ---------------------------------------------------------------
        movlw b'00000000'
        movwf TRISA             ; Todas las patas port A como salidas
        movlw b'00000000'
        movwf TRISB             ; Todas las patas port B como salidas
        movlw b'10111111'
        movwf TRISC             ; Todas las patas port C como entradas excepto RC6/TX
        movlw 0x06              ; Todas las patas del puerto entrada/salida digital
        movwf ADCON1            ; esto es necesario para el buen funcionamiento
                                ; de los puertos que tienen 
                                ; opciones analógicas (convertidor A/D)
;
; -----------------------------------------------------------
; BANCO
        bcf STATUS,RP0          ; Página RAM 0, la operación normal se realiza
                                ; en la página 0 de RAM
; -----------------------------------------------------------

Las líneas de inicialización en este bloque están ampliamente explicadas con comentarios. En la última parte, debo aclarar que los registros TRIS son los que definen si una pata de entrada/salida es una entrada o una salida. Hay un registro TRIS para cada puerto: TRISA, TRISB y TRISC. Un 0 las define como salidas, un 1 las define como entradas. Por último, los microcontroladores con puertos cuyas patas se pueden definir como entradas al módulo Convertidor Analógico Digital (Analog/Digital Converter, o ADC, en inglés) tienen un registro de configuración en el que se debe definir si se utilizarán o no esas patas como entradas analógicas. Esto lo define el registro ADCON1 y el valor a definir para utilizar todas las patas como entrada/salida digital (tal como las utilizaremos por el momento) es 0x06 (hexadecimal 06).

Esencial: La parte del programa en sí

Observando el diagrama en bloques del robot programable, y con una lectura al artículo de apoyo sobre el chip de manejo de motores, podemos determinar que uno de los motores, el derecho, se maneja a través de dos patas del puerto A, RA0 y RA1, y el otro (izquierdo) a través de las patas RA2 y RA3 del puerto A.

La tabla de señales de control para los motores es como sigue:

     MOTOR DERECHO     
|
       MOTOR IZQUIERDO       
    RA0     RA1     ACCIÓN | RA2 RA3 ACCIÓN
    1     0     AVANCE | 0 1 AVANCE
    0     1     RETROCESO | 1 0 RETROCESO
    0     0     DETENIDO | 0 0 DETENIDO
    1     1     DETENIDO | 1 1 DETENIDO


Por lo tanto, las instrucciones de manejo de los motores se pueden definir del siguiente modo:

;------------
; SUBRUTINAS
;------------

DerechoAdelante
        bsf PORTA,0        ; PORTA 0 = 1 - Motor derecho ad.
        bcf PORTA,1        ; PORTA 1 = 0 - Motor derecho ad.
return
;-------------------------------------

DerechoAtras
        bcf PORTA,0        ; PORTA 0 = 0 = Motor derecho atr.
        bsf PORTA,1        ; PORTA 1 = 1 = Motor derecho atr. 
return
;-------------------------------------

DerechoDetenido
        bcf PORTA,0        ; PORTA 0 = 0 = Motor derecho det.
        bcf PORTA,1        ; PORTA 1 = 0 = Motor derecho det.
return
;-------------------------------------

IzquierdoAdelante
        bcf PORTA,2        ; PORTA 2 = 0 = Motor izquierdo ad.
        bsf PORTA,3        ; PORTA 3 = 1 = Motor izquierdo ad.
return
;-------------------------------------

IzquierdoAtras
        bsf PORTA,2        ; PORTA 2 = 1 = Motor izquierdo atr.
        bcf PORTA,3        ; PORTA 3 = 0 = Motor izquierdo atr.
return
;-------------------------------------

IzquierdoDetenido
        bcf PORTA,2        ; PORTA 2 = 0 = Motor izquierdo det.
        bcf PORTA,3        ; PORTA 3 = 0 = Motor izquierdo det.
return
; -----------------------------------------------------------

Para realizar un movimiento necesitamos definir tiempos, y para eso, para empezar, podemos utilizar un simple rutina de “pérdida de tiempo” (el microcontrolador se queda “perdiendo tiempo” dentro de esta subrutina, y no hace ninguna otra cosa). La rutina la calculé utilizando los servicios del sitio Delay Code Generator donde se puede crear un código de retardo para PICs definiendo algunos parámetros (en el futuro usaremos un módulo TIMER del microcontrolador, pero cada cosa a su tiempo).

La rutina de pérdida de tiempo es:

;------------
Retardo1seg
        movlw d'0'
; Frecuencia de reloj = 4 MHz
; Retardo real = 1 segundo = 1000000 ciclos
; Error = 0 %
                ;999997 ciclos
        movlw        d'8'        ; 0x08
        movwf        d1
        movlw        d'47'        ; 0x2F
        movwf        d2
        movlw        d'3'        ; 0x03
        movwf        d3
Retardo_01
        decfsz        d1, f
        goto        $+2
        decfsz        d2, f
        goto        $+2
        decfsz        d3, f
        goto        Retardo_01
                ; 3 ciclos más
        goto        $+1
        nop
        return
; -----------------------------------------------------------

Veamos entonces cómo es un programa que utilice estas subrutinas para ordenar al robot un movimiento en L.

; -----------------------------------------------------------
Principal
        call DerechoAdelante
        call IzquierdoAdelante
;
        call Retardo1seg
;
        call DerechoAdelante
        call IzquierdoDetenido
;
        call Retardo1seg
;
        call DerechoAdelante
        call IzquierdoAdelante
;
        call Retardo1seg
;
        call DerechoDetenido
        call IzquierdoDetenido
;
; las siguientes llamadas al retardo son para que el robot 
; se detenga unos segundos antes de moverse nuevamente en 'L'
; y repetir esta secuencia constantemente...
        call Retardo1seg 
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
;
        goto Principal

; -----------------------------------------------------------

El programa completo en ASM con el método de llamado a subrutinas es el que sigue. Más abajo encontrarán un enlace para bajarse el archivo en formato TXT con el programa completo en ASM listo para compilar. En el próximo artículo presentaré la conversión del programa al método de programación con MACROS y una serie de ejemplos de programas con distintas rutinas de movimiento.

;************************************************************************
; Procesador: PIC16F876 con Xtal 4 MHz
; Función: Manejo del robot programable
; Hardware: Protoboard
; Archivo: 01
; Autor: Eduardo J. Carletti 
; Fecha: 21 septiembre 2014
;
; Historia: El robot avanza formando una L   
;    
;*************************************************************************

        list P = 16F876a
        include "P16f876a.inc"

        ERRORLEVEL 1;-302        ; para evitar los mensajes de cambio de
                                ; banco en el resultado del compilador

        __config  _CP_OFF & _XT_OSC & _WDT_OFF & _PWRTE_ON & _LVP_OFF & _BODEN_OFF

        CBLOCK 0x20        ; Declarar las variables
          d1 ; usada en Retardo1seg
          d2 ; usada en Retardo1seg
          d3 ; usada en Retardo1seg
        ENDC
;
; -----------
; INICIALIZAR
; -----------
;
        org 0x0000                ; Indica la dirección de origen del programa
        clrf STATUS                ; limpia el registro de estado
        movlw 0x00                ; valor cero 00
        movwf PCLATH                ; al contador de programa = comienzo 
        goto Comienzo                ; Salto a comienzo
        org 0x0004                
;
Comienzo
; BANCO
        bcf STATUS,RP0
        bcf STATUS,RP1                  ; RAM Página 0
; ------------------------------------
        movlw 0x00      
        movwf PORTA                ; Inicializar PORT A
        movlw 0x00
        movwf PORTB                ; Inicializar PORT B
        movlw 0x80
        movwf PORTC                ; Inicializar PORT C 
;
; ------------------------------------
; BANCO
        bsf STATUS,RP0                ; RAM Page 1
; ---------------------------------------------------------------
; FUNCION DE LAS PATAS DE LOS PORTS
; ---------------------------------------------------------------
;
        movlw 0x00
        movwf TRISA                ; Todas las patas port A salida
        movlw 0x00
        movwf TRISB                ; Todas las patas port B salida
        movlw b'10000000'
        movwf TRISC                ; Todas las patas port C salida excepto RC7/RX

        movlw 0x06                ; Todas las patas entrada/salida digital
        movwf ADCON1
;
; -----------------------------------------------------------
; BANCO
        bcf STATUS,RP0        ; Página RAM 0
; -----------------------------------------------------------
; -----------------------------------------------------------
; PRINCIPAL
; -----------------------------------------------------------

Principal
        call DerechoAdelante
        call IzquierdoAdelante
;
        call Retardo1seg
;
        call DerechoAdelante
        call IzquierdoDetenido
;
        call Retardo1seg
;
        call DerechoAdelante
        call IzquierdoAdelante
;
        call Retardo1seg
;
        call DerechoDetenido
        call IzquierdoDetenido
;
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
        call Retardo1seg
;
        goto Principal
;
;-------------------------------------
; SUBRUTINAS
;-------------------------------------

DerechoAdelante
        bsf PORTA,0        ; PORTA 0 = 1 - Motor derecho ad.
        bcf PORTA,1        ; PORTA 1 = 0 - Motor derecho ad.
return
;-------------------------------------

DerechoAtras
        bcf PORTA,0        ; PORTA 0 = 0 = Motor derecho atr.
        bsf PORTA,1        ; PORTA 1 = 1 = Motor derecho atr. 
return
;-------------------------------------

DerechoDetenido
        bcf PORTA,0        ; PORTA 0 = 0 = Motor derecho det.
        bcf PORTA,1        ; PORTA 1 = 0 = Motor derecho det.
return
;-------------------------------------

IzquierdoAdelante
        bcf PORTA,2        ; PORTA 2 = 0 = Motor izquierdo ad.
        bsf PORTA,3        ; PORTA 3 = 1 = Motor izquierdo ad.
return
;-------------------------------------

IzquierdoAtras
        bsf PORTA,2        ; PORTA 2 = 1 = Motor izquierdo atr.
        bcf PORTA,3        ; PORTA 3 = 0 = Motor izquierdo atr.
return
;-------------------------------------

IzquierdoDetenido
        bcf PORTA,2        ; PORTA 2 = 0 = Motor izquierdo det.
        bcf PORTA,3        ; PORTA 3 = 0 = Motor izquierdo det.
return
;-------------------------------------

Retardo1seg
        movlw d'0'
; Frecuencia de reloj = 4 MHz
; Retardo real = 1 seconds = 1000000 cycles
; Error = 0 %
                ;999997 cycles
        movlw        d'8'        ; 0x08
        movwf        d1
        movlw        d'47'        ; 0x2F
        movwf        d2
        movlw        d'3'        ; 0x03
        movwf        d3
Retardo_01
        decfsz        d1, f
        goto        $+2
        decfsz        d2, f
        goto        $+2
        decfsz        d3, f
        goto        Retardo_01
                ; 3 ciclos más
        goto        $+1
        nop
        return

; ----------------------------

        END

El archivo ASM se puede bajar de AQUÍ.

Base robótica

Construir un robot sobre un chassis comprado, que ya tiene los elementos necesarios, es mucho más fácil que crear su mecánica: se necesita habilidad de manipuleo, las herramientas correctas y precisión en el trabajo

Si queremos crearlo a partir de materiales de desarme, ya es otra cosa. Un robot necesita una base donde montar la estructura. La plataforma en sí no es un gran problema, se puede recortar de partes de cajas de monitores, impresoras, frentes de PCs, bandejas de CR-ROM, chassis y tapas de discos rígidos, etc. No necesita tener tantas perforaciones y ranuras como tienen las plataformas comerciales. Agujereamos según las necesidades.

La imagen lo ilustraChassis comprado

El problema cuando se busca obtener todos los materiales desde la recuperación de elementos de equipos descartados son las otras tres partes: dos motores con reducción, sus ruedas y una rueda de giro libre, o rueda loca.


En la serie de artículos de los últimos tiempos estuve tratando sobre la recuperación de motores con reducción que puedan adaptarse a un robot didáctico. Quien los haya leído, se habrá dado cuenta de que no es tan fácil como parece, ya que la mecánica de las unidades de CD-ROM, de discos rígidos y de disketteras suele ser muy variada. Cuesta mucho conseguir los pares para cada robot. Deben ser idénticos en lo mecánico y también eléctricamente, aunque compensar las diferencias en la parte eléctrica es más fácil.

Los artículos hasta ahora fueron:

Así que los próximos movimientos deben estar orientados a conseguir ruedas que se adapten a los mecanismos de motor y engranaje que he rescatado de unidades de CR-ROM. No deberían ser compradas (aunque sí pueden provenir de donaciones), o entramos a la situación de crear un robot que no esté formado de partes rescatadas; y este es el programa propuesto.

Otro elemento a lograr es la rueda libre, o rueda loca. El tercer punto de apoyo del robot. Luego vienen los portapilas, y finalmente la electrónica. Son los temas que iré tratando en unas pequeñas notas que seguirán. Hay diversas opciones, pero la elegida no debe hacernos muy esclavos en tiempo de trabajo: las horas-hombre tienen valor cuando no se tiene un mecenas que te mantenga.

Ejemplo de rueda loca compradaRueda loca

Próximamente, un elemento que por simple no se aleja de ser crítico: Ruedas para el robot didáctico.

Ejemplo de base y rueda loca caserasBase y rueda loca caseras






Donaciones para los robots desde Marcos Paz

Nuevas donaciones para desarme y para construir robots de mi plan Robots Didácticos Sociales. Como verán, algunas muy específicas e interesantes. Gracias, Susi, Leonel, Andrea

Conjunto de donaciones recibidasConjunto donaciones
Donaciones

Donaciones para los robots desde Marcos Paz: un auto a control remoto; sin el transmisor del control, aunque igual debe valer mucho dineroAuto de carrera

Donaciones para los robots desde Marcos Paz: este tipo de ruedas, con cubiertas blandas neumáticas, son excelentes para la marcha y agarre de un robot y tienen importantes precios en el mercadoRuedas






Sensores reflectivos QTR para siguelíneas

¿Quién dice que la electrónica no es linda? Este lo que se ve en la imagen de abajo es un sensor por reflexión a utilizar en un robot sigue-líneas avanzado, para que pueda seguir líneas a alta velocidad…

Sensor QTR-8RCSensor QTR-8RC

Por ahora el robot didáctico utilizará con unos sensores más básicos que se llaman CNY70, porque el primer paso en el aprendizaje es hacer que los chicos entiendan bien el concepto. ¡Pero después vamos a hacer el robot que VUELE sobre las pistas!

Ejemplo:

Sensor CNY70Sensor CNY70

Estos son sensores individuales para robots siguelíneas de la misma familia, cada uno equivalente al CNY70. El tamaño del sensor en sí es mucho más pequeño; en este caso, están montados sobre un módulo que ya contiene la electrónica necesaria para adaptar y conectar el sensor al microcontrolador.

Sensores QTR-1RCSensores QTR-1RC

Sensor QTR-1RC Escala del sensor comparada con un fósforo

Los pequeños rectangulitos negros son un conjunto de emisor de infrarrojo y receptor, que emiten un haz contra el suelo y detectan el brillo (o capacidad reflectiva) que tiene éste. Utilizando esta medición y los algoritmos correspondientes en el programa de manejo, el robot puede desplazarse con precisión sobre una línea trazada en el suelo. Los sensores vienen en pares porque va uno de cada lado de la línea guía a seguir.

Sensores QTR-8RC

El sensor para siguelíneas de alta velocidad, en lugar de tener dos sensores (uno a cada lado de la línea) lleva una hilera de 8 (cuatro a cada lado). Esto permite que el robot siga la línea a gran velocidad y con un andar de regulación sobre la línea menos abrupto que cuando trabaja con dos únicos sensores.

Sensor QTR-8RCQTR-8RC

Sensor QTR-8RC / escala con un fósforoQTR-8RC comparado con fósforo

El resistor es para cambiar si se quiere una salida analógica o una salida de pulso (midiendo la longitud del pulso se sabe cuánto está reflejando el sensor, en el caso de que la salida sea analógica, hay que utilizar un convertidor A/D = analógico a digital).


La medición de longitud de pulsos es una opción recomendable, ya que se puede hacer por software o utilizando módulos internos del microcontrolador que son específicos para medir longitud de pulsos. Por esta razón los LEDs no están alimentados todo el tiempo; existe una línea que permite que el funcionamiento del sensor sea pulsado en lugar de poseer una alimentación constante. En la configuración con salida analógica, los LEDs podrían estar alimentados siempre (aunque esto produce un consumo mayor de energía de las baterías). Cuando el circuito está basado en pulsos RC, el funcionamiento debe ser sí o sí pulsado, para que la carga y descarga del capacitor a través del resistor produzca el pulso proporcional a la calidad del reflejo en el objeto inferior, la banda colocada sobre el piso que debe seguir el siguelíneas. No se obtendrían pulsos con una alimentación constante.

DetallesQTR-(RC
QTR-(RC

El conjunto de 8 sensores tiene una marca a lo largo de la cual es posible cortar sin dañar el circuito, lo que lo convierte en un conjunto de 6 sensores por un lado, y uno de dos por el otro.

Sensor QTR-8RCQTR-8RC

CircuitoCircuito

El sensor se instala en el frente del robot, como se observa en las fotografías que siguen con diversos modelos de robots. Obsérvese la escala, teniendo en cuenta que el sensor de reflexión QTR tiene sólo 7 cm de longitud y 12,5 mm de ancho.

Robots con sensores QTR-8RCRobot 1
Robot 2
Robot 3
Robot 4

Para más detalles se pueden leer los datos de los fabricantes.






Robot Programable: Diagrama Básico en Bloques

El robot programable de nuestras clases posee un microcontrolador PIC16F876A como centro de control, un integrado L293D de manejo de potencia para los motores y circuitos auxiliares.

En el momento de introducir la programación al robot se inserta un módulo de comunicación USB/USART que convierte las señales de nivel USB que salen de la PC al nivel TTL utilizado en el microcontrolador.

Diagrama básico en bloquesDiagrama en bloques

La comunicación se establece entre un programa de carga de datos en la PC y el módulo de comunicaciones serie del microcontrolador (USART o Universal Serial Asynchronous Receiver / Transmiter = Receptor / Transmisor Asincrónico Serie Universal), que es controlado en el microcontrolador por un pequeño programa de carga de datos llamado “bootloader“, o cargador inicial.

Este programa se ocupa de tomar los datos que componen nuestro programa a través del puerto serie del microcontrolador (USART), y grabarlos en la memoria de programa. Describiré con más detalles este proceso en el próximo artículo.

En este caso, el microcontrolador PIC16F876A trabaja a una velocidad de reloj de 4 MHz (puede hacerlo hasta 20 MHz). Esto lo determina un cristal conectado a sus patas de oscilador. El cristal, como es habitual, tiene dos capacitores auxiliares en su circuito. Para los observadores, en la imagen que sigue verán otro chip (el que maneja la corriente de los motores), un regulador de voltaje, capacitores y resistores auxiliares, una llave de encendido (de color negro), una llave de reinicio (de color rojo), y hacia la parte baja de la imagen un conjunto de pequeñas llaves deslizantes (llamado DIP switch, también de color rojo y con las llavecitas en blanco) que utilizo para ingresar indicaciones al microcontrolador. Estos indicadores se pueden comprobar en el programa a través de unas entradas y seguir, según su posición, diferentes acciones. En un principio, con las primeras 6 llavecitas se eligen partes del programa que realizan diferentes secuencias de movimiento.

En las imágenes que siguen se puede observar el montaje del robot a nivel de prueba (con plaqueta base de prototipo, o protoboard), primero con la conexión USB-USART inserta, luego el robot libre (tal como funciona al ponerlo en marcha), y el mismo montaje visto de abajo.Robot con cable
Robot sin cable
Robot de abajo


Esta imagen muestra de cerca la parte de circuito de control.

Detalle del área del controlÁrea de control

En la imagen de abajo se observa un detalle del área del microcontrolador, el cristal con sus capacitores, y la llave que se utiliza para reiniciar (reset) al momento de programar o de reponer el funcionamiento del robot a sus condiciones iniciales.

Detalle del área del microcontroladorÁrea del microcontrolador

El microcontrolador maneja los motores derecho e izquierdo utilizando un amplificador de potencia L293D. Las señales de control son 4, dos para cada uno de los motores, y permiten seleccionar tres estados: marcha adelante, marcha atrás y detención.

Detalle del L293D y su conexión con el microcontrolador.Área del control de motores

El arranque de los motores puede generar bajones de tensión en los 6V que aportan 4 pilas recargables tamaño AA de 1,5V. Por eso entre las pilas y la alimentación del microcontrolador se insertó un regulador de voltaje LM2940CT-5.0 que lleva los 6V a 5V, y que tiene a su salida un capacitor electrolítico de alto valor que ayuda, con su carga, a mantener estable el voltaje de la parte de control en los momentos en que los motores producen bajones de tensión al arrancar. La parte de los motores se alimenta directamente con 6V, en la etapa previa a la regulación.

En la imagen, un detalle de la parte de regulación de voltaje.Área de regulación de voltaje

El microcontrolador recibe su programación a través de dos señales, RX, o recepción, y TX, o transmisión. Esto configura la comunicación serie entre el microcontrolador del robot y el programa en la PC que envía los datos a programar.

Detalle de la conexión entre el módulo adaptador entre el puerto USB de la PC y el puerto USART del microcontrolador.Área de interconexión con la PC

El módulo tiene 4 contactos enchufables, y se desenchufa para operar el robot dejándolo moverse libremente.

Se observan en el circuito unos pequeños capacitores azules de 0,1 uF, llamados capacitores de desacople, que sirven para filtrar los ruidos de alta frecuencia producidos por las chispas de las escobillas de los motores, que podrían interferir con el funcionamiento del microcontrolador.

La imagen señala la posición de estos capacitores.Capacitores de filtro

Aquí se observan una cantidad de módulos comerciales de adaptación
del puerto USB de la PC al puerto USART de un microcontrolador.
Módulos

Continuaré con más detalles de circuito y de programación en los próximos artículos.