1
00:00:00,110 --> 00:00:05,650
Hola a todos y bienvenidos al capítulo 5 de Arduino desde cero en español.

2
00:00:06,389 --> 00:00:11,269
En esta oportunidad vamos a conectar un sensor ultrasonico para medir distancia

3
00:00:11,269 --> 00:00:16,550
y activar un LED cuando un objeto se encuentre dentro de un determinado rango.

4
00:00:17,309 --> 00:00:19,510
También hablaremos sobre el monitor serial.

5
00:00:20,210 --> 00:00:23,890
Antes de armar el circuito veamos un poco sobre este sensor.

6
00:00:24,789 --> 00:00:28,870
Específicamente se trata del modelo HC-SR04.

7
00:00:28,870 --> 00:00:39,810
Existen otros modelos disponibles en el mercado que funcionan correctamente con Arduino, pero este se caracteriza por ser muy fácil de usar y tiene un bajo precio.

8
00:00:40,649 --> 00:00:48,929
Si lo miramos de frente resaltan dos componentes con forma de cápsula. Estos son el transmisor y receptor ultrasonico.

9
00:00:49,109 --> 00:00:55,509
El sensor usa ondas de sonido a alta frecuencia para detectar la distancia a un objeto.

10
00:00:55,509 --> 00:01:01,390
el sonido que emite no lo podemos escuchar ya que tiene una frecuencia de 40 kHz

11
00:01:01,390 --> 00:01:07,349
prácticamente el doble de la frecuencia máxima que el oído humano puede percibir

12
00:01:07,349 --> 00:01:10,950
el sonido se propaga a una velocidad constante en el aire

13
00:01:10,950 --> 00:01:15,709
con lo cual si calculamos el tiempo que demora en emitirse la señal

14
00:01:15,709 --> 00:01:20,590
y la recepción de la misma causada por el rebote sobre un objeto

15
00:01:20,590 --> 00:01:24,670
podremos calcular la distancia con buena precisión

16
00:01:24,670 --> 00:01:37,810
Este es un sensor activo, ya que debemos alimentarlo para usarlo y también incluye varios circuitos integrados que son los encargados de generar el pulso de sonido y luego recibirlo.

17
00:01:38,530 --> 00:01:51,650
Estos circuitos que incluye nos facilitan la vida a la hora de la programación, por eso veremos que solo tiene 4 pines, que son VCC, Trigger, Echo y GND.

18
00:01:51,650 --> 00:01:58,030
VCC y GND serán la alimentación que la obtendremos directamente de Arduino

19
00:01:58,030 --> 00:02:04,090
Trigger será el pin al cual le enviaremos una señal para que dispare el pulso ultrasonico

20
00:02:04,090 --> 00:02:10,870
Y por el pin ECO obtendremos otro pulso indicando que la señal ha sido recibida

21
00:02:10,870 --> 00:02:14,250
Ahora si vamos al circuito de protoboard

22
00:02:14,250 --> 00:02:17,150
Coloquemos el sensor como se muestra

23
00:02:17,150 --> 00:02:22,689
VCC lo conectaremos al positivo del riel de tensión GND a masa

24
00:02:22,689 --> 00:02:28,490
del trigger iremos con un cable directo al pin digital 10 de Arduino

25
00:02:28,490 --> 00:02:33,729
y del pin ECO con otro cable directo al pin digital 9

26
00:02:33,729 --> 00:02:35,949
eso es todo para el sensor

27
00:02:35,949 --> 00:02:40,430
ahora el clásico circuito del LED conectando el cátodo a masa

28
00:02:40,430 --> 00:02:47,210
y a través de una resistencia de 330 ohms conectamos el ánodo al pin digital 3.

29
00:02:47,889 --> 00:02:53,349
Finalmente alimentamos la protoboard con 5V y GND de Arduino.

30
00:02:54,409 --> 00:03:01,650
Comenzaremos el código definiendo las variables que representan los pines a los cuales tenemos conectados el sensor y el LED.

31
00:03:01,650 --> 00:03:13,810
Así que escribiremos int trig igual a 10, int echo igual a 9, int led igual a 3.

32
00:03:14,750 --> 00:03:22,650
Y también definiremos estas dos variables que luego usaremos, int duración e int distancia.

33
00:03:24,030 --> 00:03:25,289
Ahora el setup.

34
00:03:26,909 --> 00:03:30,150
PinMode trig output.

35
00:03:31,650 --> 00:03:35,270
Pin Mode, Echo, Input.

36
00:03:36,289 --> 00:03:39,550
Pin Mode, LED, Output.

37
00:03:40,689 --> 00:03:42,990
Perfecto, ahora haremos el loop.

38
00:03:43,469 --> 00:03:48,610
Lo primero será generar una señal que debemos enviar al pin trigger del sensor.

39
00:03:49,449 --> 00:03:54,770
Este pulso debe tener una duración que le especifica el fabricante del sensor.

40
00:03:54,770 --> 00:04:01,729
por eso cada vez que utilicemos un sensor activo es importante leer las indicaciones de la planilla de datos

41
00:04:01,729 --> 00:04:10,909
en este caso debemos enviar un pulso generado inicialmente con un nivel alto de 1 milisegundo y luego un nivel bajo

42
00:04:10,909 --> 00:04:23,350
por eso escribiremos digital write trig high delay 1 digital write trig low

43
00:04:23,350 --> 00:04:36,209
De esa forma le estaremos indicando al sensor que deseamos que emita un pulso y luego con la siguiente función tomaremos el tiempo que tarda en respondernos mediante el pin echo.

44
00:04:37,129 --> 00:04:43,410
Duración igual a PulseInEchoHigh.

45
00:04:43,410 --> 00:04:48,709
El nombre de la función es PulseIn con la I mayúscula

46
00:04:48,709 --> 00:04:53,550
Quizás en pantalla parezca una L pero es una I mayúscula

47
00:04:53,550 --> 00:05:00,529
Lo que hace es devolver un valor de tiempo en microsegundos que lo asignamos a la variable duración

48
00:05:00,529 --> 00:05:06,990
El primer parámetro es el pin en donde espera por el pulso, en nuestro caso Echo

49
00:05:06,990 --> 00:05:12,350
Y el segundo parámetro es High ya que espera por un pulso alto

50
00:05:12,350 --> 00:05:17,589
en definitiva con esa simple línea ya tenemos el tiempo que ha transcurrido

51
00:05:17,589 --> 00:05:22,410
desde la emisión del pulso ultrasonico hasta la recepción del mismo

52
00:05:22,410 --> 00:05:24,829
provocado por el rebote en un objeto

53
00:05:24,829 --> 00:05:30,170
ahora convertiremos ese valor de tiempo en distancia que es lo que nos interesa

54
00:05:30,170 --> 00:05:38,050
distancia igual a duración dividido 58.2

55
00:05:38,050 --> 00:05:41,689
para obtener la distancia medida en centímetros

56
00:05:41,689 --> 00:05:49,769
debemos dividir el valor de duración por una constante que es 58.2 nuevamente este es un

57
00:05:49,769 --> 00:05:56,750
valor especificado por el fabricante del sensor y no debe variarse muy bien ya con esas pocas

58
00:05:56,750 --> 00:06:04,230
líneas tenemos la distancia al objeto más cercano a nuestro sensor el detalle es cómo hacemos para

59
00:06:04,230 --> 00:06:10,230
ver el valor de la distancia si no tenemos ningún dispositivo de visualización como ser un panel

60
00:06:10,230 --> 00:06:18,189
LCD. Aquí es donde entra en juego el monitor serial, también llamado monitor serie. Nuestra

61
00:06:18,189 --> 00:06:24,769
computadora se comunica con Arduino mediante el cable USB, eso ya lo sabemos. Por el mismo

62
00:06:24,769 --> 00:06:30,449
enviamos el código que escribimos para que se ejecute. Por el mismo cable podemos también

63
00:06:30,449 --> 00:06:36,889
obtener información, es decir que Arduino le envíe información a la computadora y nosotros

64
00:06:36,889 --> 00:06:44,029
podemos visualizarla en una ventana del IDE. Para activar la comunicación serial solo se requiere

65
00:06:44,029 --> 00:06:56,350
agregar la siguiente línea de código en el setup. Serial.begin entre paréntesis 9600. 9600 es la

66
00:06:56,350 --> 00:07:03,509
tasa de velocidad de la comunicación, la cantidad de bits por segundo que estaremos recibiendo y es

67
00:07:03,509 --> 00:07:09,069
un valor adecuado para la mayoría de los casos. Ahora solo debemos enviar el valor

68
00:07:09,069 --> 00:07:19,110
de la distancia, esto lo haremos con la siguiente línea. Serial.println entre paréntesis distancia.

69
00:07:19,949 --> 00:07:28,870
La función println es println, es decir imprimir una línea. Colocará el valor de la variable

70
00:07:28,870 --> 00:07:36,290
distancia y luego un enter de forma automática. Agreguemos un delay para que nos demore un

71
00:07:36,290 --> 00:07:43,029
poco entre dato y dato, si no es muy rápido y difícil de visualizar. Con 200 milisegundos

72
00:07:43,029 --> 00:07:51,269
es suficiente. Delay entre paréntesis 200. Vamos ya mismo a verificar y subir el programa.

73
00:07:53,810 --> 00:07:59,149
Para abrir el monitor serial hacemos clic en el icono que se encuentra en el extremo

74
00:07:59,149 --> 00:08:05,550
superior derecho como se muestra en pantalla. Ahí se abrirá una nueva ventana donde podremos

75
00:08:05,550 --> 00:08:11,310
ver el valor de distancia que está leyendo el sensor. Como coloca cada valor en una nueva

76
00:08:11,310 --> 00:08:18,750
línea se realiza un desplazamiento automático o scroll. El valor de más abajo es siempre

77
00:08:18,750 --> 00:08:24,350
el último leído. Como se muestra en pantalla el sensor nos devuelve el valor leído en

78
00:08:24,350 --> 00:08:31,750
centímetros. En mi caso, el circuito está sobre un escritorio apuntando a una pared que se encuentra

79
00:08:31,750 --> 00:08:40,309
algo más de 3 metros. Por eso aparece 320 aproximadamente. En tu caso, por supuesto que

80
00:08:40,309 --> 00:08:47,950
será otro valor. Para verificar, podemos colocar un objeto delante y luego ir acercándolo de a poco.

81
00:08:47,950 --> 00:08:50,929
Se puede colocarla a mano pero no es lo ideal

82
00:08:50,929 --> 00:08:55,149
Un trozo de cartón, una caja o nuestro teléfono celular

83
00:08:55,149 --> 00:09:01,929
Darán un buen rebote a la señal y veremos como va cambiando el valor que nos muestra el monitor serial

84
00:09:01,929 --> 00:09:06,090
Perfecto, ya con eso sabemos que el sensor funciona correctamente

85
00:09:06,090 --> 00:09:11,450
Durante la prueba quizás viste que en algún momento mostró un valor negativo

86
00:09:11,450 --> 00:09:15,629
Esto es normal y significa que el sensor está fuera de rango

87
00:09:15,629 --> 00:09:22,629
ya sea porque el objeto está muy lejos o porque no recibe correctamente el rebote del pulso ultrasonico.

88
00:09:22,870 --> 00:09:26,389
Ahora vamos a agregar unas líneas de código a nuestro programa

89
00:09:26,389 --> 00:09:33,330
para que se encienda el LED cuando el sensor detecte una distancia de 20 centímetros o menos.

90
00:09:34,070 --> 00:09:37,110
Es un método muy utilizado para la detección de obstáculos.

91
00:09:37,669 --> 00:09:41,509
Si estamos haciendo un robot o dispositivo que se desplaza

92
00:09:41,509 --> 00:09:47,690
seguramente desearemos que detecte si hay un obstáculo en su camino y actuar en consecuencia

93
00:09:47,690 --> 00:09:52,769
como ser detener el motor de avance, recalcular una nueva ruta, etc.

94
00:09:53,370 --> 00:09:57,389
Nosotros lo haremos haciendo encender un LED.

95
00:09:57,389 --> 00:09:59,169
Escribamos la siguiente

96
00:09:59,169 --> 00:10:14,429
if distancia menor igual 20 and and distancia mayor igual 0 cerramos paréntesis abrimos llave enter

97
00:10:14,429 --> 00:10:21,669
la sentencia if ya la vimos en el capítulo 3 y la condición que deseamos evaluar es la distancia

98
00:10:21,669 --> 00:10:29,730
es decir que si la distancia está entre 0 y 20 centímetros ejecutaremos el código dentro de las llaves

99
00:10:29,730 --> 00:10:36,090
recuerdan que hablamos que algunas veces si el sensor está fuera de rango devuelve un valor negativo

100
00:10:36,090 --> 00:10:45,649
por eso dentro del if colocamos luego del doble ampersand para que evalúe también si el valor es mayor a 0

101
00:10:45,649 --> 00:10:50,990
de manera de desestimar si obtenemos una distancia con valor negativo

102
00:10:50,990 --> 00:11:00,009
Queda claro entonces que este IF evaluará verdadero si la distancia está entre 0 y 20 centímetros

103
00:11:00,009 --> 00:11:03,730
Por eso debemos encender el LED con

104
00:11:03,730 --> 00:11:09,009
DigitalWrite entre paréntesis LED coma high

105
00:11:09,009 --> 00:11:15,269
Como ya sabemos debemos aplicar una demora para poder visualizar el LED encendido

106
00:11:15,269 --> 00:11:22,269
Lo que haremos es aprovechar el valor de distancia para generar una demora que sea proporcional a la distancia.

107
00:11:23,389 --> 00:11:25,629
Escribamos las siguientes líneas.

108
00:11:26,309 --> 00:11:30,669
Delay entre paréntesis distancia por 10.

109
00:11:31,789 --> 00:11:36,269
Luego DigitalWrite entre paréntesis LED Low.

110
00:11:37,710 --> 00:11:43,470
El delay en vez de tener un valor fijo será el producto de la distancia por 10.

111
00:11:43,470 --> 00:11:50,110
entonces si por ejemplo entramos al IF con una distancia media de 20 centímetros

112
00:11:50,110 --> 00:11:55,289
el delay será de 20 por 10 es decir 200 milisegundos

113
00:11:55,289 --> 00:12:01,190
si el objeto se sigue acercando entonces el delay será un número menor

114
00:12:01,190 --> 00:12:06,070
haciendo que el LED prenda y apague cada vez con mayor rapidez

115
00:12:06,070 --> 00:12:11,250
luego solo resta apagar el LED y será todo el código necesario

116
00:12:11,250 --> 00:12:15,870
Vamos a verificar, subir y abrir el monitor serial.

117
00:12:16,429 --> 00:12:22,509
Como se puede ver en el monitor serial cuando la distancia sea de 20 centímetros o menos,

118
00:12:23,250 --> 00:12:31,289
el LED encenderá y apagará de forma repetida y lo hará más rápidamente a medida que el objeto esté más cerca.

119
00:12:31,669 --> 00:12:40,450
Una modificación posible al circuito es reemplazar el conjunto LED y resistencia directamente por un zumbador o buzzer.

120
00:12:40,450 --> 00:12:45,850
entonces cuando el objeto esté en rango en vez de encender el led

121
00:12:45,850 --> 00:12:49,330
encenderá el zumbador emitiendo un pitido

122
00:12:49,330 --> 00:12:53,990
que se incrementará en frecuencia a medida que el objeto esté más cerca

123
00:12:53,990 --> 00:13:00,070
muy parecido a lo que muchos coches tienen en su paragolpes al activar la marcha atrás

124
00:13:00,070 --> 00:13:02,549
eso es todo por este capítulo

125
00:13:02,549 --> 00:13:06,210
en el próximo veremos cómo utilizar un servomotor

126
00:13:06,210 --> 00:13:12,990
que se caracteriza por tener una gran fuerza o torque y gran precisión también aprenderemos a

127
00:13:12,990 --> 00:13:19,690
alimentar arduino con una alimentación externa como siempre les pido se suscriban para recibir

128
00:13:19,690 --> 00:13:26,570
notificaciones y por cualquier duda o comentario lo pueden hacer debajo que con gusto les responderé

129
00:13:26,570 --> 00:13:28,250
chao y hasta la próxima