Introducción

En este caso vamos a realizar la tercera versión de nuestro robot móvil.  Para ello uniremos la funcionalidad de nuestros 2 robots anteriormente diseñados y construidos ("Robot Esquivaobstáculos" y "Robot dirigido mediante mando a distancia") para crear un prototipo que añada las funciones de ambos proyectos.
El objetivo de nuestra proyecto será crear un robot que cambie su función según la pulsación de un determinado botón del mando a distancia de modo que: - Si es pulsado el botón 1 del mando a distancia el robot actuará como "esquivaobstáculos" - Si es pulsado el botón 2 del mando a distancia el robot podrá ser dirigido con el mando a distancia sin tener en cuenta el sensor de ultrasonidos.

Material necesario

En este caso los componentes son la suma de los componentes usados para el Robot Esquivaobstáculos así como los usados para el Robot dirigido mediante mando a distancia por lo que se recomienda leer los citados artículos para obtener el total de elementos.

Circuito eléctrico (diagrama de conexiones)

En este caso, añadiremos la circuitería necesaria para integrar estos elementos con el circuito de nuestro robot. Para no complicar demasiado el diagrama por excesivo número de conexiones, mostraremos por separado el circuito que gobierna el funcionamiento de nuestro robot y el circuito con los elementos no relevantes como son los LED y el zumbador.

Circuito Inicial

RobotMultifuncionCircuitoCompleto

Circuito LED + Zumbador

circuitoLEDzumbador

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.

Distinguiremos 2 codificaciones diferentes:

  • En el primero de los casos no controlaremos la velocidad de los motores (mantendremos sin conectar los jumpers para ENA y ENB del driver L298D)
Arduino Code
  1. /*
  2.   Nombre: Robot Multifunción
  3.   Autor: Daniel Pascual Gallegos
  4.   Fecha: Enero 2017
  5.   Funcionalidad: Este proyecto reune las propiedades de varios proyectos
  6.   Leerá la información de un mando a distancia:
  7.   - Si el usuario pulsa el botón 1 el robot realizará las funciones
  8.   del robotesquivaobstáculos
  9.   - Si el usuario pulsa el botón 2 el robot se convertirá
  10.   en el robot dirigido mando a distancia
  11. */
  12.  
  13. // Inclusión de librería para trabajar con el sensor IR
  14. #include "IRremote.h"
  15.  
  16. // Definición de variables y constantes relacionadas con el motor izquierdo
  17. const int IN1 = 13; // Pin digital 13 para controlar sentido giro motor izquierdo
  18. const int IN2 = 12; // Pin digital 12 para controlar sentido giro motor izquierdo
  19.  
  20. // Definición de variables y constantes relacionadas con el motor derecho
  21. const int IN3 = 11; // Pin digital 11 para controlar sentido giro motor izquierdo
  22. const int IN4 = 10; // Pin digital 10 para controlar sentido giro motor izquierdo
  23.  
  24. // Definición de variables y constantes relacionadas con los LEDs
  25. const int ledVerde1 = 4; // Pin digital 4 para conectar el LED verde 1
  26. const int ledVerde2 = 5; // Pin digital 5 para conectar el LED verde 2
  27. const int ledRojo1 = 6; // Pin digital 6 para conectar el LED rojo 1
  28. const int ledRojo2 = 7; // Pin digital 7 para conectar el LED rojo 2
  29.  
  30. // Definición de variables y constantes relacionadas con el zumbador
  31. const int zumbadorPiezo = 8; // Pin digital 8 para conectar el zumbador
  32.  
  33. /// Definición de variables y constantes relacionadas con el sensor infrarrojos
  34. const int sensorInfrarrojos = 9; // Pin digital 9 para conectar el sensor
  35. IRrecv irrecv(sensorInfrarrojos); // Se crea un nuevo objeto para trabajar con el sensor
  36. decode_results results;
  37.  
  38. // Definición de códigos asociados al mando Keyes más sencillo
  39. const unsigned long BOTON_ARRIBA = 0xFF629D;
  40. const unsigned long BOTON_ABAJO = 0xFFA857;
  41. const unsigned long BOTON_IZQ = 0xFF22DD;
  42. const unsigned long BOTON_DER = 0xFFC23D;
  43. const unsigned long BOTON_OK = 0xFF02FD;
  44. const unsigned long BOTON_1 = 0xFF6897;
  45. const unsigned long BOTON_2 = 0xFF9867;
  46. const unsigned long BOTON_3 = 0xFFB04F;
  47.  
  48. // Definición de variables y constantes relacionadas con la detección de obstáculos
  49. const int triggerEmisor = 3;
  50. const int echoReceptor = 2;
  51. const int valorUmbral = 10;
  52. long tiempoEntrada; // Tiempo de respuesta del sensor de entrada
  53. float distanciaEntrada; // Distancia en cm a la que se encuentra el objeto del sensor
  54.  
  55. // Variables y constantes que almacenan la función del ROBOT
  56. // Será 1 cuando esté en modo esquivaobstáculos
  57. // Será 2 cuando esté controlado por el mando a distancia
  58. int funcionRobot = 0; // Al inicio el robot no tiene funcionalidad
  59. // Función que se ejecuta una sola vez al cargar el programa
  60. void setup()
  61. {
  62. // Se declaran todos los pines como salidas
  63. // Pines asociados a los motores
  64. pinMode (IN1, OUTPUT);
  65. pinMode (IN2, OUTPUT);
  66. pinMode (IN3, OUTPUT);
  67. pinMode (IN4, OUTPUT);
  68.  
  69. // Pines asociados a los LEDS
  70. pinMode (ledVerde1, OUTPUT);
  71. pinMode (ledVerde2, OUTPUT);
  72. pinMode (ledRojo1, OUTPUT);
  73. pinMode (ledRojo2, OUTPUT);
  74.  
  75. // Pines asociados al zumbador
  76. pinMode (zumbadorPiezo, OUTPUT);
  77.  
  78. // Pines asociados al sensor ultrasonico HCSR04
  79. pinMode(triggerEmisor,OUTPUT); // El emisor emite por lo que es configurado como salida
  80. pinMode(echoReceptor,INPUT); // El receptor recibe por lo que es configurado como entrada
  81.  
  82. // Se inicia el receptor IR
  83. irrecv.enableIRIn();
  84.  
  85. // Se inicia el puerto de comunicaciones en serie
  86. Serial.begin(9600); //
  87. }
  88.  
  89. // Función que se repite de manera periódica
  90. void loop()
  91. {
  92. robotFuncion(); // Analiza si el robot funciona como esquivaobstáculos o con el mando
  93.  
  94. if(funcionRobot==1)
  95. {
  96. robotEsquivaObstaculos(); // Se crea la funcionalidad robotesquivaosbtaculos
  97. }
  98. else if(funcionRobot==2)
  99. {
  100. robotMandoDistancia(); // Se lee la señal del sensor IR
  101. }
  102. }
  103.  
  104. void robotEsquivaObstaculos()
  105. {
  106. Serial.println("Entra esquiva ");
  107. // Se inicializa el sensor de infrasonidos
  108. digitalWrite(triggerEmisor,LOW); // Para estabilizar
  109. delayMicroseconds(10);
  110.  
  111. // Comenzamos las mediciones
  112. // Se envía una señal activando la salida trigger durante 10 microsegundos
  113. digitalWrite(triggerEmisor, HIGH); // envío del pulso ultrasónico
  114. delayMicroseconds(10);
  115. tiempoEntrada=pulseIn(echoReceptor, HIGH);
  116. distanciaEntrada= int(0.017*tiempoEntrada); // Calcula la distancia en cm
  117. Serial.println("El valor de la distancia es ");
  118. Serial.println(distanciaEntrada);
  119. delay(200);
  120. // Si el valor de la distancia es menor que el valor umbral
  121. if(distanciaEntrada<valorUmbral)
  122. {
  123. robotAvance(); // El robot avanza mientras no encuentre obstáculos
  124. enciendeLEDVerde(); // Enciende los LED verdes delanteros
  125. }
  126. else
  127. {
  128. enciendeLEDRojoZumbador(); // Enciende los LED rojos traseros y el zumbador
  129. // Retrocede 1 segundo y gira a la derecha 0,5 segundos para esquivarlo
  130. robotRetroceso();
  131. delay(1000);
  132. robotDerecha ();
  133. delay(500);
  134. }
  135. }
  136. /*
  137.   Función robotAvance: esta función hará que ambos motores se activen a máxima potencia
  138.   por lo que el robot avanzará hacia delante
  139. */
  140. void robotAvance()
  141. {
  142. // Motor izquierdo
  143. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  144. digitalWrite (IN1, HIGH);
  145. digitalWrite (IN2, LOW);
  146.  
  147. // Motor derecho
  148. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  149. digitalWrite (IN3, HIGH);
  150. digitalWrite (IN4, LOW);
  151. }
  152. /*
  153.   Función robotRetroceso: esta función hará que ambos motores se activen a máxima potencia
  154.   en sentido contrario al anterior por lo que el robot avanzará hacia atrás
  155. */
  156. void robotRetroceso()
  157. {
  158. // Motor izquierdo
  159. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  160. digitalWrite (IN1, LOW);
  161. digitalWrite (IN2, HIGH);
  162.  
  163. // Motor derecho
  164. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  165. digitalWrite (IN3, LOW);
  166. digitalWrite (IN4, HIGH);
  167. }
  168.  
  169. /*
  170.   Función robotDerecha: esta función acccionará el motor izquierdo y parará el derecho
  171.   por lo que el coche girará hacia la derecha (sentido horario)
  172. */
  173. void robotDerecha()
  174. {
  175. // Motor izquierdo
  176. // Se activa el motor izquierdo
  177. digitalWrite (IN1, HIGH);
  178. digitalWrite (IN2, LOW);
  179.  
  180. // Motor derecho
  181. // Se para el motor derecho
  182. digitalWrite (IN3, LOW);
  183. digitalWrite (IN4, LOW);
  184.  
  185. }
  186. /*
  187.   Función robotIzquierda: esta función acccionará el motor derecho y parará el izquierdo
  188.   por lo que el coche girará hacia la izquierda (sentido antihorario)
  189. */
  190. void robotIzquierda ()
  191. {
  192. // Motor izquierdo
  193. // Se para el motor izquierdo
  194. digitalWrite (IN1, LOW);
  195. digitalWrite (IN2, LOW);
  196.  
  197. // Motor derecho
  198. // Se activa el motor derecho
  199. digitalWrite (IN3, HIGH);
  200. digitalWrite (IN4, LOW);
  201.  
  202. }
  203. /*
  204.   Función robotParar: esta función parará ambos motores
  205.   por lo que el robot se parará.
  206. */
  207. void robotParar()
  208. {
  209. // Motor izquierdo
  210. // Se para el motor izquierdo
  211. digitalWrite (IN1, LOW);
  212. digitalWrite (IN2, LOW);
  213.  
  214. // Motor derecho
  215. // Se para el motor derecho
  216. digitalWrite (IN3, LOW);
  217. digitalWrite (IN4, LOW);
  218. }
  219. /*
  220.   Función enciendeLEDVerde: esta función hará que ambos LED verdes se enciendan
  221.   y se apaguen los LED rojos (en caso de que estuvieran encendidos)
  222.   y el zumbador (en caso de que estuviera sonando)
  223. */
  224. void enciendeLEDVerde()
  225. {
  226. // Manda 5 V a los pines por lo que enciende los 2 LED verdes
  227. digitalWrite (ledVerde1, HIGH);
  228. digitalWrite (ledVerde2, HIGH);
  229.  
  230. // Quita 5V de los otros pines por lo que apaga los 2 LED rojos y el zumbador
  231. digitalWrite (ledRojo1, LOW);
  232. digitalWrite (ledRojo2, LOW);
  233. digitalWrite (zumbadorPiezo, HIGH);
  234. }
  235. /*
  236.   Función enciendeLEDRojoZumbador: esta función hará que ambos LED rojos se enciendan
  237.   y que empiece a sonar el zumbador. Además de que se apaguen los LED verdes
  238. */
  239. void enciendeLEDRojoZumbador()
  240. {
  241. // Manda 5 V a los pines por lo que enciende los 2 LED rojos y el zumbador
  242. digitalWrite (ledRojo1, HIGH);
  243. digitalWrite (ledRojo2, HIGH);
  244. digitalWrite (zumbadorPiezo, HIGH);
  245.  
  246. // Quita 5V de los otros pines por lo que apaga los 2 LED verdes
  247. digitalWrite (ledVerde1, LOW);
  248. digitalWrite (ledVerde2, LOW);
  249. }
  250.  
  251. /*
  252.   Función robotFuncion: esta función recibirá los valores del mando a distancia
  253.   - Si el usuario pulsa el botón 1 el robot realizará las funciones
  254.   del robotesquivaobstáculos
  255.   - Si el ususario pulsa el botón 2 el robot se convertirá
  256.   en el robot dirigido mando a distancia
  257.  
  258. */
  259. void robotFuncion()
  260. {
  261. if (irrecv.decode(&results))
  262. {
  263. Serial.println (results.value, HEX); //display HEX
  264. Serial.println (results.value);
  265. delay(1000);
  266. // Comprueba inicialmente la función del robot
  267. // Si pulsa el botón 1
  268. if(results.value==BOTON_1)
  269. {
  270. funcionRobot = 1;
  271. }
  272. else if(results.value==BOTON_2)
  273. {
  274. funcionRobot = 2;
  275. }
  276. irrecv.resume(); // Busca el siguiente valor del mando
  277. }
  278. }
  279.  
  280. void robotMandoDistancia()
  281. {
  282. Serial.println("Entra mando ");
  283. if (irrecv.decode(&results))
  284. {
  285. Serial.println (results.value, HEX); //display HEX
  286. Serial.println (results.value);
  287. switch (results.value)
  288. {
  289. case BOTON_1:
  290. Serial.println("Botón 1");
  291. funcionRobot = 1;
  292. break;
  293.  
  294. case BOTON_ARRIBA:
  295. Serial.println("Boton arriba");
  296. robotAvance();
  297. enciendeLEDVerde();
  298. break;
  299.  
  300. case BOTON_ABAJO:
  301. Serial.println("Boton abajo");
  302. robotRetroceso();
  303. enciendeLEDRojoZumbador();
  304. break;
  305.  
  306. case BOTON_IZQ:
  307. Serial.println("Boton izquierda");
  308. robotIzquierda();
  309. break;
  310.  
  311. case BOTON_DER:
  312. Serial.println("Boton derecha");
  313. robotDerecha();
  314. break;
  315.  
  316. case BOTON_OK:
  317. Serial.println("Boton OK");
  318. robotParar();
  319. break;
  320. }
  321. irrecv.resume();
  322. }
  323. }
  324.  
  • En el segundo conectaremos la salida ENA al pin digital 6 y la salida ENB al pin digital 5 (para poder controlar la velocidad de giro del motor para proyectos siguientes).
Arduino Code
  1. /*
  2.   Nombre: Robot Multifunción
  3.   Autor: Daniel Pascual Gallegos
  4.   Fecha: Enero 2017
  5.   Funcionalidad: Este proyecto reune las propiedades de varios proyectos
  6.   Leerá la información de un mando a distancia:
  7.   - Si el usuario pulsa el botón 1 el robot realizará las funciones
  8.   del robotesquivaobstáculos
  9.   - Si el usuario pulsa el botón 2 el robot se convertirá
  10.   en el robot dirigido mando a distancia
  11. */
  12.  
  13. // Inclusión de librería para trabajar con el sensor IR
  14. #include "IRremote.h"
  15.  
  16. // Definición de variables y constantes relacionadas con el motor izquierdo
  17. const int IN1 = 13; // Pin digital 13 para controlar sentido giro motor izquierdo
  18. const int IN2 = 12; // Pin digital 12 para controlar sentido giro motor izquierdo
  19. const int ENA = 6;
  20.  
  21. // Definición de variables y constantes relacionadas con el motor derecho
  22. const int IN3 = 11; // Pin digital 11 para controlar sentido giro motor izquierdo
  23. const int IN4 = 10; // Pin digital 10 para controlar sentido giro motor izquierdo
  24. const int ENB = 5;
  25.  
  26. // Definición de variables y constantes relacionadas con los LEDs
  27. const int ledVerde1 = 4; // Pin digital 4 para conectar el LED verde 1
  28. const int ledRojo2 = 7; // Pin digital 7 para conectar el LED rojo 2
  29.  
  30. // Definición de variables y constantes relacionadas con el zumbador
  31. const int zumbadorPiezo = 8; // Pin digital 8 para conectar el zumbador
  32.  
  33. /// Definición de variables y constantes relacionadas con el sensor infrarrojos
  34. const int sensorInfrarrojos = 9; // Pin digital 9 para conectar el sensor
  35. IRrecv irrecv(sensorInfrarrojos); // Se crea un nuevo objeto para trabajar con el sensor
  36. decode_results results;
  37.  
  38. // Definición de códigos asociados al mando Keyes más sencillo
  39. const unsigned long BOTON_ARRIBA = 0xFF629D;
  40. const unsigned long BOTON_ABAJO = 0xFFA857;
  41. const unsigned long BOTON_IZQ = 0xFF22DD;
  42. const unsigned long BOTON_DER = 0xFFC23D;
  43. const unsigned long BOTON_OK = 0xFF02FD;
  44. const unsigned long BOTON_1 = 0xFF6897;
  45. const unsigned long BOTON_2 = 0xFF9867;
  46. const unsigned long BOTON_3 = 0xFFB04F;
  47.  
  48. // Definición de variables y constantes relacionadas con la detección de obstáculos
  49. const int triggerEmisor = 3;
  50. const int echoReceptor = 2;
  51. const int valorUmbral = 20;
  52. long tiempoEntrada; // Tiempo de respuesta del sensor de entrada
  53. float distanciaEntrada; // Distancia en cm a la que se encuentra el objeto del sensor
  54.  
  55. // Variables y constantes que almacenan la función del ROBOT
  56. // Será 1 cuando esté en modo esquivaobstáculos
  57. // Será 2 cuando esté controlado por el mando a distancia
  58. int funcionRobot = 0; // Al inicio el robot no tiene funcionalidad
  59. // Función que se ejecuta una sola vez al cargar el programa
  60. void setup()
  61. {
  62. // Se declaran todos los pines como salidas
  63. // Pines asociados a los motores
  64. pinMode (IN1, OUTPUT);
  65. pinMode (IN2, OUTPUT);
  66. pinMode (IN3, OUTPUT);
  67. pinMode (IN4, OUTPUT);
  68. pinMode (ENA, OUTPUT);
  69. pinMode (ENB, OUTPUT);
  70.  
  71. // Pines asociados a los LEDS
  72. pinMode (ledVerde1, OUTPUT);
  73. pinMode (ledRojo2, OUTPUT);
  74.  
  75. // Pines asociados al zumbador
  76. pinMode (zumbadorPiezo, OUTPUT);
  77.  
  78. // Pines asociados al sensor ultrasonico HCSR04
  79. pinMode(triggerEmisor,OUTPUT); // El emisor emite por lo que es configurado como salida
  80. pinMode(echoReceptor,INPUT); // El receptor recibe por lo que es configurado como entrada
  81.  
  82. // Se inicia el receptor IR
  83. irrecv.enableIRIn();
  84.  
  85. // Se inicia el puerto de comunicaciones en serie
  86. Serial.begin(9600); //
  87. }
  88.  
  89. // Función que se repite de manera periódica
  90. void loop()
  91. {
  92. robotFuncion(); // Analiza si el robot funciona como esquivaobstáculos o con el mando
  93.  
  94. if(funcionRobot==1)
  95. {
  96. robotEsquivaObstaculos(); // Se crea la funcionalidad robotesquivaosbtaculos
  97. }
  98. else if(funcionRobot==2)
  99. {
  100. robotMandoDistancia(); // Se lee la señal del sensor IR
  101. }
  102. }
  103.  
  104. void robotEsquivaObstaculos()
  105. {
  106. Serial.println("Entra esquiva ");
  107. // Se inicializa el sensor de infrasonidos
  108. digitalWrite(triggerEmisor,LOW); // Para estabilizar
  109. delayMicroseconds(10);
  110.  
  111. // Comenzamos las mediciones
  112. // Se envía una señal activando la salida trigger durante 10 microsegundos
  113. digitalWrite(triggerEmisor, HIGH); // envío del pulso ultrasónico
  114. delayMicroseconds(10);
  115. tiempoEntrada=pulseIn(echoReceptor, HIGH);
  116. distanciaEntrada= int(0.017*tiempoEntrada); // Calcula la distancia en cm
  117. Serial.println("El valor de la distancia es ");
  118. Serial.println(distanciaEntrada);
  119. delay(200);
  120. // Si el valor de la distancia es menor que el valor umbral
  121. if(distanciaEntrada>valorUmbral)
  122. {
  123. robotAvance(); // El robot avanza mientras no encuentre obstáculos
  124. enciendeLEDVerde(); // Enciende los LED verdes delanteros
  125. }
  126. else
  127. {
  128. enciendeLEDRojoZumbador(); // Enciende los LED rojos traseros y el zumbador
  129. // Retrocede 1 segundo y gira a la derecha 0,5 segundos para esquivarlo
  130. robotRetroceso();
  131. delay(1000);
  132. robotDerecha ();
  133. delay(500);
  134. }
  135. }
  136. /*
  137.   Función robotAvance: esta función hará que ambos motores se activen a máxima potencia
  138.   por lo que el robot avanzará hacia delante
  139. */
  140. void robotAvance()
  141. {
  142. // Motor izquierdo
  143. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  144. digitalWrite (IN1, HIGH);
  145. digitalWrite (IN2, LOW);
  146. analogWrite (ENA, 255); //Velocidad motor A
  147.  
  148. // Motor derecho
  149. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
  150. digitalWrite (IN3, HIGH);
  151. digitalWrite (IN4, LOW);
  152. analogWrite (ENB, 255); //Velocidad motor B
  153. }
  154. /*
  155.   Función robotRetroceso: esta función hará que ambos motores se activen a máxima potencia
  156.   en sentido contrario al anterior por lo que el robot avanzará hacia atrás
  157. */
  158. void robotRetroceso()
  159. {
  160. // Motor izquierdo
  161. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  162. digitalWrite (IN1, LOW);
  163. digitalWrite (IN2, HIGH);
  164. analogWrite (ENA, 255); //Velocidad motor A
  165.  
  166. // Motor derecho
  167. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
  168. digitalWrite (IN3, LOW);
  169. digitalWrite (IN4, HIGH);
  170. analogWrite (ENB, 255); //Velocidad motor B
  171. }
  172.  
  173. /*
  174.   Función robotDerecha: esta función acccionará el motor izquierdo y parará el derecho
  175.   por lo que el coche girará hacia la derecha (sentido horario)
  176. */
  177. void robotDerecha()
  178. {
  179. // Motor izquierdo
  180. // Se activa el motor izquierdo
  181. digitalWrite (IN1, HIGH);
  182. digitalWrite (IN2, LOW);
  183. analogWrite (ENA, 255); //Velocidad motor A
  184.  
  185. // Motor derecho
  186. // Se para el motor derecho
  187. digitalWrite (IN3, LOW);
  188. digitalWrite (IN4, LOW);
  189. analogWrite (ENB, 0); //Velocidad motor A
  190.  
  191. }
  192. /*
  193.   Función robotIzquierda: esta función acccionará el motor derecho y parará el izquierdo
  194.   por lo que el coche girará hacia la izquierda (sentido antihorario)
  195. */
  196. void robotIzquierda ()
  197. {
  198. // Motor izquierdo
  199. // Se para el motor izquierdo
  200. digitalWrite (IN1, LOW);
  201. digitalWrite (IN2, LOW);
  202. analogWrite (ENA, 0); //Velocidad motor A
  203.  
  204. // Motor derecho
  205. // Se activa el motor derecho
  206. digitalWrite (IN3, HIGH);
  207. digitalWrite (IN4, LOW);
  208. analogWrite (ENB, 255); //Velocidad motor A
  209.  
  210. }
  211. /*
  212.   Función robotParar: esta función parará ambos motores
  213.   por lo que el robot se parará.
  214. */
  215. void robotParar()
  216. {
  217. // Motor izquierdo
  218. // Se para el motor izquierdo
  219. digitalWrite (IN1, LOW);
  220. digitalWrite (IN2, LOW);
  221. analogWrite (ENA, 0); //Velocidad motor A
  222.  
  223. // Motor derecho
  224. // Se para el motor derecho
  225. digitalWrite (IN3, LOW);
  226. digitalWrite (IN4, LOW);
  227. analogWrite (ENB, 0); //Velocidad motor A
  228. }
  229. /*
  230.   Función enciendeLEDVerde: esta función hará que ambos LED verdes se enciendan
  231.   y se apaguen los LED rojos (en caso de que estuvieran encendidos)
  232.   y el zumbador (en caso de que estuviera sonando)
  233. */
  234. void enciendeLEDVerde()
  235. {
  236. // Manda 5 V a los pines por lo que enciende los 2 LED verdes
  237. digitalWrite (ledVerde1, HIGH);
  238.  
  239. // Quita 5V de los otros pines por lo que apaga los 2 LED rojos y el zumbador
  240. digitalWrite (ledRojo2, LOW);
  241. digitalWrite (zumbadorPiezo, HIGH);
  242. }
  243. /*
  244.   Función enciendeLEDRojoZumbador: esta función hará que ambos LED rojos se enciendan
  245.   y que empiece a sonar el zumbador. Además de que se apaguen los LED verdes
  246. */
  247. void enciendeLEDRojoZumbador()
  248. {
  249. // Manda 5 V a los pines por lo que enciende los 2 LED rojos y el zumbador
  250. digitalWrite (ledRojo2, HIGH);
  251. digitalWrite (zumbadorPiezo, HIGH);
  252.  
  253. // Quita 5V de los otros pines por lo que apaga los 2 LED verdes
  254. digitalWrite (ledVerde1, LOW);
  255. }
  256.  
  257. /*
  258.   Función robotFuncion: esta función recibirá los valores del mando a distancia
  259.   - Si el usuario pulsa el botón 1 el robot realizará las funciones
  260.   del robotesquivaobstáculos
  261.   - Si el ususario pulsa el botón 2 el robot se convertirá
  262.   en el robot dirigido mando a distancia
  263.  
  264. */
  265. void robotFuncion()
  266. {
  267. if (irrecv.decode(&results))
  268. {
  269. Serial.println (results.value, HEX); //display HEX
  270. Serial.println (results.value);
  271. delay(1000);
  272. // Comprueba inicialmente la función del robot
  273. // Si pulsa el botón 1
  274. if(results.value==BOTON_1)
  275. {
  276. funcionRobot = 1;
  277. }
  278. else if(results.value==BOTON_2)
  279. {
  280. funcionRobot = 2;
  281. }
  282. irrecv.resume(); // Busca el siguiente valor del mando
  283. }
  284. }
  285.  
  286. void robotMandoDistancia()
  287. {
  288. Serial.println("Entra mando ");
  289. if (irrecv.decode(&results))
  290. {
  291. Serial.println (results.value, HEX); //display HEX
  292. Serial.println (results.value);
  293. switch (results.value)
  294. {
  295. case BOTON_1:
  296. Serial.println("Botón 1");
  297. funcionRobot = 1;
  298. break;
  299.  
  300. case BOTON_ARRIBA:
  301. Serial.println("Boton arriba");
  302. robotAvance();
  303. enciendeLEDVerde();
  304. break;
  305.  
  306. case BOTON_ABAJO:
  307. Serial.println("Boton abajo");
  308. robotRetroceso();
  309. enciendeLEDRojoZumbador();
  310. break;
  311.  
  312. case BOTON_IZQ:
  313. Serial.println("Boton izquierda");
  314. robotIzquierda();
  315. break;
  316.  
  317. case BOTON_DER:
  318. Serial.println("Boton derecha");
  319. robotDerecha();
  320. break;
  321.  
  322. case BOTON_OK:
  323. Serial.println("Boton OK");
  324. robotParar();
  325. break;
  326. }
  327. irrecv.resume();
  328. }
  329. }
  330.  
Spanish English French German Italian Portuguese Russian

Redes sociales

facebook iconotwitterGoogle plus iconpinterest

Artículos

TIC