INSTITUTO TECNOLÓGICO SUPERIOR DE

MACUSPANA

COMPLEMENTARIAS: Curso Taller de Arduino Básico

DOCENTE: Julio Méndez Chipol

EST: Sergio Alejandro Jimenez Jimenez

Macuspana, tabasco, de noviembre del 2023

Sensor ultrasónico

• Arduino UNO
• Protoboard donde conectaremos los componentes
• Cables para hacer las conexiones
• 3 resistencias de 220 Ω
• 1 LED verde
• 1 LED amarillo
• 1 LED rojo
• 1 sensor ultrasónico Arduino (HC-SR04)
• 1 buzze
Se trata de un circuito muy sencillo. Por un lado vamos a tener toda la
parte de alertas, acústica y visual, y por otra parte el sensor de
ultrasonidos. En el siguiente esquema te muestro el conexionado.

Lo primero que haré será plantear el algoritmo del sistema de

detección de obstáculos.

1. Comprobar la distancia de los objetos

1. ¿Está dentro del rango para avisar?
1. Si
1. Lanzar alarma visual y sonora
2. Continuar
2. No
1. Continuar
El algoritmo del sistema de alerta visual y sonora sería el siguiente.

1. ¿Está en zona verde?

1. Si
1. Encender LED verde
2. Emitir sonido 1
3. Salir
2. No
1. Continuar
2. ¿Está en zona amarilla?
1. Si
1. Encender LED amarillo
2. Emitir sonido 2
3. Salir
2. No
1. Continuar
3. ¿Está en zona roja?
1. Si
1. Encender LED rojo
2. Emitir sonido 2
3. Salir
2. No
1. Continuar

De los dos algoritmos anteriores, deducimos que vamos a necesitar

varios umbrales de decisión, uno para cada situación. Podemos
coger una simple regla y determinarlos.

• Umbral 1: está en zona verde desde 30 cm a 20 cm.

• Umbral 2: está en zona amarilla, desde 20 cm a 10 cm.
• Umbral 3: está en zona roja, menos de 10 cm.

1. // Pines utilizados
2. #define LEDVERDE 2
3. #define LEDAMARILLO 3
4. #define LEDROJO 4
5. #define TRIGGER 5
6. #define ECHO 6
7. #define BUZZER 9
8.
9. // Constantes
10. const float sonido = 34300.0; // Velocidad del sonido en
cm/s
11. const float umbral1 = 30.0;
12. const float umbral2 = 20.0;
13. const float umbral3 = 10.0;
14.
15. void setup() {
16. // Iniciamos el monitor serie
17. [Link](9600);
18.
19. // Modo entrada/salida de los pines
20. pinMode(LEDVERDE, OUTPUT);
21. pinMode(LEDAMARILLO, OUTPUT);
22. pinMode(LEDROJO, OUTPUT);
23. pinMode(ECHO, INPUT);
24. pinMode(TRIGGER, OUTPUT);
25. pinMode(BUZZER, OUTPUT);
26.
27. // Apagamos todos los LEDs
28. apagarLEDs();
29.
30. }
31.
32. void loop() {
33. // Preparamos el sensor de ultrasonidos
34. iniciarTrigger();
35.
36. // Obtenemos la distancia
37. float distancia = calcularDistancia();
38.
39. // Apagamos todos los LEDs
40. apagarLEDs();
41.
42. // Lanzamos alerta si estamos dentro del rango de peligro
43. if (distancia < umbral1)
44. {
45. // Lanzamos alertas
46. alertas(distancia);
47. }
48.
49. }
50.
51. // Apaga todos los LEDs
52. void apagarLEDs()
53. {
54. // Apagamos todos los LEDs
55. digitalWrite(LEDVERDE, LOW);
56. digitalWrite(LEDAMARILLO, LOW);
57. digitalWrite(LEDROJO, LOW);
58. }
59.
60. // Función que comprueba si hay que lanzar alguna alerta
visual o sonora
61. void alertas(float distancia)
62. {
63. if (distancia < umbral1 && distancia >= umbral2)
64. {
65. // Encendemos el LED verde
66. digitalWrite(LEDVERDE, HIGH);
67. tone(BUZZER, 2000, 200);
68. }
69. else if (distancia < umbral2 && distancia > umbral3)
70. {
71. // Encendemos el LED amarillo
72. digitalWrite(LEDAMARILLO, HIGH);
73. tone(BUZZER, 2500, 200);
74. }
75. else if (distancia <= umbral3)
76. {
77. // Encendemos el LED rojo
78. digitalWrite(LEDROJO, HIGH);
79. tone(BUZZER, 3000, 200);
80. }
81. }
82.
83. // Método que calcula la distancia a la que se encuentra un
objeto.
84. // Devuelve una variable tipo float que contiene la distancia
 85. float calcularDistancia()
86. {
87. // La función pulseIn obtiene el tiempo que tarda en
cambiar entre estados, en este caso a HIGH
88. unsigned long tiempo = pulseIn(ECHO, HIGH);
89.
90. // Obtenemos la distancia en cm, hay que convertir el
tiempo en segudos ya que está en microsegundos
91. // por eso se multiplica por 0.000001
92. float distancia = tiempo * 0.000001 * sonido / 2.0;
93. [Link](distancia);
94. [Link]("cm");
95. [Link]();
96. delay(500);
97.
98. return distancia;
99. }
100.
101. // Método que inicia la secuencia del Trigger para
comenzar a medir
102. void iniciarTrigger()
103. {
104. // Ponemos el Triiger en estado bajo y esperamos 2 ms
105. digitalWrite(TRIGGER, LOW);
106. delayMicroseconds(2);
107.
108. // Ponemos el pin Trigger a estado alto y esperamos 10
ms
109. digitalWrite(TRIGGER, HIGH);
110. delayMicroseconds(10);
111.
112. // Comenzamos poniendo el pin Trigger en estado bajo
113. digitalWrite(TRIGGER, LOW);
114. }

Conclusión
En este artículo hemos visto un ejemplo de la vida real, un sensor de
aparcamiento asistido. Gracias a placa como Arduino podemos
descubrir cómo funciona el mundo. Si te ha gustado, te agradecería que
lo compartieras, muchas gracias.
CONTROL DE UN SERVOMOTOR
Hay varios modelos de servomotor con Arduino. En este caso vamos a
utilizar un Micro Servo 9g SG90 de Tower Pro. Como siempre digo, hay
que mirar la ficha técnica del producto. Todos tienen un funcionamiento
muy parecido y la programación puede variar muy poco.

Cosas a tener en cuenta con este dispositivo. Lo primero, el ángulo de

giro, en este caso nos permite hacer un barrido entre -90º y 90º. Lo
que viene a ser un ángulo de giro de 180º.

Aunque el servo puede moverse con una resolución de más de 1

grado, este es el máximo de resolución que vamos a conseguir debido
a la limitación de la señal PWM que es capaz de generar Arduino
UNO.

Estos motores funcionan con una señal PWM, con un pulso de trabajo
entre 1 ms y 2 ms y con un periodo de 20 ms (50 Hz). ¿Qué quiere
decir todo esto? Este dato nos indica la velocidad máxima a la que
podemos mover el servomotor con Arduino. Solo podremos cambiar
de posición cada 20 ms. Esto dependerá del tipo y marca de nuestro
servo.

El elegir una salida PWM u otra da lo mismo, todas las salidas de este
tipo funcionan igual.

Esta acción ya nos ha hecho un include en nuestro código que nos

permite controlar el servo. Os dejo a continuación un código básico para
posicionar el servo en los ángulos 0º, 90º y 180º.
1. /*
2. Creado: Luis del Valle (ldelvalleh@[Link])
3. [Link]
4. */

5. // Incluímos la librería para poder controlar el servo

6. #include <Servo.h>
7. // Declaramos la variable para controlar el servo
8. Servo servoMotor;

9. void setup() {
10. // Iniciamos el monitor serie para mostrar el resultado
11. [Link](9600);

12. // Iniciamos el servo para que empiece a trabajar con el pin

9
13. [Link](9);
14. }

15. void loop() {

16. // Desplazamos a la posición 0º

17. [Link](0);
18. // Esperamos 1 segundo
19. delay(1000);

20. // Desplazamos a la posición 90º

21. [Link](90);
22. // Esperamos 1 segundo
23. delay(1000);

24. // Desplazamos a la posición 180º

25. [Link](180);
26. // Esperamos 1 segundo
27. delay(1000);
28. }

Conclusión
En este artículo hemos visto un ejemplo de la vida real, un sensor
de aparcamiento asistido. Gracias a placa como Arduino podemos
descubrir cómo funciona el mundo. Si te ha gustado, te
agradecería que lo compartieras, muchas gracias.