Ya tenemos nuestro robot ensamblado, soldado y preparado para comenzar a experimentar con él. En esta sección revisaremos los componentes y programaremos pequeñas funciones que nos ayudarán a controlar de una manera más fácil los elementos del robot.
Primero que todo, veamos el esquemático.
Ver esquemático
Peripherals
Partamos por lo más simple. Los periféricos (en inglés «peripherals»). Los peripherals son todos los elementos del robot, cuya función son interactuar con el «sistema operativo», como por ejemplo, los botones y los buzzer).
El botón nos servirá para ir cambiando funciones en el robot, y el buzzer nos ayudará como feedback de la ejecución del programa.
La primera función que haremos, nos ayudará a «detener» la ejecución del programa, hasta que apretemos el botón. A esta función le llamaremos «WaitBoton«.
Ver código
/*
Este tutorial inicia cuando ya tenemos nuestro robot armado.
Lo primero que debemos aprender, es a comunicarnos con el robot a través de su interfáz Humano-Máquina.
Para esto, Open Lamborghino tiene los siguientes periféricos:
- Un botón conectado al pin digital 2 de Arduino Nano.
- Un buzzer conectado en el pin digital 10 de Arduino Nano
- Un led conectado al pin digital 13, conectado en la placa de Arduino.
Con estos periféricos podremos operar el robot y navegar por sus sistemas.
Para esto crearemos las siguientes funciones:
WaitBoton(): El robot queda a la espera de que se presione el botón.
beep(): El buzzer hace bip.
*/
#define PINBUZZER 10
#define PINBOTON 2
#define PINLED 13
void setup() {
Serial.begin(115200);
Peripherals_init();
digitalWrite(PINLED, LOW);
Serial.println("Hola, ahora estás en el void setup()");
WaitBoton();
digitalWrite(PINLED, HIGH);
}
void loop() {
Serial.println("Ahora estás en el void loop()");
delay(1000);
}
// Función para esperar el botón
void WaitBoton() {
// Entra en un bucle infinito de espera hasta que se presione el botón
while (!digitalRead(PINBOTON))
; // No hace nada dentro del bucle, solo espera
beep(); // Se llama a la función beep() cuando se presiona el botón
}
// Función para emitir un sonido
void beep() {
tone(PINBUZZER, 2000, 100); // Emite un tono de 2000 Hz durante 100 ms
delay(200); // Espera 200 ms antes de continuar
}
void Peripherals_init() {
// Configuración de pines
pinMode(PINBOTON, INPUT); // El pin del botón se configura como entrada
pinMode(PINBUZZER, OUTPUT); // El pin del buzzer se configura como salida
pinMode(PINLED, OUTPUT); // El pin del LED se configura como salida
}
Si experimentas un rato los peripherals, podrás hacer lo que se te ocurra .
Sensores de línea y laterales
Los sensores de línea, como el que utiliza Open Lamborghino, son muy simples de utilizar. Solo se debe hacer una lectura analógica de los sensores.
Recordemos el orden de los sensores:
De izquierda a derecha
Como pueden observar, solo utilizaremos 6 de los 8 sensores de la matriz (No se preocupen, porque con un buen sistema de control, el tener 6 sensores no debería afectar).
Ahora con una simple lectura analógica, podemos acceder a los valores de cada sensor, de manera independiente. Recuerde que también debes activar el pin LEDON (D11 en Arduino), para activar los led infrarrojos.
Con este simple código podemos obtener el valor de todos los sensores.
Ver código
#define PINBUZZER 10
#define PINBOTON 2
void setup() {
WaitBoton();
Serial.begin(115200);
pinMode(11, OUTPUT);
digitalWrite(11, HIGH);
}
void loop() {
int HL = analogRead(A7);
int s1 = analogRead(A6);
int s2 = analogRead(A5);
int s3 = analogRead(A4);
int s4 = analogRead(A3);
int s5 = analogRead(A2);
int s6 = analogRead(A1);
int HR = analogRead(A0);
Serial.print(HL);
Serial.print("\t");
Serial.print(s1);
Serial.print("\t");
Serial.print(s2);
Serial.print("\t");
Serial.print(s3);
Serial.print("\t");
Serial.print(s4);
Serial.print("\t");
Serial.print(s5);
Serial.print("\t");
Serial.print(s6);
Serial.print("\t");
Serial.println(HR);
delay(1);
}
void Peripherals_init() {
pinMode(PINBOTON, INPUT);
pinMode(PINBUZZER, OUTPUT);
}
void WaitBoton() { // Entra en un bucle infinito de espera.
while (!digitalRead(PINBOTON))
; // Se sale del bucle cuando se aprieta el botón
tone(PINBUZZER, 2000, 100); // Cuando sale del bucle, suena el buzzer
}
Motores
Para mover los motores, necesitamos hacerlo con 3 pines por motor. (2 digitales y 1 digital con pwm). El funcionamiento es muy fácil, y pueden leerlo en la hoja de datos del proveedor. Acá, para facilitar las cosas, creamos una función que nos ayudará a mover los motores con una simple función.
Ver código
# define AIN1 8 // pin 1 de dirección del Motor Izquierdo
# define AIN2 9 // pin 2 de dirección del Motor Izquierdo
# define PWMA 5 // pin PWM del Motor Izquierdo
# define BIN1 4 // pin 1 de dirección del Motor Derecho
# define BIN2 7 // pin 2 de dirección del Motor Derecho
# define PWMB 6 // pin PWM del Motor Derecho
void TB6612FNG_init() {
pinMode(AIN1, OUTPUT);
pinMode(AIN2, OUTPUT);
pinMode(PWMA, OUTPUT);
pinMode(BIN1, OUTPUT);
pinMode(BIN2, OUTPUT);
pinMode(PWMB, OUTPUT);
}
void MotorIz(int value) {
if (value >= 0) {
// si valor positivo vamos hacia adelante
digitalWrite(AIN1, HIGH);
digitalWrite(AIN2, LOW);
} else {
// si valor negativo vamos hacia atras
digitalWrite(AIN1, LOW);
digitalWrite(AIN2, HIGH);
value *= -1;
}
// Setea Velocidad
analogWrite(PWMA, value);
}
void MotorDe(int value) {
if (value >= 0) {
// si valor positivo vamos hacia adelante
digitalWrite(BIN1, HIGH);
digitalWrite(BIN2, LOW);
} else {
// si valor negativo vamos hacia atras
digitalWrite(BIN1, LOW);
digitalWrite(BIN2, HIGH);
value *= -1;
}
// Setea Velocidad
analogWrite(PWMB, value);
}
void Motores(int left, int right) {
MotorIz(left);
MotorDe(right);
}
Como puedes ver, ahora solo necesitamos utilizar la función Motores() para mover nuestro robot.
void Motores(int left, int right) {
MotorIz(left);
MotorDe(right);
}
Esta función debe recibir dos valores (left,right), donde «left y right» deben ser valores enteros con un rango de -255 hasta 255. Cuando el número es negativo, el sentido de giro cambia.
Con este paso dominado, es hora de comenzar con la robótica pura y dura. Nuestro objetivo ahora es hacer que lamborghino siga la línea.
