Es un robot que mantiene el equilibrio en dos ruedas y se controla con una placa uno,un controlador de motores, de sensor un acelerómetro y por último, de actuadores dos motores.
Aquí, les dejamos los esquemas :
Por: Aida Galán Velilla y Emma Blanco Tapia.
A continuación tenemos un programa que al subirse a arduino, nos permite cambiar nombre, velocidad y/o contraseña:
————————————————————–
#include <SoftwareSerial.h>
/* Programa el modulo bluetooth HC-06 con un nuevo:
NOMBRE (Nombre de 20 caracteres)
PIN (Clave de cuatro numeros)
BPS (Velocidad de conexion en baudios)
CONEXIONES:
ARDUINO BLUETOOTH
5V VCC
GND GND
PIN 2 TX
PIN 3 RX
*/
SoftwareSerial BT(7, 8); //Crea conexion al bluetooth – PIN 2 a TX y PIN 3 a RX
char NOMBRE[21] = «HAWK»; // Nombre de 20 caracteres maximo
char BPS = ‘4’; // 1=1200 , 2=2400, 3=4800, 4=9600, 5=19200, 6=38400, 7=57600, 8=115200
char PASS[5] = «1234»; // PIN O CLAVE de 4 caracteres numericos
void setup()
{
BT.begin(38400); // inicialmente la comunicacion serial a 9600 Baudios (velocidad de fabrica)
pinMode(13,OUTPUT);
digitalWrite(13,HIGH); // Enciende el LED 13 durante 4s antes de configurar el Bluetooth
delay(4000);
digitalWrite(13,LOW); // Apaga el LED 13 para iniciar la programacion
BT.print(«AT»); // Inicializa comando AT
delay(1000);
BT.print(«AT+NAME»); // Configura el nuevo nombre
BT.print(NOMBRE);
delay(1000); // espera 1 segundo
BT.print(«AT+BAUD»); // Configura la nueva velocidad
BT.print(BPS);
delay(1000);
BT.print(«AT+PIN»); // Configura el nuevo PIN
BT.print(PASS);
delay(1000);
}
void loop()
{
digitalWrite(13, !digitalRead(13)); // cuando termina de configurar el Bluetooth queda el LED 13 parpadeando
delay(300);
}
Para trabajar con las placas arduino conectadas al ordenador y a la vez poder utilizar el módulo bluetooth, es necesario no conectar el módulo bluetooth a los pines 0 y 1.
En primer lugar probaremos el siguiente programa para estar seguros de que la comunicación funciona y la velocidad es la correcta:
——————————————
#include <SoftwareSerial.h>
SoftwareSerial BT(7, 8); // RX | TX
char val;
void setup()
{ pinMode(13, OUTPUT);pinMode(12, OUTPUT);
BT.begin(38400);
Serial.begin(38400);
Serial.write («hola»);
BT.write («Hola»);
}void loop() {
if(BT.available()) // Si llega un dato por el puerto BT se envía al monitor serial
{
Serial.write(BT.read());
}
if(Serial.available()) // Si llega un dato por el monitor serial se envía al puerto BT
{
BT.write(Serial.read());
}
}——————————————————————-
Una vez funcione la comunicación, podemos probar el siguiente programa, el cual sirve para controlar dos led colocados en los pines 12 y 13:
———————————————————————-
#include <SoftwareSerial.h>
SoftwareSerial BT(7, 8); // RX | TX
char val;
void setup()
{ pinMode(13, OUTPUT); // Al poner en HIGH forzaremos el modo AT
pinMode(12, OUTPUT); // cuando se alimente de aqui
BT.begin(38400);
Serial.begin(38400);
Serial.write («hola»);
BT.write («Hola»);
}void loop() {
if(BT.available()) // Si llega un dato por el puerto BT se envía al monitor serial
{
val = BT.read ();
Serial.write (val);
}if (val == ‘a’){
digitalWrite (12, HIGH);
}
if (val == ‘b’){
digitalWrite (13, HIGH);
}
if (val == ‘c’){
digitalWrite (12, LOW);
digitalWrite (13, LOW);
}
}
————————————————-
Los comandos los enviaremos desde un teléfono móvil con una app tipo bluetooth controller.
Este curso estamos participando en la competición promovida por la Fundación Endesa. Os ponemos un link al blog del proyecto y si nos hacéis un favor entráis y nos votáis. Nosotros en compensación os regalaremos un jamón, es broma.
El proyecto es muy chulo y en el vídeo presentación veréis volar nuestro primer dron hecho en el taller. Seréis capaces de verlo??
http://retotech.fundacionendesa.org/ies-alfonso-moreno/
Utilizaremos la aplicación para móvil bluetoothcontroller, la configuración y el interface son:
en cada tecla enviamos una variable de tipo char.
El programa para arduino más sencillo será:
Declaramos la variable, inicializamos el puerto serie y definimos todos estos pines como de salida. Si vemos la entrada dedicada a la placa fundumoto, veremos que los pines 10 y 12 controlan la rueda derecha, los pines 11 y 13 la rueda izquierda y el pin 4 el claxon.
Con estos comandos vemos si ha llegado algo por el puerto serie vía bluetooth, y lo que haya llegado lo almacenamos en la variable val. Importante el delay para que no se atragante.
Y ahora la cadena de condicionales, con a suena el claxon, con b se mueve hacia adelante, etc.
En primer lugar vamos a ver la parte de appinventor y luego veremos el lado de arduino. El diseño de pantalla podría ser algo como ésto:
hay que añadir dos componentes no visibles, el bluetooth, y un reloj. El listado de todos los componentes será:
Los bloques de programación para conexión y desconexión del bluetooth:
vemos como la conexión es muy sencilla, pero no se puede seleccionar el bluetooth, sino que se fija en el programa. Hay formas un poco más complejas para poder seleccionar uno u otro bluetooth.
La programación de los botones para encender o apagar el led consiste en el envío de una letra:
y no hace falta más en la parte de appinventor, veamos la parte de programación de arduino con el programa bitbloq de bq (programación por bloques).
Las conexiones serán las siguientes:
cuidado con el bluetooth RXD se conecta al 0 y TXD al 1, al contrario que el propio hardware. El conjunto de bloques será:
Definimos una variable para alojar el carácter enviado por bluetooth y con un par de condicionales encendemos y apagamos. Aunque en la aplicación del móvil pone led 2, se enciende el 13, es indiferente. hay una condicional para mostrar por puerto serie el carácter recibido, es para las primeras pruebas, luego se puede eliminar.
Se pueden añadir todas las acciones que se quieran enviando otros caracteres e implementando más condicionales
Ésta es la nueva motor shield que hemos adquirido, menos de 6 euros en internet, su aspecto exterior es:
encaja sobre la arduino uno y básicamente nos permite conectar dos motores de continua y algunas cosas más. Veamos una imagen con algunas cosillas conectadas:
En la imagen vemos que lleva pines específicos para conectar diversos dispositivos, básicamente los que necesitamos cuando construimos coches, eso si, con motores de continua, no servos.
Muestro ahora un esquema de la placa:
Y tras investigar un poco, los dispositivos conectados y probados corresponden a los siguientes pines:
– Zumbador, pin digital 4
– Sensor infrarrojo línea, pin digital 2
– Sensor de distancia, pin digital 7 echo (T), pin digital 8 trigger (R)
– Servo, para colocar encima el sensor de distancia, pin digital 9
– Bluetooth, tiene unos pines hembra para pinchar directamente el módulo (muy muy útil)
– Motor A (derecha en mi caso), pin digital 12 la dirección y pin digital 10 (pwm) la velocidad, de 0 a 255.
– Motor B (izquierda en mi caso), pin digital 13 la dirección y pin digital 11 (pwm) la velocidad, de 0 a 255.
Alimentación, en teoría se debería alimentar por un lado la arduino y por otro los motores, y se puede hacer. Yo he hecho la prueba alimentando sólo la arduino, sin alimentar los motores independientemente y los motores funcionan. Imagino que si hacemos funcionar a la vez los motores cuesta arriba, el servo y los sensores tendremos problemas, pero vamos, yo probaría con una sola alimentación, nos ahorramos mucho cable.
Espero que esta información nos sirva para poder programarla con éxito. He hecho todas las pruebas con bitbloq.
Pues eso, que nos ha dado por mejorar el plotclock y para no depender del ordenador, le vamos a incorporar un RTC. La información que vamos a utilizar la sacaremos de la web Thinkering. Dejo el enlace en la foto.
Esta tarjeta tiene el siguiente aspecto:
Además de tener la SD tiene un reloj, de ahí la pila. Sirve para tomar datos de sensores cada cierto tiempo y luego poder graficarlos.
El programa más básico que he hecho es un derivado del que viene con la librería SD modificado para que lea n entradas analógicas. En caso de tener entradas de sensores no analógicos la cosa es diferente y hay que fusionar ejemplos de librerías. No usaré el reloj en este primer ejemplo.
El código viene comentado:
/*
Ejemplo sencillo para manejo de la sd shield sin el reloj
*/
#include <SPI.h>
#include <SD.h>
int n=1; //número de sensores que tenemos conectados en orden A0 A1 A2 A3 A4 A5
const int chipSelect = 10; // para esta shield seleccionamos el 10
void setup() {
Serial.begin(9600); //en el setup se establece comunicación serial y se nos dice si se encuentra la tarjeta
while (!Serial) {
;
}
Serial.print(«Initializing SD card…»);
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println(«Card failed, or not present»);
// don’t do anything more:
return;
}
Serial.println(«card initialized.»);
}
void loop() {
String dataString = «»; // vamos a montar un string para ver los valores de las entradas A0 A1 y A2
for (int analogPin = 0; analogPin < n; analogPin++) {
int sensor = analogRead(analogPin);
dataString += String(sensor);
if (analogPin < (n-1)) {
dataString += «,»;
}
}
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
File dataFile = SD.open(«datalog.txt», FILE_WRITE);
// if the file is available, write to it:
if (dataFile) {
dataFile.println(dataString);
dataFile.close();
// print to the serial port too:
Serial.println(dataString);
delay (5000); // aqui ajustas el tiempo entre lecturas
}
// if the file isn’t open, pop up an error:
else {
Serial.println(«error opening datalog.txt»);
}
}
El programa inicializa la tarjeta y monta un array el tamaño que le hayamos dicho con la variable n. Abre un archivo con extensión txt, (podemos cambiar el nombre), e imprime en dicho archivo el array.
Lo mejor que podemos hacer con el archivo es cambiar la extensión a csv:
y luego abrirlo con openOffice, al importarlo nos da opción de separar en columnas los datos separados por comas:
en el ejemplo solo había un sensor, pero funciona sin problemas. Luego dibujas la gráfica y ya está:
Robótica en el IES Alfonso Moreno de Brunete 