programación

Dic

2014

Paso 7. Montando los bigotes

Última actualizacón: 16 noviembre 2017 a las 17:00

Muchas máquinas robotizadas dependen de una variedad de interruptores táctiles para, por ejemplo, contar objetos en una línea de producción o alinearlos durante los procesos industriales. En estos casos los interruptores ofrecen una entrada de datos que ordenan otro tipo de salida programada de datos.

En el paso anterior enseñamos a andar al robot, pero lo hacía a ciegas ya que si tropezaba con un obstáculo allí se quedaba. Ahora vamos a colocarle unos sensores que le avisen de la presencia de obstáculos en su camino, además de indicarle si dicho obstáculo se encuentra a la derecha o a la izquierda. Con esa información podremos indicarle que realice un movimiento de desvío que lo evite y así pueda proseguir hacia su objetivo.

Para ello vamos a emplear dos bumpers, nombre técnico con el que se conoce a ciertos interruptores que cierran sus contactos cuando se presiona uno de ellos. En nuestro caso, los bumpers están conformados por dos alambres de acero y tienen el aspecto de bigotes o antenas. Los llamaremos bigotes porque sirven para detectar objetos como lo hacen los bigotes de un gato. En este paso los utilizaremos solos, pero pueden ser combinados con otros sensores como veremos más adelante.

Montando los bigotes

Antes de grabar un programa para que robot se mueva en función de lo que encuentra en su camino, necesitamos montarlos y probarlos primero. Vamos a utilizar los siguientes materiales:

Dos alambres de acero.
Dos tornillos de cabeza plana de 3×15 mm.
Dos separadores metálicos de 3×10 mm.
Dos arandelas de baquelita de 3 mm.
Dos conectores de tres pines.
Dos resistencias de 220 Ω.
Dos resistencias de 10 Ω.

Material para el montaje de los bigotes.

Primero debemos quitar los tornillos que unen la tarjeta Home Work con los dos separadores frontales. Colocamos un separador y una arandela de baquelita en cada uno de los tornillos.

Retirar el tornillo.

Colocamos el separador y la arandela.

Colocamos los tornillos sobre los agujeros de la tarjeta y atornillamos a los separadores que hay debajo, pero no debemos apretarlos completamente todavía. Enganchamos los bigotes a los tornillos y colocamos uno por encima de una de las arandelas y el otro por debajo, de tal forma que no se toquen entre sí.

Insertamos los bigotes.

Ahora podemos terminar de apretar los tornillos y colocar los conectores de tres pines:

Resultado.

Colocamos los conectores de tres pines.

Prueba de funcionamiento

Ahora vamos a construir el circuito eléctrico de los bigotes para añadirlo a los circuitos de zumbador y los servos que montamos en el paso anterior:

Diagrama de circuito para el montaje de los bigotes.

Cada bigote es una extensión mecánica de un interruptor normalmente abierto que tiene un extremo conectado a tierra. La razón de que los bigotes estén conectados a tierra (Vss) es que los agujeros en los bordes exteriores de la tarjeta están conectados a tierra. Los separadores y tornillos metálicos conectan la señal de tierra con los bigotes.

Podemos programar el módulo del microcontrolador para que detecte cuándo se presiona un bigote. Los pines o patitas de E/S conectados a cada interruptor están configurados como entradas y reciben un voltaje. Cuando los bigotes no se presionan, el voltaje que reciben es de 5 V (1 lógico). Pero si son presionados, el circuito se cierra con tierra y los pines reciben 0 V (0 lógico).

Colocamos las conexiones y resistencias como hemos visto en el diagrama anterior y ya podemos pasar a crear el programa de control:

Montaje del circuito.

Resultado final.

Programa de prueba

Este programa está diseñado para que se puedan probar los bigotes y asegurar que funcionan correctamente. Lo que hace es mostrar el estado lógico de las entradas que corresponden a los pines P7 y P5 conectados a los bigotes (IN7 e IN5).

Todos los pines de E/S son de entrada por defecto, a menos que se programe lo contrario. Por lo tanto, los pines conectados a los bigotes tendrán un “1” si el voltaje que reciben es de 5 V (cuando el bigote no está presionado), o un “0” si lo que reciben es 0 V (cuando el bigote está presionado). Vamos a utilizar el debug terminal para mostrar esos valores:

‘ Programa de prueba. pruebabigotes.bs2
‘ Visualizar las líneas de E/S conectadas a los «bigotes»
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Estado bigotes», CR,
«Izquierda derecha», CR,
«_____ _____»
DO
DEBUG CRSRXY, 0, 3,
«P5 = «, BIN1 IN5,
«P7 = «, BIN1 IN7
PAUSE 50
LOOP

El terminal debería mostrar que que P7 y P5 tienen unos valores igual a 1. Si presionamos el bigote derecho contra el conector de tres pines hasta que haga buen contacto, deberíamos ver en el terminar: P5 = 1, P7 = 0. Si presionamos el bigote izquierdo de la misma forma, debería aparecer: P5 = 0, P7 = 1. Si presionamos ambos al mismo tiempo debería mostrar: P5 = 0, P7 = 0. Una vez que todo es correcto seguimos adelante.

Escribimos el código en el programa de edición y lo guardamos.

Ejecutamos e introducimos en el robot. No presionamos ningún bigote.

Presionamos el bigote derecho.

Presionamos el bigote izquierdo.

Presionamos ambos bigotes.

NOTA: el comando CRSRXY es un formateador que permite ordenar la información que el programa envía al terminal. En el programa, el formateador coloca el cursor en la columna 0 y fila 3 para mostrar los datos de forma ordenada.

Otra forma de probar los bigotes

Imaginemos que tenemos que probar los bigotes cuando no disponemos de un ordenador para ver su estado en la terminal. ¿Cómo podríamos comprobar que se han montado correctamente? Una solución pasa por programar el microprocesador para que saque un valor determinado en función de cuál es la entrada que reciba. Podemos visualizarlo con un par de circuitos LED´s que se enciendan y se apaguen en función de si los bigotes están presionados o no.

Para montar este circuito necesitamos:

Dos resistencias de 220 Ω (bandas roja, roja y marrón).
Dos diodos LED.

Como siempre, antes de montar el circuito sobre la placa debemos recordar desconectar las pilas de la tarjeta y los servos. Seguiremos el siguiente esquema:

Diagrama de circuito LED para la comprobación del funcionamiento de los bigotes con LED.

Prueba de funcionamiento con LEDs.

Una vez montado, volvemos a conectar las pilas, e introducimos el siguiente programa en el editor:

‘ Programa de prueba. pruebabigotesconleds.bs2
‘ Visualizar las líneas de E/S conectadas a los «bigotes»
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Estado bigotes», CR,
«Izquierda derecha», CR,
«_____ _____»
DO
DEBUG CRSRXY, 0, 3,
«P5 = «, BIN1 IN5,
» P7 = «, BIN1 IN7
PAUSE 50
IF (IN7 = 0) THEN
HIGH 1
ELSE
LOW 1
ENDIF
IF (IN5 = 0) THEN
HIGH 10
ELSE
LOW 10
ENDIF
LOOP

Escribir el código en el programa de edición. Ejecutarlo e introducirlo en el robot.

Como vemos, lo que hemos hecho ha sido insertar dos bloques de código IF…THEN entre el comando de pausa y el comando de bucle. Los comandos IF…THEN los explicaremos un poco más tarde pero baste decir ahora que se emplean en PBASIC para tomar decisiones. La primera declaración pone P1 a nivel alto, de forma que el LED se iluminará cuando el bigote conectado a P7 esté presionado (IN7=0). La parte del ELSE hace que el LED se apague cuando el bigote no está presionado. La segunda declaración hace lo mismo para el otro bigote. Veamos cómo funciona:

Programando el robot para navegar con los bigotes

Ha llegado el momento de poner en práctica todo lo aprendido hasta ahora para lograr que el robot reaccione a la información que le facilitan los bigotes acerca de los obstáculos que puede encontrar en su camino y pueda guiarse con ella. Cuando el robot esté en movimiento y uno de sus bigotes se presione significará que ha tropezado con un obstáculo. El programa de exploración deberá comprobar esa entrada de información, decidir qué significa y, a partir de ahí, realizar la maniobra hay que ejecutar para evitar el obstáculo y dirigir al robot en otra dirección (debemos tener presente que se trata de un movimiento libre y no podremos controlar dónde acabará el recorrido).

El siguiente programa hace que el robot vaya hacia delante hasta que se encuentre con un obstáculo. En el momento en que sea detectado por los bigotes, las rutinas y subrutinas escritas en el capítulo anterior harán que el robot retroceda y gire. Después volverá a avanzar hacia delante hasta que se encuentre con otro obstáculo.

El microcontrolador que gobierna el robot tiene que ser programado para que tome decisiones cuando uno de los bigotes es presionado. El lenguaje PBASIC dispone de un comando llamado IF…THEN. La sintaxis es como sigue:

IF (condición) THEN… {ELSEIF (condición)}…{ELSE}…ENDIF

Los puntos suspensivos significan que se puede meter un trozo de código en su lugar. El comando hace que el robot ejecute el bloque de código para la primera condición que sea verdadera. Entonces, salta hasta el comando ENDIF y continúa desde ahí.

El siguiente programa muestra una forma de evaluar las entradas de datos proporcionadas por los bigotes para decidir a qué subrutina de movimiento llamar utilizando los comandos IF…THEN:

‘ Sorteo de obstaculos. andandoconbigotes.bs2
‘ El robot utiliza los bigotes para detectar
‘ objetos y navegar en función de los mismos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Programa funcionando»
‘—–[ Variables ]
pulseCount VAR Byte
‘—–[ Inicializacion ]
FREQOUT 4, 2000, 3000
‘—–[ Rutina principal ]
DO
IF (IN5 = 0) AND (IN7 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
GOSUB Turn_Left
ELSEIF (IN5 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Right
ELSEIF (IN7 = 0) THEN
GOSUB Back_Up
GOSUB Turn_Left
ELSE
GOSUB Forward_Pulse
ENDIF
LOOP
‘—–[ Subrutinas ]
Forward_Pulse:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
RETURN
Turn_Left:
FOR pulseCount = 0 TO 20
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN
Turn_Right:
FOR pulseCount = 0 TO 20
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
RETURN
Back_Up:
FOR pulseCount = 0 TO 20
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN

Escribir el código en el programa de edición. Ejecutarlo e introducirlo en el robot.

El comando IF…THEN en el programa principal comprueba el estado de los bigotes. Si los dos bigotes están presionados (IN5 = 0, IN7 = 0), el robot realizará un giro en “U” llamando a la subrutina Back_Up seguida de la subrutina Turn_Left dos veces (lo que supone un giro de 180o).

Si el bigote izquierdo es el único que está presionado (IN5 = 0), el programa ejecutará la subrutina Back_Up seguida de la subrutina Turn_Right para retroceder y girar a la derecha 90o. Por el contrario, si el bigote presionado es el derecho (IN7 = 0), el programa ejecutará la subrutina Back_Up seguida de la subrutina Turn_Left para retroceder y girar a la izquierda 90o. La única posibilidad que no está resuelta en el programa es cuando los dos bigotes no están presionados (IN5 = 1, IN7 = 1) en cuyo caso el comando ELSE llama a la subrutina Forward_Pulse y envía un pulso para que el robot avance en línea recta al no haber obstáculos.

Esta subrutina tiene un detalle que hemos resaltar:

Forward_Pulse:
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
RETURN

Sólo envía un pulso y después devuelve el control al programa principal. Esto es importante porque permite al robot comprobar sus bigotes entre cada pulso que le hace avanzar (esto lo hace gracias al comando ENDIF). Significa que el robot comprueba si hay obstáculos alrededor de 40 veces por segundo mientras avanza hacia delante: cada pulso hacia delante hace que el robot avance medio centímetro por lo que es una buena idea enviar sólo un pulso para volver a comprobar los bigotes. Dado que el comando IF…THEN está dentro de un bucle DO…LOOP, cada vez que el programa realiza un pulso hacia delante entra en el bucle que envía el programa arriba hasta el comando DO. ¿Qué sucede entonces? Que el comando IF…THEN vuelve a comprobar los bigotes de nuevo y así sucesivamente. Si no lo hiciéramos así, cuando el robot entrara en la subrutina Forward_Pulse ya no volvería a comprobarlos.

Veamos el resultado de nuestros esfuerzos:

Jun

2014

Paso 6. Programando los movimientos del robot

Última actualizacón: 16 noviembre 2017 a las 13:40

En esta anotación aprenderemos a programar las maniobras fundamentales del robot: hacia delante, atrás, giros y rotaciones. Es fundamental que comprendamos bien estas maniobras y sus técnicas de programación porque las utilizaremos de ahora en adelante, aunque ahora el robot andará “a ciegas” porque aún no hemos instalado los sensores que le permitan informarse acerca del entorno que lo rodea. Nuestra tarea en los próximos pasos será instalar estos dispositivos que permitirán a nuestro robot esquivar obstáculos o seguir un camino marcado en el suelo.

Como parte indispensable de este paso, también vamos a aprender a poner a punto y calibrar la navegación del robot para que se mueva en línea recta, haga giros precisos y podamos hacer cálculos de distancias. Al final hay un vídeo donde se muestran en la práctica los mismos pasos que iremos dando.

En la imagen inferior vemos los diferentes movimientos que puede hacer el robot (como ya indicamos en pasos anteriores, debemos recordar que cuando el robot se mueve hacia delante su rueda derecha gira en el sentido de las agujas del reloj, mientras que la izquierda lo hace en sentido contrario):

Movimiento hacia delante

Con el programa que indicamos a continuación el robot avanzará en línea recta durante tres segundos.

Recordemos que el argumento Duración del comando PULSOUT controla la velocidad y la dirección de giro de los servos. Los argumentos StartValue y EndValue del bucle FOR…NEXT controlan por su parte el número de pulsos que se envían. Dado que cada pulso tiene la misma duración, el argumento EndValue también controla el tiempo que funcionan los servos.

‘ Programa de movimiento. Avancetressegundos.bs2
‘ El robot avanza hacia delante durante tres segundos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘marcha hacia delante durante 3 s
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
END

Controlando la distancia y la velocidad

Si cambiamos por ejemplo el valor EndValue del bucle FOR…NEXT de 122 a 61, haremos que el robot se desplace hacia delante durante la mitad de tiempo, y que recorra, por tanto, la mitad de la distancia.

Hagamos la comprobación:

Ahora podemos repetir lo mismo pero cambiando el valor EndValue a 244. ¿Qué ocurre?

Los cambios que hemos hecho están relacionados con la distancia que recorre el robot, pero también podemos modificar su velocidad. Por ejemplo, si ajustamos el parámetro Duración de PULSOUT cerca de 650 o 850, los servos girarán a su máxima velocidad; mientras que si se aproximan a 750, haremos que se muevan más lentos.

Modificamos el programa de la siguiente forma:

PULSOUT 13, 720

PULSOUT 12, 780

Mover el robot hacia atrás, rotarlo y pivotarlo

Todo lo que tenemos que hacer para conseguir otros movimientos del robot es utilizar diferentes combinaciones del parámetro Duración del comando PULSOUT. Por ejemplo, estas dos instrucciones hacen que el robot vaya hacia atrás:

PULSOUT 13, 850

PULSOUT 12, 650

Estas dos para que el robot gire a la izquierda:

PULSOUT 13, 650

PULSOUT 12, 650

Y éstas para que lo haga a la derecha:

PULSOUT 13, 850

PULSOUT 12, 850

Podemos combinar estos comandos para el robot vaya en diferentes direcciones como muestra el ejemplo del siguiente programa:

‘ Programa de movimiento. Delanteizquierdaderechaatras.bs2
‘ Hacer que el robot realice los cuatro movimientos básicos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 122 ‘marcha hacia delante durante 3s
PULSOUT 13, 650
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 24 ‘rotación izquierda ¼ de vuelta
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 24 ‘rotación derecha ¼ de vuelta
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200 ‘espera
FOR counter = 1 TO 122 ‘retroceso
PULSOUT 13, 850
PULSOUT 12, 650
PAUSE 20
NEXT
END

También podemos hacer que el robot pivote sobre una rueda. Para ello basta con que sólo gire una rueda mientras la otra permanece parada. Por ejemplo, si se quiere que la rueda izquierda permanezca parada y la derecha gire hacia delante para que el robot pivote, se deberán utilizar las siguientes líneas de código:

PULSOUT 13, 750

PULSOUT 12, 650

Si por el contrario se quiere que pivote hacia delante y a la derecha, simplemente se detiene la rueda derecha y hacemos que la rueda izquierda gire hacia delante:

PULSOUT 13, 850

PULSOUT 12, 750

Hacia atrás y la derecha:

PULSOUT 13, 650

PULSOUT 12, 750

Hacia atrás y a la izquierda:

PULSOUT 13, 750

PULSOUT 12, 850

Retocando las maniobras básicas

Más abajo veremos un vídeo con todas estas maniobras realizadas en la práctica y comprobamos que, a pesar de que el robot está programado para avanzar en línea recta, es frecuente que se vaya desviando ligeramente hacia uno de los lados. Vamos a corregir este desajuste mediante el software, para lo cual deberemos modificar el programa Avancetressegundos.bs2 para que en vez de 3 segundos se mueva durante 10, tiempo necesario para comprobar si se desvía o no. Esta modificación se hace cambiando el valor de EndValue en el comando FOR Counter de 122 a 407:

‘ Programa de movimiento. Avancediezsegundos.bs2
‘ El robot avanza hacia delante durante diez segundos
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 407 ‘giro hacia delante durante 10 s
PULSOUT 13, 650 ‘servo izquierdo máxima velocidad
PULSOUT 12, 850 ‘servo derecho máxima velocidad
PAUSE 20
NEXT
END

Pongamos por caso que el robot se desvía hacia la izquierda. Esto puede pasar por dos motivos: o bien la rueda izquierda gira más lenta, o es la rueda derecha la que lo hace más rápido. Como el robot está programado para que cada servo gire a la máxima velocidad, lo más lógico será pensar que la rueda derecha debería girar un poco más despacio.

Ya hemos visto que la velocidad de los servos está determinada por el argumento Duración del comando PULSOUT. Cuanto más se acerque este valor a 750, más lento girará el servo. Esto significa que hay que cambiar el valor 850 del comando PULSOUT 12 a un valor más cercano a 750. Si el robot no se desvía demasiado, con un valor de 837 será suficiente. Si por el contrario el grado de desvío es grande, habrá que poner como mínimo un valor de 810. Como vemos, será necesario hacer varias pruebas modificando este argumento hasta lograr que el robot siga una línea completamente recta.

En nuestro caso, ha sido necesario un valor de 800 para conseguir un movimiento rectilíneo.

Al igual que hemos hecho para el avance, tendremos que hacer los mismos ajustes para el movimiento hacia atrás.

También es posible regular los giros del robot mediante el software. El tiempo que dura el movimiento de las ruedas del robot es lo que determina el ángulo de giro. Como ya hemos visto que el comando que controla el tiempo de giro en el programa es el bucle FOR … NEXT, lo que tenemos que hacer es modificar el argumento EndValue para que gire más o menos según queramos.

En el programa Delanteizquierdaderechaatras.bs2 introdujimos una serie de órdenes para que el robot realizase distintos giros, por lo que si hay cualquier tipo de desviación deberemos modificar el contador del bucle FOR counter = 1 TO 24 y disminuir el tiempo de giro (probamos primero con 23, 22 etc.) Si sigue sin girar los 90o exactos, modificaremos el comando PULSOUT a un valor más cercano a 750, como hicimos para que fuese recto. Repetiremos la acción hasta que gire los 90o exactos.

Cálculo de distancias

Es frecuente que en las competiciones que se organizan los robots tengan que seguir un recorrido desde un punto inicial hasta un destino situado a cierta distancia, para luego regresar al punto de partida. Vamos a aprender a calcular distancias, para lo cual aplicamos la fórmula general de la velocidad:

Tiempo = distancia / velocidad

Distancia = velocidad x tiempo

Lo que traducido al funcionamiento de nuestro robot sería:

Tiempo de movimiento del servo = distancia recorrida / velocidad del robot

Para poder aplicar esta sencilla fórmula debemos calcular en primer lugar la velocidad del robot. La forma más fácil de hacerlo es poner una regla a su lado y ver qué distancia recorre en un tiempo dado (un segundo por ejemplo). Conociendo los centímetros que ha recorrido y el tiempo en segundos empleado en ello, podremos determinar la velocidad del robot en centímetros por segundo. Emplearemos para ello el siguiente programa:

‘ Programa de movimiento. Avanceunsegundo.bs2
‘ El robot avanza hacia delante durante un segundo
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
FOR counter = 1 TO 41 ‘marcha hacia delante durante 1s
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
END

Este programa controla el movimiento del robot durante un segundo por lo que si ha recorrido 23 cm durante su ejecución, la velocidad será de 23 cm/s (es conveniente recordar que en un paso anterior aprendimos que los servos tardan 24,6 milisegundos (0,0246 segundos) en completar un ciclo de ejecución del bucle FOR … NEXT, por lo que el microcontrolador envía 40,65 pulsos cada segundo a los servos (1/0,0246 pulsos por segundo).

Una vez aclarado este concepto, podemos hacer que el robot se desplace en cualquier dirección una distancia concreta. Por ejemplo, sabiendo la velocidad que alcanza, podemos calcular el tiempo que necesitaría el robot para recorrer una distancia de 51 centímetros:

Tiempo = 51 cm / 23 cm/s = 2,22 s

Cuando tenemos este dato, basta calcular los pulsos que han de enviarse a los servos para que el robot recorra esa distancia, teniendo en cuenta que para que el robot se mueva durante un segundo son necesarios 40,65 pulsos:

Pulsos = 2,22 s x 40,65 pulsos/s = 90,24 pulsos = 90 pulsos

90 es el valor que tendremos que usar en el argumento EndValue del bucle FOR … NEXT

En cualquier caso tenemos que tener presente que estas mediciones no son completamente exactas. No hemos tenido en cuenta, por ejemplo, que el robot necesita un determinado número de pulsos para alcanzar la máxima velocidad, ni tampoco la distancia que recorre hasta que se detiene por completo o el hecho de que los servos girarán más despacio cuando las baterías pierdan potencia.

Maniobras de aceleración y desaceleración

Lo que pretendemos es que el robot acelere y desacelere de forma gradual. De esta forma conseguiremos que los servos y las baterías duren más y que el arranque y la parada no sean tan bruscos.

La clave para acelerar es ajustar el parámetro Duración del comando PULSOUT. Gracias al bucle FOR … NEXT podemos hacer que el robot acelere:

PulseCount VAR Word

FOR pulseCount = 1 TO 100

PULSOUT 13, 750 – pulseCount

PULSOUT 12, 750 + pulseCount

PAUSE 20

Cada vez que se ejecuta el bucle FOR … NEXT la variable pulseCount se incrementa en 1. A medida que el valor de pulseCount es mayor, la velocidad de los servos también. La primera vez que se ejecuta el bucle, la variable pulseCount vale 1, que es lo mismo que usar los comandos PULSOUT 13, 749 y PULSOUT 12, 751. La segunda vez, la variable valdrá 2, y así, a la centésima vez que hemos ejecutaado el bucle, la variable pulseCount valdrá 100 que es lo mismo que usar los comandos PULSOUT 13, 650 y PULSOUT 12, 850 (máxima velocidad hacia delante)

Si por el contrario hacemos que el bucle FOR … NEXT reduzca la variable pulseCount, el robot desacelerará hasta pararse. Hagamos las pruebas:

‘ Programa de movimiento. Arranqueyparo.bs2
‘ El robot acelera y luego decelera hasta pararse
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
pulseCount VAR Word ‘contador del bucle FOR … NEXT
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
‘aceleración gradual
FOR pulseCount = 1 TO 100 ‘bucle aceleración de 100 pulsos
PULSOUT 13, 750 – pulseCount
PULSOUT 12, 747 + pulseCount
PAUSE 20
NEXT
‘avance constante de 75 pulsos
FOR pulseCount = 1 TO 75
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
‘desaceleración hasta detenerse
FOR pulseCount = 100 TO 1 ‘bucle desaceleración de 100 pulsos
PULSOUT 13, 750 – pulseCount
PULSOUT 12, 747 + pulseCount
PAUSE 20
NEXT
END

Facilitar los movimientos con subrutinas

En los siguientes pasos de la construcción del robot vamos a programarlo para que sea capaz de realizar maniobras con el fin de evitar obstáculos. Una de las formas más eficientes de hacerlo es realizando maniobras pre-programadas mediante el empleo de subrutinas. Ahora vamos a aprender a crear y utilizar esta herramienta.

Una subrutina es una secuencia de instrucciones que se repite en diversas ocasiones a lo largo del programa principal. Para no tener que reescribirla e insertarla cada vez que se necesite, lo que hacemos es ponerla como un programa independiente al que se “llama” cada vez que sea preciso.

Hay dos partes dentro de una subrutina en PBASIC. La primera es la “llamada a la subrutina”, es decir, la instrucción que hace que una vez que el programa llegue allí, se ejecute la parte de código que se contiene dentro de la subrutina. La otra parte es la propia subrutina en sí, la parte reutilizable del código. La subrutina comienza cuando se referencia con GOSUB su nombre (también llamado etiqueta) y finaliza con el comando RETURN, que devuelve el control a la siguiente instrucción después de GOSUB. El código que hay entre la etiqueta del nombre de la subrutina y RETURN es lo que se ejecutará en cada llamada a esa subrutina:

DEBUG “Antes de la subrutina”, CR

PAUSE 1000

GOSUB Mi_subrutina

DEBUG “Después de la subrutina”, CR

PAUSE 1000

LOOP

Mi_subrutina:

DEBUG “Subrutina en ejecución”, CR

PAUSE 1000

RETURN

Este trozo de código nos muestra una llamada a una subrutina y la propia subrutina. Como hemos dicho, la llamada a la subrutina se realiza con el comando GOSUB y el nombre de la subrutina, en nuestro caso “Mi_subrutina” (ojo con los espacios en blanco). Una vez se inicia la subrutina se ejecuta línea a línea hasta encontrar el comando RETURN que obliga a salir de la subrutina y continuar ejecutando el programa en el punto en que se dejó.

Vamos a usar esta herramienta para manejar los movimientos del robot:

‘ Programa de movimiento con subrutinas. Movimientoconsubrutina.bs2
‘ El robot realiza los movimientos básicos mediante subrutinas
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
Counter VAR Word
FREQOUT 4, 2000, 3000 ‘señal de inicio/reset
GOSUB Delante
GOSUB Izquierda
GOSUB Derecha
GOSUB Atras
END
‘movimiento hacia delante
Delante:
FOR counter = 1 TO 64
PULSOUT 13, 650
PULSOUT 12, 800
PAUSE 20
NEXT
PAUSE 200
RETURN
‘giro a la izquierda
Izquierda:
FOR counter = 1 TO 24
PULSOUT 13, 650
PULSOUT 12, 650
PAUSE 20
NEXT
PAUSE 200
RETURN
‘giro a la derecha
Derecha:
FOR counter = 1 TO 24
PULSOUT 13, 850
PULSOUT 12, 850
PAUSE 20
NEXT
PAUSE 200
RETURN
‘movimiento hacia atrás
Atras:
FOR counter = 1 TO 64
PULSOUT 13, 840
PULSOUT 12, 650
PAUSE 20
NEXT
RETURN

Ago

2013

Paso 3. Circuitos LED

Última actualizacón: 25 mayo 2017 a las 11:09

Hasta ahora hemos utilizado la tarjeta Home Work y la pantalla del ordenador para enviar mensajes a través de los programas y realizar un control del tiempo. Ha llegado el momento de estudiar el funcionamiento y la programación de diferentes dispositivos físicos conectándolos a las clavijas de entrada y salida (I/O Imput/Output, o Entrada/Salida) de forma que el microcontrolador establezca sus funciones.

Como primer paso sencillo, vamos a probar un circuito LED (diodo emisor de luz o Light-Emitting Diode), es decir, construiremos circuitos que emitan luz para poder “comprobar” el tipo de señales electrónicas que se usan, entre otras cosas, para controlar los motores del robot. Este es uno de los tipos de LEDES que vamos a emplear:

Estos dispositivos LED, que podemos ver en la gran parte de los aparatos electrónicos que tenemos en nuestras casas son dispositivos diodos semiconductores de silicio y otros materiales, que disponen de dos patitas o terminales. Cuando se les aplica una diferencia de tensión (o voltaje) entre ambos con la polaridad correcta se encienden y emiten una luz que puede ser de diversos colores. Un terminal se denomina ánodo (con polaridad positiva y que se corresponde con el más largo) y el otro, el cátodo (y polaridad negativa), es el más corto.

Para que se ilumine el LED hay que aplicar entre unos 2 a 4 V entre sus terminales (dependiendo de su color). Dado que a través de la tarjeta Home Work obtenemos 5 V de tensión, deberemos colocar delante del LED una resistencia (resistor) que se encargue de absorber la tensión sobrante.

La resistencia es un dispositivo que no tiene polaridad, por lo que es indiferente la posición en la que se coloquen sus dos terminales. Veamos a continuación una imagen de las resistencias que vamos a utilizar:

El efecto de absorción de tensión de las resistencias depende del valor que tengan, que se mide en ohmios (Ω). Una buena iluminación LED puede conseguirse con una resistencia de 220 Ω, aunque también se puede conseguir que se encienda débilmente con una resistencia de 470 Ω. Dado que las resistencias suelen ser muy pequeñas y cilíndricas no se puede grabar fácilmente su valor por lo que se utiliza un código de colores para indicarlo. A continuación se muestra la tabla con el código de colores:

Además de los nueve primeros colores (que sirven para determinar el valor) se utilizan otros dos encargados de informar sobre la tolerancia o exactitud del valor indicado por los mismos. Así, si la última franja tiene color ORO, significa que el valor real que tiene la resistencia no se desvía más de ±5% del que indican sus colores. En el caso de ser plata, la tolerancia es de ±10% (si no hay ninguna de estas dos bandas, la tolerancia es de ±20%).

Para hacer la lectura correcta, deberemos colocar la resistencia de forma que la última franja, la de la derecha, sea la que indique la tolerancia: el color de la primera franja corresponde al primer número del valor; el color de la segunda franja al segundo; mientras que el de la tercera franja indica el número de ceros que hay que añadir a los dos anteriores para obtener el resultado en ohmios (esto es, un multiplicador):

Como un ±5% de 470 Ω son ±23,5 Ω, el valor real de la resistencia estará comprendido entre 470 ± 23,5 Ω, o sea, entre 493,5 y 446,5 Ω.

Encendido del LED

Una vez comprendidos los aspectos básicos, para encender un LED basta conectarle en serie una resistencia y aplicarle una tensión de 5 V, de forma que el polo positivo se conecte al ánodo, y el negativo al cátodo como podemos ver en el esquema representado más abajo:

En nuestro banco de pruebas, la “board of education”, el polo negativo de la alimentación se conecta a un terminal común que se denomina “tierra” y se representa con la tensión Vss. El esquema quedaría de la siguiente forma:

Montaje de componentes

Como hemos dicho, la tarjeta Home Work posee una superficie destinada al montaje de los componentes de los circuitos (“board of education”) compuesta de numerosos orificios interconectados que permiten realizar la conexión entre los componentes sin usar soldadura ni estropearlos, únicamente aplicando presión.

La placa de pruebas tiene dos zonas blancas de 17 filas con cinco orificios en cada una. Los orificios de cada fila están conectados entre sí de forma que si, por ejemplo, colocamos el cátodo del LED en uno de los orificios de la primera fila y en cualquiera de los cuatro restantes el terminal de una resistencia, ambos quedarán conectados.

Como vemos en la imagen, tanto en la parte superior como en el lado izquierdo de la placa de pruebas existen dos líneas negras de conectores (rotuladas como X2 la vertical, y X3 la horizontal). La línea vertical tiene 16 orificios denominados P0 a P15 y están conectados a las 16 líneas de entrada o salida del microcontrolador. A través de la programación del microcontrolador podremos establecer que cada una de estas líneas sea entrada o salida y, en caso de ser salida, podremos sacar un nivel alto o +5 V (o Vdd), o bien un nivel bajo o 0 V (o Vss). Si la línea es de entrada, el microcontrolador leerá en ella la tensión exterior aplicada y reconocerá nivel alto o bajo. El nivel alto puede estar comprendido entre 2 y 5 V, mientras que el bajo siempre será inferior a 1,4 V.

Haciendo parpadear un LED

El primer experimento consistirá en encender un LED durante tres segundos, luego volver a apagarlo otros 3 segundos y repetir estas dos acciones tres veces (es decir, el LED parpadeará tres veces cada tres segundos).

Elegiremos una de las clavijas de entrada/salida de la placa de pruebas (por ejemplo la P15), que actuará como salida generando por ella un nivel alto durante tres segundos y un nivel bajo durante otros tres segundos. Para hacerlo será necesario conectar, como explicamos más arriba, una resistencia de absorción según el siguiente esquema:

En primer lugar, introducimos el ánodo (polo +) del LED en uno de los orificios de la placa de pruebas. Por su parte, el cátodo se introduce en uno de los orificios de la fila de conectores X3 rotulada como Vss (es nuestra toma de tierra). Ya tenemos conectado el LED. Acto seguido tomamos una resistencia de 470 Ω e insertamos uno de sus extremos en un orificio junto al ánodo del LED (lo que hace que estén conectados entre sí), mientras que el otro extremo se introduce en el orificio P15 de la fila de conectores X2 (actuará como salida). Las imágenes de abajo muestran la conexión:

Para encender el LED hay que sacar un nivel alto por la clavija P15 y, para apagarlo un nivel bajo. Vamos a estudiar los comandos en lenguaje PBASIC que configuran cada clavija como E/S, y otras que sacan por ella un nivel alto o bien un nivel bajo.

El comando HIGH seguido por el número de la clavija que se quiera hará que salga por ella un nivel alto; por otro lado, el comando LOW sacará un nivel bajo (Vss). Por ejemplo, HIGH 15 saca un nivel alto (Vdd) por la clavija P15, lo que hace que el LED conectado a ella se encienda; y LOW 15 saca un nivel bajo y hace que se apague.

Para mantener congelado el estado del microcontrolador un tiempo determinado se utiliza el comando PAUSE (que ya hemos estudiado) seguido del número de milisegundos que deseemos (por tanto, para controlar espacios de tiempo de 3 segundos emplearemos PAUSE 3000).

Veamos por tanto las líneas de código del programa de parpadeo del LED:

‘ Programa parpadeo LED. ParpadeoLED.bs2
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Parpadeo tres veces durante tres segundos»
HIGH 15‘Sale por P15 un nivel alto
PAUSE 3000 ‘Pausa de tres segundos
LOW 15 ‘Sale por P15 un nivel bajo
PAUSE 3000
HIGH 15 ‘Sale por P15 un nivel alto
PAUSE 3000 ‘Pausa de tres segundos
LOW 15 ‘Sale por P15 un nivel bajo
PAUSE 3000
HIGH 15 ‘Sale por P15 un nivel alto
PAUSE 3000 ‘Pausa de tres segundos
LOW 15 ‘Sale por P15 un nivel bajo
PAUSE 3000
END ‘Fin del programa

Como ya hemos hecho en otras ocasiones, escribimos el programa en el editor y lo ejecutamos para que quede grabado en la memoria del microcontrolador:

Como alguno de ustedes se habrá percatado, incluir la linea de comando DEBUG únicamente se ha hecho para comprobar que el programa se ha cargado adecuadamente.

Veamos una demostración en vídeo del funcionamiento:

Con estas instrucciones es muy sencillo cambiar el tiempo de parpadeo o las veces de repetición del mismo pero, ¿qué debemos hacer para que el LED parpadee de forma indefinida?, es una función que muy necesaria más adelante. Existe una forma cómoda y fácil de repetir de forma ininterrumpida una secuencia de instrucciones evitando tener que reproducir hasta el infinito las líneas de código: con un comando PBASIC llamado GOTO. Con él se pasa a ejecutar la instrucción que se desee, previamente identificada, y cuando el programa regrese a la línea de código que contiene el comando GOTO, todo vuelve a comenzar. Es parecido a un bucle aunque esto lo explicaremos más detenidamente en siguientes entradas. Veamos un ejemplo:

‘ Programa parpadeo infinito. Parpadeoinfinito.bs2
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Parpadeo infinito del LED»
INICIO: HIGH 15 ‘Sale por P15 un nivel alto
PAUSE 1000 ‘Pausa de un segundo
LOW 15 ‘Sale por P15 un nivel bajo
PAUSE 1000
GOTO INICIO ‘Salta a la instrucción con etiqueta INICIO

Al ejecutar este programa, el LED permanece parpadeando durante tres segundos de forma indefinida:

Ago

2013

Paso 2: Primeros pasos en la programación

Última actualizacón: 24 mayo 2017 a las 14:04

En el paso anterior descargamos el software y conectamos la tarjeta al PC. Repasemos los pasos del procedimiento de Ayuda que habíamos comenzado:

Identificación de la tarjeta que estamos utilizando.
Conexión de la tarjeta al ordenador.
Realizar una prueba de la conexión.
Resolver los problemas con la conexión si es necesario.
Escribir nuestro primer programa en lenguaje PBASIC.
Desconectar el hardware cuando hayamos finalizado.

Una vez realizadas las tareas 1 a 4 (y la 6 para la desconexión), vamos a centrarnos en la tarea 5 y escribir el primer programa en lenguaje de programación PBASIC, conectando para ello la tarjeta Home Work al PC como ya hicimos.

Este sencillo programa va a consistir en decirle a la tarjeta Home Work que transmita un mensaje al PC. Para escribir el código utilizaremos el programa BASIC Stamp Editor (en adelante programa de edición) que hemos instalado en el paso anterior.

Es importante señalar que cada línea de código tiene una función determinada que iremos explicando a medida que avancemos y que contiene una serie de comandos. Un comando o instrucción es una palabra que el usuario proporciona a un sistema informático y que describe una acción a realizar por el microcontrolador.

Estas son las líneas de código del primer programa:

‘ Primer programa de prácticas del robot Boe-Bot. Primerprograma.bs2
‘ El microcontrolador envía un mensaje de texto al PC.
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Hola, este es un mensaje enviado desde el robot!»
END

Los números al principio de cada línea NO DEBEN INCLUIRSE EN EL PROGRAMA, están ahí únicamente para facilitar esta explicación.

Vemos que las cuatro primeras líneas, llamadas comentarios, vienen precedidas de un apóstrofe ( ‘ ) ―el apóstrofe se obtiene pulsando la tecla de cierre de interrogación situada a continuación del número cero―. Estos comentarios que se escriben al principio del código no son interpretados por el programa de edición ya que su función es servir de información a nosotros, seres humanos, que lo estamos leyendo. En nuestro caso, las lineas 1 y 2 informan del nombre del programa y de qué es lo que hace exactamente.

Las dos siguientes líneas (la 3 y 4) también son comentarios pero se trata de mensajes especiales. Son las llamadas “directivas del compilador” cuya misión es informar al programa de edición de ciertas condiciones. Todos los programas tienen como mínimo dos de tales directivas, en nuestro caso:

‘ {$STAMP BS2}

‘ {$PBASIC 2.5}

La primera le indica al programa de edición en qué clase de microcontrolador se va a descargar el programa (el Basic Stamp 2); mientras que la segunda le informa que el lenguaje de programación que vamos a emplear es la versión 2.5 de PBASIC.

En nuestro programa de edición, la primera directiva de compilación la podemos introducir automáticamente pulsando el botón que se indica en la imagen. En cualquier caso, es más recomendable hacerlo manualmente para acostumbrarnos a introducir los comandos. Lo mismo sucede con la segunda:

Aunque hemos recomendado escribir estas directivas manualmente, hay que tener cuidado y no poner signos diferentes: si no se emplean las llaves { } y se colocan paréntesis por ejemplo, el programa no funcionará. En cualquier caso, si las introducimos manualmente, deberemos cerciorarnos que el programa de edición las destaca en colores diferentes. Al aparecer los comandos destacados en colores nos cercioramos de que el programa de edición los ha codificado correctamente al tiempo que facilita una lectura rápida de la línea de comandos en busca de posibles errores.

Bien, ahora terminamos escribiendo las dos últimas líneas de comandos:

DEBUG «Hola, este es un mensaje enviado desde el robot!»

END

El primer comando del programa es DEBUG, que sirve para mandar un mensaje al PC a través del puerto USB. El mensaje que queramos que aparezca debe introducirse entrecomillado (las comillas son importantes, si falta alguna de ellas, el programa no funcionará). El segundo es el comando END que indica la finalización del programa. Una vez leído este comando, el microcontrolador permanece en modo de bajo consumo de energía en espera de que se pulse el botón de reinicio, o bien se introduzca un nuevo programa. Es importante resaltar que cuando se introduce un nuevo programa, el anterior se borra automáticamente.

Bien, ya tenemos nuestro primer programa así que lo guardamos en nuestro disco duro (pulsando en la pestaña File y acto seguido en Save). Ya estamos preparados para enviarlo a la tarjeta Home Work.

Una vez grabado, solo nos queda abrir la pestaña RUN y de nuevo pulsar RUN para activar el programa (o bien, de forma directa pulsando el botón con un triángulo azul situado en la barra de tareas). Tras pulsar el botón aparecerá una ventana de transferencia y, justo después, deberá aparecer la ventana de debug (Debug Terminal) en la que se visualiza el mensaje enviado desde la tarjeta Home Work:

Una vez editado y ejecutado el programa, desde la tarjeta Home Work se habrá enviado el mensaje para su visualización en la pantalla del PC. Esto asegura tanto el correcto funcionamiento de la tarjeta como la comunicación con el PC y su software. Pueden comprobar que el mensaje proviene de la tarjeta Home Work pulsando varias veces el botón de reinicio de la misma (etiquetado con el número 10 como vimos en el paso 1) y aparecerá lo siguiente:

Comprobamos que el programa se reinicia cada vez y envía de nuevo el mensaje.

En conclusión, el primer programa ha tenido como objetivo enviar un mensaje a la pantalla del PC con la misión de comprobar el correcto funcionamiento de los sistemas.

Comando PAUSE

Una vez que hemos aprendido a escribir un sencillo programa, vamos a conocer nuevos comandos.

El primero de ellos es PAUSE. Como habrán adivinado, el comando retarda la ejecución del programa un tiempo determinado en milisegundos (1000 milisegundos corresponden a 1 segundo). Veamos cómo funciona:

Modifiquemos el programa anterior añadiendo la siguiente línea de comandos encima de la primera línea DEBUG:

PAUSE 1000

El programa quedará así:

Ejecutemos el programa y comprobaremos que el mensaje tarda en aparecer 1 segundo.

Formatos del comando DEBUG y caracteres de control

El comando DEBUG dispone de diversos formatos para enviar un texto con ciertas características a la ventana de debug. DEC es un ejemplo que sirve para mostrar un valor en decimal. Otro ejemplo de formato para un carácter de control es CR, que sirve para enviar un retorno de carro (escribirá el siguiente texto en una línea diferente).

Probemos el siguiente programa y lo guardamos:

‘ Segundo programa de prácticas del robot Boe-Bot. Segundoprograma.bs2
‘ El microcontrolador realiza un cálculo y envía el resultado
‘ al PC.
‘ {$STAMP BS2}
‘ {$PBASIC 2.5}
DEBUG «Hola, este es un mensaje enviado desde el robot!»
DEBUG CR, “¿Cuánto es 7×11?”
DEBUG CR, “El resultado es: ”
DEBUG DEC 7 * 11
END

Al ejecutarlo visualizaremos lo siguiente:

Si expresamos operaciones como 7 * 11 el microprocesador las calcula y genera el resultado. El símbolo % detrás del comando DEBUG generará los resultados en binario (empleando únicamente 0 y 1). Por otro lado, si utilizamos el comando DEBUG sin ningún símbolo se presentarán los caracteres en código ASCII.

En este ejemplo hemos cambiado el último comando DEBUG para que muestre la letra A (el número 65 en código ASCII).