Introducción

En este tutorial daremos un paso más y explicaremos el procedimiento para crear un robot móvil con Arduino usando nuestros conocimientos previos adquiridos tras la lectura de los correspondientes artículos publicados en este blog, sobre el receptor de infrarrojos (ver artículo) y sobre los motores de corriente continua (ver artículo) para crear un interesante robot móvil en el que usaremos los 2 componentes de manera sincronizada.
El objetivo de nuestro proyecto será crear un robot móvil que pueda ser dirigido mediante un mando a distancia que emite señal infrarroja. El robot debe avanzar recto cuando se accione el botón "arriba del mando", avanzar marcha atrás (cuando se accione el botón "atrás" del mando), girar a la derecha (cuando se accione el botón "derecha" del mando, girar a la izquierda (cuando se accione el botón "izquierda" del mando) o parar (cuando se accione el botón "Ok" del mando).
 

Material necesario

Nombre Imagen Descripción
Placa Arduino Uno arduino uno large comp Placa Arduino Uno (o cualquier otra versión) 
Protoboard, breadboard o placa de conexiones protoboard Placa de conexiones o protoboard que usaremos en el montaje de circuitos eléctrico-electrónico para ahorrar y simplificar el cableado. Para aprender algo más sobre el uso de este dispositivo pulsa aquí
1 driver L298n
driverl298n

El driver L298n nos permitirá gobernar los motores de corriente continua con las ruedas acopladas y, por tanto, gobernar el movimiento de nuestro vehículo. Se recomienda leer el artículo para más información.

Receptor/sensor de infrarrojos sensorIR Un receptor de infrarrojos integrado como el AX1838HS. Independiente o con breakout board
Un mando a distancia (emisor infrarrojos)
mandoKeyes

Cualquier mando a distancia puede ser usado para probar la señal infrarroja.

Cables de conexiones entre los componentes, la placa de pruebas y Arduino cables Estos cables nos permiten conectar de manera sencilla todos los elementos del circuito.

Circuito eléctrico (diagrama de conexiones)

Dado que en otras sesiones ya trabajamos con el driver L298n para controlar 2 motores de corriente contínua y con el sensor de infrarrojos para detectar señales procedentes de un mando a distancia, combinaremos la circuitería de ambos circuitos para crear nuestro proyecto conjunto.

circuitoIRDriver

Código programa Arduino

Para poder detectar señales lo mejor es usar una librería (código generado que permite usar determinaciones funciones que no pertenecen al IDE de Arduino). No entraremos en profundidad en el uso de dichas librerías (vitales para cualquier programador en cualquier idioma) (leer artículo de Prometec sobre librerías) pero en este caso usaremos la librería Arduino-IRremote desarrollada por Rafi Khan (z3t0) disponible en este enlace.

Arduino Code
  1. /*
  2.   Nombre: Robot Mando Distancia
  3.   Autor: Daniel Pascual Gallegos
  4.   Fecha: Diciembre 2016
  5.   Funcionalidad: Este subproyecto forma parte de la construcción de nuestro robot autónomo.
  6.   En este subproyecto usaremos un mando a distancia y un sensor infrarrojos
  7.   para accionar nuestro robot móvil de manera inalámbrica.
  8.   En este caso, usaremos 5 botones del robot:
  9.   - Flecha arriba: el robot avanzará recto y 2 LEDs verdes ON
  10.   - Flecha abajo: el robot irá marcha atrás y 2 LEDs rojos ON
  11.   - Flecha derecha: el robot irá hacia la derecha
  12.   - Flecha izquierda: el robot irá hacia la izquierda
  13.   - Botón OK: el robot parará y se apagarán todos los LEDs
  14. */
  15.  
  16. // Inclusión de librería para trabajar con el sensor IR
  17. #include "IRremote.h"
  18.  
  19. // Definición de variables y constantes relacionadas con el motor izquierdo
  20. const int IN1 = 13; // Pin digital 13 para controlar sentido giro motor izquierdo
  21. const int IN2 = 12; // Pin digital 12 para controlar sentido giro motor izquierdo
  22.  
  23. // Definición de variables y constantes relacionadas con el motor derecho
  24. const int IN3 = 11; // Pin digital 11 para controlar sentido giro motor izquierdo
  25. const int IN4 = 10; // Pin digital 10 para controlar sentido giro motor izquierdo
  26.  
  27. // Definición de variables y constantes relacionadas con los LEDs
  28. const int ledVerde1 = 4; // Pin digital 4 para conectar el LED verde 1
  29. const int ledVerde2 = 5; // Pin digital 5 para conectar el LED verde 2
  30. const int ledRojo1 = 6; // Pin digital 6 para conectar el LED rojo 1
  31. const int ledRojo2 = 7; // Pin digital 7 para conectar el LED rojo 2
  32.  
  33. // Definición de variables y constantes relacionadas con el zumbador
  34. const int zumbadorPiezo = 8; // Pin digital 8 para conectar el zumbador
  35.  
  36. // Definición de variables y constantes relacionadas con el sensor infrarrojos
  37. const int sensorInfrarrojos = 9; // Pin digital 9 para conectar el sensor
  38. IRrecv irrecv(sensorInfrarrojos); // Se crea un nuevo objeto para trabajar con el sensor
  39. decode_results results;
  40.  
  41. // Definición de códigos asociados al mando Keyes más sencillo
  42. const unsigned long BOTON_ARRIBA = 0xFF629D;
  43. const unsigned long BOTON_ABAJO = 0xFFA857;
  44. const unsigned long BOTON_IZQ = 0xFF22DD;
  45. const unsigned long BOTON_DER = 0xFFC23D;
  46. const unsigned long BOTON_OK = 0xFF02FD;
  47.  
  48. // Función que se ejecuta una sola vez al cargar el programa
  49. void setup()
  50. {
  51. // Se declaran todos los pines como salidas
  52. // Pines asociados a los motores
  53. pinMode (IN1, OUTPUT);
  54. pinMode (IN2, OUTPUT);
  55. pinMode (IN3, OUTPUT);
  56. pinMode (IN4, OUTPUT);
  57.  
  58. // Pines asociados a los LEDS
  59. pinMode (ledVerde1, OUTPUT);
  60. pinMode (ledVerde2, OUTPUT);
  61. pinMode (ledRojo1, OUTPUT);
  62. pinMode (ledRojo2, OUTPUT);
  63.  
  64. // Pines asociados al zumbador
  65. pinMode (zumbadorPiezo, OUTPUT);
  66.  
  67. // Se inicia el receptor IR
  68. irrecv.enableIRIn();
  69.  
  70. // Se inicia el puerto de comunicaciones en serie
  71. Serial.begin(9600);
  72. }
  73.  
  74. // Función que se repite de manera periódica
  75. void loop()
  76. {
  77. lecturaSensor(); // Se lee la señal del sensor IR
  78.  
  79. }
  80.  
  81. /*
  82.   Función robotAvance: esta función hará que ambos motores se activen a máxima potencia
  83.   por lo que el robot avanzará hacia delante
  84. */
  85. void robotAvance()
  86. {
  87. // Motor izquierdo
  88. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  89. digitalWrite (IN1, HIGH);
  90. digitalWrite (IN2, LOW);
  91.  
  92. // Motor derecho
  93. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  94. digitalWrite (IN3, HIGH);
  95. digitalWrite (IN4, LOW);
  96. }
  97. /*
  98.   Función robotRetroceso: esta función hará que ambos motores se activen a máxima potencia en sentido contrario al anterior
  99.   por lo que el robot avanzará hacia atrás
  100. */
  101. void robotRetroceso()
  102. {
  103. // Motor izquierdo
  104. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  105. digitalWrite (IN1, LOW);
  106. digitalWrite (IN2, HIGH);
  107.  
  108. // Motor derecho
  109. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  110. digitalWrite (IN3, LOW);
  111. digitalWrite (IN4, HIGH);
  112. }
  113.  
  114. /*
  115.   Función robotDerecha: esta función acccionará el motor izquierdo y parará el derecho
  116.   por lo que el coche girará hacia la derecha (sentido horario)
  117. */
  118. void robotDerecha()
  119. {
  120. // Motor izquierdo
  121. // Se activa el motor izquierdo
  122. digitalWrite (IN1, HIGH);
  123. digitalWrite (IN2, LOW);
  124.  
  125. // Motor derecho
  126. // Se para el motor derecho
  127. digitalWrite (IN3, LOW);
  128. digitalWrite (IN4, LOW);
  129.  
  130. }
  131. /*
  132.   Función robotIzquierda: esta función acccionará el motor derecho y parará el izquierdo
  133.   por lo que el coche girará hacia la izquierda (sentido antihorario)
  134. */
  135. void robotIzquierda ()
  136. {
  137. // Motor izquierdo
  138. // Se para el motor izquierdo
  139. digitalWrite (IN1, LOW);
  140. digitalWrite (IN2, LOW);
  141.  
  142. // Motor derecho
  143. // Se activa el motor derecho
  144. digitalWrite (IN3, HIGH);
  145. digitalWrite (IN4, LOW);
  146.  
  147. }
  148. /*
  149.   Función robotParar: esta función parará ambos motores
  150.   por lo que el robot se parará.
  151. */
  152. void robotParar()
  153. {
  154. // Motor izquierdo
  155. // Se para el motor izquierdo
  156. digitalWrite (IN1, LOW);
  157. digitalWrite (IN2, LOW);
  158.  
  159. // Motor derecho
  160. // Se para el motor derecho
  161. digitalWrite (IN3, LOW);
  162. digitalWrite (IN4, LOW);
  163. }
  164. /*
  165.   Función enciendeLEDVerde: esta función hará que ambos LED verdes se enciendan
  166.   y se apaguen los LED rojos (en caso de que estuvieran encendidos)
  167.   y el zumbador (en caso de que estuviera sonando)
  168. */
  169. void enciendeLEDVerde()
  170. {
  171. // Manda 5 V a los pines por lo que enciende los 2 LED verdes
  172. digitalWrite (ledVerde1, HIGH);
  173. digitalWrite (ledVerde2, HIGH);
  174.  
  175. // Quita 5V de los otros pines por lo que apaga los 2 LED rojos y el zumbador
  176. digitalWrite (ledRojo1, LOW);
  177. digitalWrite (ledRojo2, LOW);
  178. digitalWrite (zumbadorPiezo, HIGH);
  179. }
  180. /*
  181.   Función enciendeLEDRojoZumbador: esta función hará que ambos LED rojos se enciendan
  182.   y que empiece a sonar el zumbador. Además de que se apaguen los LED verdes
  183. */
  184. void enciendeLEDRojoZumbador()
  185. {
  186. // Manda 5 V a los pines por lo que enciende los 2 LED rojos y el zumbador
  187. digitalWrite (ledRojo1, HIGH);
  188. digitalWrite (ledRojo2, HIGH);
  189. digitalWrite (zumbadorPiezo, HIGH);
  190.  
  191. // Quita 5V de los otros pines por lo que apaga los 2 LED verdes
  192. digitalWrite (ledVerde1, LOW);
  193. digitalWrite (ledVerde2, LOW);
  194. }
  195. /*
  196.   Función lecturaSensor: esta función recibirá los valores del mando a distancia
  197. */
  198. void lecturaSensor()
  199. {
  200. if (irrecv.decode(&results))
  201. {
  202. Serial.println (results.value, HEX); //display HEX
  203. Serial.println (results.value);
  204. switch (results.value)
  205. {
  206. case BOTON_ARRIBA:
  207. Serial.println("Boton arriba");
  208. robotAvance();
  209. enciendeLEDVerde();
  210. break;
  211.  
  212. case BOTON_ABAJO:
  213. Serial.println("Boton abajo");
  214. robotRetroceso();
  215. enciendeLEDRojoZumbador();
  216. break;
  217.  
  218. case BOTON_IZQ:
  219. Serial.println("Boton izquierda");
  220. robotIzquierda();
  221. break;
  222.  
  223. case BOTON_DER:
  224. Serial.println("Boton derecha");
  225. robotDerecha();
  226. break;
  227.  
  228. case BOTON_OK:
  229. Serial.println("Boton OK");
  230. robotParar();
  231. break;
  232. }
  233. irrecv.resume();
  234. }
  235. }
  236.  
Spanish English French German Italian Portuguese Russian

Redes sociales

facebook iconotwitterGoogle plus iconpinterest

Artículos

TIC