1
00:00:05,169 --> 00:00:15,009
Buenas tardes. Tengo aquí otro esquema donde he introducido un nuevo elemento que sería el sensor HC-SR04 que es el que aparece aquí.

2
00:00:15,470 --> 00:00:26,629
Si veis, consta de cuatro pines. Estos serían los cuatro pines. Está formado por un VCC, que sería alimentación, un GND, que sería tierra, y luego un trigger y un eco.

3
00:00:26,629 --> 00:00:35,450
El HC-SSR04 es un sensor de distancia por ultrasonidos

4
00:00:35,450 --> 00:00:39,070
muy utilizado en proyectos con Arduino, robótica y automatización

5
00:00:39,070 --> 00:00:42,490
Su función es medir la distancia a un objeto sin contacto físico

6
00:00:42,490 --> 00:00:45,710
utilizando ondas sonoras de alta frecuencia, o sea, ultrasonidos

7
00:00:45,710 --> 00:00:48,350
imperceptibles para el oído humano

8
00:00:48,350 --> 00:00:54,710
El rango típico de medición va entre 2 cm y 400 cm

9
00:00:54,710 --> 00:01:00,630
Y la precisión aproximada es de más o menos 3 milímetros de error.

10
00:01:00,869 --> 00:01:13,450
La alimentación que necesita este sensor es de 5 voltios y este tipo de sensor se usa en robots que evitan obstáculos, en sistemas de aparcamiento, en medidores de nivel, domótica y seguridad.

11
00:01:14,370 --> 00:01:17,829
¿Cómo funciona el sensor?

12
00:01:18,450 --> 00:01:22,010
El sensor tiene dos transductores circulares.

13
00:01:22,010 --> 00:01:41,109
Aquí sería una imagen del sensor y estaría formada en su parte frontal por estos dos traductores que serían estos de aquí y uno sería el emisor que sería el T que aparece aquí en el que envía un pulso de ultrasonidos.

14
00:01:41,109 --> 00:01:46,790
Luego el otro transductor, que sería este, el R, recibe el eco reflejado por el objeto.

15
00:01:47,549 --> 00:02:09,689
El proceso es el siguiente, Arduino envía un pulso eléctrico al pin TRICK, que sería de trigger, este aquí Arduino envía un pulso, el sensor emite un sonido de ultrasonidos que iría a 40 kHz, el sonido, una vez que lo ha emitido, este sería el sonido original por ultrasonidos,

16
00:02:09,689 --> 00:02:12,629
El sonido rebota en un objeto

17
00:02:12,629 --> 00:02:14,530
Y el eco

18
00:02:14,530 --> 00:02:16,990
Que sería la vuelta de ese sonido

19
00:02:16,990 --> 00:02:18,229
Vuelve al sensor

20
00:02:18,229 --> 00:02:19,590
Que sería el

21
00:02:19,590 --> 00:02:22,210
Receiver, que sería el R

22
00:02:22,210 --> 00:02:24,729
El que transmite sería el T

23
00:02:24,729 --> 00:02:27,229
Y el que recibe sería el R

24
00:02:27,229 --> 00:02:28,810
El pin eco

25
00:02:28,810 --> 00:02:30,330
Que sería el otro pin que aparece aquí

26
00:02:30,330 --> 00:02:32,990
Permanece en high durante el tiempo

27
00:02:32,990 --> 00:02:34,909
Que tarda el sonido en ir y volver

28
00:02:34,909 --> 00:02:37,169
Solo en ese

29
00:02:37,169 --> 00:02:38,210
Intervalo de tiempo

30
00:02:38,210 --> 00:02:39,289
En ir y volver

31
00:02:39,289 --> 00:02:42,789
Arduino va a medir ese tiempo y calculará la distancia

32
00:02:42,789 --> 00:02:48,150
¿Cómo la calcula? La distancia la calcula a través de una fórmula

33
00:02:48,150 --> 00:02:51,150
que sería el tiempo por la velocidad del sonido, dividido entre dos

34
00:02:51,150 --> 00:02:58,449
puesto que el divisor es debido porque el sonido tiene que recoger

35
00:02:58,449 --> 00:03:01,870
tanto la ida como la vuelta, por eso lo divide entre dos

36
00:03:01,870 --> 00:03:06,250
por lo tanto los pines del sensor son cuatro pines que sean el VCC

37
00:03:06,250 --> 00:03:35,250
que es este de aquí, en el que sería el de alimentación 5 voltios, aquí se ve muchísimo mejor, aquí tenemos el UCC que sería el de 5 voltios, el trigger que sería la entrada de disparo, por eso se llama trigger, es el disparo el que envía el ultrasonido y que necesita pues un pin de entrada para que entre un valor alto y genere la salida del ultrasonido.

38
00:03:36,729 --> 00:03:39,949
Después tenemos el otro pin, que sería el eco, en el que sería la salida.

39
00:03:39,949 --> 00:03:43,389
Cuando lo recibe, ha chocado contra el objeto y recibimos esos ultrasonidos,

40
00:03:43,849 --> 00:03:47,949
por tanto, necesitamos un pin de salida.

41
00:03:49,229 --> 00:03:56,530
Este pin de salida lo que va a hacer es que recogerá ese eco que va a recibir.

42
00:03:56,710 --> 00:03:58,969
Y por último, es el último, que sería el GND,

43
00:03:59,110 --> 00:04:02,610
que es para cerrar el circuito correctado a tierra o a cero voltios.

44
00:04:02,610 --> 00:04:06,770
por tanto este es el transmisor y este es el receptor

45
00:04:06,770 --> 00:04:11,009
vamos a ver el circuito

46
00:04:11,009 --> 00:04:12,349
vamos a quitar esto

47
00:04:12,349 --> 00:04:14,930
y este sería el circuito

48
00:04:14,930 --> 00:04:17,829
si nosotros le damos, este es el código que aparece aquí que luego explicaré

49
00:04:17,829 --> 00:04:19,430
y lo vamos a hacer poco a poco

50
00:04:19,430 --> 00:04:20,529
cuando le damos a simular

51
00:04:20,529 --> 00:04:23,329
y cerramos el código

52
00:04:23,329 --> 00:04:29,709
si yo selecciono el sensor de ultrasonidos

53
00:04:29,709 --> 00:04:31,329
veis que aquí aparece un círculo verde

54
00:04:31,329 --> 00:04:37,269
que es lo que nosotros podemos modificar, él va a ir detectando distintas distancias

55
00:04:37,269 --> 00:04:41,029
en función de cómo lo hallamos, dónde está el obstáculo.

56
00:04:41,129 --> 00:04:45,310
Esto sería el obstáculo en el que el que transmite ultrasonido llega hasta el obstáculo

57
00:04:45,310 --> 00:04:49,550
y rebota y lo recoge el receptor, que sería este, a través del eco.

58
00:04:50,209 --> 00:04:55,949
Veis aquí que está midiendo 90,2 centímetros, el código lo he hecho con el monitor en serie

59
00:04:55,949 --> 00:05:00,990
para que detectemos la distancia a la que está el objeto.

60
00:05:00,990 --> 00:05:13,189
Veis, ahora mismo está en 90,2, aproximadamente le pone que la distancia será 89, si yo lo modifico y el objeto está más cerca, veis, se modifica y aparece que estaría a 64 centímetros.

61
00:05:13,889 --> 00:05:20,250
Siempre hay un intervalo de error entre la medición, pero es un error muy pequeño.

62
00:05:21,050 --> 00:05:28,829
Bien, vamos a hacer el circuito y vamos a explicar el código.

63
00:05:28,829 --> 00:05:41,800
Por lo tanto, cogemos un nuevo elemento, creamos un nuevo proyecto y vamos a ir un poquito deprisa para ponerlo.

64
00:05:41,980 --> 00:05:53,360
Esta sería la placa de Arduino y vamos a poner todos los objetos, todos, para que nos aparezca el sensor de distancia que sería este de aquí.

65
00:05:54,040 --> 00:06:00,779
Bien, vamos a conectar primero la alimentación, el VCC, con 5 voltios, como siempre.

66
00:06:02,000 --> 00:06:03,620
Lo ponemos de color rojo.

67
00:06:05,660 --> 00:06:09,500
A continuación cogemos el GND y lo vamos a unir con el de arriba.

68
00:06:13,310 --> 00:06:15,649
Y con esto ya tendríamos cerrado el circuito.

69
00:06:15,889 --> 00:06:17,129
Lo ponemos de color negro.

70
00:06:18,209 --> 00:06:20,550
Y lo único que nos quedaría son el trigger y el eco.

71
00:06:20,550 --> 00:06:23,689
El trigger lo tenemos que conectar a un pin.

72
00:06:24,569 --> 00:06:29,670
Que lo vamos a poner concretamente al pin 2.

73
00:06:32,480 --> 00:06:34,060
Lo vamos a poner de color verde.

74
00:06:34,060 --> 00:06:37,000
y luego el

75
00:06:37,000 --> 00:06:41,759
el eco lo vamos a conectar con el pin 3

76
00:06:41,759 --> 00:06:50,269
para diferenciarlos el eco lo vamos a poner de color azul

77
00:06:50,269 --> 00:06:55,319
y el trigger de color verde

78
00:06:55,319 --> 00:06:59,000
ya estaría el circuito y lo único que nos quedaría es el código

79
00:06:59,000 --> 00:07:02,240
vamos a poner texto y le damos a continuar

80
00:07:02,240 --> 00:07:04,060
y borramos estas dos líneas

81
00:07:04,060 --> 00:07:07,149
y estas

82
00:07:07,149 --> 00:07:11,379
bien, ya tenemos las conexiones

83
00:07:11,379 --> 00:07:23,939
hemos puesto el trigger al 2 y el eco al pin 3. Hemos dicho que el trigger se configura

84
00:07:23,939 --> 00:07:31,459
como una salida, puesto que le tiene que enviar al trigger un valor de un 1 para que el sensor

85
00:07:31,459 --> 00:07:40,000
envíe la señal de ultrasonidos hacia el objeto. Después el eco va a rebotar en el objeto

86
00:07:40,000 --> 00:07:45,279
y obtendremos la vuelta del sonido

87
00:07:45,279 --> 00:07:48,519
entonces el eco se va a encargar

88
00:07:48,519 --> 00:07:50,339
será un pin de lectura

89
00:07:50,339 --> 00:07:53,100
y leerá si le ha llegado señal o no

90
00:07:53,100 --> 00:08:00,860
bien, por lo tanto el trigger se configurará de salida

91
00:08:00,860 --> 00:08:03,060
y el eco se configurará como entrada

92
00:08:03,060 --> 00:08:05,500
lo primero vamos a generar dos variables

93
00:08:05,500 --> 00:08:08,920
acordaos, en C++ se podían definir dos variables

94
00:08:08,920 --> 00:08:12,399
a través de estas dos líneas con define

95
00:08:12,399 --> 00:08:26,060
Define en el que vamos a poner que trig sea el 2 y define el echo que sería el 3.

96
00:08:26,540 --> 00:08:29,160
Bien, ya tenemos las dos constantes que serían estas dos.

97
00:08:29,939 --> 00:08:36,059
Donde yo ponga trig supone que es un 2 y donde ponga yo echo se hace suponer que es un 3.

98
00:08:36,679 --> 00:08:40,220
Bien, vamos a la configuración inicial que se realizaría en el setup,

99
00:08:40,360 --> 00:08:42,580
en aquel método en el que se lee una única vez.

100
00:08:42,580 --> 00:08:46,580
vamos a configurar los pines, habrá un pin de entrada y un pin de salida

101
00:08:46,580 --> 00:08:51,519
el pin de entrada y el pin de salida

102
00:08:51,519 --> 00:09:02,120
el pin de trig, que sería concretamente el 2

103
00:09:02,120 --> 00:09:05,759
ese le vamos a hacer de, lo hemos dicho, de salida, entonces sería output

104
00:09:05,759 --> 00:09:12,230
mientras que el pin echo, que sería el 3

105
00:09:12,230 --> 00:09:15,830
será un pin de entrada, input

106
00:09:15,830 --> 00:09:39,340
Una vez configurados, configuramos también el monitor en serie, que sería este de aquí para que podamos ver los resultados. Si os acordáis de otros vídeos, eso se hacía con Serial y a través de su método Begin, para que el monitor en serie se inicialice. Esto se hacía con 9600 baudios por defecto.

107
00:09:39,340 --> 00:09:58,820
Y ya tendríamos esto que sería la primera parte. Una vez que hemos realizado el setup, que hemos inicializado los dos pines y hemos inicializado también el monitor en serie, lo siguiente va a ser, vamos a ir hacia el loop,

108
00:09:58,820 --> 00:10:06,519
donde vamos a hacer que se ponga el trig en un valor bajo, low o cero

109
00:10:06,519 --> 00:10:08,259
para que se estabilice el sensor

110
00:10:08,259 --> 00:10:12,580
después envía un pulso high de 10 microsegundos

111
00:10:12,580 --> 00:10:15,379
va a ser una cantidad de tiempo muy pequeña

112
00:10:15,379 --> 00:10:21,059
o sea primero dejamos que la señal del trig sea cero

113
00:10:21,059 --> 00:10:27,320
se estabiliza y después mandamos una señal de ultrasonidos durante 10 microsegundos únicamente

114
00:10:27,320 --> 00:10:29,779
esos 10 microsegundos llegaran hasta el objeto

115
00:10:29,779 --> 00:10:34,279
el sensor emite el ultrasonido durante esos 10 microsegundos

116
00:10:34,279 --> 00:10:38,740
y Arduino lo que va a hacer es que cuando rebote y llegue al eco

117
00:10:38,740 --> 00:10:43,700
va a medir el eco con una función o un método que se llama pulseIn

118
00:10:43,700 --> 00:10:46,039
se calcula la distancia en centímetros

119
00:10:46,039 --> 00:10:48,200
ya hemos visto que la distancia era

120
00:10:48,200 --> 00:10:51,480
la distancia era, vamos a ponerla aquí

121
00:10:51,480 --> 00:10:58,590
para medir la distancia

122
00:10:58,590 --> 00:11:02,529
se va a realizar así

123
00:11:02,529 --> 00:11:03,850
distancia

124
00:11:03,850 --> 00:11:06,330
es igual

125
00:11:06,330 --> 00:11:11,929
a duración

126
00:11:11,929 --> 00:11:15,330
por

127
00:11:15,330 --> 00:11:19,370
0,034

128
00:11:19,370 --> 00:11:20,710
que sería aproximadamente

129
00:11:20,710 --> 00:11:22,250
la velocidad del sonido

130
00:11:22,250 --> 00:11:24,629
partido de 2 puesto que hay

131
00:11:24,629 --> 00:11:26,909
un camino de ida y uno de vuelta

132
00:11:26,909 --> 00:11:28,809
0,034

133
00:11:28,809 --> 00:11:30,990
serían concretamente centímetros

134
00:11:30,990 --> 00:11:32,470
por microsegundo

135
00:11:32,470 --> 00:11:34,970
que es la velocidad de sonido del aire

136
00:11:34,970 --> 00:11:38,809
¿Qué ocurre físicamente cuando el circuito está funcionando?

137
00:11:38,809 --> 00:11:43,509
Pues cada vez que el Arduino envía un pulso al sensor

138
00:11:43,509 --> 00:11:45,730
Este emite un sonido ultrasonico

139
00:11:45,730 --> 00:11:49,590
Este sonido rebota en el objeto que tiene delante y vuelve al sensor

140
00:11:49,590 --> 00:11:58,549
Ya lo vimos, a través del T, traductor T, emisión, traductor R, receptor

141
00:11:58,549 --> 00:12:04,350
Midiendo el tiempo que tarda en regresar esa señal de otro sonido desde que va hasta que viene

142
00:12:04,350 --> 00:12:07,909
y eso se realiza a través de esta fórmula que aparece aquí

143
00:12:07,909 --> 00:12:09,409
y esta es la que vamos a medir

144
00:12:09,409 --> 00:12:17,659
bien, vamos por tanto a crear una variable

145
00:12:17,659 --> 00:12:20,919
y lo vamos a poner aquí

146
00:12:20,919 --> 00:12:26,139
primero en el loop vamos a crear dos variables

147
00:12:26,139 --> 00:12:29,279
concretamente una sería de tipo long

148
00:12:29,279 --> 00:12:50,580
El tipo long es un tipo de números decimales, pero un tipo grande, sería un poquito mayor que el tipo, bueno, sería un double ni sería un float, sería un tipo long que es un número grande.

149
00:12:50,580 --> 00:12:54,019
El long lo vamos a llamar duración

150
00:12:54,019 --> 00:13:02,259
Y luego vamos a poner otro tipo long que sería distancia

151
00:13:02,259 --> 00:13:08,990
Vale, una vez que hemos creado estas dos variables

152
00:13:08,990 --> 00:13:11,710
Aquí, ¿qué vamos a hacer?

153
00:13:12,029 --> 00:13:16,129
Primero, hemos dicho que íbamos a lanzar desde el trigger un valor bajo

154
00:13:16,129 --> 00:13:17,309
Para estabilizar el sensor

155
00:13:17,309 --> 00:13:26,570
Y vamos a poner digital

156
00:13:26,570 --> 00:13:28,789
acordaos, write

157
00:13:28,789 --> 00:13:30,870
para escribir un valor

158
00:13:30,870 --> 00:13:32,610
en un determinado pin

159
00:13:32,610 --> 00:13:35,230
como el trigger es un pin de salida

160
00:13:35,230 --> 00:13:36,090
en trigger

161
00:13:36,090 --> 00:13:38,809
le vamos a dar un valor

162
00:13:38,809 --> 00:13:40,950
primero de 0, entonces vamos a poner un valor

163
00:13:40,950 --> 00:13:43,029
de 0 o de low, podríamos haber puesto ahí también

164
00:13:43,029 --> 00:13:44,809
bien, posteriormente

165
00:13:44,809 --> 00:13:47,549
vamos a leer

166
00:13:47,549 --> 00:13:51,240
el tiempo

167
00:13:51,240 --> 00:13:52,960
del echo

168
00:13:52,960 --> 00:13:55,720
bueno, primero vamos

169
00:13:55,720 --> 00:13:57,000
antes del echo

170
00:13:57,000 --> 00:14:22,080
Lo voy a poner aquí, pero luego lo vemos. Lo que primero nos quedaría aquí es que una vez que se establece el sensor o se estabiliza el sensor con un valor de cero, le decimos que detenga delay microseconds y le vamos a poner 10 microsegundos.

171
00:14:22,080 --> 00:14:47,710
Acordaos, aquí ahora estamos diciéndole que durante 10 microsegundos envíe un pulso, enviar pulso durante 10 microsegundos.

172
00:14:47,710 --> 00:15:10,399
Pero para ello, aquí hemos estabilizado, para enviar un pulso durante 10 microsegundos tenemos que decirle digital write, ahora trig, trig 1.

173
00:15:10,399 --> 00:15:24,220
Ahora lo explico. Bien, ya tenemos el valor. Aquí espera 10 microsegundos que envíe el pulso durante 10 microsegundos y posteriormente volvemos a apagarlo.

174
00:15:24,220 --> 00:15:25,659
digital write

175
00:15:25,659 --> 00:15:30,370
trig

176
00:15:30,370 --> 00:15:32,409
0

177
00:15:32,409 --> 00:15:34,870
vamos a separarlo

178
00:15:34,870 --> 00:15:36,789
para que se vea mejor, aquí tenemos la variable

179
00:15:36,789 --> 00:15:38,009
de tipo long

180
00:15:38,009 --> 00:15:47,700
vale, aquí tenemos

181
00:15:47,700 --> 00:15:49,120
vamos a separarlo

182
00:15:49,120 --> 00:15:50,580
para que quede muchísimo mejor

183
00:15:50,580 --> 00:15:52,639
estabilizar el sensor y

184
00:15:52,639 --> 00:15:54,960
primero aquí sería estabilizar el sensor

185
00:15:54,960 --> 00:15:57,320
y luego tendríamos aquí esta otra parte

186
00:15:57,320 --> 00:16:02,429
hemos hecho

187
00:16:02,429 --> 00:16:03,690
vamos a ver

188
00:16:03,690 --> 00:16:07,690
creamos

189
00:16:07,690 --> 00:16:19,049
Tenemos dos variables de tipo long, que sería de tipo de 32 bits.

190
00:16:20,690 --> 00:16:25,009
Bien, en la primera fase lo que hemos es creado dos variables, una que es a maturación y otra que es a distancia.

191
00:16:25,110 --> 00:16:31,289
Son de tipo long. Esto es un rango de valores bastante alto, de valores decimales, de 32 bits.

192
00:16:31,950 --> 00:16:35,190
Perdón, de valores enteros de 32 bits.

193
00:16:35,190 --> 00:16:57,230
Eso es lo que vamos a generar aquí, son dos variables que serían duración y distancia en el que en vez de utilizar, por ejemplo, un tipo long, o sea, un tipo in entero, que sería un valor entero más corto, que estaría aproximadamente entre menos 32.000 y 32.000 como valor numérico, pues utilizamos un tipo long que es muchísimo mayor.

194
00:16:57,230 --> 00:17:06,470
Estamos hablando de valores que van desde menos 2.147 millones a más 2.147 millones.

195
00:17:06,650 --> 00:17:13,190
Ese es el rango para que podría alojar esta variable, pero que aloja valores enteros, de tipo long, enteros.

196
00:17:14,970 --> 00:17:17,849
Bien, posteriormente estabilizamos el sensor, lo he explicado antes.

197
00:17:18,029 --> 00:17:26,170
Primero le decimos que le pase al trigger, que era el pin 2, le pase un valor de 0.

198
00:17:26,170 --> 00:17:33,549
Con eso establecemos el sensor y posteriormente enviamos un pulso de 10 microsegundos.

199
00:17:33,710 --> 00:17:41,529
¿Por qué lo enviamos? Primero le envía un valor de un 1, le envía un valor al pin 2 de un valor de 1

200
00:17:41,529 --> 00:17:55,430
y aquí nos ha faltado que haya un intervalo entre, vamos a copiarlo aquí, 2 microsegundos.

201
00:17:55,430 --> 00:17:58,009
estabilizamos el sensor

202
00:17:58,009 --> 00:18:00,069
que es, le enviamos desde el pin 2

203
00:18:00,069 --> 00:18:01,230
o sea, hacia el trig

204
00:18:01,230 --> 00:18:03,630
le enviamos un valor de 0

205
00:18:03,630 --> 00:18:05,190
con eso estabilizamos el sensor

206
00:18:05,190 --> 00:18:05,750
¿cuánto?

207
00:18:06,069 --> 00:18:07,789
delay microseconds es un método

208
00:18:07,789 --> 00:18:10,509
que nos va a paralizar la ejecución

209
00:18:10,509 --> 00:18:11,549
o la pausa

210
00:18:11,549 --> 00:18:13,210
durante un determinado tiempo

211
00:18:13,210 --> 00:18:14,990
acordaos que ya utilizamos delay

212
00:18:14,990 --> 00:18:16,849
y delay era en milisegundos

213
00:18:16,849 --> 00:18:19,890
ahora, delay microseconds es en microsegundos

214
00:18:19,890 --> 00:18:21,589
o sea, cantidades muy muy pequeñas

215
00:18:21,589 --> 00:18:22,750
y le estamos diciendo que

216
00:18:22,750 --> 00:18:25,490
tenga un 0 durante 2 microsegundos

217
00:18:25,490 --> 00:18:27,410
o sea que durante los 2 microsegundos

218
00:18:27,410 --> 00:18:28,990
le hemos enviado un 0

219
00:18:28,990 --> 00:18:30,289
para que establece el sensor

220
00:18:30,289 --> 00:18:33,150
posteriormente una vez que han pasado

221
00:18:33,150 --> 00:18:34,170
esos 2 microsegundos

222
00:18:34,170 --> 00:18:37,130
le enviamos ahora a TRIG un valor de 1

223
00:18:37,130 --> 00:18:39,190
con lo cual está activando el valor

224
00:18:39,190 --> 00:18:40,349
de TRIG para que envíe

225
00:18:40,349 --> 00:18:43,309
un pulso

226
00:18:43,309 --> 00:18:44,269
de ultrasonidos

227
00:18:44,269 --> 00:18:47,690
¿cuánto tiempo vamos a enviar ese pulso de ultrasonidos?

228
00:18:48,069 --> 00:18:48,869
aquí tendríamos

229
00:18:48,869 --> 00:18:51,450
que en un principio

230
00:18:51,450 --> 00:18:53,049
con el valor de 0

231
00:18:53,049 --> 00:18:54,349
hacia TRIG

232
00:18:54,349 --> 00:18:57,390
le estamos diciendo que estabilice durante 2 microsegundos

233
00:18:57,390 --> 00:18:58,569
el sensor

234
00:18:58,569 --> 00:19:01,529
posteriormente una vez que han pasado esos 2 microsegundos

235
00:19:01,529 --> 00:19:03,369
lo que hacemos es que ahora le mandamos a TRIG

236
00:19:03,369 --> 00:19:05,250
le mandamos a través de DigitalWrite

237
00:19:05,250 --> 00:19:07,309
le mandamos un 1 o un HIGH

238
00:19:07,309 --> 00:19:09,029
lo que hace que

239
00:19:09,029 --> 00:19:11,470
este trigger funcione

240
00:19:11,470 --> 00:19:13,309
y haga que el sensor envíe una señal

241
00:19:13,309 --> 00:19:15,250
de ultrasonidos, pero ¿cuánto tiempo lo vamos a hacer?

242
00:19:15,569 --> 00:19:17,130
durante 10 microsegundos

243
00:19:17,130 --> 00:19:19,890
te fijas aquí, 10 microsegundos

244
00:19:19,890 --> 00:19:21,230
porque le estamos diciendo que

245
00:19:21,230 --> 00:19:23,349
este valor de 1 se lo proporcione durante

246
00:19:23,349 --> 00:19:24,450
10 microsegundos

247
00:19:24,450 --> 00:19:26,710
una vez que hayan pasado esos 10 microsegundos

248
00:19:26,710 --> 00:19:29,369
ya habrían pasado 12 porque había 2 de estabilización

249
00:19:29,369 --> 00:19:31,569
en 0 y 10 con un valor de 1

250
00:19:31,569 --> 00:19:33,890
cuando haya llegado a 12 microsegundos

251
00:19:33,890 --> 00:19:34,569
el

252
00:19:34,569 --> 00:19:37,210
sensor deja de emitir

253
00:19:37,210 --> 00:19:39,670
la señal de ultrasonidos

254
00:19:39,670 --> 00:19:41,430
ahora lo único que nos interesa

255
00:19:41,430 --> 00:19:43,390
y porque lo deja de transmitir

256
00:19:43,390 --> 00:19:45,509
porque le hemos puesto aquí después de esos 10 microsegundos

257
00:19:45,509 --> 00:19:47,250
que le ponga otra vez el valor de trig

258
00:19:47,250 --> 00:19:48,589
a un valor 0

259
00:19:48,589 --> 00:19:50,730
entonces ahora que nos quedaría

260
00:19:50,730 --> 00:19:53,130
no nos quedaría nada más que recoger

261
00:19:53,130 --> 00:19:55,029
el valor del eco

262
00:19:55,029 --> 00:19:56,529
o sea el rebote

263
00:19:56,529 --> 00:19:59,029
de la señal, aquí han pasado ya

264
00:19:59,029 --> 00:20:00,950
los 10 microsegundos, al ponerle un 0

265
00:20:00,950 --> 00:20:03,049
en trig, estas líneas desaparecen

266
00:20:03,049 --> 00:20:05,009
ya no hay pulso de salida, ahora lo único

267
00:20:05,009 --> 00:20:06,829
que nos quedaría es recoger

268
00:20:06,829 --> 00:20:08,430
cuando haya rebotado con el objeto

269
00:20:08,430 --> 00:20:11,049
el pulso de llegada que sería

270
00:20:11,049 --> 00:20:12,750
el eco, y el eco es un pin

271
00:20:12,750 --> 00:20:14,910
de entrada en el que lo que va a recoger

272
00:20:14,910 --> 00:20:16,809
es ese pulso a través

273
00:20:16,809 --> 00:20:19,150
de este pin, eso se va a realizar

274
00:20:19,150 --> 00:20:20,349
a través de una función que se llama

275
00:20:20,349 --> 00:20:22,869
pulseIn, vamos a leer el tiempo del eco

276
00:20:22,869 --> 00:20:24,349
y lo ponemos aquí debajo

277
00:20:24,349 --> 00:20:26,529
vale

278
00:20:26,529 --> 00:20:29,049
lo primero que vamos a hacer

279
00:20:29,049 --> 00:20:30,849
es, hemos utilizado una variable

280
00:20:30,849 --> 00:20:31,710
que se llama duración

281
00:20:31,710 --> 00:20:35,109
y en esa variable de tipo long vamos a recoger

282
00:20:35,109 --> 00:20:36,890
lo que venga

283
00:20:36,890 --> 00:20:38,670
el pulso que venga rebotado

284
00:20:38,670 --> 00:20:40,529
eso se hace con una función que se llama

285
00:20:40,529 --> 00:20:41,390
pulseIn

286
00:20:41,390 --> 00:20:44,329
que

287
00:20:44,329 --> 00:20:47,250
tiene dos parámetros, uno sería el eco

288
00:20:47,250 --> 00:20:49,069
lógicamente

289
00:20:49,069 --> 00:20:51,150
y le estamos diciendo, oye ponme

290
00:20:51,150 --> 00:20:53,029
en el eco un 1, ahora

291
00:20:53,029 --> 00:20:55,269
el eco al activar este pin

292
00:20:55,269 --> 00:20:56,750
con un 1

293
00:20:56,750 --> 00:20:59,109
le estamos diciendo que recoja ese pulso

294
00:20:59,109 --> 00:21:01,230
que va a venir rebotado

295
00:21:01,230 --> 00:21:03,210
del objeto, bien una vez que

296
00:21:03,210 --> 00:21:04,970
hemos leído el eco

297
00:21:04,970 --> 00:21:07,089
nos quedaría ahora calcular la distancia

298
00:21:07,089 --> 00:21:07,750
calcular

299
00:21:07,750 --> 00:21:10,390
la

300
00:21:10,390 --> 00:21:12,049
distancia

301
00:21:12,049 --> 00:21:18,849
en centímetros y eso tenemos otra variable de tipo long que hemos definido arriba que se llama

302
00:21:18,849 --> 00:21:26,089
distancia y donde vamos a recoger la fórmula que hemos puesto aquí esta sería la fórmula de que

303
00:21:26,089 --> 00:21:31,130
nos va a permitir calcular la distancia que ha recorrido ya lo he explicado anteriormente

304
00:21:31,130 --> 00:21:38,769
distancia o espacio es igual a velocidad por tiempo eso es una fórmula básica en física

305
00:21:38,769 --> 00:21:49,269
espacio es igual a velocidad por tiempo por tanto esta sería la la fórmula que

306
00:21:49,269 --> 00:21:52,809
podemos aplicar entonces lo que tenemos que poner aquí primero la velocidad

307
00:21:52,809 --> 00:21:57,109
hemos dicho que la velocidad era centímetros por microsegundo y que

308
00:21:57,109 --> 00:22:00,609
aproximadamente tiene un valor de 0.034 eso es una constante nada más que

309
00:22:00,609 --> 00:22:05,950
puedes saber que es esta y por la duración lo que ha durado o sea por el

310
00:22:05,950 --> 00:22:11,970
tiempo, veis esta es la velocidad por el tiempo y la duración que es lo que ha durado entre que

311
00:22:11,970 --> 00:22:17,130
se envió el pulso y vino, claro hay que dividirlo entre dos porque es una de llamada y una de vuelta

312
00:22:17,130 --> 00:22:24,670
o sea una de ida y una vuelta por eso dividimos la mitad para dividir porque este recorrido si

313
00:22:24,670 --> 00:22:29,809
no pusiéramos dividido entre dos tendríamos que mediríamos la distancia que hay de aquí a aquí

314
00:22:29,809 --> 00:22:33,250
y luego la que hay de aquí a aquí que sería el doble de lo que queremos medir porque nosotros

315
00:22:33,250 --> 00:22:39,349
queremos saber qué distancia hay entre el sensor y el objeto por eso se divide entre dos una vez

316
00:22:39,349 --> 00:22:45,369
que tenemos calculada la distancia que sería este de aquí y que nos quedaría ahora mostrar

317
00:22:45,369 --> 00:22:54,019
el resultado donde vamos a mostrar el resultado en el monitor en serie mostrar un resultado el

318
00:22:54,019 --> 00:23:02,920
monitor en serie era serial el objeto serial y para imprimir el monitor se utilizaba un método

319
00:23:02,920 --> 00:23:13,779
que se llama print el print vamos a poner en principio vamos a poner en distancia distancia

320
00:23:13,779 --> 00:23:21,299
la cadena distancia con un espacio y esto lo vamos a copiar y puesto que vamos a poner tanto

321
00:23:21,299 --> 00:23:37,319
el valor de la distancia copiar y copiar después de distancia tendríamos que queremos que imprima

322
00:23:37,319 --> 00:23:38,920
la variable distancia

323
00:23:38,920 --> 00:23:41,559
que es la variable que hemos

324
00:23:41,559 --> 00:23:42,299
calculado aquí

325
00:23:42,299 --> 00:23:45,599
o sea que imprimiría distancia dos puntos

326
00:23:45,599 --> 00:23:47,920
espacio, luego el valor de la distancia que ha calculado

327
00:23:47,920 --> 00:23:49,579
y por último nos pondría

328
00:23:49,579 --> 00:23:51,539
los centímetros para que

329
00:23:51,539 --> 00:23:53,420
pongamos unidades a esa distancia

330
00:23:53,420 --> 00:23:55,420
dejamos un espacio y ponemos centímetros

331
00:23:55,420 --> 00:23:57,500
y con esto tendríamos

332
00:23:57,500 --> 00:23:59,579
solo nos faltaría poner

333
00:23:59,579 --> 00:23:59,960
aquí

334
00:23:59,960 --> 00:24:03,960
como este método se está repitiendo

335
00:24:03,960 --> 00:24:05,660
infinitas veces

336
00:24:05,660 --> 00:24:09,720
vamos a hacer que eso lo realice cada un cierto tiempo.

337
00:24:10,319 --> 00:24:13,960
Entonces le vamos a poner un delay para que pause la ejecución

338
00:24:13,960 --> 00:24:16,799
cada, por ejemplo, 300 milisegundos.

339
00:24:20,019 --> 00:24:22,019
Y ya estaría el circuito. Vamos a ver si funciona.

340
00:24:24,140 --> 00:24:27,380
Vamos a darle aquí a Iniciar simulación

341
00:24:27,380 --> 00:24:30,039
y nos dice que hay un error.

342
00:24:33,980 --> 00:24:36,779
Dice que la directiva está mal porque he puesto aquí,

343
00:24:36,779 --> 00:24:40,380
si veis, no he puesto define, lo he escrito mal

344
00:24:40,380 --> 00:24:45,200
ahora estaría bien, le damos a ejecutar

345
00:24:45,200 --> 00:24:47,839
y vemos que funciona perfectamente

346
00:24:47,839 --> 00:24:51,720
vamos a poner el esquema aquí

347
00:24:51,720 --> 00:24:55,960
y vamos a seleccionar la distancia

348
00:24:55,960 --> 00:24:59,480
si vamos al monitor en serie, vemos que distancia

349
00:24:59,480 --> 00:25:01,180
pero veis, me lo está poniendo

350
00:25:01,180 --> 00:25:05,259
me lo está poniendo todo de seguido en la misma línea

351
00:25:05,259 --> 00:25:07,299
y yo quiero que aparezca en vertical

352
00:25:07,299 --> 00:25:11,019
que haya un retorno de carro por cada vez que la pone

353
00:25:11,019 --> 00:25:12,680
entonces vamos a pararlo

354
00:25:12,680 --> 00:25:16,259
y aquí serial tiene un método que se llama print

355
00:25:16,259 --> 00:25:19,359
pero tiene otro método que se llama println

356
00:25:19,359 --> 00:25:23,000
ln es que además de imprimir centímetros

357
00:25:23,000 --> 00:25:27,000
luego genera un retorno de carro que iría a la siguiente línea

358
00:25:27,000 --> 00:25:29,619
con eso evitamos que aparezcan todos así

359
00:25:29,619 --> 00:25:37,000
le damos a ejecutar y ahora vamos viendo que nos sale los 112 centímetros

360
00:25:37,000 --> 00:25:43,180
siempre hay un pequeño intervalo de error entre lo que sale aquí y la medida del sensor

361
00:25:43,180 --> 00:25:54,640
si ponemos el obstáculo más cerca pasaría 56 centímetros y así sucesivamente en función de la distancia a la que esté el objeto