microcontrolador

     Última actualizacón: 15 noviembre 2017 a las 22:55

En este nuevo paso de la construcción del robot, vamos a comprobar que las conexiones eléctricas entre la tarjeta y los servos son correctas. Es preciso que nos aseguremos de que el servo de la derecha gira cuando recibe señales procedentes de P13 y que el servo de la izquierda hace lo propio cuando recibe señales de P12 según el montaje realizado en el paso anterior.

En la siguiente imagen vemos nuestro robot con las indicaciones de posición que se seguirán de ahora en adelante para evitar confusiones:

5.1 Comprobando el funcionamiento de las ruedas

Vamos a ejecutar un sencillo programa para probar el servo conectado a la rueda derecha. Hará que la rueda gire en la dirección de las agujas del reloj durante 3 segundos, parará durante un segundo y, después, girará en sentido contrario durante otros 3 segundos.

Para ponerlo en marcha, cargaremos el programa en el editor de Basic Stamp y lo introduciremos en la tarjeta del robot como hemos visto en pasos anteriores. Acto seguido colocamos el interruptor de energía en la posición 2 (que alimenta los servos) y ejecutamos el programa.

Los mismos pasos daremos con el servo de la rueda izquierda:

Vemos cómo la única diferencia entre estos dos programas es que hemos sustituido el punto de enganche del servo derecho (P13) por el servo izquierdo (P12) en el segundo programa.

Ahora vamos a comprobar como el robot se mueve según las indicaciones de la programación: la rueda derecha girará en sentido horario durante tres segundos, se detendrá un segundo, y volverá a girar en sentido antihorario otros 3 segundos (lo mismo sucederá con la rueda izquierda).

5.2 Detector acústico de baja tensión y reinicio

Cuando el suministro de voltaje eléctrico cae por debajo del nivel que el dispositivo necesita para funcionar correctamente se produce un apagón parcial. La tarjeta se protege a sí misma de esta situación haciendo que el procesador y los microchips de memoria permanezcan en estado de reposo hasta que el suministro de energía vuelva a niveles normales.

Una bajada de tensión en Vin por debajo de 5,2 V provoca un voltaje inferior a 4,3 V en el regulador interno de la tarjeta, valor insuficiente que origina una anomalía y que provoca, como hemos señalado, que se ponga en marcha un mecanismo de autoprotección del sistema en el que tanto el procesador como la memoria pasan a un estado de reposo que detiene la ejecución de instrucciones. Cuando el voltaje vuelve a niveles adecuados, la tarjeta se pone en funcionamiento de nuevo pero no donde había quedado ejecutándose el programa, sino desde el principio del mismo. Es lo mismo que sucede cuando pulsamos el botón de reinicio del sistema.

Cuando las baterías están bajas, es posible que estas bajadas de tensión hagan reiniciarse al robot cuando menos lo esperamos, haciendo que tome direcciones erróneas, dé vueltas sobre sí mismo etc.

Esto hace que un programa que indique la posibilidad de reinicio del robot sea muy útil (de esta forma sabemos claramente cuál ha sido la causa del funcionamiento incorrecto de nuestro robot). Una forma para avisar de un posible reinicio es incluir una señal inconfundible al comienzo de todos los programas del robot. La señal se produce cada vez que se conecta el suministro de energía y cuando se produce un reinicio debido a una bajada de tensión.

En este ejercicio vamos a colocar un dispositivo llamado zumbador piezoeléctrico que se puede usar para generar diferentes tonos en función de la frecuencia de las señales que se envíen desde la tarjeta.

El programa que vamos a cargar a continuación produce un pitido a través del zumbador. Utiliza el comando FREQOUT para enviar las señales de la frecuencia que se deseemos por una patita de la tarjeta. Su sintaxis es como sigue:

FREQOUT Pin, duración, frecuencia1, {Frecuencia2

Un ejemplo sería FREQOUT 4, 2000, 3000: envía una señal de 3000 hercios (3 kHz) durante 2000 ms (2 segundos) por el pin 4.

En este punto debemos tener presente que la frecuencia es una magnitud que mide el número de repeticiones por unidad de tiempo de cualquier fenómeno o suceso periódico. Nuestro zumbador funciona gracias a la piezoelectricidad: es un fenómeno presentado por determinados cristales que al ser sometidos a tensiones mecánicas adquieren una polarización eléctrica en su masa, apareciendo una diferencia de potencial y cargas eléctricas en su superficie. Este fenómeno también se presenta a la inversa, esto es, se deforman bajo la acción de fuerzas internas al ser sometidos a un campo eléctrico. El efecto piezoeléctrico es normalmente reversible: al dejar de someter los cristales a un voltaje exterior o campo eléctrico, recuperan su forma.

De esta forma, cuando aplicamos cambios de voltaje a gran velocidad hacemos que el cristal piezoeléctrico cambie de forma rápidamente. Esto provoca una vibración. Los objetos que vibran hacen que el aire que los rodea vibre también, y esta vibración es lo que nuestros oídos detectan como sonido y tonos.

La frecuencia se mide en hercios (Hz). Un hercio representa un ciclo por cada segundo, entendiendo ciclo como la repetición de un suceso. De esta forma, un kHz representa mil ciclos por segundo.

Más abajo se muestra el símbolo del zumbador y el esquema de conexión del terminal positivo del zumbador a la patita P4 de E/S.

Para el montaje tomamos el zumbador y lo colocamos sobre la tarjeta. Vemos que una pegatina indica cuál de las dos patas es de signo positivo así que solo tenemos que presionar y listo. Para dejar más espacio para el resto de componentes, y dado que este elemento quedará fijo de forma permanente, es mejor colocarlo lo más esquinado posible.

Una vez colocado, sólo tenemos que realizar la conexión de los cables, uno conectando el polo positivo del zumbador a P4 (cable azul) y el otro al conector de energía (Vss)

Programa ejemplo

El siguiente programa emite un pitido del zumbador al iniciarse su ejecución y luego envía mensajes visualizadores de DEBUG cada medio segundo dentro de un bucle infinito. Se puede simular una bajada de tensión presionando el botón de reinicio o bien desconectando la batería del robot; entonces el programa se reiniciará, emitiendo un pitido de nuevo. Cada vez que se produce un pitido sabemos que el programa se ha iniciado desde el principio.

El programa comienza mostrando el mensaje (en la pantalla del ordenador) “Beep!!!” cuando se inicia su ejecución. Inmediatamente envía una señal de 3 kHz al zumbador durante 2 segundos. Como la tarjeta ejecuta muy rápidamente las instrucciones dará la sensación de que el mensaje se muestra al mismo tiempo que el zumbador comienza a pitar.

Cuando cesa el pitido, el programa entra en un bucle infinito mostrando una y otra vez el mensaje “Esperando el reinicio”. Cada vez que se produzca un reinicio, bien porque se aprieta el botón o porque se desconectan las baterías o pierden tensión, el programa se reiniciará.

De ahora en adelante vamos a usar este programa cada vez que escribamos otro. Lo consideraremos parte de la rutina de inicialización de cada programa.

5.3 Probando el control de velocidad del robot

En este paso de comprobación vamos a dibujar las curvas que relacionan la velocidad de giro de los servos con la amplitud de los pulsos que se aplican desde la tarjeta Home Work. Este gráfico nos resultará muy útil ya que cuando queramos obtener una velocidad concreta de las ruedas del robot sólo tendremos que consultar éste para saber la amplitud del pulso que se debe aplicar a cada una. Para ello vamos a utilizar el panel de transmisión del terminal DEBUG del programa de edición para enviar valores al programa de ejecución de la tarjeta.

Empleo del comando DEBUGIN

Ya hemos visto en anteriores ocasiones que gracias al comando DEBUG se visualizan los mensajes en la pantalla del ordenador que manda la tarjeta al ejecutar un programa determinado. El terminal DEBUG del programa de edición Basic Stamp también tiene una ventana de transmisión que nos permite enviar información al microcontrolador mientras se está ejecutando un programa. Esto lo hacemos a través del comando DEBUGIN, que toma el valor que introducimos con el teclado y lo envía al programa que está ejecutando la tarjeta para que una o más variables queden fijadas por dicho valor. Es decir, con este comando se introducen valores de variables que se usan en los programas de la tarjeta Home Work.

En el siguiente programa de ejemplo, utilizaremos la variable pulseWidth (amplitud de pulso) para almacenar los valores que el comando DEBUGIN recibe. Evidentemente, tendremos que declarar previamente esta variable al programa

pulseWidth        VAR       Word

Ahora, el comando DEBUGIN captura los valores decimales que introducimos con el teclado a través del panel de transmisión y los almacena en la variable pulseWidth:

DEBUGIN            DEC        pulseWidth

De esta forma podemos programar el microcontrolador para que use este valor. En el siguiente ejemplo se utiliza la variable pulseWidth como el argumento Duración del comando PULSOUT:

PULSOUT 12, pulseWidth

Programa ejemplo

Este programa nos va a permitir establecer el argumento Duración del comando PULSOUT introduciéndolo a través del panel de transmisión del terminal DEBUG del programa de edición.

Nota importante: cuando en un programa se definen variables, tanto el tipo como la dirección hay que colocarlas alineadas para su correcta ejecución.

Pasos a seguir

1. Haremos una pequeña marca en la rueda del robot para tener un punto de referencia.
2. Colocamos el interruptor de encendido del robot en la posición “2” (que envía energía a los servos).
3. Ejecutar el programa Pruebavelocidadservo.bs2
4. Introducir el valor 650 en el panel de transmisión del terminal DEBUG y pulsar ENTER
5. Contar las vueltas que da la rueda izquierda (el servo habrá girado durante 6 segundos en el sentido de las agujas del reloj, por lo que si multiplicamos el número de vueltas por 10 obtendremos el número de RPM).
6. Escribimos el valor en la tabla que reproducimos más abajo junto a la celda de 1300 ms.
7. Introducir el valor 655.
8. Contar las vueltas que da la rueda.
9. Multiplicar el valor por 10 y escribirlo junto al valor 1310 ms de la tabla.
10. Ir incrementando los valores de 5 en 5 (0,01 ms) hasta llegar a 850 (1700 ms).
11. Repetir el proceso para el otro servo (para ello tendremos que modificar el comando PULSOUT del programa de forma que los pulsos se envíen a P12).

¿Cómo trabaja el programa?

Se declaran tres variables: counter para el bucle FOR…NEXT, pulseWidth para los comandos DEBUGIN y PULSOUT, y pulseWidthComp, que almacena un valor que se usa en un segundo comando PULSOUT.

counter                         VAR       Word

pulseWidth                  VAR       Word

pulseWidthComp       VAR       Word

El commando FREQOUT (como vimos en el paso 5.2) lo utilizamos para indicar mediante un pitido del zumbador que el programa se ha iniciado.

El resto del programa se incluye dentro del bucle DO…LOOP lo que indica que se ejecutará una y otra vez. El programa le pide al operador del terminal DEBUG (nosotros) que introduzcamos un valor decimal que determinará la duración del pulso que se va a guardar en la variable pulseWidth. Para lograr una medición del tiempo más exacta se envían dos comandos PULSOUT cuyos argumentos Duración sumarán 1500 entre los dos

pulseWidthComp = 1500 – pulseWidth

Así se consigue que el bucle FOR…NEXT tarde siempre el mismo tiempo en ejecutarse independientemente del valor del argumento Duración que hayamos introducido y, por tanto, que las mediciones de las RPM que hagamos sean más exactas. Este bucle FOR…NEXT envía pulsos al servo izquierdo (P12) durante 6 segundos. El valor de la variable pulseWidthComp se envía al servo derecho (P13), haciendo que gire en la dirección contraria.

En el paso 4 vimos cómo se calculaba el tiempo: recordemos que el argumento Duración del comando PULSOUT se expresa en unidades de 2 millonésimas de segundo por lo que un valor de 650 envía pulsos de 1,3 ms de duración (a lo que es lo mismo 1300 ms).

Con los datos que vayamos obtenido vamos a completar la siguiente tabla para obtener nuestra propia curva de transferencia (debemos tener en cuenta que nuestro programa de ejemplo controla la rueda izquierda con los valores que introducimos. La rueda derecha gira en dirección contraria).

Una vez completada la tabla para la rueda izquierda, debemos modificar el comando PULSOUT para enviar el pulso a la rueda derecha, cambiando los parámetros como se indica

PULSOUT 13, pulseWidth

PULSOUT 12, pulseWidthComp

realizando a continuación las mismas mediciones.

Debemos tener en cuenta que los valores positivos de RPM se dan cuando la rueda gira en el sentido de las agujas del reloj, mientras que los valores negativos indican un giro de las ruedas en sentido antihorario. Recordar igualmente que, dada la disposición de los servos, para que el robot ande hacia adelante la rueda derecha tendrá que girar en sentido de las agujas del reloj, mientras que la izquierda en sentido antihorario.

     Última actualizacón: 14 noviembre 2017 a las 16:52

Bien, es hora de ponernos manos a la obra. Tras aprender a programar y hacer las debidas comprobaciones con los componentes esenciales, ha llegado el momento de montar el robot en sí mismo.

Describiremos paso a paso las operaciones necesarias para montar la estructura, las ruedas del robot y hacer las primeras conexiones. Se trata de un trabajo muy sencillo que, en mi caso, no me ha llevado más de una hora (y eso que he ido tomando las fotografías que ilustran cada explicación).

Las herramientas que vamos a emplear son el destornillador que acompaña el kit de montaje, unos alicates de punta y las pinzas de relojero que ya he utilizado con anterioridad.

Montaje del chasis

Para montar el chasis vamos a necesitar los siguientes componentes:

• Chasis metálico.
• 4 tubos metálicos (llamados separadores) de 20 mm.
• 4 tornillos de 10 mm.
• 1 goma que recubre el hueco interior por donde pasarán los cables.

Lo primero que haremos será introducir a presión la goma con la que vamos a recubrir el hueco situado en el centro del chasis ya que será por donde pasarán los diferentes cables. Acto seguido atornillaremos los cuatro tubos metálicos que actuarán como separadores entre el chasis en sí mismo y la tarjeta Home Work. Los puntos de fijación están situados en cada esquina:

Ya tenemos la estructura básica. Lo siguiente que haremos será colocar los servos en su lugar (recordemos que actúan como los motores de las ruedas). Para ello, primero debemos retirar las aspas quitando el tornillo central (recomiendo sujetar las aspas mientras se realiza esta operación para evitar forzar el servo). Las aspas salen fácilmente aplicando una leve presión. Una vez hecho lo anterior, guardaremos los dos tornillos porque serán necesarios más adelante.

Montaje de los servos en el chasis

Para montar los servos necesitaremos los siguientes elementos:

• 8 tornillos de 6 mm.
• 8 tuercas.

De nuevo la operación es muy sencilla. Elegiremos uno de los laterales del chasis e insertaremos el servo correspondiente como se muestra en la imagen inferior, de forma que el rotor sobresalga por el exterior (aquí irá montada la rueda). Acto seguido atornillaremos cada uno de los cuatro tornillos en su lugar junto con sus tuercas correspondientes:

Haremos lo mismo en el otro lateral:

Vemos como en este caso el potenciómetro queda «mirando» al interior del chasis con un acceso bastante difícil debido a la posición del portapilas (como nosotros hemos centrado los servos con anterioridad no resulta relevante). Sin embargo, esto se hace así porque el robot gana en maniobrabilidad. En cualquier caso, no hay problema en situar el potenciómetro hacia afuera aunque habría que hacer unos pequeños ajustes en la programación para corregir esta ubicación.

Una vez montados ambos servos, procederemos a introducir los cables por el hueco interior donde antes pusimos la goma protectora:

Instalación del portapilas

Como ya hemos explicado, el robot utiliza cuatro baterías para el movimiento de los servos, que constituyen la mayor parte de su peso y va situado detrás de los dos servos. Este elemento de plástico ya cuenta con dos orificios donde se introducirán los tornillos. Para su sujeción necesitamos los siguientes elementos:

• 2 tornillos de 10 mm. con la cabeza plana.
• 2 tuercas.

De nuevo el montaje es muy sencillo. Colocamos el portapilas, introducimos los dos tornillos y los sujetamos con las tuercas. Es importante colocarlo de forma que el cable quede lo más cerca posible del hueco central para evitar enredos:

Una vez colocados los servos y el portapilas, e introducidos los cables por el hueco central, esta es la vista de la parte superior del chasis:

Como detalle decir que he colocado dos etiquetas de colores para diferenciar el servo izquierdo y el derecho ya que será necesario tener claro cuál es cuál a la hora de hacer la conexión en la tarjeta Home Work y programar el movimiento del robot:

Montaje de las ruedas

Para montar las ruedas vamos a necesitar los siguientes elementos:

• 2 ruedas de plástico.
• 2 gomas elásticas (actúan como neumáticos).
• 1 bola de plástico (es la rueda trasera).
• 2 tornillos (los que reservamos al retirar las aspas de los servos).
• 1 chaveta metálica.

Lo primero que vamos a hacer es colocar la rueda trasera. Se trata de una bola de plástico con un agujero que la atraviesa. La chaveta metálica funcionará como un eje y permitirá que el robot tome cualquier dirección con el movimiento de las dos ruedas motrices delanteras.

Para ello, colocaremos la bola entre los dos agujeros en la parte trasera del chasis e introduciremos la chaveta metálica:

Acto seguido doblaremos los dos extremos para impedir que se salga de su lugar (más adelante podremos recortarlos ya que, aunque no impide el libre movimiento de la rueda, resulta algo antiestético).

Antes de posicionar las ruedas en los servos, tenemos que estirar las gomas elásticas y ajustarlas a la superficie exterior de cada rueda:

La colocación de las ruedas delanteras es muy sencilla ya que cada una tiene un hueco que encaja con el eje exterior de los servos. Presionamos levemente y empleamos los tornillos que antes retenían las aspas para sujetar las ruedas. Estas son las imágenes que muestran el robot con todas sus ruedas y el cableado asomando por el agujero central:

El último paso consistirá en montar la tarjeta Home Work de control sobre el chasis. Para ello emplearemos cuatro tornillos de cabeza redonda de 10 mm. y los fijaremos en los tubos metálicos que actúan como separadores:

Podemos darnos cuenta de que los cables tienen una longitud excesiva por lo que es recomendable utilizar una presilla o cualquier otro medio de recogerlos entre el chasis y la parte inferior de la tarjeta, dejando solo el tramo necesario para realizar las conexiones. Esto evitará que sobresalgan y se enreden con las ruedas:

Acto seguido conectamos el cable del portapilas en su lugar:

Y por último, conectamos los cables de los servos a los conectores adecuados de la tarjeta Home Work como hemos hecho en los pasos anteriores a este montaje:

Muy bien, ya tenemos listo nuestro robot para comenzar a instalar diversos sensores y realizar las pruebas.

     Última actualizacón: 30 mayo 2017 a las 18:37

Poco a poco vamos entrando en materia.  En este paso vamos a conectar, ajustar y probar los motores del robot.  Para ello necesitaremos comprender ciertos comandos del lenguaje PBASIC y unas técnicas de programación que determinarán la dirección, velocidad y duración del movimiento de los servomotores (llamados también servos).

Los motores del Boe-Bot

Los servos de rotación continua que vamos a emplear son los que aparecen en las siguientes imágenes:

Los servomotores estándar se diferencian de los de giro continuo en que éstos últimos pueden girar de forma continua en los dos sentidos, mientras que los primeros sólo giran 270o.  Los servos estándar se han diseñado para recibir señales electrónicas que les dicen qué posición concreta mantener.  En cambio, las señales que reciben los servos de rotación continua les dicen qué velocidad y dirección deben seguir, lo que los convierten en ideales para controlar ruedas y poleas (aquí dejo un tutorial para convertir un servo estándar en uno de rotación continua como una buena manera de conocer mejor el funcionamiento de ambos).

Primera tarea: medición del tiempo y control de repeticiones

Para controlar la velocidad de un servo y su dirección se requiere un programa que haga que el microcontrolador envíe el mismo mensaje de forma continua (las señales deben repetirse unas 50 veces por segundo para que el servo mantenga su velocidad y dirección).  Para lograrlo, vamos a escribir varios programas de ejemplo en PBASIC que muestran cómo repetir la misma señal una y otra vez y controlar la duración de la misma.

En el paso 2, y con más detalle en el paso 3, aprendimos el funcionamiento del comando PAUSE que indica al microcontrolador que debe esperar un tiempo determinado antes de ejecutar el siguiente comando.  Como recordarán, el formato es:

PAUSE duración

El valor del parámetro duración establece el tiempo de espera en milisegundos (por lo tanto, si queremos que el microcontrolador espere un segundo deberemos utilizar como valor 1000).

Vamos a utilizar un sencillo programa para comprobar otras funciones de este comando:

Es conveniente que tengamos en cuenta que el valor máximo de duración para el comando PAUSE es 65535 (poco más de un minuto y cinco segundos).

Uno de los motivos por los que son tan útiles un ordenador y un microcontrolador es que pueden hacer una y otra vez las mismas cosas aburridas sin quejarse.  Vamos a ver el ejemplo de un programa que hace que se repita la misma operación constantemente. Para ello emplearemos los comandos DO y LOOP:

Con la estructura del lenguaje PBASIC formada por DO … LOOP se puede repetir de forma indefinida la secuencia de instrucciones que se encuentra entre dichos comandos.

También se puede modificar el programa de forma que parte de él se ejecute una sola vez y otra parte se ejecute varias veces:

Segunda tarea: comando de control del servo

Antes de explicar los comandos que controlan los servos, necesitamos saber qué es un diagrama de tiempos porque lo emplearemos a menudo para representar la relación entre los niveles alto (HIGH — Vdd) y bajo (LOW — Vss) y el tiempo de duración de cada uno de esos estados (ya vimos la utilidad de los comandos HIGH y LOW en el paso anterior).

En el diagrama, el tiempo se representa de forma creciente de izquierda a derecha:

Este diagrama muestra un tren de pulsos de un segundo de duración en el que se envía un nivel alto durante medio segundo, y uno bajo durante otro medio segundo.  Esto puede representar, por ejemplo, el encendido de un led durante medio segundo y su apagado durante otro medio segundo de forma reiterada (la línea de puntos de la derecha indica que la señal se repite continuamente).

Los niveles lógicos altos y bajos que genere el programa de control de giro de los servos deben durar una cantidad muy concreta de tiempo.  Esto es así porque el circuito electrónico que gobierna los servos mide la cantidad de tiempo que una señal permanece alta y la usa como si se tratase de una instrucción para girar.  Para controlar con precisión el giro, el tiempo que esas señales permanecen altas tiene que ser mucho más exacto de lo que se puede conseguir utilizando los comandos HIGH y PAUSE.  En el caso del comando PAUSE, como hemos visto, sólo se puede controlar su parámetro duración con pasos de 1 ms.

Sin embargo, para una mayor precisión hay un comando diferente: PULSOUT, que proporciona señales de nivel alto durante periodos de tiempo muy pequeños (en este caso, su parámetro duración se expresa en valores de unidades de 2 millonésimas de segundo). Se escribe:

PULSOUT pin, duración

Tercera tarea: conexión de los servos

Vamos a montar los servos y los conectaremos a unas baterías de alimentación así como a la tarjeta. Emplearemos circuitos LED para controlar las señales que el microcontrolador envíe a los servos para determinar su movimiento ya que de esta forma las señales también iluminarán los LED.

En primer lugar, debemos asegurarnos que el interruptor de energía de la tarjeta está en la posición “0” de apagado.

La siguiente imagen muestra el lugar donde se conectan los servos. Pueden observar como entre los conectores X4 y X5 hay tres pines con una leyenda en la parte superior (Vdd) y otra en la inferior (Vin). Dos de estos pines aparecen conectados por un puente. En la imagen vemos cómo el puente está colocado en la posición superior (Vdd) así que tendremos que cambiarlo a la posición (Vin) ya que vamos a utilizar un bloque de 4 pilas como fuente de energía (los servos consumen bastante intensidad por lo que es recomendable utilizar pilas potentes y recargables):

Extraerlo es muy sencillo, basta utilizar unas pinzas para sacar el puente de su lugar. Luego lo insertaremos de nuevo a presión en la posición inferior:

Bien, una vez solucionado el tema de la alimentación, ya podemos conectar los servos como se muestra en las siguientes imágenes:

Importante: tengamos en cuenta que de los servos parten tres cables: el blanco se conecta a cualquiera de los conectores P12 o P13, el rojo a la toma Vin y el negro a la toma de tierra (Vss).

Como hemos indicado al inicio, montaremos el siguiente circuito LED para visualizar las señales que se envíen a los servos y comprobar que todo funciona correctamente:

Cuarta tarea: ajustando los servos

Vamos a ejecutar un programa que enviará una señal a los servos que les obligará a permanecer parados. Como los servos, por lo general, no vienen ajustados de fábrica, cuando se aplica la señal de “paro” es posible que mantengan un ligero movimiento que hay que eliminar (esta operación recibe el nombre de “centrar” los servos). Para realizar el ajuste emplearemos un destornillador con punta de estrella.

El siguiente diagrama muestra la señal que se enviará para calibrar los servos. Es la señal de centrado y consiste en una serie de pulsos de 1,5 ms de duración, con una pausa entre cada uno de ellos de 20 ms, que generaremos con el comando PULSOUT que ya hemos visto:

Los servos están preparados para permanecer detenidos cuando se les envía un pulso de 1,5 ms, así que daremos al comando PULSOUT un parámetro duración con valor 750 (recordemos que 1,5 milisegundos son 0,0015 segundos, por lo que al expresarse el valor del parámetro duración en unidades de 2 millonésimas de segundo, la cifra que tendremos que darle tendrá que ser el cociente entre ambas:

Es conveniente ajustar los servos de uno en uno ya que así podremos escuchar si el que estamos probando se está moviendo ligeramente. El siguiente programa va a ajustar el servo conectado a P12, cuando terminemos la operación, bastará cambiar a P13 para repetir el procedimiento con el otro servo:

Antes de cargar y ejecutar el programa deberemos encender la placa colocando el interruptor en la posición “2”, que es la que entrega energía a los servos. Una vez ejecutado el programa comprobaremos que el LED de monitorización conectado a P12 se enciende, lo que indica que se están transmitiendo pulsos al servo. Si el servo no está bien ajustado (lo más probable), su aspa comenzará a girar y oiremos el motor interno haciendo ruido.

Es posible que el servo no gire en absoluto. Esto puede significar que, o bien está ajustado de fábrica, o que está dañado o defectuoso. Más tarde realizaremos una comprobación antes de que instalemos los servos en el chasis del robot para verificar que el servo funciona correctamente.

Bien, esto es lo que debemos hacer:

Acto seguido repetiremos el proceso con el servo conectado a P13.

Quinta tarea: registrando valores y contando

Vamos a aprender qué son las variables y a utilizarlas en los programas para almacenar valores. Todos los programas que vamos a necesitar a partir de ahora utilizarán en gran medida las variables. La utilidad más importante cuando se guardan variables es que permite que el programa las use para contar. De esta forma podremos controlar el número de veces que se repiten las cosas.

Antes de que podamos usar una variable en lenguaje PBASIC, debemos nombrarla y establecer su tamaño, esto es lo que se llama “declarar” la variable:

Nombrevariable VAR tamaño

Podemos declarar cuatro tamaños diferentes:

Bit ― 0 a 1

Nib ― 0 a 15

Byte ― 0 a 255

Word ― 0 a 65535

Una vez declarada una variable, podemos inicializarla, es decir, podemos asignarle un valor inicial (si no lo hacemos el programa comenzará automáticamente almacenando el número 0 que es el valor por defecto):

valor = 500

otro_valor = 2000

El símblo «=» es un operador. Podemos utilizar distintos para realizar operaciones matemáticas y como por ejemplo, multiplicar «*»:

valor = 10 * valor

Programa de ejemplo: variablesymatemáticassimples.bs2

Este programa muestra la forma de declarar variables, inicializarlas y realizar algunas operaciones con ellas:

Conteo y control de repeticiones

La manera más adecuada de controlar el número de veces que se ejecuta un fragmento de código de programa es utilizando el bucle FOR…NEXT. Su sintaxis es la que sigue:

FOR contador = valorinicial TO valorfinal {STEP valorincremento}…NEXT

Los puntos suspensivos se sustituyen por el comando o comandos que deseamos repetir. Debemos declarar previamente las variables «contador» (esta variable la podemos llamar como queramos), «valorinicial» y «valorfinal» que pueden ser tanto números como variables o, incluso, una expresión (que veremos más adelante). Cuando veamos algo entre llaves { } en una descripción de la sintaxis de una instrucción, significa que es un parámetro opcional.

Programa de ejemplo: contarhastadiez.bs2

Como vemos, lo que hace el programa es contar hasta diez. Si modificamos los valores inicial y final, por ejemplo, colocando como valor inicial un 9 y valor final un 1, lo que veremos será una cuenta atrás ya que el valor inicial es mayor que el final.

Del mismo modo, el parámetro STEP hace que el bucle cuente por pasos: en vez de números seguidos, podemos hacer que cuente de dos en dos, o de cien en cien según el valor que le demos:

Sexta tarea: comprobando los servos

Antes de montar los servos en el robot debemos comprobar que responden correctamente. Para ello vamos a ejecutar un programa que enviará señales de giro a los servos en diferentes direcciones y a diferentes velocidades.

Control de la velocidad y la dirección

El circuito electrónico que gobierna el servo está preparado para que cuando reciba impulsos de 1,3 ms de duración cada 20 ms haga girar el eje del motor en el sentido de las agujas del reloj y a la máxima velocidad (oscila entre 50 y 60 revoluciones por minuto, RPM). Cuando se aumenta la duración del impulso de 1,3 ms a 1,5 ms la velocidad de giro decrece hasta que se para el motor. Cuando se aplica al servo un impulso de 1,7 ms de duración cada 20 ms, el eje del motor gira en sentido antihorario y a máxima velocidad. Cuando se reduce la duración del impulso a 1,5 ms decrece la velocidad de giro hasta detenerse.

Un esquema general de los impulsos necesarios para el movimiento del servo sería el siguiente:

Veamos los programas que controlan el giro:

Programa de ejemplo: servoP12sentidohorario.bs2

Basta con realizar cambios en los parámetros de duración para hacer que los servos giren en un sentido o en el otro, o hacer que uno de ellos lo haga en sentido horario y el otro en el sentido antihorario. El que cada servo gire en diferente dirección es de gran importancia ya que una vez montados, ambos servos se encuentran enfrentados, por lo que si giran en el mismo sentido el robot no dejará de dar vueltas sobre su propio eje. Para que el robot avance en la misma dirección, cada uno de los servos deberá girar en un sentido distinto y a la misma velocidad:

Programa de ejemplo: P12horarioP13antihorario.bs2

Control del tiempo que gira el servo

Ya conocemos la forma de controlar la velocidad de giro y la dirección del servo, lo único que nos falta es determinar el tiempo que permanece girando. Para ello emplearemos el bucle FOR…NEXT:

Para calcular el tiempo de forma adecuada necesitamos saber la cantidad exacta de tiempo que tarda el código en hacer que el servo gire. Cada vez que se recorre el bucle, el comando PULSOUT tarda 1,7 ms en ejecutarse, el comando PAUSE tarda 20 ms y el bucle en sí mismo tarda unos 1,3 ms en ejecutarse. Por lo tanto, un ciclo completo se completa en 23 ms o, lo que es lo mismo, en 0,023 segundos.

Ya que según el ejemplo anterior el bucle se ejecuta 100 veces, tardará 2,3 segundos en llevarse a cabo.

Programa de ejemplo: Controltiempofuncionamientoservo.bs2

Veamos un vídeo que resume lo hecho hasta ahora: