Saltar navegación

Activa JavaScript para disfrutar de los vídeos de la Mediateca.

LCD I2C y sensor distancia en arduíno - Contenido educativo

Ajuste de pantalla

El ajuste de pantalla se aprecia al ver el vídeo en pantalla completa. Elige la presentación que más te guste:

Subido el 16 de diciembre de 2025 por Francisco J. G.

5 visualizaciones

LCD I2C y sensor distancia en arduíno

Más información Transcripción

Descargar la transcripción

Hola a todos, tengo aquí otro esquema de otro circuito en el que he añadido dos elementos. 00:00:05
Un elemento sería el sensor de distancia, el HCSR04 que está aquí, que ya vimos, 00:00:12
y tenemos también un LCD I2C que tenía cuatro pines nada más. 00:00:20
En cuanto a la idea del proyecto es sencilla, el sensor mide cuántos centímetros hay hasta un objeto 00:00:26
y el LCD lo enseña en tiempo real. 00:00:33
Este montaje es muy útil como base para proyectos más avanzados, 00:00:36
por ejemplo, una barra automática, un medidor de aparcamiento o una alarma de proximidad. 00:00:40
Bien, con respecto al LCD, teníamos los cuatro pines, acordaos, 00:00:44
el GND que iba a masa, el VCC que iba a alimentación y luego el SDA que era los datos 00:00:49
y el SCL que lo que era la señal o el serial clock, 00:00:54
que iban a los pines A4 y A5 analógicos 00:00:59
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. 00:01:02
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. 00:01:23
entonces cuando el eco vuelve 00:01:44
cuando hay un objeto aquí 00:01:47
que ese ultrasonido choca contra el objeto 00:01:48
ese sonido rebotará 00:01:51
y volverá otra vez al sensor 00:01:54
entonces cuando lo detectará 00:01:55
a través de lo que es el eco 00:01:58
se activará 00:02:00
entonces se vuelve el pin eco 00:02:01
se activa durante ese tiempo 00:02:04
cuando lo recibe 00:02:06
entonces Arduino mide ese tiempo 00:02:07
y lo convierte en centímetros 00:02:09
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. 00:02:11
¿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. 00:02:28
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. 00:02:50
eso sería lo que va a hacer 00:03:10
si le damos a ejecutar 00:03:14
veis en un principio nos aparece sensor distancia 00:03:16
iniciando y nos dice la distancia que hay aproximada 00:03:20
que serían 66 centímetros 00:03:23
si yo selecciono el sensor 00:03:25
moviendo este circulito verde 00:03:28
nos sacará distintas distancias 00:03:30
en función del objeto donde esté localizado 00:03:35
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. 00:03:37
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. 00:03:56
Queremos el LCD I2C, que es el que tiene menos pines 00:04:12
Una vez que lo tenemos aquí, vamos a hacer las conexiones 00:04:16
Vamos rápido en cuanto a esto 00:04:19
Lo que hacemos es que alimentamos la placa de pruebas 00:04:21
Primero con una línea de alimentación de 5 voltios 00:04:24
Que iría hasta la placa de pruebas 00:04:32
Y alimentaría esta línea 00:04:37
Vamos a ponerla de color rojo 00:04:39
luego tenemos el gnd para alimentar la otra línea de la placa de pruebas que sería la de aquí bien 00:04:42
ya la tenemos y la ponemos de color negro bien una vez que ya están alimentadas a través y hemos 00:04:52
cerrado el circuito con la placa de pruebas ya podemos derivar líneas desde aquí a cada uno de 00:04:59
los componentes que tenemos vamos a bajarlo un poco y vamos a primero a crear primero el gnd 00:05:04
que el GND iría aquí 00:05:11
a esta línea 00:05:16
y la de alimentación del LCD 00:05:24
que iría a la línea roja. 00:05:33
Esta la vamos a poner de color rojo 00:05:38
y ya tendríamos esas dos líneas alimentadas. 00:05:39
Nos quedaría el SDA y el SCL. 00:05:42
Acordaos, el SCL iba al pin 5 00:05:44
para que no se crucen más líneas 00:05:47
vamos a poner el SDA primero, que iría, bueno, no va a quedar junto, pero bueno, va a ir 00:05:51
al 4, vamos a ponerlo de color verde, y el SCL, que iría al 5. Vamos a crear otro punto 00:06:02
aquí, para que quede un poquito mejor. Y ya tendríamos lo que es toda la placa de 00:06:14
LCD y 2D. Ahora, a continuación, tendríamos que sacar el sensor. Vamos a por él, que estaría aquí. 00:06:25
Vamos a coger este. Y igual, tenemos, por un lado, tenemos la alimentación o potencia que tendrá que ir. 00:06:41
Vamos a hacerlo de tal manera que nos quede un poquito ordenado. Iría hasta la línea de alimentación, 00:06:51
que ya lo hemos puesto ahí, la vamos a poner de color rojo 00:07:03
para que lo identifiquemos 00:07:05
y el GND 00:07:07
que iría 00:07:08
a la otra línea de 0 voltios 00:07:10
que sería esta de aquí 00:07:17
la ponemos 00:07:18
y la ponemos de color negro 00:07:20
bien, ya lo tenemos, ahora lo único que nos queda 00:07:21
es tanto el trigger 00:07:24
como el eco que iban a dos pines 00:07:26
vamos a poner este por ejemplo 00:07:28
al pin número 00:07:30
le ponemos de color verde 00:07:34
y este otro que iría al pin número 4 00:07:35
y con esto ya tendríamos todo lo que es el montaje del LCD unido al sensor 00:07:41
bien, vamos a pasar a lo que es la programación 00:07:54
entonces vamos a crear todo el código necesario para que esto funcione 00:07:57
entonces nos vamos al código, quitamos todo esto 00:08:04
y para que el vídeo no sea excesivamente largo 00:08:11
primero voy copiando y pegando 00:08:21
ya tengo las líneas y las voy explicando 00:08:24
entonces esto era igual que en el LCD 00:08:28
teníamos las dos librerías que necesitábamos incluir 00:08:31
que eran estas dos, que eran tanto Wire como Liquid Crystal y 2C 00:08:34
la creación del objeto Liquid Crystal y 2C 00:08:38
que sería aquí 00:08:44
vale, acordaos que era el 35 00:08:47
la dirección y luego 00:08:52
de 16 por 2, vamos a seleccionar el mismo 00:08:54
y le vamos a poner el 00:08:56
igual que aparecía en el 00:08:58
vídeo anterior, bien 00:09:01
ya estaría configurado eso 00:09:02
y pasaríamos ahora a lo que es 00:09:04
lo que sería el disparo del sensor 00:09:08
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. 00:09:12
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. 00:09:33
¿Lo veis? El 3 es el trigger y el pin 4 es el eco. 00:09:47
Entonces el trigger es un 3 y el eco es un 4. 00:09:55
A continuación necesitamos medir la distancia y lo vamos a hacer a través de un método 00:10:00
Un método en C++, nada más que un método al que vamos a llamar 00:10:10
Y que ejecutará una serie de comandos o de líneas dentro de ese método 00:10:14
Y luego devolverá un valor 00:10:18
El método que va a ser es una función 00:10:20
Esta función va a ser esta que aparece aquí 00:10:24
La ponemos aquí como si fuera un método más 00:10:27
tenemos aquí, si veis aquí tenemos dos funciones 00:10:31
que devolvían setup y loop 00:10:34
no devolvían ningún valor 00:10:36
tenían void 00:10:38
y ahora vamos a generar aquí otra función que sería esta de aquí 00:10:39
en el que lo que vais a ver 00:10:42
es que devuelve un valor 00:10:44
long, un valor decimal 00:10:46
le hemos llamado 00:10:48
a la función, le llamamos medir distancia 00:10:50
en centímetros y 00:10:52
dentro vamos a tener 00:10:54
primero le estamos indicando 00:10:55
un digital write en el que 00:10:58
le estamos diciendo que al trigger le confiera un valor bajo, un valor de cero. 00:11:00
Después retrase la ejecución dos microsegundos 00:11:07
y después de esos dos microsegundos le confiere desde el pin del trigger, 00:11:13
que era el pin 3, le está diciendo que le proporciona un valor alto. 00:11:21
¿Para qué? Para que envíe la onda de ultrasonidos. 00:11:25
Una vez que se le ha enviado el trigger o ha sido lanzada, le espera 10 microsegundos. 00:11:31
Veis que este delay es diferente al que teníamos anteriormente. 00:11:36
El delay sin microseconds lo medía en milisegundos. 00:11:39
Esto al ponerle aquí este nombre, este otro método, lo que lo va a hacer es microsegundos. 00:11:46
Queremos que sea un tiempo muy corto. 00:11:51
después de otros 10 microsegundos lo que hace es que 00:11:54
DigitalWrite le vamos a conferir 00:11:57
al valor del trigger 00:11:59
le ponemos a 0 00:12:00
después tenemos la lectura 00:12:02
del eco, la lectura del eco se hace 00:12:05
a través de, lo vimos en 00:12:07
en el vídeo en el que 00:12:09
explicábamos el sensor, le decimos 00:12:11
que 00:12:13
reciba el eco 00:12:14
al chocar contra el objeto 00:12:16
reciba un 00:12:18
valor de high y lo 00:12:21
metemos con esta función pulseIn, lo metemos dentro de una variable que se llama duración. 00:12:23
A continuación, convertimos esa duración en distancia, ¿cómo? Pues con la fórmula que he dicho anteriormente. 00:12:31
Esta sería 0.034, que sería la velocidad aproximada del sonido, partido de 2 porque hay una ida y una vuelta. 00:12:39
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. 00:12:46
Bien, ya tendríamos esto. Después en el setup tendríamos que configurar tanto el sensor como el LCD. 00:12:59
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. 00:13:07
mientras que el otro pin que sería el pin mode el eco tenga un valor de entrada luego explicaré 00:13:29
cuando explique y ponga los comentarios del código lo explicaré más detalladamente el eco tiene que 00:13:45
ser de entrada porque es la señal que vamos a recibir de cuando choca con el objeto el trigger 00:13:50
es una señal de salida porque está enviando un señal de sonidos hacia el objeto por eso este 00:13:55
de salida y este es de entrada. Bien, a continuación pasamos al LCD, que bueno, esto ya lo vimos, 00:14:01
LCD.init, que lo inicializamos. Después de inicializarlo le ponemos el backlight para 00:14:10
que encienda el LED y luego pasamos al mensaje inicial. El mensaje inicial sería LCD.init 00:14:20
el objeto LCD que imprima, primero habrá que localizar el cursor, set cursor, 00:14:34
y ponemos en el 00, 0, 0. 00:14:42
Posteriormente imprimimos en el LCD con print, vamos a poner hc-sr04, 00:14:50
0.4 que sería el sensor 00:15:06
más 00:15:08
LCD 00:15:09
y lo tendríamos ya 00:15:11
a continuación 00:15:16
seleccionamos otra parte del cursor 00:15:17
que sería con set 00:15:19
cursor 00:15:21
y pondríamos el que 00:15:23
tendríamos ahora 00:15:25
queremos que sea 00:15:27
la columna 0 00:15:29
pero la fila 1 00:15:32
bien 00:15:34
Le ponemos que aquí vamos a poner que ponga el texto imprimir inicializando y ya tendríamos esto. 00:15:35
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. 00:15:54
Clear nos dice que nos borre la pantalla, el método clear. 00:16:11
Bien, ¿qué nos quedaría? 00:16:16
Nos quedaría ahora lo que es programar lo que sería el loop. 00:16:17
El loop, vamos a, aquí desde el loop vamos a llamar a la distancia 00:16:22
y lo tiene que hacer, necesitamos un método que esté continuamente recorriéndose 00:16:28
y que mejor que el loop que se está recorriendo 00:16:33
mientras está en ejecución de manera infinitas veces. 00:16:36
Por tanto, tenemos que ir recogiendo la distancia que va determinando el sensor. 00:16:39
Eso lo vamos a coger en un valor long, de tipo long, y le vamos a poner distancia. 00:16:44
¿Qué vamos a recoger aquí? Pues el valor que obtenemos del método medir distancia en centímetros. 00:16:52
Por tanto, habrá que llamar al método medir distancia en centímetros. 00:16:58
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. 00:17:08
Entonces, lcd, le damos a set cursor, y lo ponemos en la fila y columna 0. 00:17:24
Una vez que hemos localizado el cursor, imprimimos, vamos a poner que la distancia, 00:17:36
Vamos a poner en texto dist, dos puntos, espacio y comillas. Esa va a ser la distancia. 00:17:47
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. 00:17:57
Si no, nos va a poner exactamente el valor de la distancia que se determina. 00:18:15
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 00:18:21
Si distancia es menor o igual a cero o distancia es mayor que 400, 00:18:28
entonces lo que vamos a decir es que en el LCD 00:18:47
en el LCD imprima cuatro rayas 00:18:53
que nos va a indicar que esos valores no nos interesan 00:19:10
sería así 00:19:15
ahora ponemos el ELSE 00:19:17
si no, entonces 00:19:25
que nos escriba, vamos a poner esto mejor identado 00:19:28
ahí. Pondremos que el LCD lo que va a imprimir es la distancia que nos está dando el método al que 00:19:32
hemos llamado, medir distancia en centímetros. Entonces meteremos aquí la variable distancia. 00:19:42
Y a continuación de esto le pondremos unos centímetros para que aparezca la distancia del 00:19:50
número con el centímetro, con las unidades a su derecha. Entonces pondremos LCD.print 00:19:56
y aquí pondremos centímetros y un espacio. Cerramos la llave del ELSE y tendríamos ya 00:20:03
así. Bien, ya tenemos este condicional ya creado. ¿Qué sucede ahora? Esto sería lo que es la primera 00:20:18
línea, que sería la de la distancia. Si yo quiero ahora, vamos a copiar esto y le vamos a poner otra 00:20:30
a través del condicionar. Pero esta va a ser ahora la segunda línea. Ahora en la segunda 00:20:43
línea, esta sería la primera línea, vamos a ponerla como línea 1, que nos va a aparecer 00:20:47
la distancia, mientras que esto va a ser la línea 2, la de debajo, que sería línea 00:21:01
2 y que sería estado por rangos. Ahora veremos qué es eso. Bien, ¿qué vamos a sustituirlo? Como lo 00:21:09
vamos a sustituir en la segunda línea, estamos sustituyéndolo en la 01. ¿Y aquí qué vamos a 00:21:23
poner? Vamos a poner esto. Todavía no vamos a imprimir nada. Lo borramos. Y ahora lo que vamos 00:21:29
a decir es que si distancia es mayor que 0 y distancia es menor de 20, este va a ser 00:21:37
el rango, le vamos a decir que imprima muy cerca, ¿vale? Vamos a dejarle aquí un espacio, 00:22:03
vale 00:22:19
si no 00:22:20
si no está entre 0 y 20 00:22:22
vamos a poner un 00:22:25
el set if 00:22:26
si no, si 00:22:28
ponemos otra condición, que será 00:22:30
si distancia 00:22:32
es mayor 00:22:33
o igual 00:22:37
vamos a poner 00:22:39
y distancia 00:22:43
es menor 00:22:46
o igual 00:22:52
a 100 00:22:53
fijaos lo que estamos haciendo 00:22:55
estamos poniendo que si distancia está entre 0 y 20 00:22:57
que ponga muy cerca 00:23:00
pero si ahora esta distancia está entre 20 y 100 00:23:01
entonces que imprima 00:23:04
distancia ok 00:23:06
vale 00:23:15
por último nos quedaría 00:23:20
esto vamos a borrarlo 00:23:22
el último else 00:23:24
que sería else 00:23:28
abrimos llave 00:23:30
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. 00:23:32
bien, entonces que hemos hecho 00:24:09
en la primera línea hemos dicho 00:24:11
esto está mal 00:24:12
que coja en la variable distancia 00:24:13
y de tipo long 00:24:17
reciba 00:24:19
el valor medir distancia de centímetros 00:24:21
que venía de esta función 00:24:23
de aquí arriba 00:24:25
una vez que lo recoge 00:24:26
el cursor 00, o sea aquí 00:24:28
va a poner distance dist 00:24:30
y luego si la distancia está 00:24:32
es menor que 0 o mayor que 400 00:24:34
o sea rangos que no nos van a importar 00:24:36
que le ponga las rayitas. 00:24:38
Si no, si está entre 0 y 400, 00:24:42
pues entonces que imprima distancia con el valor en centímetros. 00:24:49
Eso sería en la línea de arriba. 00:24:52
En la línea de abajo sería listado por rangos. 00:24:54
Ahora, en la línea de abajo, en la fila 1, lo colocaría aquí. 00:24:56
Si distancia es mayor que 0 y distancia es menor que 20, 00:25:00
o sea, una distancia sería muy cercana, 00:25:03
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. 00:25:05
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. 00:25:30
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. 00:25:47
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. 00:26:01
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. 00:26:15
Vale, hemos vuelto a poner esto en mayúscula y vamos a ver si era eso. 00:26:45
Vale, dice que hay más errores, lcd setCursor, está perfecto, esto también, setCursor01, print, delay y clear, borrar. 00:26:53
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. 00:27:03
y hemos puesto ese excursor, lcd print 00:27:13
y correcto, si distancia menor o igual que cero 00:27:16
o distancia, distancia 00:27:19
es mayor que 400, perfecto, esto también 00:27:21
y está correcto, todas las llaves están bien 00:27:24
vale, si veis aquí 00:27:30
no hemos cerrado la llave 00:27:34
vale, a ver, me falta 00:27:36
cerrar la llave del condición 00:27:40
no, estaría cerrada aquí, tendríamos que haberla cerrada 00:27:43
aquí. No hemos cerrado esa llave. Eso estaba mal. Aquí está bien. Aquí tampoco lo hemos 00:27:47
cerrado. Y yo creo que está todo bien. Vamos a darle. Y ya nos funciona. ¿Veis? Lo que 00:27:54
está haciendo ahora mismo está midiendo una distancia de 112 centímetros. Ahí hemos 00:28:11
puesto que era lejos de los intervalos o rangos que eran OK. Era en cuanto la distancia 00:28:15
estaba entre 20 y 100. Vamos al sensor y lo vamos a bajar un poco para que nos dé una distancia más 00:28:20
adecuada. Veis, lo bajamos de 100 y ya nos está poniendo que la distancia es ok. ¿Por qué? Porque 00:28:30
está entre 20 y 100. Si bajamos de 20, como hemos visto anteriormente, nos tendría que salir las 00:28:34
rayas indicando que no queremos esos valores y que aparece que está muy cerca. Si el valor que 00:28:40
habíamos puesto para las cuatro líneas que había puesto aquí era cuando era menor que 00:28:47
cero o mayor que 400. Entonces vamos a hacer que el sensor llegue a 400. Vamos a seleccionarla 00:28:55
aquí y vamos a hacer que llegue a 400 para que nos salgan las rayas. O incluso sería 00:29:03
más fácil porque no llega a llegar a cero. Si llegamos a cero centímetros nos tendrá 00:29:11
que aparecer aquí. Cuando se sale de aquí ya no mide el valor de cero o sea que el propio 00:29:16
sensor no habría hecho falta ni siquiera poner el valor de cero. Pero si por ejemplo 00:29:31
si ponemos que sea por ejemplo menor de 10, vamos a cambiarlo en el código, vamos a ver 00:29:37
si se aparecen las rayas vamos a poner que éstas sean cuando sean menor que 10 y vamos a poner que 00:29:42
por ejemplo sea cuando sea mayor de 250 le damos a ejecutar ahora y veremos que cuándo 00:29:48
está por debajo de 10 está inicializando cuando veis aparecen las cuatro rayitas cuando están por 00:30:00
encima también de 250 vamos a poner 250 aquí nos aparecería también 248 vamos a un poquito más 00:30:06
y veis que nos aparecen las líneas en el que ya no esos valores no nos interesa y esto sería todo 00:30:16
todo lo que es el esquema de este circuito. Voy a comentar el código como último paso 00:30:24
del vídeo para que repasemos todas las partes del código. Entonces, lo primero que hacíamos 00:30:43
aquí, en el include, era 00:30:50
incluimos 00:30:51
librerías 00:30:55
tanto wire como 00:30:57
liquid, cristal y 2C 00:31:02
aquí creamos 00:31:04
un objeto 00:31:05
liquid 00:31:09
cristal 00:31:14
y 2C 00:31:17
bien, esto es la definición 00:31:20
en C++ de dos constantes. Definimos dos constantes. La primera se llamaría trick, que albergaría 00:31:23
un valor de 3 y la segunda sería echo, que albergaría un valor de 4. A continuación 00:31:35
Creamos la función MedirDistanciaEnCentímetros. 00:31:41
La función devuelve un valor de tipo log, que es un valor decimal de gran tamaño. 00:31:57
A continuación, el disparo del sensor, que es el DigitalWrite, ya está puesto aquí 00:32:17
Entonces lo que hace es que el trigger, que es el que va a enviar la señal de ultrasonidos 00:32:22
En un principio lo pone a un valor de 0 y luego tras 2 microsegundos lo pone a un valor de 1 00:32:28
Lo veis aquí, el disparo del sensor serían estas tres líneas 00:32:34
Luego retrasa, esto sería para la ejecución o la pausa 10 microsegundos y a continuación 00:32:39
apaga el 00:32:59
le da 00:33:01
trigger 00:33:07
valor 00:33:13
de 0 voltios 00:33:15
lo que está haciendo aquí es que 00:33:17
lo está parando el trigger 00:33:21
solo queremos que envíe una señal 00:33:23
envíe en un principio 00:33:25
cuando se ha llamado este método 00:33:28
envíe una señal 00:33:29
el trigger y después 00:33:30
deje de enviarlas. 00:33:32
Ese trigger recibirá luego una señal de eco 00:33:34
cuando rebote en el objeto al que ha lanzado. 00:33:38
Aquí es la lectura del eco, ¿veis? 00:33:41
El eco ahora, como veremos aquí abajo, 00:33:43
en la definición de los pin mode, 00:33:48
el eco es una señal de entrada, 00:33:49
el trigger es una señal de salida. 00:33:51
El trigger es el que ha salido un valor de 1 00:33:53
y luego a los 10 microsegundos 00:33:57
ha dejado de enviar esa señal. 00:34:00
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. 00:34:02
A continuación, ha convertido esa duración o ese tiempo en microsegundos. 00:34:16
Esta es una fórmula que ya nos da el propio sensor. 00:34:21
Esto sería velocidad igual, perdón, espacio igual a velocidad por tiempo. 00:34:28
Fórmula física en la que la velocidad sería la duración, que hemos determinado, 00:34:39
que lo multiplica además por 0.04 00:34:43
que es la velocidad de sonido partido de 2 00:34:46
porque hay dos señales, una de salida y una de entrada 00:34:47
y luego retorna 00:34:49
esta función que una vez que hemos obtenido 00:34:51
el valor de la distancia 00:34:53
generado por ese trigger 00:34:54
lanzado y ese echo recibido 00:34:57
en una fracción de segundo 00:34:59
lo mete 00:35:02
en la variable de distancia que ya tiene un valor 00:35:04
de long y lo devuelve en la función 00:35:05
devuelve cuando ya esa función 00:35:07
sea llamada, medir distancia de centímetro 00:35:09
recibirá esa distancia 00:35:11
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. 00:35:13
Luego aquí tenemos los parámetros de configuración del LCD 00:35:38
En el que tenemos el init, que ya lo vimos, cómo se inicializa, cómo se enciende la luz 00:35:48
Después colocamos el cursor en la opción 00 o sea aquí 00:35:53
Y le imprime esta cadena 00:35:58
Después lo posiciona en el 01, que sería aquí, y pone inicializando 00:36:00
espera un segundo y medio 00:36:06
y luego limpia toda la pantalla 00:36:08
porque después en el loop 00:36:09
tiene que ir apareciendo la distancia 00:36:11
que está midiendo el sensor 00:36:12
esto lo va a realizar solo una vez 00:36:15
entonces aparecerá al principio 00:36:18
cuando le demos a ejecutar 00:36:19
y luego desaparecerá 00:36:20
y aparecerá ya lo que queremos 00:36:21
por último tenemos el loop 00:36:23
que tiene dos líneas 00:36:26
una primera línea es la de arriba 00:36:27
que sigue a la distancia 00:36:29
entonces al llamar al método 00:36:30
medir distancia en centímetros 00:36:32
o sea la función de arriba 00:36:33
está recibiendo la distancia que está creando este método. 00:36:34
Lo recibe con un valor log y luego lo que hace aquí 00:36:41
es que sitúa el cursor en el 00 otra vez aquí y le pone dist. 00:36:44
A continuación aquí tenemos una serie de condicionales, 00:36:53
este condicional que sería este de aquí, 00:36:57
en el que lo que nos va a medir es condicional que comprueba que la distancia esté entre 10 y 250 centímetros. 00:36:59
Si distancia es menor que 0 o mayor de 250, entonces imprime las cuatro rayitas. 00:37:28
seguido de centímetros. ¿Qué sucede si no? Si no es así, imprime la distancia. Esto lo va a hacer 00:38:01
¿Cuándo? Cuando sea un valor entre 10 y 250 centímetros. 00:38:26
A continuación pasamos a la línea 2, que es el estado por rangos. 00:38:53
Va a hacer lo mismo, ahora se sitúa en esta otra línea, con el SD aquí, 00:38:57
y después tenemos otro condicional, en el que ahora la distancia, 00:39:01
lo que nos va a medir es que, vamos a coger esto de aquí, 00:39:04
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. 00:39:08
Si la distancia es menor que 0 y mayor de 20, pues imprimirá el que muy cerca. 00:39:39
Bien, luego tenemos otro, el else, el else if, nos está diciendo si no, si esto no se cumple, 00:40:00
si el valor no está comprendido entre el valor entre 0 y 20, entonces comprueba otro condicional, 00:40:09
¿Qué sucede si ahora está entre 20 y 100? 00:40:15
Si está entre 20 y 100, pues que imprime distancia, ok. 00:40:22
Y si no cumple ninguno de los dos, si ya pasamos a este último else, 00:40:43
y ya no cumple ni el intervalo de 0 a 20, ni el de 20 a 100, nos dirá que está lejos. 00:40:48
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. 00:41:26
Idioma/s:
es
Materias:
Informática
Niveles educativos:
▼ Mostrar / ocultar niveles
  • Formación Profesional
    • Ciclo formativo de grado básico
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado medio
      • Primer Curso
      • Segundo Curso
    • Ciclo formativo de grado superior
      • Primer Curso
      • Segundo Curso
Autor/es:
Francisco José González Constanza
Subido por:
Francisco J. G.
Licencia:
Todos los derechos reservados
Visualizaciones:
5
Fecha:
16 de diciembre de 2025 - 9:47
Visibilidad:
Público
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
41′ 49″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
3.94

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid