Cómo construir un robot seguidor de línea paso a paso – Guía completa para principiantes

Código del programa Arduino

A continuación se muestra el código Arduino que implementa la funcionalidad.. Debe tenerse mucho cuidado con la correspondencia izquierda/derecha de los sensores y con el sentido de giro de las ruedas del vehículo…

Presentaremos 2 versiones..

• En la primera controlaremos la velocidad del motor mediante la activación de los jumpers (ENA, ENB) del driver L298n..

1. /*
2.   Nombre: Robot Siguelíneas
3.   Autor: Daniel Pascual Gallegos
4.   Fecha: Febrero 2017
5.   Funcionalidad: este proyecto representa la típica función
6.   del robot siguelíneas que se desplaza siguiendo una linea recta
7.   de color negro.
8. */
9. // Definición de variables y constantes relacionadas con el motor izquierdo
10. const int IN1 = 13; // Pin digital 13 para controlar sentido giro motor izquierdo
11. const int IN2 = 12; // Pin digital 12 para controlar sentido giro motor izquierdo
12. const int ENA = 6;
14. // Definición de variables y constantes relacionadas con el motor derecho
15. const int IN3 = 11; // Pin digital 11 para controlar sentido giro motor izquierdo
16. const int IN4 = 10; // Pin digital 10 para controlar sentido giro motor izquierdo
17. const int ENB = 5;
19. const int vel = 175;
21. // Definición de variables y constantes relacionadas con los sensores IR
22. int lecturaSensorIzq; // Almacena el valor de la lectura del sensor izquierdo
23. int lecturaSensorDer; // Almacena el valor de la lectura del sensor derecho
24. const int sensorIzqPin = A0; // El sensor izq irá conectado al pin analógico A0
25. const int sensorDerPin = A1; // El sensor derecho irá conectado al pin analógico A1
27. void setup()
28. {
29. // Se declaran todos los pines como salidas
30. // Pines asociados a los motores
31. pinMode (IN1, OUTPUT);
32. pinMode (IN2, OUTPUT);
33. pinMode (IN3, OUTPUT);
34. pinMode (IN4, OUTPUT);
35. pinMode (ENA, OUTPUT);
36. pinMode (ENB, OUTPUT);
37. pinMode( sensorIzqPin , INPUT) ;
38. pinMode( sensorDerPin , INPUT) ;
39. Serial.begin(9600); // Se inicia el puerto de comunicaciones en serie
40. }
42. void loop()
43. {
45. lecturaSensorIR(); // Se lee el valor de los sensores IR
46. // Se analiza el resultado de los sensores para hacer que el robot siga la línea negra
48. // Si el resultado de ambos sensores es 0 (zona blanca) el robot sigue se para
49. if(lecturaSensorIzq == 0 && lecturaSensorDer == 0)
50. {
51. robotParar(); // El robot para
53. }
54. // Si el izquierdo retorna 0 (zona blanca) y el derecho 1 (negra) el robot gira derecha
55. if (lecturaSensorIzq == 0 && lecturaSensorDer == 1)
56. {
57. robotDerecha();
58. // El robot gira a la derecha
60. }
61. // Si el izquierdo retorna 1 (zona negra) y el derecho 0 (blanca) el robot gira izquierda
62. if (lecturaSensorIzq == 1 && lecturaSensorDer == 0)
63. {
64. robotIzquierda();
66. }
67. // Si ambos sensores retornan 0 (zona negra) el robot sigue recto
68. if (lecturaSensorIzq == 1 && lecturaSensorDer == 1)
69. {
70. robotAvance(); // El robot avanza
71. Serial.println(«robot avanza»);
72. }
74. }
75. /*
76.   Función lecturaSensorIR: leerá el valor del sensor de infrarrojos TCRT5000
77.   y lo almacena en una variable. Dicho sensor retornará el valor 0 (LOW) si
78.   el sensor está en zona blanca y el valor 1 (HIGH) si el sensor está en zona
79.   negra.
80. */
81. void lecturaSensorIR()
82. {
83. lecturaSensorIzq = digitalRead(sensorIzqPin); // Almacena la lectura del sensor izquierdo
84. lecturaSensorDer = digitalRead(sensorDerPin); // Almacena la lectura del sensor derecho
86. Serial.println(«El valor del sensor izquierdo es «);
87. Serial.println(lecturaSensorIzq);
89. Serial.println(«El valor del sensor derecho es «);
90. Serial.println(lecturaSensorDer);
92. }
93. /*
94.   Función robotAvance: esta función hará que ambos motores se activen a máxima potencia
95.   por lo que el robot avanzará hacia delante
96. */
97. void robotAvance()
98. {
99. // Motor izquierdo
100. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
101. digitalWrite (IN1, HIGH);
102. digitalWrite (IN2, LOW);
103. analogWrite (ENA, vel); //Velocidad motor A
105. // Motor derecho
106. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
107. digitalWrite (IN3, HIGH);
108. digitalWrite (IN4, LOW);
109. analogWrite (ENB, vel); //Velocidad motor B
110. }
111. /*
112.   Función robotRetroceso: esta función hará que ambos motores se activen a máxima potencia
113.   en sentido contrario al anterior por lo que el robot avanzará hacia atrás
114. */
115. void robotRetroceso()
116. {
117. // Motor izquierdo
118. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
119. digitalWrite (IN1, LOW);
120. digitalWrite (IN2, HIGH);
121. analogWrite (ENA, vel); //Velocidad motor A
123. // Motor derecho
124. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
125. digitalWrite (IN3, LOW);
126. digitalWrite (IN4, HIGH);
127. analogWrite (ENB, vel); //Velocidad motor B
128. }
130. /*
131.   Función robotDerecha: esta función acccionará el motor izquierdo y parará el derecho
132.   por lo que el coche girará hacia la derecha (sentido horario)
133. */
134. void robotDerecha()
135. {
136. // Motor izquierdo
137. // Se activa el motor izquierdo
138. digitalWrite (IN1, HIGH);
139. digitalWrite (IN2, LOW);
140. analogWrite (ENA, vel); //Velocidad motor A
142. // Motor derecho
143. // Se para el motor derecho
144. digitalWrite (IN3, LOW);
145. digitalWrite (IN4, HIGH);
146. analogWrite (ENB, vel); //Velocidad motor A
148. }
149. /*
150.   Función robotIzquierda: esta función acccionará el motor derecho y parará el izquierdo
151.   por lo que el coche girará hacia la izquierda (sentido antihorario)
152. */
153. void robotIzquierda ()
154. {
155. // Motor izquierdo
156. // Se para el motor izquierdo
157. digitalWrite (IN1, LOW);
158. digitalWrite (IN2, HIGH);
159. analogWrite (ENA, vel); //Velocidad motor A
161. // Motor derecho
162. // Se activa el motor derecho
163. digitalWrite (IN3, HIGH);
164. digitalWrite (IN4, LOW);
165. analogWrite (ENB, vel); //Velocidad motor A
166. }
167. /*
168.   Función robotParar: esta función parará ambos motores
169.   por lo que el robot se parará.
170. */
171. void robotParar()
172. {
173. // Motor izquierdo
174. // Se para el motor izquierdo
175. digitalWrite (IN1, LOW);
176. digitalWrite (IN2, LOW);
178. // Motor derecho
179. // Se para el motor derecho
180. digitalWrite (IN3, LOW);
181. digitalWrite (IN4, LOW);
183. }

• En la segunda no controlaremos la velocidad del motor y no estarán activados los jumpers (ENA, ENB) del driver L298n..

2. /*
3.   Nombre: Robot Siguelíneas
4.   Autor: Daniel Pascual Gallegos
5.   Fecha: Febrero 2017
6.   Funcionalidad: este proyecto representa la típica función
7.   del robot siguelíneas que se desplaza siguiendo una linea recta
8.   de color negro.
9. */
10. // Definición de variables y constantes relacionadas con el motor izquierdo
11. const int IN1 = 13; // Pin digital 13 para controlar sentido giro motor izquierdo
12. const int IN2 = 12; // Pin digital 12 para controlar sentido giro motor izquierdo
14. // Definición de variables y constantes relacionadas con el motor derecho
15. const int IN3 = 11; // Pin digital 11 para controlar sentido giro motor izquierdo
16. const int IN4 = 10; // Pin digital 10 para controlar sentido giro motor izquierdo
19. // Definición de variables y constantes relacionadas con los sensores IR
20. int lecturaSensorIzq; // Almacena el valor de la lectura del sensor izquierdo
21. int lecturaSensorDer; // Almacena el valor de la lectura del sensor derecho
22. const int sensorIzqPin = A1; // El sensor izq irá conectado al pin analógico A0
23. const int sensorDerPin = A0 ; // El sensor derecho irá conectado al pin analógico A1
25. void setup()
26. {
27. // Se declaran todos los pines como salidas
28. // Pines asociados a los motores
29. pinMode (IN1, OUTPUT);
30. pinMode (IN2, OUTPUT);
31. pinMode (IN3, OUTPUT);
32. pinMode (IN4, OUTPUT);
33. pinMode( sensorIzqPin , INPUT) ;
34. pinMode( sensorDerPin , INPUT) ;
35. Serial.begin(9600); // Se inicia el puerto de comunicaciones en serie
36. }
38. void loop()
39. {
41. lecturaSensorIR(); // Se lee el valor de los sensores IR
42. // Se analiza el resultado de los sensores para hacer que el robot siga la línea negra
44. // Si el resultado de ambos sensores es 0 (zona blanca) el robot sigue se para
45. if(lecturaSensorIzq == 0 && lecturaSensorDer == 0)
46. {
47. robotParar(); // El robot para
49. }
50. // Si el izquierdo retorna 0 (zona blanca) y el derecho 1 (negra) el robot gira derecha
51. if (lecturaSensorIzq == 0 && lecturaSensorDer == 1)
52. {
53. robotDerecha();
54. // El robot gira a la derecha
56. }
57. // Si el izquierdo retorna 1 (zona negra) y el derecho 0 (blanca) el robot gira izquierda
58. if (lecturaSensorIzq == 1 && lecturaSensorDer == 0)
59. {
60. robotIzquierda();
62. }
63. // Si ambos sensores retornan 0 (zona negra) el robot sigue recto
64. if (lecturaSensorIzq == 1 && lecturaSensorDer == 1)
65. {
66. robotAvance(); // El robot avanza
67. Serial.println(«robot avanza»);
68. }
70. }
71. /*
72.   Función lecturaSensorIR: leerá el valor del sensor de infrarrojos TCRT5000
73.   y lo almacena en una variable. Dicho sensor retornará el valor 0 (LOW) si
74.   el sensor está en zona blanca y el valor 1 (HIGH) si el sensor está en zona
75.   negra.
76. */
77. void lecturaSensorIR()
78. {
79. lecturaSensorIzq = digitalRead(sensorIzqPin); // Almacena la lectura del sensor izquierdo
80. lecturaSensorDer = digitalRead(sensorDerPin); // Almacena la lectura del sensor derecho
82. Serial.println(«El valor del sensor izquierdo es «);
83. Serial.println(lecturaSensorIzq);
85. Serial.println(«El valor del sensor derecho es «);
86. Serial.println(lecturaSensorDer);
88. }
89. /*
90.   Función robotAvance: esta función hará que ambos motores se activen a máxima potencia
91.   por lo que el robot avanzará hacia delante
92. */
93. void robotAvance()
94. {
95. // Motor izquierdo
96. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
97. digitalWrite (IN1, HIGH);
98. digitalWrite (IN2, LOW);
100. // Motor derecho
101. // Al mantener un pin HIGH y el otro LOW el motor gira en un sentido
102. digitalWrite (IN3, HIGH);
103. digitalWrite (IN4, LOW);
104. }
105. /*
106.   Función robotRetroceso: esta función hará que ambos motores se activen a máxima potencia
107.   en sentido contrario al anterior por lo que el robot avanzará hacia atrás
108. */
109. void robotRetroceso()
110. {
111. // Motor izquierdo
112. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
113. digitalWrite (IN1, LOW);
114. digitalWrite (IN2, HIGH);
116. // Motor derecho
117. // Al mantener un pin LOW y el otro HIGH el motor gira en sentido contrario al anterior
118. digitalWrite (IN3, LOW);
119. digitalWrite (IN4, HIGH);
120. }
122. /*
123.   Función robotDerecha: esta función acccionará el motor izquierdo y parará el derecho
124.   por lo que el coche girará hacia la derecha (sentido horario)
125. */
126. void robotDerecha()
127. {
128. // Motor izquierdo
129. // Se activa el motor izquierdo
130. digitalWrite (IN1, HIGH);
131. digitalWrite (IN2, LOW);
133. // Motor derecho
134. // Se para el motor derecho
135. digitalWrite (IN3, LOW);
136. digitalWrite (IN4, HIGH);
138. }
139. /*
140.   Función robotIzquierda: esta función acccionará el motor derecho y parará el izquierdo
141.   por lo que el coche girará hacia la izquierda (sentido antihorario)
142. */
143. void robotIzquierda ()
144. {
145. // Motor izquierdo
146. // Se para el motor izquierdo
147. digitalWrite (IN1, LOW);
148. digitalWrite (IN2, HIGH);
150. // Motor derecho
151. // Se activa el motor derecho
152. digitalWrite (IN3, HIGH);
153. digitalWrite (IN4, LOW);
154. }
155. /*
156.   Función robotParar: esta función parará ambos motores
157.   por lo que el robot se parará.
158. */
159. void robotParar()
160. {
161. // Motor izquierdo
162. // Se para el motor izquierdo
163. digitalWrite (IN1, LOW);
164. digitalWrite (IN2, LOW);
166. // Motor derecho
167. // Se para el motor derecho
168. digitalWrite (IN3, LOW);
169. digitalWrite (IN4, LOW);
171. }