1
00:00:05,179 --> 00:00:12,119
Hola a todos, tengo aquí otro esquema de otro circuito en el que he añadido dos elementos.

2
00:00:12,960 --> 00:00:19,780
Un elemento sería el sensor de distancia, el HCSR04 que está aquí, que ya vimos,

3
00:00:20,519 --> 00:00:25,519
y tenemos también un LCD I2C que tenía cuatro pines nada más.

4
00:00:26,280 --> 00:00:33,979
En cuanto a la idea del proyecto es sencilla, el sensor mide cuántos centímetros hay hasta un objeto

5
00:00:33,979 --> 00:00:36,159
y el LCD lo enseña en tiempo real.

6
00:00:36,740 --> 00:00:40,159
Este montaje es muy útil como base para proyectos más avanzados,

7
00:00:40,280 --> 00:00:44,179
por ejemplo, una barra automática, un medidor de aparcamiento o una alarma de proximidad.

8
00:00:44,979 --> 00:00:49,219
Bien, con respecto al LCD, teníamos los cuatro pines, acordaos,

9
00:00:49,219 --> 00:00:54,340
el GND que iba a masa, el VCC que iba a alimentación y luego el SDA que era los datos

10
00:00:54,340 --> 00:00:58,520
y el SCL que lo que era la señal o el serial clock,

11
00:00:59,219 --> 00:01:02,579
que iban a los pines A4 y A5 analógicos

12
00:01:02,579 --> 00:01:23,620
Y con esto ya tendríamos este componente. En cuanto al sensor, HCSR04, recordaros que mide distancia por ultrasonidos, entonces este sensor lo que va a tener es una, cuando detecte un objeto en esta posición a una determinada distancia, pues hará una determinada cosa.

13
00:01:23,620 --> 00:01:44,180
El mide distancia por ultrasonidos y lo que tiene es que este sensor envía un pulso al pin que sería este, que sería el trigger, le veis, aquí aparece como trig, que sería el trigger, y el sensor lo que hará es que cuando reciba esa señal, el sensor emite ultrasonidos.

14
00:01:44,180 --> 00:01:47,040
entonces cuando el eco vuelve

15
00:01:47,040 --> 00:01:48,980
cuando hay un objeto aquí

16
00:01:48,980 --> 00:01:51,319
que ese ultrasonido choca contra el objeto

17
00:01:51,319 --> 00:01:54,040
ese sonido rebotará

18
00:01:54,040 --> 00:01:55,540
y volverá otra vez al sensor

19
00:01:55,540 --> 00:01:58,680
entonces cuando lo detectará

20
00:01:58,680 --> 00:02:00,280
a través de lo que es el eco

21
00:02:00,280 --> 00:02:01,599
se activará

22
00:02:01,599 --> 00:02:04,939
entonces se vuelve el pin eco

23
00:02:04,939 --> 00:02:06,319
se activa durante ese tiempo

24
00:02:06,319 --> 00:02:07,299
cuando lo recibe

25
00:02:07,299 --> 00:02:09,400
entonces Arduino mide ese tiempo

26
00:02:09,400 --> 00:02:11,139
y lo convierte en centímetros

27
00:02:11,139 --> 00:02:28,840
La distancia la obtiene porque la señal que va hasta el objeto recibe una señal de vuelta o eco y en cuanto calcula esa distancia.

28
00:02:28,840 --> 00:02:50,360
¿Cómo la calcula? Pues la calcula en centímetros. Esa distancia sería la duración, lo que tarda, por 0,034 partido de 2. ¿Qué son 0,034? Pues son los 0,034 centímetros por microsegundo, que es la velocidad del sonido aproximadamente. Por eso utiliza esa constante, que sería 0,034.

29
00:02:50,360 --> 00:03:10,460
Es una fórmula fácil de física clásica en la que distancia es igual a velocidad por tiempo. Por tanto, la velocidad sería en esos 0.034 centímetros por microsegundo, que es la velocidad del sonido aproximada, y la divide entre dos porque el sonido va y vuelve.

30
00:03:10,460 --> 00:03:14,199
eso sería lo que va a hacer

31
00:03:14,199 --> 00:03:16,960
si le damos a ejecutar

32
00:03:16,960 --> 00:03:20,780
veis en un principio nos aparece sensor distancia

33
00:03:20,780 --> 00:03:23,000
iniciando y nos dice la distancia que hay aproximada

34
00:03:23,000 --> 00:03:25,360
que serían 66 centímetros

35
00:03:25,360 --> 00:03:28,020
si yo selecciono el sensor

36
00:03:28,020 --> 00:03:30,280
moviendo este circulito verde

37
00:03:30,280 --> 00:03:35,080
nos sacará distintas distancias

38
00:03:35,080 --> 00:03:37,759
en función del objeto donde esté localizado

39
00:03:37,759 --> 00:03:56,580
Y esto sería el circuito que vamos a realizar. Lo vamos a realizar desde cero. Vamos a detener la simulación y vamos a crear un nuevo circuito. Le damos a crear, le decimos circuito y vamos sacando cada uno de los elementos del circuito.

40
00:03:56,580 --> 00:04:12,139
En un principio necesitaremos la placa de Arduino, necesitamos la placa de pruebas que la vamos a poner aquí, vamos a ponerla más abajo y vamos a necesitar también un LCD. Vamos a poner todos los elementos y buscamos el LCD.

41
00:04:12,139 --> 00:04:16,860
Queremos el LCD I2C, que es el que tiene menos pines

42
00:04:16,860 --> 00:04:19,600
Una vez que lo tenemos aquí, vamos a hacer las conexiones

43
00:04:19,600 --> 00:04:21,480
Vamos rápido en cuanto a esto

44
00:04:21,480 --> 00:04:24,259
Lo que hacemos es que alimentamos la placa de pruebas

45
00:04:24,259 --> 00:04:32,379
Primero con una línea de alimentación de 5 voltios

46
00:04:32,379 --> 00:04:37,259
Que iría hasta la placa de pruebas

47
00:04:37,259 --> 00:04:39,279
Y alimentaría esta línea

48
00:04:39,279 --> 00:04:42,000
Vamos a ponerla de color rojo

49
00:04:42,000 --> 00:04:52,199
luego tenemos el gnd para alimentar la otra línea de la placa de pruebas que sería la de aquí bien

50
00:04:52,199 --> 00:04:59,060
ya la tenemos y la ponemos de color negro bien una vez que ya están alimentadas a través y hemos

51
00:04:59,060 --> 00:05:04,279
cerrado el circuito con la placa de pruebas ya podemos derivar líneas desde aquí a cada uno de

52
00:05:04,279 --> 00:05:11,300
los componentes que tenemos vamos a bajarlo un poco y vamos a primero a crear primero el gnd

53
00:05:11,300 --> 00:05:16,139
que el GND iría aquí

54
00:05:16,139 --> 00:05:24,740
a esta línea

55
00:05:24,740 --> 00:05:33,459
y la de alimentación del LCD

56
00:05:33,459 --> 00:05:35,160
que iría a la línea roja.

57
00:05:38,009 --> 00:05:39,250
Esta la vamos a poner de color rojo

58
00:05:39,250 --> 00:05:41,550
y ya tendríamos esas dos líneas alimentadas.

59
00:05:42,050 --> 00:05:44,209
Nos quedaría el SDA y el SCL.

60
00:05:44,490 --> 00:05:47,529
Acordaos, el SCL iba al pin 5

61
00:05:47,529 --> 00:05:51,949
para que no se crucen más líneas

62
00:05:51,949 --> 00:06:02,420
vamos a poner el SDA primero, que iría, bueno, no va a quedar junto, pero bueno, va a ir

63
00:06:02,420 --> 00:06:14,509
al 4, vamos a ponerlo de color verde, y el SCL, que iría al 5. Vamos a crear otro punto

64
00:06:14,509 --> 00:06:25,089
aquí, para que quede un poquito mejor. Y ya tendríamos lo que es toda la placa de

65
00:06:25,089 --> 00:06:32,629
LCD y 2D. Ahora, a continuación, tendríamos que sacar el sensor. Vamos a por él, que estaría aquí.

66
00:06:41,290 --> 00:06:50,269
Vamos a coger este. Y igual, tenemos, por un lado, tenemos la alimentación o potencia que tendrá que ir.

67
00:06:51,009 --> 00:07:03,720
Vamos a hacerlo de tal manera que nos quede un poquito ordenado. Iría hasta la línea de alimentación,

68
00:07:03,720 --> 00:07:05,819
que ya lo hemos puesto ahí, la vamos a poner de color rojo

69
00:07:05,819 --> 00:07:07,100
para que lo identifiquemos

70
00:07:07,100 --> 00:07:08,160
y el GND

71
00:07:08,160 --> 00:07:10,240
que iría

72
00:07:10,240 --> 00:07:17,279
a la otra línea de 0 voltios

73
00:07:17,279 --> 00:07:18,160
que sería esta de aquí

74
00:07:18,160 --> 00:07:20,100
la ponemos

75
00:07:20,100 --> 00:07:21,720
y la ponemos de color negro

76
00:07:21,720 --> 00:07:24,860
bien, ya lo tenemos, ahora lo único que nos queda

77
00:07:24,860 --> 00:07:26,480
es tanto el trigger

78
00:07:26,480 --> 00:07:28,699
como el eco que iban a dos pines

79
00:07:28,699 --> 00:07:30,180
vamos a poner este por ejemplo

80
00:07:30,180 --> 00:07:31,860
al pin número

81
00:07:31,860 --> 00:07:34,279
3

82
00:07:34,279 --> 00:07:35,560
le ponemos de color verde

83
00:07:35,560 --> 00:07:41,459
y este otro que iría al pin número 4

84
00:07:41,459 --> 00:07:54,110
y con esto ya tendríamos todo lo que es el montaje del LCD unido al sensor

85
00:07:54,110 --> 00:07:57,769
bien, vamos a pasar a lo que es la programación

86
00:07:57,769 --> 00:08:04,930
entonces vamos a crear todo el código necesario para que esto funcione

87
00:08:04,930 --> 00:08:11,529
entonces nos vamos al código, quitamos todo esto

88
00:08:11,529 --> 00:08:21,670
y para que el vídeo no sea excesivamente largo

89
00:08:21,670 --> 00:08:24,709
primero voy copiando y pegando

90
00:08:24,709 --> 00:08:28,209
ya tengo las líneas y las voy explicando

91
00:08:28,209 --> 00:08:31,110
entonces esto era igual que en el LCD

92
00:08:31,110 --> 00:08:34,649
teníamos las dos librerías que necesitábamos incluir

93
00:08:34,649 --> 00:08:38,490
que eran estas dos, que eran tanto Wire como Liquid Crystal y 2C

94
00:08:38,490 --> 00:08:44,289
la creación del objeto Liquid Crystal y 2C

95
00:08:44,289 --> 00:08:47,350
que sería aquí

96
00:08:47,350 --> 00:08:52,710
vale, acordaos que era el 35

97
00:08:52,710 --> 00:08:54,230
la dirección y luego

98
00:08:54,230 --> 00:08:56,850
de 16 por 2, vamos a seleccionar el mismo

99
00:08:56,850 --> 00:08:58,490
y le vamos a poner el

100
00:08:58,490 --> 00:09:01,029
igual que aparecía en el

101
00:09:01,029 --> 00:09:02,789
vídeo anterior, bien

102
00:09:02,789 --> 00:09:04,070
ya estaría configurado eso

103
00:09:04,070 --> 00:09:06,929
y pasaríamos ahora a lo que es

104
00:09:06,929 --> 00:09:07,370
la

105
00:09:07,370 --> 00:09:08,929
el

106
00:09:08,929 --> 00:09:12,210
lo que sería el disparo del sensor

107
00:09:12,210 --> 00:09:33,990
Bien, entonces primero vamos a generar dos constantes en C++ para generar una constante se hace con define, vamos a generarlo aquí y lo que vamos a hacer es que estamos generando la constante trig con define en el que va a albergar un valor de 9.

108
00:09:33,990 --> 00:09:47,070
La otra constante sería eco y que albergaría un valor de 10, que van a ser, concretamente en nuestro caso, no lo he puesto en el 9 y en el 10, sino que lo he puesto en el 3 y en el 4.

109
00:09:47,210 --> 00:09:55,330
¿Lo veis? El 3 es el trigger y el pin 4 es el eco.

110
00:09:55,529 --> 00:10:00,549
Entonces el trigger es un 3 y el eco es un 4.

111
00:10:00,549 --> 00:10:10,850
A continuación necesitamos medir la distancia y lo vamos a hacer a través de un método

112
00:10:10,850 --> 00:10:14,149
Un método en C++, nada más que un método al que vamos a llamar

113
00:10:14,149 --> 00:10:18,909
Y que ejecutará una serie de comandos o de líneas dentro de ese método

114
00:10:18,909 --> 00:10:20,269
Y luego devolverá un valor

115
00:10:20,269 --> 00:10:24,049
El método que va a ser es una función

116
00:10:24,049 --> 00:10:27,210
Esta función va a ser esta que aparece aquí

117
00:10:27,210 --> 00:10:31,990
La ponemos aquí como si fuera un método más

118
00:10:31,990 --> 00:10:34,809
tenemos aquí, si veis aquí tenemos dos funciones

119
00:10:34,809 --> 00:10:36,769
que devolvían setup y loop

120
00:10:36,769 --> 00:10:38,730
no devolvían ningún valor

121
00:10:38,730 --> 00:10:39,889
tenían void

122
00:10:39,889 --> 00:10:42,950
y ahora vamos a generar aquí otra función que sería esta de aquí

123
00:10:42,950 --> 00:10:44,750
en el que lo que vais a ver

124
00:10:44,750 --> 00:10:46,230
es que devuelve un valor

125
00:10:46,230 --> 00:10:48,809
long, un valor decimal

126
00:10:48,809 --> 00:10:50,529
le hemos llamado

127
00:10:50,529 --> 00:10:52,809
a la función, le llamamos medir distancia

128
00:10:52,809 --> 00:10:54,149
en centímetros y

129
00:10:54,149 --> 00:10:55,830
dentro vamos a tener

130
00:10:55,830 --> 00:10:58,750
primero le estamos indicando

131
00:10:58,750 --> 00:11:00,309
un digital write en el que

132
00:11:00,309 --> 00:11:05,950
le estamos diciendo que al trigger le confiera un valor bajo, un valor de cero.

133
00:11:07,169 --> 00:11:13,649
Después retrase la ejecución dos microsegundos

134
00:11:13,649 --> 00:11:20,990
y después de esos dos microsegundos le confiere desde el pin del trigger,

135
00:11:21,169 --> 00:11:25,809
que era el pin 3, le está diciendo que le proporciona un valor alto.

136
00:11:25,809 --> 00:11:30,830
¿Para qué? Para que envíe la onda de ultrasonidos.

137
00:11:31,230 --> 00:11:36,009
Una vez que se le ha enviado el trigger o ha sido lanzada, le espera 10 microsegundos.

138
00:11:36,629 --> 00:11:39,769
Veis que este delay es diferente al que teníamos anteriormente.

139
00:11:39,929 --> 00:11:46,570
El delay sin microseconds lo medía en milisegundos.

140
00:11:46,730 --> 00:11:51,750
Esto al ponerle aquí este nombre, este otro método, lo que lo va a hacer es microsegundos.

141
00:11:51,850 --> 00:11:54,789
Queremos que sea un tiempo muy corto.

142
00:11:54,789 --> 00:11:57,690
después de otros 10 microsegundos lo que hace es que

143
00:11:57,690 --> 00:11:59,750
DigitalWrite le vamos a conferir

144
00:11:59,750 --> 00:12:00,929
al valor del trigger

145
00:12:00,929 --> 00:12:02,870
le ponemos a 0

146
00:12:02,870 --> 00:12:05,830
después tenemos la lectura

147
00:12:05,830 --> 00:12:07,590
del eco, la lectura del eco se hace

148
00:12:07,590 --> 00:12:09,389
a través de, lo vimos en

149
00:12:09,389 --> 00:12:11,549
en el vídeo en el que

150
00:12:11,549 --> 00:12:13,750
explicábamos el sensor, le decimos

151
00:12:13,750 --> 00:12:14,149
que

152
00:12:14,149 --> 00:12:16,730
reciba el eco

153
00:12:16,730 --> 00:12:18,809
al chocar contra el objeto

154
00:12:18,809 --> 00:12:21,470
reciba un

155
00:12:21,470 --> 00:12:23,529
valor de high y lo

156
00:12:23,529 --> 00:12:30,450
metemos con esta función pulseIn, lo metemos dentro de una variable que se llama duración.

157
00:12:31,370 --> 00:12:39,269
A continuación, convertimos esa duración en distancia, ¿cómo? Pues con la fórmula que he dicho anteriormente.

158
00:12:39,269 --> 00:12:46,769
Esta sería 0.034, que sería la velocidad aproximada del sonido, partido de 2 porque hay una ida y una vuelta.

159
00:12:46,769 --> 00:12:58,450
Esta operación nos daría el valor de la distancia y luego retorna o devuelve el valor de distancia que ha obtenido a través de esta función que devuelve un valor log.

160
00:12:59,169 --> 00:13:07,450
Bien, ya tendríamos esto. Después en el setup tendríamos que configurar tanto el sensor como el LCD.

161
00:13:07,450 --> 00:13:29,429
En el sensor y el LCD, pues igual que poníamos el pin y estamos diciendo que el pin mode del trigger, del trig, acordaos, la constante trig está diciendo que es un pin 3, pues que el trig sea un valor de salida.

162
00:13:29,429 --> 00:13:45,330
mientras que el otro pin que sería el pin mode el eco tenga un valor de entrada luego explicaré

163
00:13:45,330 --> 00:13:50,669
cuando explique y ponga los comentarios del código lo explicaré más detalladamente el eco tiene que

164
00:13:50,669 --> 00:13:55,470
ser de entrada porque es la señal que vamos a recibir de cuando choca con el objeto el trigger

165
00:13:55,470 --> 00:14:01,429
es una señal de salida porque está enviando un señal de sonidos hacia el objeto por eso este

166
00:14:01,429 --> 00:14:10,409
de salida y este es de entrada. Bien, a continuación pasamos al LCD, que bueno, esto ya lo vimos,

167
00:14:10,649 --> 00:14:20,769
LCD.init, que lo inicializamos. Después de inicializarlo le ponemos el backlight para

168
00:14:20,769 --> 00:14:34,639
que encienda el LED y luego pasamos al mensaje inicial. El mensaje inicial sería LCD.init

169
00:14:34,659 --> 00:14:42,080
el objeto LCD que imprima, primero habrá que localizar el cursor, set cursor,

170
00:14:42,080 --> 00:14:49,460
y ponemos en el 00, 0, 0.

171
00:14:50,679 --> 00:15:06,309
Posteriormente imprimimos en el LCD con print, vamos a poner hc-sr04,

172
00:15:06,309 --> 00:15:08,490
0.4 que sería el sensor

173
00:15:08,490 --> 00:15:09,409
más

174
00:15:09,409 --> 00:15:11,370
LCD

175
00:15:11,370 --> 00:15:16,379
y lo tendríamos ya

176
00:15:16,379 --> 00:15:17,639
a continuación

177
00:15:17,639 --> 00:15:19,740
seleccionamos otra parte del cursor

178
00:15:19,740 --> 00:15:21,679
que sería con set

179
00:15:21,679 --> 00:15:23,620
cursor

180
00:15:23,620 --> 00:15:25,539
y pondríamos el que

181
00:15:25,539 --> 00:15:27,840
tendríamos ahora

182
00:15:27,840 --> 00:15:29,240
queremos que sea

183
00:15:29,240 --> 00:15:32,519
la columna 0

184
00:15:32,519 --> 00:15:34,299
pero la fila 1

185
00:15:34,299 --> 00:15:35,440
bien

186
00:15:35,440 --> 00:15:53,159
Le ponemos que aquí vamos a poner que ponga el texto imprimir inicializando y ya tendríamos esto.

187
00:15:54,440 --> 00:16:11,139
Ponemos un retraso de, vamos a poner un segundo y medio y por último le decimos que después de ese tiempo nos borre la pantalla.

188
00:16:11,139 --> 00:16:15,960
Clear nos dice que nos borre la pantalla, el método clear.

189
00:16:16,519 --> 00:16:17,620
Bien, ¿qué nos quedaría?

190
00:16:17,779 --> 00:16:22,179
Nos quedaría ahora lo que es programar lo que sería el loop.

191
00:16:22,659 --> 00:16:28,879
El loop, vamos a, aquí desde el loop vamos a llamar a la distancia

192
00:16:28,879 --> 00:16:33,480
y lo tiene que hacer, necesitamos un método que esté continuamente recorriéndose

193
00:16:33,480 --> 00:16:36,580
y que mejor que el loop que se está recorriendo

194
00:16:36,580 --> 00:16:38,700
mientras está en ejecución de manera infinitas veces.

195
00:16:39,220 --> 00:16:43,500
Por tanto, tenemos que ir recogiendo la distancia que va determinando el sensor.

196
00:16:44,080 --> 00:16:50,639
Eso lo vamos a coger en un valor long, de tipo long, y le vamos a poner distancia.

197
00:16:52,299 --> 00:16:58,240
¿Qué vamos a recoger aquí? Pues el valor que obtenemos del método medir distancia en centímetros.

198
00:16:58,240 --> 00:17:08,849
Por tanto, habrá que llamar al método medir distancia en centímetros.

199
00:17:08,849 --> 00:17:24,109
Es así, ¿no? Bien. Una vez que ya hemos llamado, a continuación queremos que en el LCD aparezca el valor que hemos obtenido al llamar al método medir distancia a centímetros.

200
00:17:24,109 --> 00:17:34,670
Entonces, lcd, le damos a set cursor, y lo ponemos en la fila y columna 0.

201
00:17:36,049 --> 00:17:47,410
Una vez que hemos localizado el cursor, imprimimos, vamos a poner que la distancia,

202
00:17:47,410 --> 00:17:57,130
Vamos a poner en texto dist, dos puntos, espacio y comillas. Esa va a ser la distancia.

203
00:17:57,730 --> 00:18:15,210
Entonces, si la distancia, vamos a introducir aquí un if. El if nos va a decir que si la distancia es menos que cero o la distancia es mayor de 400, pues que no ponga, vamos a ponerle unos guiones en el que de tal manera que no nos ponga ningún valor.

204
00:18:15,210 --> 00:18:21,130
Si no, nos va a poner exactamente el valor de la distancia que se determina.

205
00:18:21,490 --> 00:18:28,950
Entonces tendremos que utilizar un condicional que será if en el que la condición que vamos a meter dentro del condicional va a ser

206
00:18:28,950 --> 00:18:47,549
Si distancia es menor o igual a cero o distancia es mayor que 400,

207
00:18:47,549 --> 00:18:53,980
entonces lo que vamos a decir es que en el LCD

208
00:18:53,980 --> 00:19:10,779
en el LCD imprima cuatro rayas

209
00:19:10,779 --> 00:19:15,279
que nos va a indicar que esos valores no nos interesan

210
00:19:15,279 --> 00:19:17,019
sería así

211
00:19:17,019 --> 00:19:25,440
ahora ponemos el ELSE

212
00:19:25,440 --> 00:19:28,380
si no, entonces

213
00:19:28,380 --> 00:19:32,319
que nos escriba, vamos a poner esto mejor identado

214
00:19:32,319 --> 00:19:42,200
ahí. Pondremos que el LCD lo que va a imprimir es la distancia que nos está dando el método al que

215
00:19:42,200 --> 00:19:48,099
hemos llamado, medir distancia en centímetros. Entonces meteremos aquí la variable distancia.

216
00:19:50,660 --> 00:19:56,480
Y a continuación de esto le pondremos unos centímetros para que aparezca la distancia del

217
00:19:56,480 --> 00:20:02,119
número con el centímetro, con las unidades a su derecha. Entonces pondremos LCD.print

218
00:20:03,819 --> 00:20:15,779
y aquí pondremos centímetros y un espacio. Cerramos la llave del ELSE y tendríamos ya

219
00:20:18,319 --> 00:20:30,839
así. Bien, ya tenemos este condicional ya creado. ¿Qué sucede ahora? Esto sería lo que es la primera

220
00:20:30,839 --> 00:20:43,339
línea, que sería la de la distancia. Si yo quiero ahora, vamos a copiar esto y le vamos a poner otra

221
00:20:43,339 --> 00:20:47,500
a través del condicionar. Pero esta va a ser ahora la segunda línea. Ahora en la segunda

222
00:20:47,500 --> 00:21:01,059
línea, esta sería la primera línea, vamos a ponerla como línea 1, que nos va a aparecer

223
00:21:01,059 --> 00:21:09,980
la distancia, mientras que esto va a ser la línea 2, la de debajo, que sería línea

224
00:21:09,980 --> 00:21:23,859
2 y que sería estado por rangos. Ahora veremos qué es eso. Bien, ¿qué vamos a sustituirlo? Como lo

225
00:21:23,859 --> 00:21:29,299
vamos a sustituir en la segunda línea, estamos sustituyéndolo en la 01. ¿Y aquí qué vamos a

226
00:21:29,299 --> 00:21:37,380
poner? Vamos a poner esto. Todavía no vamos a imprimir nada. Lo borramos. Y ahora lo que vamos

227
00:21:37,380 --> 00:22:03,019
a decir es que si distancia es mayor que 0 y distancia es menor de 20, este va a ser

228
00:22:03,019 --> 00:22:19,190
el rango, le vamos a decir que imprima muy cerca, ¿vale? Vamos a dejarle aquí un espacio,

229
00:22:19,190 --> 00:22:20,630
vale

230
00:22:20,630 --> 00:22:22,910
si no

231
00:22:22,910 --> 00:22:25,410
si no está entre 0 y 20

232
00:22:25,410 --> 00:22:26,609
vamos a poner un

233
00:22:26,609 --> 00:22:28,410
el set if

234
00:22:28,410 --> 00:22:30,369
si no, si

235
00:22:30,369 --> 00:22:32,329
ponemos otra condición, que será

236
00:22:32,329 --> 00:22:33,529
si distancia

237
00:22:33,529 --> 00:22:37,779
es mayor

238
00:22:37,779 --> 00:22:39,559
o igual

239
00:22:39,559 --> 00:22:42,579
vamos a poner

240
00:22:42,579 --> 00:22:43,559
20

241
00:22:43,559 --> 00:22:46,920
y distancia

242
00:22:46,920 --> 00:22:52,269
es menor

243
00:22:52,269 --> 00:22:53,069
o igual

244
00:22:53,069 --> 00:22:55,769
a 100

245
00:22:55,769 --> 00:22:57,430
fijaos lo que estamos haciendo

246
00:22:57,430 --> 00:23:00,529
estamos poniendo que si distancia está entre 0 y 20

247
00:23:00,529 --> 00:23:01,509
que ponga muy cerca

248
00:23:01,509 --> 00:23:04,849
pero si ahora esta distancia está entre 20 y 100

249
00:23:04,849 --> 00:23:06,609
entonces que imprima

250
00:23:06,609 --> 00:23:08,829
distancia ok

251
00:23:08,829 --> 00:23:15,210
ok

252
00:23:15,210 --> 00:23:20,599
vale

253
00:23:20,599 --> 00:23:22,519
por último nos quedaría

254
00:23:22,519 --> 00:23:24,319
esto vamos a borrarlo

255
00:23:24,319 --> 00:23:28,819
el último else

256
00:23:28,819 --> 00:23:30,940
que sería else

257
00:23:30,940 --> 00:23:32,759
abrimos llave

258
00:23:32,759 --> 00:24:09,140
y aquí le vamos a decir que es LCD, imprima, lejos, cerramos la llave y después le dejamos que lo haga cada, vamos a poner 200 milisegundos para que lo vaya actualizando.

259
00:24:09,140 --> 00:24:11,500
bien, entonces que hemos hecho

260
00:24:11,500 --> 00:24:12,579
en la primera línea hemos dicho

261
00:24:12,579 --> 00:24:13,799
esto está mal

262
00:24:13,799 --> 00:24:17,559
que coja en la variable distancia

263
00:24:17,559 --> 00:24:19,160
y de tipo long

264
00:24:19,160 --> 00:24:21,339
reciba

265
00:24:21,339 --> 00:24:23,380
el valor medir distancia de centímetros

266
00:24:23,380 --> 00:24:25,500
que venía de esta función

267
00:24:25,500 --> 00:24:26,460
de aquí arriba

268
00:24:26,460 --> 00:24:28,440
una vez que lo recoge

269
00:24:28,440 --> 00:24:30,500
el cursor 00, o sea aquí

270
00:24:30,500 --> 00:24:32,539
va a poner distance dist

271
00:24:32,539 --> 00:24:34,599
y luego si la distancia está

272
00:24:34,599 --> 00:24:36,240
es menor que 0 o mayor que 400

273
00:24:36,240 --> 00:24:38,059
o sea rangos que no nos van a importar

274
00:24:38,059 --> 00:24:39,839
que le ponga las rayitas.

275
00:24:42,640 --> 00:24:48,579
Si no, si está entre 0 y 400,

276
00:24:49,059 --> 00:24:51,839
pues entonces que imprima distancia con el valor en centímetros.

277
00:24:52,039 --> 00:24:53,380
Eso sería en la línea de arriba.

278
00:24:54,000 --> 00:24:56,079
En la línea de abajo sería listado por rangos.

279
00:24:56,460 --> 00:25:00,460
Ahora, en la línea de abajo, en la fila 1, lo colocaría aquí.

280
00:25:00,920 --> 00:25:03,640
Si distancia es mayor que 0 y distancia es menor que 20,

281
00:25:03,779 --> 00:25:05,980
o sea, una distancia sería muy cercana,

282
00:25:05,980 --> 00:25:30,339
Entonces pone ahí, aquí pondrá muy cerca. Si eso no se cumple y le pregunta si distancia ahora está entre 20 y entre 100. Si está entre 20 y 100 es lo que nosotros queremos y por tanto pondrá distancia, ok. Y si ni siquiera está entre 0 y 20 y tampoco entre 20 y 100, entonces será que será mayor que 100 y entonces tendremos que poner que está lejos.

283
00:25:30,339 --> 00:25:44,940
Y esto sería todo el código de este proyecto. Vamos a ver si lo he codificado bien. Vamos a darle a ejecutar, a simular y vamos a ver.

284
00:25:47,079 --> 00:26:01,619
Nos dice que inválida cabecera. A ver, tenemos algo mal. Vamos a repasar todo. Esto estaría bien. El liquid crystal I2C LCD 35162. Bien.

285
00:26:01,619 --> 00:26:15,920
Luego hemos definido dos constantes, que serían Trigger 3 y Echo 4, que están bien. El Trigger era esta y el Echo es la 4. Luego hemos dicho definir distancia en centímetros.

286
00:26:15,920 --> 00:26:43,440
Hemos dicho digital write, hemos dicho que el trigger sea low, delay microseconds también estaría bien. ¿Qué más? Sí, está correcto. Esto está bien. ¿Qué tenemos más? La distancia, eso está bien. Pin mode de salida, de entrada, LCD, backlight, que también está bien.

287
00:26:45,920 --> 00:26:50,279
Vale, hemos vuelto a poner esto en mayúscula y vamos a ver si era eso.

288
00:26:53,579 --> 00:27:03,660
Vale, dice que hay más errores, lcd setCursor, está perfecto, esto también, setCursor01, print, delay y clear, borrar.

289
00:27:03,660 --> 00:27:13,759
Vale, en cuanto a la distancia hemos llamado al método o a la función medir distancia en centímetro, vamos a ver si le he puesto el mismo nombre, medir distancia en centímetro, correcto.

290
00:27:13,759 --> 00:27:16,500
y hemos puesto ese excursor, lcd print

291
00:27:16,500 --> 00:27:19,099
y correcto, si distancia menor o igual que cero

292
00:27:19,099 --> 00:27:21,559
o distancia, distancia

293
00:27:21,559 --> 00:27:24,500
es mayor que 400, perfecto, esto también

294
00:27:24,500 --> 00:27:30,630
y está correcto, todas las llaves están bien

295
00:27:30,630 --> 00:27:34,559
vale, si veis aquí

296
00:27:34,559 --> 00:27:36,779
no hemos cerrado la llave

297
00:27:36,779 --> 00:27:40,720
vale, a ver, me falta

298
00:27:40,720 --> 00:27:43,900
cerrar la llave del condición

299
00:27:43,900 --> 00:27:47,039
no, estaría cerrada aquí, tendríamos que haberla cerrada

300
00:27:47,039 --> 00:27:54,079
aquí. No hemos cerrado esa llave. Eso estaba mal. Aquí está bien. Aquí tampoco lo hemos

301
00:27:54,079 --> 00:28:11,079
cerrado. Y yo creo que está todo bien. Vamos a darle. Y ya nos funciona. ¿Veis? Lo que

302
00:28:11,079 --> 00:28:15,380
está haciendo ahora mismo está midiendo una distancia de 112 centímetros. Ahí hemos

303
00:28:15,380 --> 00:28:20,599
puesto que era lejos de los intervalos o rangos que eran OK. Era en cuanto la distancia

304
00:28:20,599 --> 00:28:30,220
estaba entre 20 y 100. Vamos al sensor y lo vamos a bajar un poco para que nos dé una distancia más

305
00:28:30,220 --> 00:28:34,259
adecuada. Veis, lo bajamos de 100 y ya nos está poniendo que la distancia es ok. ¿Por qué? Porque

306
00:28:34,259 --> 00:28:40,480
está entre 20 y 100. Si bajamos de 20, como hemos visto anteriormente, nos tendría que salir las

307
00:28:40,480 --> 00:28:47,019
rayas indicando que no queremos esos valores y que aparece que está muy cerca. Si el valor que

308
00:28:47,019 --> 00:28:55,599
habíamos puesto para las cuatro líneas que había puesto aquí era cuando era menor que

309
00:28:55,599 --> 00:29:03,519
cero o mayor que 400. Entonces vamos a hacer que el sensor llegue a 400. Vamos a seleccionarla

310
00:29:03,519 --> 00:29:11,980
aquí y vamos a hacer que llegue a 400 para que nos salgan las rayas. O incluso sería

311
00:29:11,980 --> 00:29:16,920
más fácil porque no llega a llegar a cero. Si llegamos a cero centímetros nos tendrá

312
00:29:16,920 --> 00:29:31,779
que aparecer aquí. Cuando se sale de aquí ya no mide el valor de cero o sea que el propio

313
00:29:31,779 --> 00:29:37,359
sensor no habría hecho falta ni siquiera poner el valor de cero. Pero si por ejemplo

314
00:29:37,359 --> 00:29:42,660
si ponemos que sea por ejemplo menor de 10, vamos a cambiarlo en el código, vamos a ver

315
00:29:42,660 --> 00:29:48,480
si se aparecen las rayas vamos a poner que éstas sean cuando sean menor que 10 y vamos a poner que

316
00:29:48,480 --> 00:29:59,380
por ejemplo sea cuando sea mayor de 250 le damos a ejecutar ahora y veremos que cuándo

317
00:30:00,759 --> 00:30:06,220
está por debajo de 10 está inicializando cuando veis aparecen las cuatro rayitas cuando están por

318
00:30:06,220 --> 00:30:16,839
encima también de 250 vamos a poner 250 aquí nos aparecería también 248 vamos a un poquito más

319
00:30:16,839 --> 00:30:24,059
y veis que nos aparecen las líneas en el que ya no esos valores no nos interesa y esto sería todo

320
00:30:24,059 --> 00:30:43,000
todo lo que es el esquema de este circuito. Voy a comentar el código como último paso

321
00:30:43,000 --> 00:30:50,059
del vídeo para que repasemos todas las partes del código. Entonces, lo primero que hacíamos

322
00:30:50,059 --> 00:30:51,680
aquí, en el include, era

323
00:30:51,680 --> 00:30:55,079
incluimos

324
00:30:55,079 --> 00:30:57,680
librerías

325
00:30:57,680 --> 00:31:02,140
tanto wire como

326
00:31:02,140 --> 00:31:04,339
liquid, cristal y 2C

327
00:31:04,339 --> 00:31:05,359
aquí creamos

328
00:31:05,359 --> 00:31:09,839
un objeto

329
00:31:09,839 --> 00:31:14,789
liquid

330
00:31:14,789 --> 00:31:17,670
cristal

331
00:31:17,670 --> 00:31:20,710
y 2C

332
00:31:20,710 --> 00:31:23,650
bien, esto es la definición

333
00:31:23,650 --> 00:31:35,750
en C++ de dos constantes. Definimos dos constantes. La primera se llamaría trick, que albergaría

334
00:31:35,750 --> 00:31:41,210
un valor de 3 y la segunda sería echo, que albergaría un valor de 4. A continuación

335
00:31:41,210 --> 00:31:57,779
Creamos la función MedirDistanciaEnCentímetros.

336
00:31:57,779 --> 00:32:17,289
La función devuelve un valor de tipo log, que es un valor decimal de gran tamaño.

337
00:32:17,289 --> 00:32:22,170
A continuación, el disparo del sensor, que es el DigitalWrite, ya está puesto aquí

338
00:32:22,170 --> 00:32:28,589
Entonces lo que hace es que el trigger, que es el que va a enviar la señal de ultrasonidos

339
00:32:28,589 --> 00:32:34,730
En un principio lo pone a un valor de 0 y luego tras 2 microsegundos lo pone a un valor de 1

340
00:32:34,730 --> 00:32:39,410
Lo veis aquí, el disparo del sensor serían estas tres líneas

341
00:32:39,410 --> 00:32:59,549
Luego retrasa, esto sería para la ejecución o la pausa 10 microsegundos y a continuación

342
00:32:59,549 --> 00:33:01,509
apaga el

343
00:33:01,509 --> 00:33:04,650
le da

344
00:33:04,650 --> 00:33:07,150
al

345
00:33:07,150 --> 00:33:09,529
trigger

346
00:33:09,529 --> 00:33:13,210
un

347
00:33:13,210 --> 00:33:15,190
valor

348
00:33:15,190 --> 00:33:17,190
de 0 voltios

349
00:33:17,190 --> 00:33:21,220
lo que está haciendo aquí es que

350
00:33:21,220 --> 00:33:23,480
lo está parando el trigger

351
00:33:23,480 --> 00:33:25,819
solo queremos que envíe una señal

352
00:33:25,819 --> 00:33:28,019
envíe en un principio

353
00:33:28,019 --> 00:33:29,859
cuando se ha llamado este método

354
00:33:29,859 --> 00:33:30,819
envíe una señal

355
00:33:30,819 --> 00:33:32,700
el trigger y después

356
00:33:32,700 --> 00:33:34,319
deje de enviarlas.

357
00:33:34,859 --> 00:33:38,380
Ese trigger recibirá luego una señal de eco

358
00:33:38,380 --> 00:33:40,940
cuando rebote en el objeto al que ha lanzado.

359
00:33:41,539 --> 00:33:43,160
Aquí es la lectura del eco, ¿veis?

360
00:33:43,519 --> 00:33:47,799
El eco ahora, como veremos aquí abajo,

361
00:33:48,059 --> 00:33:49,579
en la definición de los pin mode,

362
00:33:49,940 --> 00:33:51,519
el eco es una señal de entrada,

363
00:33:51,799 --> 00:33:53,920
el trigger es una señal de salida.

364
00:33:53,920 --> 00:33:57,039
El trigger es el que ha salido un valor de 1

365
00:33:57,039 --> 00:34:00,059
y luego a los 10 microsegundos

366
00:34:00,059 --> 00:34:02,059
ha dejado de enviar esa señal.

367
00:34:02,700 --> 00:34:16,260
En cuanto aquí a la lectura del eco, con el pulse in, pues claro que eco es un pin de entrada, estamos leyendo lo que no vamos a recibir o la señal de ultrasonido es que vamos a recibir y por eso le pone un valor de 1 y lo mete dentro de duración.

368
00:34:16,260 --> 00:34:21,619
A continuación, ha convertido esa duración o ese tiempo en microsegundos.

369
00:34:21,900 --> 00:34:27,500
Esta es una fórmula que ya nos da el propio sensor.

370
00:34:28,440 --> 00:34:38,800
Esto sería velocidad igual, perdón, espacio igual a velocidad por tiempo.

371
00:34:39,219 --> 00:34:43,719
Fórmula física en la que la velocidad sería la duración, que hemos determinado,

372
00:34:43,719 --> 00:34:46,239
que lo multiplica además por 0.04

373
00:34:46,239 --> 00:34:47,559
que es la velocidad de sonido partido de 2

374
00:34:47,559 --> 00:34:49,980
porque hay dos señales, una de salida y una de entrada

375
00:34:49,980 --> 00:34:51,719
y luego retorna

376
00:34:51,719 --> 00:34:53,800
esta función que una vez que hemos obtenido

377
00:34:53,800 --> 00:34:54,739
el valor de la distancia

378
00:34:54,739 --> 00:34:57,780
generado por ese trigger

379
00:34:57,780 --> 00:34:59,880
lanzado y ese echo recibido

380
00:34:59,880 --> 00:35:02,099
en una fracción de segundo

381
00:35:02,099 --> 00:35:04,199
lo mete

382
00:35:04,199 --> 00:35:05,780
en la variable de distancia que ya tiene un valor

383
00:35:05,780 --> 00:35:07,780
de long y lo devuelve en la función

384
00:35:07,780 --> 00:35:09,800
devuelve cuando ya esa función

385
00:35:09,800 --> 00:35:11,800
sea llamada, medir distancia de centímetro

386
00:35:11,800 --> 00:35:13,519
recibirá esa distancia

387
00:35:13,519 --> 00:35:38,340
En el setup tenemos aquí la definición de los pines, tanto el trigger como el eco, en el que uno, el trigger lógicamente tiene que ser de salida porque sale en busca del objeto y el eco tiene que ser de entrada, tenemos que leer lo que rebota esa señal de tres sonidos que vamos a recibir.

388
00:35:38,340 --> 00:35:48,079
Luego aquí tenemos los parámetros de configuración del LCD

389
00:35:48,079 --> 00:35:53,860
En el que tenemos el init, que ya lo vimos, cómo se inicializa, cómo se enciende la luz

390
00:35:53,860 --> 00:35:58,320
Después colocamos el cursor en la opción 00 o sea aquí

391
00:35:58,320 --> 00:36:00,699
Y le imprime esta cadena

392
00:36:00,699 --> 00:36:06,059
Después lo posiciona en el 01, que sería aquí, y pone inicializando

393
00:36:06,059 --> 00:36:08,400
espera un segundo y medio

394
00:36:08,400 --> 00:36:09,860
y luego limpia toda la pantalla

395
00:36:09,860 --> 00:36:11,239
porque después en el loop

396
00:36:11,239 --> 00:36:12,760
tiene que ir apareciendo la distancia

397
00:36:12,760 --> 00:36:15,659
que está midiendo el sensor

398
00:36:15,659 --> 00:36:18,340
esto lo va a realizar solo una vez

399
00:36:18,340 --> 00:36:19,599
entonces aparecerá al principio

400
00:36:19,599 --> 00:36:20,559
cuando le demos a ejecutar

401
00:36:20,559 --> 00:36:21,780
y luego desaparecerá

402
00:36:21,780 --> 00:36:23,820
y aparecerá ya lo que queremos

403
00:36:23,820 --> 00:36:26,300
por último tenemos el loop

404
00:36:26,300 --> 00:36:27,539
que tiene dos líneas

405
00:36:27,539 --> 00:36:29,059
una primera línea es la de arriba

406
00:36:29,059 --> 00:36:30,179
que sigue a la distancia

407
00:36:30,179 --> 00:36:32,340
entonces al llamar al método

408
00:36:32,340 --> 00:36:33,679
medir distancia en centímetros

409
00:36:33,679 --> 00:36:34,739
o sea la función de arriba

410
00:36:34,739 --> 00:36:40,679
está recibiendo la distancia que está creando este método.

411
00:36:41,079 --> 00:36:44,059
Lo recibe con un valor log y luego lo que hace aquí

412
00:36:44,059 --> 00:36:52,539
es que sitúa el cursor en el 00 otra vez aquí y le pone dist.

413
00:36:53,179 --> 00:36:56,739
A continuación aquí tenemos una serie de condicionales,

414
00:36:57,519 --> 00:36:59,139
este condicional que sería este de aquí,

415
00:36:59,139 --> 00:37:28,880
en el que lo que nos va a medir es condicional que comprueba que la distancia esté entre 10 y 250 centímetros.

416
00:37:28,880 --> 00:38:01,699
Si distancia es menor que 0 o mayor de 250, entonces imprime las cuatro rayitas.

417
00:38:01,820 --> 00:38:26,769
seguido de centímetros. ¿Qué sucede si no? Si no es así, imprime la distancia. Esto lo va a hacer

418
00:38:26,769 --> 00:38:49,349
¿Cuándo? Cuando sea un valor entre 10 y 250 centímetros.

419
00:38:53,949 --> 00:38:56,929
A continuación pasamos a la línea 2, que es el estado por rangos.

420
00:38:57,110 --> 00:39:00,590
Va a hacer lo mismo, ahora se sitúa en esta otra línea, con el SD aquí,

421
00:39:01,329 --> 00:39:04,369
y después tenemos otro condicional, en el que ahora la distancia,

422
00:39:04,369 --> 00:39:08,110
lo que nos va a medir es que, vamos a coger esto de aquí,

423
00:39:08,510 --> 00:39:39,510
Y en este nudo condicional, el condicional comprueba si la distancia está entre, entre si la distancia es menor que 0 y, perdón, mayor que 0, que 0 y menor de 20.

424
00:39:39,510 --> 00:39:53,579
Si la distancia es menor que 0 y mayor de 20, pues imprimirá el que muy cerca.

425
00:40:00,090 --> 00:40:09,449
Bien, luego tenemos otro, el else, el else if, nos está diciendo si no, si esto no se cumple,

426
00:40:09,530 --> 00:40:15,150
si el valor no está comprendido entre el valor entre 0 y 20, entonces comprueba otro condicional,

427
00:40:15,150 --> 00:40:20,530
¿Qué sucede si ahora está entre 20 y 100?

428
00:40:22,130 --> 00:40:38,650
Si está entre 20 y 100, pues que imprime distancia, ok.

429
00:40:43,960 --> 00:40:48,880
Y si no cumple ninguno de los dos, si ya pasamos a este último else,

430
00:40:48,880 --> 00:41:25,739
y ya no cumple ni el intervalo de 0 a 20, ni el de 20 a 100, nos dirá que está lejos.

431
00:41:26,760 --> 00:41:41,059
Y esto sería todo el código. Ya nos hemos metido en un ejemplo en el que necesitamos bastante más código para poder programar este ejemplo.