Herramientas de usuario

Herramientas del sitio


Barra lateral

Traducciones de esta página:

Página principal

Análisis y comparativas

Eventos Guías Herramientas Información de interés Proyectos
> Usuarios Varios Wiki Privado

No hay páginas en esta sección.

old admin

No hay páginas en esta sección.

proyectos:sapoconcho_bats

Sapoconcho BATS

Sapoconcho BATS es un proyecto nuevo para mezclar dos anteriores de Bricolabs:

  • BATS -Bricolabs Arduino Training Shield- es una idea original de una placa escudo (shield) para Arduino UNO con muchos de los componentes que se utilizan en los cursos para el aprendizaje inicial de esta plataforma.
  • Sapoconcho es un proyecto de robot educativo imprimible (printbot), versátil, sencillo y barato.

DISCLAIMER: este proyecto está en fase muy temprana. Algunas cosas están en constante evolución

b6c899e0-daf2-476b-9b9c-24abd7d8fbd1.jpeg

Las ideas básicas que resultan de unir los dos proyectos son:

  • Proyecto abierto y documentado.
  • Aprendizaje de electrónica básica: componentes básicos, montajes sencillos y soldadura.
  • Aprendizaje de programación básica: programación física con funciones, variables y librerías.
  • Aprendizaje de robots móviles: montaje de chasis con formato tortuga, electrónica de control y sensores.

Se trata de un proyecto de aprendizaje. No nos atrevemos a llamarlo proyecto educativo porque ninguno de los desarrolladores tenemos formación ni experiencia en pedagogía. Simplemente acumulamos la experiencia de unos cuantos años de talleres para quien quiera usar el proyecto de manera total y absolutamente libre. Tal y como está ordenado aquí o del modo que se quiera modificar.

Historia

El proyecto BATS es una idea de placa escudo (shield) sobre Arduino UNO para aprender electrónica y programación básicas, así como soldadura. En esta misma wiki hay una entrada para su montaje y una para su programación. De esas dos entradas ha salido la base para este nuevo proyecto.

bats.jpg

El proyecto Sapoconcho surgió en 2013 como una evolución de los talleres de la iniciativa KiiCS de los Museos Científicos para cambiar un producto comercial por uno DIY/DIWO. En 2020 se creó la versión XL que es la base del chasis que se usará en este remix.

5d495b8a-2aa0-402c-b93e-4d75850903ff.jpeg

Con la evolución del modelo Sapoconcho XL, que monta un Arduino UNO y una shield con una placa de prototipado, surge la idea de cambiarla por una versión evolucionada de la shield BATS que incluya un controlador de motores.

Pasos del proyecto

La idea conjunta del proyecto seguirá una serie de pasos para el aprendizaje de los diferentes objetivos:

  1. Montaje de la shield soldando los componentes.
  2. Iniciación a la programación física con Arduino.
  3. Montaje del chasis del robot móvil y pruebas de movimiento.
  4. Programación avanzada para hacer autónomo el robot.

Montaje de la Sapoconcho BATS shield

La shield aún no está terminada en formato PCB. La versión de desarrollo de la foto se parece al resultado que tendrá finalmente.

a6bf00c6-2e50-4126-9dc7-5bab1d8c114e.jpeg

Iniciación a la programación física con Arduino

Un programa no es nada más que una lista de instrucciones ordenada. Para que Arduino la entienda debemos utilizar su propio lenguaje, que es el que iremos aprendiendo por medio de ejemplos y proyectos. Llamamos programación física a la que tiene como resultado una acción en el munto real como encender una luz o un motor.

Proyecto 1. Salidas digitales

Un mundo binario

Una salida digital es una forma de comunicación binaria desde Arduino hacia el exterior. La llamamos binaria por que tiene sólo dos posibles estados: si/no, encendido/apagado, uno/cero. En el caso de un microcontrolador como Arduino esos estados significan que en un pin haya 5 voltios (estado HIGH) o cero voltios (LOW). Si en ese pin hemos conectado un led, cuando haya 5 voltios se encenderá.

El programa de Arduino para encender un led tiene dos partes: en la primera le decimos que queremos usar un pin como salida digital (los pines pueden tener muchas funciones). En la segunda le decimos que lo encienda. Más adelante veremos además qué significa eso de void loop() o setup(). Puedes teclear el código o cortar y pegar. Las instrucciones deben acabar en punto y coma ;.

void setup()
{
  pinMode(2,OUTPUT); // vamos a usar el pin 2 como salida
}

void loop()
{
  digitalWrite(2,HIGH); // pone el pin 2 en estado 'alto', a 5 voltios
}

NOTA: Para entender mejor los programas ponemos comentarios a las instrucciones. Todo lo que está después de dos barras es ignorado por Arduino.

Después de escribir cualquier programa es necesario guardarlo y subirlo a la placa Arduino. Cuando subas el código si todo ha ido bien se habrá encendido un led verde que está conectado al pin 2. Por la forma en que está conectada la placa BATS al subir un programa oiremos un pitido. Eso es que todo va bien.

Blink: el led parpadea

El programa anterior tiene dos partes, y cada una encierra un grupo de instrucciones entre llaves {}.

  • void setup(): estas tareas (instrucciones) se harán (ejecutarán) sólo una vez, cuando arrancamos o reiniciamos Arduino.
  • void loop(): esas tareas se repetirán para siempre, cuando acabe la lista empezará por el principio otra vez.

Vamos a aprovechar esto para probar a encender y apagar el led de antes indefinidamente

void setup() // esto se hará sólo una vez
{
  pinMode(2,OUTPUT); // vamos a usar el pin 2 como salida
}

void loop() // esto se va a repetir para siempre
{
  digitalWrite(8,HIGH); // pone el pin 2 en estado 'alto', a 5 voltios, y enciende el led
  delay(500); // espera medio segundo (500 milisegundos) sin hacer nada
  digitalWrite(8,LOW); // pone el pin 2 en estado 'bajo', y apaga el led
  delay(500); // espera medio segundo sin hacer nada
}

Ahora el led debería parpadear. Medio segundo encendido, medio segundo apagado y seguir así. Cambiando los valores de la instrucción delay(microsegundos) podemos cambiar el ritmo.

Arduino ya tiene este programa entre sus ejemplos como

Archivo>Ejemplos>01.Basics>Blink

Sólo hay que buscar en el programa 'LED_BUILTIN’ y en todos los sitios donde aparezca cambiarlo por un 2. O quizás decidas no cambiarlo, a ver qué sucede. La prueba y error es un método maker fundamental.

Guardar números: Variables

Supongamos que ahora queremos cambiar qué LED encendemos en el programa. El amarillo, por ejemplo, está conectado al pin 4. Podemos cambiar el 2 por 4 en todos los sitios del programa donde aparece. Pero si el programa es largo esto es un follón. Para esto (y muchas más cosas) usamos variables, que son nombres que guardan números y otros contenidos. Tendrán un nombre y un valor. Cada vez que cambiemos el valor se cambiará en todos los sitios donde aparezca la variable.

int led=2; // creamos una variable con nombre led y valor 2
void setup()
{
  pinMode(led,OUTPUT); // vamos a usar el pin 'led' como salida
}

void loop()
{
  digitalWrite(led,HIGH); // pone el pin 'led' en estado 'alto', a 5 voltios, y enciende el led
  delay(500); // espera medio segundo sin hacer nada
  digitalWrite(led,LOW); // pone el pin 'led' en estado 'bajo', y apaga el led
  delay(500); // espera medio segundo sin hacer nada
}

Este programa nuevo funciona igual que el anterior, habiendo parpadear el led verde. Pero si ahora cambiamos la primera instrucción y le damos valor 4 en vez de 2 a la variable led, todas las instrucciones que viene después (el pin es de salida, encender e pin, apagar el pin) se harán sobre el pin 4 y el que parpadeará será el pin amarillo.

Tarea 1: Mi primer semáforo, chispas

Tenemos tres leds sencillos en total

  • Un led verdes en el pin 2.
  • Un led amarillo en el pin 4.
  • Un led rojos en el pin 6.

Sabemos que los proyectos con semáforos acaban siendo odiados por lo mucho que se usan (o abusan), pero están bien para aprender. La tarea final de este proyecto es escribir un programa que encienda y apague las luces según un semáforo, de momento sin parpadear. Debe hacer lo típico:

  • Encender el led verde 5 segundos.
  • Encender el led amarillo 2 segundos.
  • Encender el led rojo 5 segundos.

El objetivo de la tarea es escribir código desde cero (en lugar de copiarlo y pegarlo) para fijar conceptos.

Proyecto 2: Instrucciones repetidas en bucle

Tengo un led amarillo, que es lo que parpadea ahora

Al semáforo de la tarea del proyecto 1 le vamos a añadir una complicación para que sea más realista: la luz amarilla en lugar de estar encendida 2 segundos, ahora va a parpadear 4 veces. Entre las tareas de encender la luz verde y la roja, meteríamos unas nuevas así:

  digitalWrite(4,HIGH);
  delay(250);
  digitalWrite(4,LOW);
  delay(250);
  digitalWrite(4,HIGH);
  delay(250);
  digitalWrite(4,LOW);
  delay(250);
  digitalWrite(4,HIGH);
  delay(250);
  digitalWrite(4,LOW);
  delay(250);
  digitalWrite(4,HIGH);
  delay(250);
  digitalWrite(4,LOW);
  delay(250);

Sin embargo viendo el código vemos que hay muchas instrucciones que se repiten continuamente. Si en vez de 4 veces fuesen muchas más esto ya no sería muy práctico. Tiene que haber una forma más simple de hacer esto.

Para eso vamos a usar una nueva forma de dar instrucciones, una estructura de programación para repetir tareas. Existe en casi todos los lenguajes de programación y se llama bucle for. En su forma más simple puede verse abajo

void loop()
{
  for (int i=0; i<8; i=i+1) // esta tarea se repetirá 8 veces
  {
    digitalWrite(4,HIGH);
    delay(250);
    digitalWrite(4,LOW);
    delay(250);
  }
}

La forma de escribir un bucle for tiene tres partes separadas por punto y coma:

  • Definir una variable y una condición inicial: usaremos la variable i, con valor inicial cero.
  • Definir la condición que indica cuándo terminar el bucle: se continuará mientras que i sea menor 8.
  • Definir el cambio entre paso y paso del bucle: sumando 1 para que i vaya tomando los valores 0, 1, 2… y al llegar a 8 terminar.

La tarea a repetir vendrá luego entre corchetes {}.

NOTA: es bastante habitual usar la variable i por índice pero podemos llamarla como queramos. O casi. No podemos usar nombres que ya tienen otro uso, como la propia palabra for.

Ver cosas en la pantalla: el monitor serie

Al contrario que cualquier ordenador al que estamos acostumbrados Arduino no tiene una pantalla en la que mostrarnos cosas, pero sí podemos usar una forma para mostrar lo que queramos en la pantalla del ordenador al que está conectado (mientras lo esté): el monitor serie.

Para usarlo tenemos que meter una instrucción especial en el setup() y cada vez que queramos mostrar -diremos imprimir en la pantalla- algo que puede ser un texto, un número…

void setup()
{
  Serial.begin(9600); // decimos a Arduino que vamos a usar el monitor serie
}

void loop()
{
  for (int i=0; i<10; i=i+1)
  {
    Serial.println(i); // "imprimimos" el valor de i por el monitor serie y saltamos de línea
  }
  delay(1000000); // ver TRUCO
}

Una vez que carguemos el código debemos abrir el monitor serie, un icono con forma de lupa arriba a la derecha en Arduino o en el menú Herramientas>Monitor Serie.

monitor_serie.jpg

TRUCO: Sabemos que Arduino está preparado para repetir todo lo que hay en void loop() (en este caso contar de 0 a 9). Si queremos que haga las cosas sólo una vez un truco posible es poner un delay muy largo al final.

Este programa está pensado para probar valores diferentes de los iniciales (i=0), finales (i<10) y de salto (i=i+1) para experimentar qué pasa viendo el resultado en el monitor serie. En general el monitor nos servirá para ver en mitad de un programa qué está pasando.

El semáforo realista

Si sólo queremos que parpadee la luz amarilla podíamos haber hecho igual que en el Blink del proyecto 1, pero para meter esto dentro de un programa que hace más cosas ésta es la manera más simple. El programa completo ahora sería

void setup()
{
  pinMode(2,OUTPUT); // led verde
  pinMode(4,OUTPUT); // led amarillo
  pinMode(6,OUTPUT); // led rojo
}

void loop()
{
  digitalWrite(2,HIGH); // instrucciones para encender y apagar la luz verde
  delay(5000);
  digitalWrite(2,LOW);

  for (int i=0; i<8; i=i+1) // esta tarea se repetirá 8 veces
  {
    digitalWrite(4,HIGH);
    delay(250);
    digitalWrite(4,LOW);
    delay(250);
  }

  digitalWrite(6,HIGH); // instrucciones para encender y apagar la luz roja
  delay(5000);
  digitalWrite(6,LOW);
}

Tarea 2: Las luces de feria

Nuestras luces ya no son un semáforo, ahora son una feria. Escribir un programa para que parpadeen todos los leds (los verdes, amarillo y rojos) por turnos. El orden de parpadeo y la frecuencia son libres.

Como bola extra, tratar de que parpadeen por grupos. El objetivo de la tarea y la bola extra es tratar de entender bien el orden en que se realizan las instrucciones.

Proyecto 3: Salidas "analógicas"

Donde dije digital, digo Diego

Tucho dixit

Los gallegos sabemos mejor que nadie que en esta vida no todo es blanco o negro, encendido o apagado y que a veces la mejor respuesta es depende.

Las salidas digitales tienen como posibles estados de Arduino 0 voltios y 5 voltios, pero entre 0 y 5 hay todo un mundo. Las salidas que pueden tener valores intermedios se llaman analógicas. En realidad Arduino hace un truco que se llama PWM (Pulse Width Modulation) que no es exactamente eso pero de momento nos vale como si lo fuera.

A las salidas analógicas les daremos valores entre 0 (que corresponde a 0 voltios) y 255 (que corresponde a 5 voltios). Los valores intermedios encenderán a medias el led según una regla de tres.

NOTA: no todos los pines de Arduino UNO pueden hacer esta función PWM. Están marcados en la placa con el símbolo ~, como el pin 6 del led rojo.

int luminosidad = 0; // probaremos valores entre 0 y 255
void setup()
{
  pinMode(6,OUTPUT); // vamos a usar el led rojo de la BATS
}

void loop()
{
  analogWrite(6,luminosidad); // poner el pin con el valor intermedio buscado
}

Cambiando el valor de la variable luminosidad entre 0 y 255 veremos que el led se va encendiendo más o menos. Y podemos comprobar que no es muy proporcional. A partir de un valor de 50 ya brilla a tope. También podemos probar qué pasa si metemos un número más grande de 255.

No me despiertes bruscamente

Si quieremos hacer cambiar la luminosidad del led poco a poco podemos probar esto

void setup()
{
  pinMode(6,OUTPUT);
}

void loop()
{
  for (int i=0; i<60; i = i+10)
  {
    analogWrite(6,i);
    delay(500);
  }
}

A diferencia del bucle que usábamos antes en la que la variable i se usaba sólo como contador para repetir muchas veces, ahora esa variable sirve para algo dentro del bucle, para definir la luminosidad. Con este programa, cada 500 milisegundos iremos subiendo la intensidad de luz hasta 50 y volverá a empezar de cero.

La variable del bucle en este caso ya no sube de uno en uno, sino de 10 en 10 tomando valores i=0, 10, 20, 30, 40, 50.

También podríamos empezar con un valor alto para la variable y reducirlo restando valores hasta llegar a un mínimo. El IDE de Arduino tiene un programa de ejemplo que hace algo parecido:

Archivo>Ejemplos>03.Analog>Fading (cambiar el pin del led de 9 a 6)

Tarea 3: el driver de motores

En el montaje de la shield hemos instalado un circuito controlador de motores. Está controlado por las salidas 6(PWM) y 7 para el motor izquierdo, y 8 y 9(PWM) para el motor derecho. El objetivo de la tarea es probar diferentes valores en los pines con números entre 0 y 255 para los PWM y únicamente HIGH/LOW para los demás. Recuerda declararlos como salidas en el setup. Ejemplo:

  digitalWrite(6,HIGH);
  analogWrite(7,128);

Proyecto 4: Entradas digitales y analógicas

Información desde el exterior

Podemos interpretar las entradas de datos a Arduino como la información que tenemos del exterior por nuestros sentidos.

Pulsar un botón

En el caso de las entradas digitales, la información será como lo visto para las salidas: si/no, encendido/apagado, uno/cero. Empezaremos con la más sencilla: un interruptor o un botón, que cuando lo pulsemos cambiará de estado. Como para las salidas, necesitamos declarar la función del pin antes de usarlo. En la shield tenemos los dos botones conectados a los pines 11 y 12. Para ver su estado, vamos a usar el monitor serie.

void setup()
{
  pinMode(11,INPUT); // vamos a usar el pin 11 como entrada
  Serial.begin(9600); // decimos a Arduino que vamos a usar el monitor serie
}

void loop()
{
  int entrada = digitalRead(10);
  Serial.println(entrada);
  delay(10);
}

Subiendo el código y abriendo el monitor serie podremos ver lo que sucede cuando pulsamos los botones. El IDE tiene un programa de ejemplo parecido

Archivo>Ejemplos>01.Basics>DigitalReadSerial (cambiar el pin digital 2 por el 11/12).

Encender la luz

Podemos unir la información de entrada con la de salida enlazando un botón con un led.

void setup()
{
  pinMode(11,INPUT); // pin 11 con un botón
  pinMode(2, OUTPUT); // pin 2 con el led verde
}

void loop()
{
  int entrada = digitalRead(10);
  digitalWrite(2,entrada);
  delay(10);
}

Entradas analógicas

Arduino tiene varios pines con entradas que son capaces de medir un valor intermedio entre LOW (0 voltios) y HIGH (5 voltios). Para medir algunos parámetros (temperatura, distancia…) utilizaremos sensores que leeremos con una entrada analógica. La shield tiene dos resistencias variables (potenciómetros) que pueden simular una entrada analógica para ver cómo se usa.

El IDE tiene un ejemplo que lee una entrada y muestra el resultado por el monitor serie.

Archivo>Ejemplos>01.Basics>AnalogReadSerial: cambiar el pin A0 por el A1/A2.

Una vez subido el programa y abierto el monitor serie giraremos el potenciómetro para ver el resultado. El número que muestra el monitor serie será 0 en un extremo, 1023 en el otro y un valor proporcional para valores intermedios.

Tipos de variables

Hasta ahora hemos definido variables con un nombre, y les hemos puesto por delante la coletilla 'int' pero sin explicar qué significa eso. Cuando creamos una variable tenemos que decirle a Arduino qué tipo de números -y otras cosas que no lo son- va a almacenar. Veremos ahora los tipos más comunes:

  1. 'int': en las variables integer almacenaremos números enteros. Positivos o negativos, pero sin decimales.
  2. 'float': en las variables floating point almacenaremos números reales. Positivos o negativos, con decimales.

Cuando leemos una entrada analógica, obtenemos un número entero entre 0 y 1023, que se corresponde con una tensión en voltios de 0 a 5 según una regla de tres. El programa de ejemplo

Archivo>Ejemplos>01.Basics>ReadAnalogVoltage

lee el valor en una entrada (entero) y lo convierte en un número real de 0 a 5 con los decimales que correspondan.

Otro tipo de variable común es 'boolean', que es una condición y sólo puede tener valores 'TRUE' o 'FALSE', o bien 1 y 0.

Tarea 4: Regular la luz

Leer una entrada (de uno de los dos potenciómetros) y en proporción a ella encender un led de forma variable.

Proyecto 5: Tareas condicionadas

Sentencia if-then

Con mucha frecuencia querremos que nuestro programa haga una determinada tarea, pero sólo si se cumple una condición. La forma de hacerlo es con una sentencia if-then (si-entonces). La forma básica es con la instrucción if, después la condición entre paréntesis () y la lista de tareas entre corchetes {}.

if (condición)
{
  // tareas a realizar si se cumple la condición
}

Una forma más completa es tener una tarea alternativa si la condición no se cumple.

if (condición)
{
  // tareas a realizar si se cumple la condición
}
else
{
  // tareas a realizar si NO se cumple la condición
}

La condición será una expresión matemática (igual, mayor, menor…). El programa anterior que enlazaba el botón con el led puede hacerse también de este modo

void setup()
{
  pinMode(11,INPUT); // pin 11 con un botón
  pinMode(2, OUTPUT); // pin 2 con el led verde
}

void loop()
{
  int entrada = digitalRead(10);
  if (entrada == 1) // la comparación de igualdad de dos números se escribe con un símbolo doble ==
  {
    digitalWrite(2,HIGH);
  }
  else
  {
    digitalWrite(2,LOW);
  }
  delay(10);
}

El IDE tiene un ejemplo de if-then que conecta un potenciómetro con un led

Arduino>Ejemplos>05.Control>IfStatementConditional: cambiar el analogPin por A1 y el ledPin por 2/4/6. Probar diferentes valores el umbral (threshold) y girar el potenciómetro.

Variables de estado

Vamos a definir ahora un estado del sistema con una variable que vamos a llamar 'encendido', y que podrá tener valores 0 y 1. El cambio de un estado a otro se hará con los botones del pin 11 y el 12. Y el resultado de estar encendido será el led verde y el apagado el led rojo.

int encendido = 0;

void setup()
{
  pinMode(11,INPUT); // pin 11 con un botón
  pinMode(12,INPUT); // pin 12 con un botón

  pinMode(2, OUTPUT); // pin 2 con el led verde
  pinMode(6, OUTPUT); // pin 6 con el led rojo

}

void loop()
{
  if (encendido == 0)
  {
    encendido = digitalRead(12); // si el sistema está apagado y se pulsa el botón verde, pasa a encendido
  }
  if (encendido == 1)
  {
    encendido = !digitalRead(11); // si el sistema está encendido y se pulsa el botón rojo, pasa de apagado. El símbolo ! indica que intercambiamos los valores 0 y 1.
  }
  digitalWrite(2,encendido);
  digitalWrite(6,!encendido);
  delay(10);
}

Este programa con una variable de estado es el ejemplo más sencillo de un autómata de estados finitos (en inglés Finite State Machine). Parece un programa sencillo, pero añadido a los programas de movimiento del robot nos permitirá pararlo o volver a ponerlo en marcha en cualquier momento.

Tarea 5: luces autónomas

En el pin A0 de la BATS hay conectado un sensor de luz. El programa debe leer la información, y si la luz no es suficiente (establecer un umbral) se debe encender una luz led. Así es como funcionan algunas farolas.

Montaje del chasis

Piezas imprimibles

El chasis de Sapoconcho XL consta de las siguientes piezas:

  • Bases superior e inferior.
  • Soporte de motores (1 unidad).
  • Pilares de unión (o separación) de las dos bases (4 unidades). Pueden usarse en su lugar separadores de circuitos de 30mm.
  • Ruedas (2 unidades).
  • Soporte de sensores de ultrasonidos (1 ó 2 unidades).

En una impresora típica de 200x200mm se pueden imprimir todas las piezas en dos tandas.

prusa_sapoconcho.jpg

Todas las piezas están en este repositorio de Github. Ahí puedes encontrar los archivos originales de OpenSCAD para modificarlos a tu gusto o los STL para imprimir directamente.

Montaje mecánico

El chasis base tiene pocas piezas y el montaje es muy sencillo.

Paso 1: Los motores amarillos se unirán al soporte con 4 tornillos M3x30.

foto_5-4-22_22_25_45.jpg

Paso 2: Unir la base inferior al soporte con dos tornillos M3x10. También se puede poner ahora la bola loca o 'ballcaster', el tercer punto de apoyo.

foto_5-4-22_22_28_43.jpg

Paso 3: Montar los 4 pilares a la base inferior con 4 tornillos M3x10.

foto_5-4-22_22_34_04.jpg

Paso 4: Montar la base superior a los pilares con otros 4 tornillos M3x10. Ojo a la orientación en la foto.

montaje_4.jpg

Paso 5: Colocar las ruedas -cada una con su 'neumático'-, montar el Arduino UNO con tornillos M3x6 (dos en diagonal son suficientes) y pinchar la Shield sobre él.

montaje_5.jpg

Hay también la opción de montar motores tipo N20, cambiando el soporte y las ruedas.

Driver de motores

Arduino no puede operar directamente un motor. Necesita un intermediario o driver. Existen dos drivers de motores muy parecidos y válidos para Sapoconcho XL: el Toshiba TB6612 y el DRV8833. Aunque los pines no son iguales, el cableado y la programación hacen que sean intercambiables.

La shield tiene un zócalo para montar cualquiera de los dos drivers y cuatro conectores para los cables de los motores. Si al probar las funciones de movimiento alguna rueda gira al revés, hay que intercambiar los cables de ese motor.

Alimentación

Para alimentación utilizaremos un portapilas para 4 pilas AA. Y para que valga para cualquier proyecto, puedas usar pilas recargables y reduzcamos la contaminación añadiremos siempre un regulador dc-dc elevador para elevar la tensión de salida (step-up). El LM2587 y el XL6009 valen y tienen un tornillo para regular la tensión de salida; un buen valor es 7,5v.

b81b3d06-ffa5-4bf8-bc31-b1728914424d.jpeg

Las conexiones del step-up son muy sencillas: entrada positiva/negativa (IN+ rojo/IN- negro) desde el portapilas y salida positiva/negaviva (OUT+ rojo/OUT- negro) a la clavija. Además sacaremos un cable con un extremo Dupont macho para alimentar el driver antes del step-up, de IN+ a VM.

e9990159-cb36-4224-b8ae-dac534b8b2ad.jpeg

Programación de Sapoconcho

Funciones en Arduino

Cuando repetimos una tarea (un conjunto de instrucciones) con frecuencia, podemos enlatarlas en una función. Las funciones tendrán un nombre y un grupo de tareas entre corchetes {}. También pueden tener valores de entrada y salida, pero eso lo veremos más adelante con ejemplos.

Para el caso de la luz parpadeante del semáforo, podemos crear la siguiente función:

void blink()
{
  for (int i=0; i<8; i=i+1) // esta tarea se repetirá 8 veces
  {
    digitalWrite(6,HIGH);
    delay(250);
    digitalWrite(6,LOW);
    delay(250);
  }
}

Una vez que hemos definido la tarea, cada vez que la llamemos por su nombre blink(), se ejecutarán las tareas que hemos escrito. De ese modo si se van a hacer varias veces a lo largo del programa, no necesitamos escribir cada vez todo el código. El código de las funciones puede estar en cualquier parte del programa, pero suele ponerse al final de todo, aparte del programa principal. También puede ponerse en una pestaña aparte en el IDE.

Función de movimiento básica

Para programar el Arduino con código escrito puedes utilizar la función de movimiento siguiente (copia y pega el código en el IDE).

El código tiene tres partes:

  • En la primera -setup- se incluye la parte del programa que se ejecuta sólo una vez, al iniciar el Arduino.
  • En la segunda -loop- es donde después escribirás el programa principal, que se ejecutará en bucle.
  • En la tercera -drive- es donde se define la función (o subrutina) de movimiento para simplificar el programa principal.

La función drive incluye la numeración y configuración de pines. Puede ponerse en una pestaña aparte en el IDE de Arduino, eso hará que el código principal con el setup y el loop se lea más fácil.

void setup() {

}

//programa principal
void loop(){

}

//función de movimiento de motores
void drive(int L, int R, int t) //velocidad de las ruedas izquierda y derecha, positivo hacia delante, tiempo en milisegundos
{
//Arduino UNO y driver TB6612/DRV8833
  const int AIN2 = 9; // PWMA
  const int AIN1 = 8;
  const int BIN1 = 7;
  const int BIN2 = 6; // PWMB

//iniciar el modo de los pines para los motores
  pinMode(AIN1,OUTPUT);
  pinMode(AIN2,OUTPUT);
  pinMode(BIN1,OUTPUT);
  pinMode(BIN2,OUTPUT);

// evitar valores no válidos para el PWM
  L=constrain(L,-255,255);
  R=constrain(R,-255,255);

// poner valores a los pines
  digitalWrite(AIN1, L<0);
  analogWrite(AIN2, L+255*(L<0));
  digitalWrite(BIN1, R<0);
  analogWrite(BIN2, R+255*(R<0));

  delay(t);
}

Movimientos de prueba

El uso de la función drive es sencillo. Se llama como drive (velocidad rueda izquierda, velocidad rueda derecha, tiempo) Las velocidades pueden estar entre -255 y 255. Positivo hacia delante, negativo hacia atrás. El tiempo en milisegundos.

Hay cuatro funciones básicas:

  • Movimiento hacia adelante: drive(200,200,1000); probar a cambiar los valores de velocidad y tiempo.
  • Movimiento hacia atrás: drive(-200,-200,1000);
  • Giro en redondo: drive(-200,200,1000); probar hacia donde gira.
  • Giro hacia el lado contrario: drive(200,-200,1000);
  • Parar: drive(0,0,0);

La última es importante. Si no la incluimos después de cualquiera de las otras, el robot no parará.

El primer ejercicio puede ser ajustar los valores de movimiento hacia adelante para que se mueva en línea recta. Es poco probable que con dos valores iguales lo haga, los motores no son idénticos.

El segundo ejercicio puede ser ajustar los valores de movimiento de giro para que rote un ángulo fijado, por ejemplo 90 grados o 180 grados.

El tercer ejercicio puede ser encadenar órdenes para hacer figuras, por ejemplo un cuadrado, una estrella…

Ejercicios más complejos:

La función drive con dos valores positivos pero diferentes describe un arco. Probar a encadenar arcos para hacer un movimiento en eses. Probar a poner obstáculos y salvarlos serpenteando.

Montaje de los sensores y movimientos autónomos

Los sensores tienen casi siempre dos pines de alimentación y uno o más pines de datos. La protoshield tiene en un lateral dos líneas para conectar la alimentación a positivo (5V) y negativo (GND).

protoshield-mini.jpg

Sensores de ultrasonidos

Los sensores del ultrasonidos HC-SR04 tienen cuatro pienes: alimentación (VCC), masa (GND), trigger y echo. Estos dos últimos los unimos con una soldadura para ahorrarnos un cable, aunque tenemos que advertir que algunos modelos de algunos fabricantes no permiten esto, y al hacerlo no funcionan. Cablearemos con Dupont hembra-macho del sensor a la protoshield.

hc-sr04_c.jpg

El montaje del soporte a la placa superior es sencillo, con un tornillo M3x10 y una tuerca. La placa tiene tres orificios, usaremos el central para montar un único sensor o los laterales para montar dos.

montaje_us.jpg

Para leer la distancia que mide el sensor usaremos una nueva función, que de nuevo podemos guardar en una pestaña nueva en el IDE para dejar más limpio el programa principal

long sonar(int trig)
{
  pinMode(trig, OUTPUT);
  digitalWrite(trig,LOW); // trigger envia un pulso ultrasónico
  delayMicroseconds(5);
  digitalWrite(trig, HIGH);
  delayMicroseconds(10);
  pinMode(trig, INPUT);
  unsigned long tiempo=pulseIn(trig, HIGH);    // echo espera a recibir la respuesta
  unsigned long distancia= int(0.17*tiempo);  // fórmula para calcular la distancia
  return distancia;
}

El uso es sencillo, la llamamos como

long distancia = sonar(pin);

En donde le decimos a qué pin hemos conectado el sensor (en los siguientes programa utilizaremos el 2 y el 3), y la función nos devuelve la distancia al obstáculo en milímetros. Este código permite leer el sensor y mostrar el resultado por el monitor serie de Arduino para comprobar que funciona.

TIP: 'long' es un nuevo tipo de variable, para números enteros muy grandes. el tipo 'int' sólo puede almacenar de -32768 a 32767.

Mantener la distancia

Con un sensor de distancia montado de forma central probaremos la distancia a una pared. Si estamos aún lejos, avanzaremos. Si estamos muy cerca, retrocederemos para mantener la distancia. Si en vez de una pared ponemos la mano, probaremos a manejar 'a distancia' nuestro robot.

7e2ce77f-1e60-4c1a-8e3b-6a59a660f16e.jpeg

El código principal (al que añadiremos con las funciones drive y sonar) es el siguiente

void setup() {}

void loop() {
  long int distancia = sonar(2);
  if (distancia<100)
  {
    drive(150,150,50);
  }
  else
  {
    drive(-150,-150,50);
  }

}

Como diversión si estamos trabajando en grupo podemos poner todos los robots en fila y encenderlos a la vez a ver qué pasa.

Evitar obstáculos

Con dos sensores de distancia podemos ver por donde está más cerca el obstáculo y girar hacia el lado contrario evitándolo.

c5231346-ecce-44e3-ada5-e3ed3365f37e.jpeg

El código ahora es

void setup() {}

void loop() {
  long int izquierda = sonar(2);
  long int derecha = sonar(3);
  long int distancia = min(izquierda, derecha);
  if (distancia<100)
  {
    if (izquierda<derecha) // cambiar menor por mayor si gira hacia el obstaculo
    {
      drive(150,-150,100);
    }
    else
    {
      drive(-150,150,100);
    }
  }
  else
  {
    drive(150,150,50);
  }

}

Sensores de líneas

Los sensores infrarrojos de líneas, tanto con salida analógica como digital utilizan tres pines: alimentación (VCC), masa (GND) y señal. Debes revisar tu sensor, cada fabricante coloca los pines como quiere, y no tiene por qué coincidir con la foto.

tcrt5000r.jpg

Utilizaremos sensores basados en reflexión TCRT5000 con regulador (importante) que se montarán en el chasis inferior y se cablean a 5v, GND y dos entradas analógicas entre A0 y A5 (con cables Dupond H-M de 20cm).

foto_5-4-22_23_20_34.jpg

Seguir una línea

Para leer los sensores no necesitamos una función extra, Arduino puede hacerlo con su propia analogRead(pin). El siguiente código lee los dos sensores y si uno de ellos está sobre la línea negra gira hacia el otro lado para evitarla (necesita la función drive).

void setup() {}

void loop()
{
  if (analogRead(A0)<500) drive(-150,150,100);
  if (analogRead(A1)<500) drive(150,-150,100);
  drive(150,150,100);
}

Equipo

Enlaces

proyectos/sapoconcho_bats.txt · Última modificación: 2022/07/14 11:00 por Félix Sánchez-Tembleque