KIT Robot Móvil 4 Llantas Sumo, Seguidor, Evasor
Conoce tu Kit 4WD
KIT Robot Móvil 4 Llantas Sumo, Seguidor, Evasor
Cod. Kit 1444
El robot puede ser programado para diferentes funciones entre las cuales tenemos:
- Seguidor Linea Blanca
- Seguidor Linea Blanca Evasor
- Seguidor Linea Negra
- Seguidor Linea Negra Evasor
- Evasor de Obstáculos
- Robot Sumo Autónomo
- Robot Bluetooth RC
Antes de ensamblar tu Kit verifica que te haya llegado completo y todo esté en buen estado.
Materiales
Tu Kit debe incluir los siguientes componentes.
- 1pza. Tarjeta Arduino Uno R3 CH340 SMD C/cable USB
- 1pza. Tarjeta Sensor Shield
- 2pzs. Base de acrílico cortada y perforada.
- 4pzs. Motorreductor plástico 1:48 de doble eje con cables
- 4pzs. Llanta de plastico 65mm x 25mm.
- 1pza. Modulo controlador dual motor L298N
- 3pzs. Modulo Sensor KY-033 para detectar líneas
- 1pza. HC-SR04 Sensor distancia Ultrasonico
- 1pza. Soporte de acrílico para sensor HC-SR04
- 1pza. Modulo Bluetooth HC-06
- 1pza. Pala de acrílico para robot sumo
- 1pza. Portapilas para 6 pilas AA con conector de barril
- 40pzs. Cables puente 20cm Hembra-Hembra
- 8pzs. Tornillo 1/8 x 1 1/4
- 12pzs. Tornillo M3 x 12 mm cabeza de gota
- 12pzs. Tornillos M3 x 8mm
- 2pzs. Tornillos M3 x 8mm
- 8pzs. Tuerca 1/8
- 15pzs. Tuerca M3
- 6pzs. Soportes metálicos 35mm
- 15pzs. Bujes Pequeños Acrílicos
- 4pzs. Sinchos
- 1pzs. Cable dúplex 25cm
Si detectas que tu kit llego incompleto o algún componente dañado, puedes mandarnos un mensaje
Correo: contacto@robodacta.mx
A nuestro numero de WhatsApp: (56) 28089523
¿Cómo vamos a armarlo?
Ensamble
Para ensamblar tu robot, sigue el siguiente video donde explicamos paso a paso el armado.
Notas:
Antes de iniciar con el ensamble remueve el plástico protector de las piezas de acrílico.
Es importante no apretar los tornillos de forma excesiva ya que podrías romper alguna de las piezas de acrílico.
No retirar los cinchos que sujetan los cables de los motores ya que estos evitan que se rompan sus terminales con el movimiento.
Diagrama de Conexiones
Una vez que hayas ensamblado tu Robot, el siguiente paso es realizar las conexiones.
A continuación te mostramos los diagramas de conexiones.
(En caso de que tambien hayas adquirido tu KIT en conjunto con la versión Explorador te dejamos un diagrama de conexiones)
Diagrama Kit 4WD Evasor de Obstáculos
Diagrama Kit Seguidor de Linea
Diagrama Bluetooth RC
Prueba de tu Kit Robot Sumo
Para probar tu Kit deberás de seguir los siguientes pasos. De esta manera sabrás si tu ensamble es correcto y si tus conexiones están correctamente cableadas.
Es importante no remover los puentes jumper que se encuentran en el puente H.
Para realizar esta tarea deberás colocar las pilas a tu kit y encenderlo. Si tu Kit se desplaza hacia adelante unos cuantos segundos, se detiene, desplaza y detiene de forma repetitiva. Podemos concluir que tu kit esta correctamente ensamblado y cableado.
A continuación te dejamos un video donde podrás ver como debe de comportarse tu robot para saber si tu robot esta correctamente armado.
Nota importante
No pases a la siguiente sección hasta que verifiques que tu Kit 4WD esta correctamente ensamblado y correctamente cableado. Logrando el comportamiento del video.
¿Cómo lo vamos a Programar?
Instalación Programa Arduino
Antes de cargar el programa de tu elección deberás instalar el entorno de programación con el cual podrás subir los códigos a tu robot.
Tu robot viene con un programa pre-cargado de prueba para que puedas verificar el funcionamiento de tu robot.
“PruebaMotoresAdelante4WD.ino”
Para esta sección preparamos un PDF el cual podrás descargar con el siguiente botón con las instrucciones detalladas de cada uno de los pasos con imágenes.
(El siguiente PDF incluye el paso 1, 2 y 3)
En caso de que ya conozcas un poco de este proceso te dejamos a continuación la explicación corta.
Paso 1.- Descargar de driver CH341
Como uno de los pasos para la instalación de nuestro entorno será el de descargar e instalar el driver necesario para que nuestra computadora pueda reconocer el dispositivo Arduino.
Paso 2.- Descarga e instalación de Arduino
Aquí descargaremos la aplicación de Arduino con el cual podrás editar, subir y abrir los códigos.
Paso 3.- Subir un código
En esta parte podremos subir nuestros programas a nuestro Kit Robot Sumo. Puedes empezar por el que mas te guste y requieras. Creamos un PDF donde detallamos cada una de las instrucciones para subir cada uno de los códigos paso a paso.
A continuación te dejamos diferentes secciones con los programas para que puedas cargarlos a tu Kit Robot Sumo. Las secciones contienen el código escrito o si lo prefieres descargar tambien te dejamos un archivo de texto con el código.
Este programa ya viene precargado en tu Arduino por nuestra parte.
Con este programa tu podrás conocer si tu Kit Robot 4WD funciona correctamente.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón.
//Movimientos básicos
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
void setup() {
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
}
void loop()
{
adelante();
delay(500);
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD deberá de seguir una Linea Negra en un fondo blanco a través de los sensores de Linea.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Seguidorde linea negra
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int sensorleft = 5;
int sensorcenter = 6;
int sensorright = 7;
int l1 = 1;
int l2 = 1;
int l3 = 1;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int vel = 100;
void setup() {
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorleft, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorright, INPUT);
}
void loop(){
//Linea Blanca
l1 = digitalRead(sensorleft);
l2 = digitalRead(sensorcenter);
l3 = digitalRead(sensorright);
/////////////////
if (l1 == 0 && l2 == 0 && l3 == 0) //Feedback cuando todos los sensores estan en negro
{
l1 = f1;
l2 = f2;
l3 = f3;
}
/////////////////
else if(l1==0 && l2==0 && l3==1)
{
derechacerrada();
}
else if(l1==0 && l2==1 && l3==1)
{
derecha();
}
else if(l1==1 && l2==0 && l3==0)
{
izquierdacerrada();
}
else if(l1==1 && l2==1 && l3==0)
{
izquierda();
}
else if(l1==0 && l2==1 && l3==0)
{
adelante();
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3; //memory variables
////////////////////////////////////////////////////////////////////
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void izquierdacerrada()
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,vel);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void derechacerrada()//Giro a la derecha cerrada
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,vel);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD deberá de seguir una Linea Blanca en un fondo negro a través de los sensores de Linea.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Evasor de Obstaculos sencillo
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int sensorleft = 5;
int sensorcenter = 6;
int sensorright = 7;
int l1 = 1;
int l2 = 1;
int l3 = 1;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int vel = 100;
void setup() {
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorleft, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorright, INPUT);
}
void loop(){
//Linea Blanca
l1 = digitalRead(sensorleft);
l2 = digitalRead(sensorcenter);
l3 = digitalRead(sensorright);
/////////////////
if (l1 == 1 && l2 == 1 && l3 == 1) //Feedback cuando todos los sensores estan en negro
{
l1 = f1;
l2 = f2;
l3 = f3;
}
/////////////////
else if(l1==1 && l2==1 && l3==0)
{
derechacerrada();
}
else if(l1==1 && l2==0 && l3==0)
{
derecha();
}
else if(l1==0 && l2==1 && l3==1)
{
izquierdacerrada();
}
else if(l1==0 && l2==0 && l3==1)
{
izquierda();
}
else if(l1==1 && l2==0 && l3==1)
{
adelante();
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3; //memory variables
////////////////////////////////////////////////////////////////////
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void izquierdacerrada()
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,vel);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void derechacerrada()//Giro a la derecha cerrada
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,vel);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD deberá de evadir obstáculos los cuales podrá detectar de frente, lo cual hará que cambie de dirección para encontrar nuevas rutas.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Evasor de Obstaculos sencillo
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int echo=2;//Sensor de obstaculos
int triger=3;
void setup() {
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
pinMode(echo,INPUT);
pinMode(triger,OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
}
void loop() {
if(distancia() >= 20){
adelante();
}else{
alto();
delay(1000);
atras();
delay(500);
izquierda();
delay(500);
}
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
long distancia() //Medicion de distancia
{
long t;
long d;
digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);
t = pulseIn(echo, HIGH);
d = t/59;
delay(10);
return d;
}
Comportamiento del programa.
Tu Kit Robot 4WD buscara cualquier oponente que este cerca de él. Girara y al encontrar a un oponente buscara impactarlo y sacarlo de la arena. Fondo Negro.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Sumo Sin Fondo
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int echo=2; //Sensor de obstaculos
int triger=3;
int vel = 175 ;
void setup()
{
pinMode(motA0,OUTPUT);
pinMode(motA1,OUTPUT);
pinMode(motB0,OUTPUT);
pinMode(motB1,OUTPUT);
pinMode(echo,INPUT);
pinMode(triger,OUTPUT);
digitalWrite(triger,LOW);
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void loop()
{
if(distancia()<=20)
{
adelante();
}
else
{
derecha();
}
}
long distancia()
{
long t;
long d;
digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);
t = pulseIn(echo, HIGH);
d = t/59;
delay(10);
return d;
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void adelanteLento()
{
analogWrite(motA0, vel);
digitalWrite(motA1, LOW);
analogWrite(motB0, vel);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD buscara cualquier oponente que este cerca de él. Girara y al encontrar a un oponente buscara impactarlo y sacarlo de la arena. Fondo Blanco.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Sumo Autonomo Fondo Negro
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int sensorleft = 5; //Sensores de linea
int sensorcenter = 6;
int sensorright = 7;
int echo=2; //Sensor de obstaculos
int triger=3;
int vel = 175 ;
void setup()
{
pinMode(sensorleft,INPUT);
pinMode(sensorcenter,INPUT);
pinMode(sensorright,INPUT);
pinMode(motA0,OUTPUT);
pinMode(motA1,OUTPUT);
pinMode(motB0,OUTPUT);
pinMode(motB1,OUTPUT);
pinMode(echo,INPUT);
pinMode(triger,OUTPUT);
digitalWrite(triger,LOW);
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void loop()
{
if(distancia()<=20)
{
if(digitalRead(sensorleft)==0 || digitalRead(sensorcenter)==0 || digitalRead(sensorright)==0)//Cambiar los “0” por “1” para fondo blanco
{
alto();
delay(100);
atras();
delay(400);
alto();
delay(500);
derecha();
delay(700);
alto();
delay(500);
adelante();
}
else
{
adelante();
}
}
else
{
if(digitalRead(sensorleft)==0 || digitalRead(sensorcenter)==0 || digitalRead(sensorright)==0)//Cambiar los “0” por “1” para fondo blanco
{
alto();
delay(100);
atras();
delay(400);
alto();
delay(500);
derecha();
delay(700);
alto();
delay(500);
adelanteLento();
}
else
{
adelanteLento();
}
}
}
long distancia()
{
long t;
long d;
digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);
t = pulseIn(echo, HIGH);
d = t/59;
delay(10);
return d;
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void adelanteLento()
{
analogWrite(motA0, vel);
digitalWrite(motA1, LOW);
analogWrite(motB0, vel);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD buscara cualquier oponente que este cerca de él. Girara y al encontrar a un oponente buscara impactarlo y sacarlo de la arena. Fondo Blanco.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Sumo Autonomo Fondo Blanco
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int sensorleft = 5; //Sensores de linea
int sensorcenter = 6;
int sensorright = 7;
int echo=2; //Sensor de obstaculos
int triger=3;
int vel = 175 ;
void setup()
{
pinMode(sensorleft,INPUT);
pinMode(sensorcenter,INPUT);
pinMode(sensorright,INPUT);
pinMode(motA0,OUTPUT);
pinMode(motA1,OUTPUT);
pinMode(motB0,OUTPUT);
pinMode(motB1,OUTPUT);
pinMode(echo,INPUT);
pinMode(triger,OUTPUT);
digitalWrite(triger,LOW);
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void loop()
{
if(distancia()<=20)
{
if(digitalRead(sensorleft)==1 || digitalRead(sensorcenter)==1 || digitalRead(sensorright)==1)//Cambiar los “1” por “0” para fondo negro
{
alto();
delay(100);
atras();
delay(400);
alto();
delay(500);
derecha();
delay(700);
alto();
delay(500);
adelante();
}
else
{
adelante();
}
}
else
{
if(digitalRead(sensorleft)==1 || digitalRead(sensorcenter)==1 || digitalRead(sensorright)==1)//Cambiar los “0” por “1” para fondo blanco
{
alto();
delay(100);
atras();
delay(400);
alto();
delay(500);
derecha();
delay(700);
alto();
delay(500);
adelanteLento();
}
else
{
adelanteLento();
}
}
}
long distancia()
{
long t;
long d;
digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);
t = pulseIn(echo, HIGH);
d = t/59;
delay(10);
return d;
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void adelanteLento()
{
analogWrite(motA0, vel);
digitalWrite(motA1, LOW);
analogWrite(motB0, vel);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
Comportamiento del programa.
Tu Kit Robot 4WD seguirá una linea blanca, si en el trayecto el robot encuentra un obstáculo, lo evitará y volverá a buscar una ruta.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
//Seguidor de linea y Evasor de Obstáculos
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
int sensorleft = 5;
int sensorcenter = 6;
int sensorright = 7;
int echo=2;//Sensor de obstaculos
int triger=3;
int l1 = 1;
int l2 = 1;
int l3 = 1;
int f1 = 0;
int f2 = 0;
int f3 = 0;
int vel = 100;
void setup() {
pinMode(motA0, OUTPUT);
pinMode(motA1, OUTPUT);
pinMode(motB0, OUTPUT);
pinMode(motB1, OUTPUT);
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW);
digitalWrite(motB0, LOW);
digitalWrite(motB1, LOW);
pinMode(sensorleft, INPUT);
pinMode(sensorcenter, INPUT);
pinMode(sensorright, INPUT);
pinMode(echo,INPUT);
pinMode(triger,OUTPUT);
}
void loop(){
//Linea Blanca
l1 = digitalRead(sensorleft);
l2 = digitalRead(sensorcenter);
l3 = digitalRead(sensorright);
/////////////////
if (l1 == 1 && l2 == 1 && l3 == 1) //Feedback cuando todos los sensores estan en negro
{
l1 = f1;
l2 = f2;
l3 = f3;
}
/////////////////
else if(l1==1 && l2==1 && l3==0)
{
derechacerrada();
if(distancia() <= 15){
izquierdacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(300);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(600);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(300);
adelante();
if(l1==0 && l2==0 && l3==0){
adelante();
delay(200);
izquierdacerrada();
}
}
}
else if(l1==1 && l2==0 && l3==0)
{
derecha();
if(distancia() <= 15){
izquierdacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(300);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(600);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(300);
adelante();
if(l1==0 && l2==0 && l3==0){
adelante();
delay(200);
izquierdacerrada();
}
}
}
else if(l1==0 && l2==1 && l3==1)
{
izquierdacerrada();
if(distancia() <= 15){
izquierdacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(300);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(600);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(300);
adelante();
if(l1==0 && l2==0 && l3==0){
adelante();
delay(200);
izquierdacerrada();
}
}
}
else if(l1==0 && l2==0 && l3==1)
{
izquierda();
if(distancia() <= 15){
izquierdacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(300);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(600);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(300);
adelante();
if(l1==0 && l2==0 && l3==0){
adelante();
delay(200);
izquierdacerrada();
}
}
}
else if(l1==1 && l2==0 && l3==1)
{
adelante();
if(distancia() <= 15){
izquierdacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(300);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(200);
adelante();
delay(600);
alto();
delay(200);
derechacerrada();
delay(500);
alto();
delay(300);
adelante();
if(l1==0 && l2==0 && l3==0){
adelante();
delay(200);
izquierdacerrada();
}
}
}
///////////////////////////////////////////////////////////////////
f1 = l1;
f2 = l2;
f3 = l3; //memory variables
////////////////////////////////////////////////////////////////////
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void izquierdacerrada()
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void derechacerrada()//Giro a la derecha cerrada
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
long distancia() //Medicion de distancia
{
long t;
long d;
digitalWrite(triger, HIGH);
delayMicroseconds(10);
digitalWrite(triger, LOW);
t = pulseIn(echo, HIGH);
d = t/59;
delay(10);
return d;
}
Comportamiento del programa.
Tu Kit Robot 4WD podrá conectarse con tu celular Android a través de la aplicación proporcionada. El siguiente video sirve de guía para poder realizare las conexiones.
En esta parte podrás ver el código completo. Pero si quieres solo descargar el archivo de texto puedes hacerlo al presionar el botón descargar.
int motA0=10; // Pines para control de motores
int motA1=11;
int motB0=9;
int motB1=8;
char valorBoton;
char penultimo = 'n';
char antepenultimo = 'm';
char vali = 'b';
void setup()
{
Serial.begin(9600);
pinMode(motA0,OUTPUT);
pinMode(motA1,OUTPUT);
pinMode(motB0,OUTPUT);
pinMode(motB1,OUTPUT);
digitalWrite(motA0,LOW);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,LOW);
}
void loop()
{
if(Serial.available() > 0)
{
valorBoton = Serial.read();
//Penultimo = n neutral antepenultimo = m neutral
//Donde se quiera una izquierda se debe poner derecha y al reves
//3 señales o 3 botones al mismo tiempo
if((antepenultimo == 'w' && penultimo == 'd' && valorBoton == 'h')
|| (antepenultimo == 'w' && penultimo == 'a' && valorBoton == 'f'))//wdh o waf
{
vali = 'i';
adelante();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 's' && penultimo == 'd' && valorBoton == 'h')
|| (antepenultimo == 's' && penultimo == 'a' && valorBoton == 'f'))//sdh o saf
{
vali = 'k';
atras();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 'a' && penultimo == 'w' && valorBoton == 't')
|| (antepenultimo == 'a' && penultimo == 's' && valorBoton == 'g'))//awt o asg
{
vali = 'j';
derecha();
penultimo = 'n';
antepenultimo = 'm';
}
else if((antepenultimo == 'd' && penultimo == 'w' && valorBoton == 't')
|| (antepenultimo == 'd' && penultimo == 's' && valorBoton == 'g'))//dwt o dsg
{
vali = 'l';
izquierda();
penultimo = 'n';
antepenultimo = 'm';
}
else if(vali == 'i')//Validacion no se suelta adelante
{
adelante();
if(valorBoton == 't')
{
vali = 'b';
alto();
}
else if(valorBoton == 'd') { //d
izquierda();
}
else if(valorBoton == 'a') { //a
derecha();
}
}
else if(vali == 'k')//Validacion no se suelta atras
{
atras();
if(valorBoton == 'g')
{
vali = 'b';
alto();
}
else if(valorBoton == 'd') { //d
atrasderecha();
}
else if(valorBoton == 'a') { //a
atrasizquierda();
}
}
else if(vali == 'j')//Validacion no se suelta izquierda
{
derecha();
if(valorBoton == 'f')
{
vali = 'b';
alto();
}
else if(valorBoton == 'w') { //w
derecha();
}
else if(valorBoton == 'a') { //s
atrasderecha();
}
}
else if(vali == 'l')//Validacion no se suelta derecha
{
izquierda();
if(valorBoton == 'h')
{
vali = 'b';
alto();
}
else if(valorBoton == 'w') { //w
izquierda();
}
else if(valorBoton == 'a') { //s
atrasizquierda();
}
}
//Combinaciones de dos botones:
else if(valorBoton == 'w') { //w
adelante();
}
else if(valorBoton == 's') { //s
atras();
}
else if(penultimo != 's' && valorBoton == 'a') { //a
derecha();
}
else if(penultimo != 's' && valorBoton == 'd') { //d
izquierda();
}
else if(penultimo == 'w' && valorBoton == 'a') { //wa
derecha();
}
else if(penultimo == 'w' && valorBoton == 'd') { //wd
izquierda();
}
else if(penultimo == 'w' && valorBoton == 'f') { //wf
adelante();
}
else if(penultimo == 'w' && valorBoton == 'h') { //wh
adelante();
}
else if(penultimo == 't' && valorBoton == 'a') { //ta
derecha();
}
else if(penultimo == 't' && valorBoton == 'd') { //td
izquierda();
}
else if(penultimo == 's' && valorBoton == 'a') { //sa
atrasizquierda();
}
else if(penultimo == 's' && valorBoton == 'd') { //sd
atrasderecha();
}
else if(penultimo == 's' && valorBoton == 'f') { //sf
atras();
}
else if(penultimo == 's' && valorBoton == 'h') { //sh
atras();
}
else if(penultimo == 'g' && valorBoton == 'a') { //ga
atrasderecha();
}
else if(penultimo == 'g' && valorBoton == 'd') { //gd
atrasizquierda();
}
//Espejo
else if(penultimo == 'a' && valorBoton == 'w') { //aw
derecha();
}
else if(penultimo == 'd' && valorBoton == 'w') { //dw
izquierda();
}
else if(penultimo == 'f' && valorBoton == 'w') { //fw
adelante();
}
else if(penultimo == 'h' && valorBoton == 'w') { //hw
adelante();
}
else if(penultimo == 'a' && valorBoton == 't') { //at
derecha();
}
else if(penultimo == 'd' && valorBoton == 't') { //dt
izquierda();
}
else if(penultimo == 'a' && valorBoton == 's') { //as
atrasderecha();
}
else if(penultimo == 'd' && valorBoton == 's') { //ds
atrasizquierda();
}
else if(penultimo == 'f' && valorBoton == 's') { //fs
atras();
}
else if(penultimo == 'h' && valorBoton == 's') { //hs
atras();
}
else if(penultimo == 'a' && valorBoton == 'g') { //ag
atrasderecha();
}
else if(penultimo == 'd' && valorBoton == 'g') { //dg
atrasizquierda();
}
else {
//Si se presionan más de dos botones o no se presionan los adecuados
alto();
penultimo = 'n';
antepenultimo = 'm';
}
//Actualizar la penultimo
Serial.print(antepenultimo);
Serial.print(" ");
Serial.print(penultimo);
Serial.print(" ");
Serial.print(valorBoton);
Serial.print(" ");
Serial.print(vali);
Serial.println(" ");
antepenultimo = penultimo;
penultimo = valorBoton;
}
}
void adelante()
{
digitalWrite(motA0, HIGH);
digitalWrite(motA1, LOW);
digitalWrite(motB0, HIGH);
digitalWrite(motB1, LOW);
}
void atras()
{
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH);
digitalWrite(motB0, LOW);
digitalWrite(motB1, HIGH);
}
void izquierda() //Giro a la izquierda
{
digitalWrite(motA0,LOW);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,LOW);
}
void derecha() //Giro a la derecha
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,LOW);
digitalWrite(motB0,LOW);
digitalWrite(motB1,HIGH);
}
void alto() //Paro total
{
digitalWrite(motA0,HIGH);
digitalWrite(motA1,HIGH);
digitalWrite(motB0,HIGH);
digitalWrite(motB1,HIGH);
}
void atrasizquierda(){
digitalWrite(motA0, LOW);
digitalWrite(motA1, LOW); //PWM
digitalWrite(motB0, LOW); //PWM
digitalWrite(motB1, HIGH);
}
void atrasderecha(){
digitalWrite(motA0, LOW);
digitalWrite(motA1, HIGH); //PWM
digitalWrite(motB0, LOW); //PWM
digitalWrite(motB1, LOW);
}