Saltar navegación

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

Sensor distancia 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.

2 visualizaciones

Sensor distancia arduíno

Más información Transcripción

Descargar la transcripción

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í. 00:00:05
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. 00:00:15
El HC-SSR04 es un sensor de distancia por ultrasonidos 00:00:26
muy utilizado en proyectos con Arduino, robótica y automatización 00:00:35
Su función es medir la distancia a un objeto sin contacto físico 00:00:39
utilizando ondas sonoras de alta frecuencia, o sea, ultrasonidos 00:00:42
imperceptibles para el oído humano 00:00:45
El rango típico de medición va entre 2 cm y 400 cm 00:00:48
Y la precisión aproximada es de más o menos 3 milímetros de error. 00:00:54
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. 00:01:00
¿Cómo funciona el sensor? 00:01:14
El sensor tiene dos transductores circulares. 00:01:18
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. 00:01:22
Luego el otro transductor, que sería este, el R, recibe el eco reflejado por el objeto. 00:01:41
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, 00:01:47
El sonido rebota en un objeto 00:02:09
Y el eco 00:02:12
Que sería la vuelta de ese sonido 00:02:14
Vuelve al sensor 00:02:16
Que sería el 00:02:18
Receiver, que sería el R 00:02:19
El que transmite sería el T 00:02:22
Y el que recibe sería el R 00:02:24
El pin eco 00:02:27
Que sería el otro pin que aparece aquí 00:02:28
Permanece en high durante el tiempo 00:02:30
Que tarda el sonido en ir y volver 00:02:32
Solo en ese 00:02:34
Intervalo de tiempo 00:02:37
En ir y volver 00:02:38
Arduino va a medir ese tiempo y calculará la distancia 00:02:39
¿Cómo la calcula? La distancia la calcula a través de una fórmula 00:02:42
que sería el tiempo por la velocidad del sonido, dividido entre dos 00:02:48
puesto que el divisor es debido porque el sonido tiene que recoger 00:02:51
tanto la ida como la vuelta, por eso lo divide entre dos 00:02:58
por lo tanto los pines del sensor son cuatro pines que sean el VCC 00:03:01
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. 00:03:06
Después tenemos el otro pin, que sería el eco, en el que sería la salida. 00:03:36
Cuando lo recibe, ha chocado contra el objeto y recibimos esos ultrasonidos, 00:03:39
por tanto, necesitamos un pin de salida. 00:03:43
Este pin de salida lo que va a hacer es que recogerá ese eco que va a recibir. 00:03:49
Y por último, es el último, que sería el GND, 00:03:56
que es para cerrar el circuito correctado a tierra o a cero voltios. 00:03:59
por tanto este es el transmisor y este es el receptor 00:04:02
vamos a ver el circuito 00:04:06
vamos a quitar esto 00:04:11
y este sería el circuito 00:04:12
si nosotros le damos, este es el código que aparece aquí que luego explicaré 00:04:14
y lo vamos a hacer poco a poco 00:04:17
cuando le damos a simular 00:04:19
y cerramos el código 00:04:20
si yo selecciono el sensor de ultrasonidos 00:04:23
veis que aquí aparece un círculo verde 00:04:29
que es lo que nosotros podemos modificar, él va a ir detectando distintas distancias 00:04:31
en función de cómo lo hallamos, dónde está el obstáculo. 00:04:37
Esto sería el obstáculo en el que el que transmite ultrasonido llega hasta el obstáculo 00:04:41
y rebota y lo recoge el receptor, que sería este, a través del eco. 00:04:45
Veis aquí que está midiendo 90,2 centímetros, el código lo he hecho con el monitor en serie 00:04:50
para que detectemos la distancia a la que está el objeto. 00:04:55
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. 00:05:00
Siempre hay un intervalo de error entre la medición, pero es un error muy pequeño. 00:05:13
Bien, vamos a hacer el circuito y vamos a explicar el código. 00:05:21
Por lo tanto, cogemos un nuevo elemento, creamos un nuevo proyecto y vamos a ir un poquito deprisa para ponerlo. 00:05:28
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í. 00:05:41
Bien, vamos a conectar primero la alimentación, el VCC, con 5 voltios, como siempre. 00:05:54
Lo ponemos de color rojo. 00:06:02
A continuación cogemos el GND y lo vamos a unir con el de arriba. 00:06:05
Y con esto ya tendríamos cerrado el circuito. 00:06:13
Lo ponemos de color negro. 00:06:15
Y lo único que nos quedaría son el trigger y el eco. 00:06:18
El trigger lo tenemos que conectar a un pin. 00:06:20
Que lo vamos a poner concretamente al pin 2. 00:06:24
Lo vamos a poner de color verde. 00:06:32
y luego el 00:06:34
el eco lo vamos a conectar con el pin 3 00:06:37
para diferenciarlos el eco lo vamos a poner de color azul 00:06:41
y el trigger de color verde 00:06:50
ya estaría el circuito y lo único que nos quedaría es el código 00:06:55
vamos a poner texto y le damos a continuar 00:06:59
y borramos estas dos líneas 00:07:02
y estas 00:07:04
bien, ya tenemos las conexiones 00:07:07
hemos puesto el trigger al 2 y el eco al pin 3. Hemos dicho que el trigger se configura 00:07:11
como una salida, puesto que le tiene que enviar al trigger un valor de un 1 para que el sensor 00:07:23
envíe la señal de ultrasonidos hacia el objeto. Después el eco va a rebotar en el objeto 00:07:31
y obtendremos la vuelta del sonido 00:07:40
entonces el eco se va a encargar 00:07:45
será un pin de lectura 00:07:48
y leerá si le ha llegado señal o no 00:07:50
bien, por lo tanto el trigger se configurará de salida 00:07:53
y el eco se configurará como entrada 00:08:00
lo primero vamos a generar dos variables 00:08:03
acordaos, en C++ se podían definir dos variables 00:08:05
a través de estas dos líneas con define 00:08:08
Define en el que vamos a poner que trig sea el 2 y define el echo que sería el 3. 00:08:12
Bien, ya tenemos las dos constantes que serían estas dos. 00:08:26
Donde yo ponga trig supone que es un 2 y donde ponga yo echo se hace suponer que es un 3. 00:08:29
Bien, vamos a la configuración inicial que se realizaría en el setup, 00:08:36
en aquel método en el que se lee una única vez. 00:08:40
vamos a configurar los pines, habrá un pin de entrada y un pin de salida 00:08:42
el pin de entrada y el pin de salida 00:08:46
el pin de trig, que sería concretamente el 2 00:08:51
ese le vamos a hacer de, lo hemos dicho, de salida, entonces sería output 00:09:02
mientras que el pin echo, que sería el 3 00:09:05
será un pin de entrada, input 00:09:12
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. 00:09:15
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, 00:09:39
donde vamos a hacer que se ponga el trig en un valor bajo, low o cero 00:09:58
para que se estabilice el sensor 00:10:06
después envía un pulso high de 10 microsegundos 00:10:08
va a ser una cantidad de tiempo muy pequeña 00:10:12
o sea primero dejamos que la señal del trig sea cero 00:10:15
se estabiliza y después mandamos una señal de ultrasonidos durante 10 microsegundos únicamente 00:10:21
esos 10 microsegundos llegaran hasta el objeto 00:10:27
el sensor emite el ultrasonido durante esos 10 microsegundos 00:10:29
y Arduino lo que va a hacer es que cuando rebote y llegue al eco 00:10:34
va a medir el eco con una función o un método que se llama pulseIn 00:10:38
se calcula la distancia en centímetros 00:10:43
ya hemos visto que la distancia era 00:10:46
la distancia era, vamos a ponerla aquí 00:10:48
para medir la distancia 00:10:51
se va a realizar así 00:10:58
distancia 00:11:02
es igual 00:11:03
a duración 00:11:06
por 00:11:11
0,034 00:11:15
que sería aproximadamente 00:11:19
la velocidad del sonido 00:11:20
partido de 2 puesto que hay 00:11:22
un camino de ida y uno de vuelta 00:11:24
0,034 00:11:26
serían concretamente centímetros 00:11:28
por microsegundo 00:11:30
que es la velocidad de sonido del aire 00:11:32
¿Qué ocurre físicamente cuando el circuito está funcionando? 00:11:34
Pues cada vez que el Arduino envía un pulso al sensor 00:11:38
Este emite un sonido ultrasonico 00:11:43
Este sonido rebota en el objeto que tiene delante y vuelve al sensor 00:11:45
Ya lo vimos, a través del T, traductor T, emisión, traductor R, receptor 00:11:49
Midiendo el tiempo que tarda en regresar esa señal de otro sonido desde que va hasta que viene 00:11:58
y eso se realiza a través de esta fórmula que aparece aquí 00:12:04
y esta es la que vamos a medir 00:12:07
bien, vamos por tanto a crear una variable 00:12:09
y lo vamos a poner aquí 00:12:17
primero en el loop vamos a crear dos variables 00:12:20
concretamente una sería de tipo long 00:12:26
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. 00:12:29
El long lo vamos a llamar duración 00:12:50
Y luego vamos a poner otro tipo long que sería distancia 00:12:54
Vale, una vez que hemos creado estas dos variables 00:13:02
Aquí, ¿qué vamos a hacer? 00:13:08
Primero, hemos dicho que íbamos a lanzar desde el trigger un valor bajo 00:13:12
Para estabilizar el sensor 00:13:16
Y vamos a poner digital 00:13:17
acordaos, write 00:13:26
para escribir un valor 00:13:28
en un determinado pin 00:13:30
como el trigger es un pin de salida 00:13:32
en trigger 00:13:35
le vamos a dar un valor 00:13:36
primero de 0, entonces vamos a poner un valor 00:13:38
de 0 o de low, podríamos haber puesto ahí también 00:13:40
bien, posteriormente 00:13:43
vamos a leer 00:13:44
el tiempo 00:13:47
del echo 00:13:51
bueno, primero vamos 00:13:52
antes del echo 00:13:55
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. 00:13:57
Acordaos, aquí ahora estamos diciéndole que durante 10 microsegundos envíe un pulso, enviar pulso durante 10 microsegundos. 00:14:22
Pero para ello, aquí hemos estabilizado, para enviar un pulso durante 10 microsegundos tenemos que decirle digital write, ahora trig, trig 1. 00:14:47
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. 00:15:10
digital write 00:15:24
trig 00:15:25
vamos a separarlo 00:15:32
para que se vea mejor, aquí tenemos la variable 00:15:34
de tipo long 00:15:36
vale, aquí tenemos 00:15:38
vamos a separarlo 00:15:47
para que quede muchísimo mejor 00:15:49
estabilizar el sensor y 00:15:50
primero aquí sería estabilizar el sensor 00:15:52
y luego tendríamos aquí esta otra parte 00:15:54
hemos hecho 00:15:57
vamos a ver 00:16:02
creamos 00:16:03
Tenemos dos variables de tipo long, que sería de tipo de 32 bits. 00:16:07
Bien, en la primera fase lo que hemos es creado dos variables, una que es a maturación y otra que es a distancia. 00:16:20
Son de tipo long. Esto es un rango de valores bastante alto, de valores decimales, de 32 bits. 00:16:25
Perdón, de valores enteros de 32 bits. 00:16:31
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. 00:16:35
Estamos hablando de valores que van desde menos 2.147 millones a más 2.147 millones. 00:16:57
Ese es el rango para que podría alojar esta variable, pero que aloja valores enteros, de tipo long, enteros. 00:17:06
Bien, posteriormente estabilizamos el sensor, lo he explicado antes. 00:17:14
Primero le decimos que le pase al trigger, que era el pin 2, le pase un valor de 0. 00:17:18
Con eso establecemos el sensor y posteriormente enviamos un pulso de 10 microsegundos. 00:17:26
¿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 00:17:33
y aquí nos ha faltado que haya un intervalo entre, vamos a copiarlo aquí, 2 microsegundos. 00:17:41
estabilizamos el sensor 00:17:55
que es, le enviamos desde el pin 2 00:17:58
o sea, hacia el trig 00:18:00
le enviamos un valor de 0 00:18:01
con eso estabilizamos el sensor 00:18:03
¿cuánto? 00:18:05
delay microseconds es un método 00:18:06
que nos va a paralizar la ejecución 00:18:07
o la pausa 00:18:10
durante un determinado tiempo 00:18:11
acordaos que ya utilizamos delay 00:18:13
y delay era en milisegundos 00:18:14
ahora, delay microseconds es en microsegundos 00:18:16
o sea, cantidades muy muy pequeñas 00:18:19
y le estamos diciendo que 00:18:21
tenga un 0 durante 2 microsegundos 00:18:22
o sea que durante los 2 microsegundos 00:18:25
le hemos enviado un 0 00:18:27
para que establece el sensor 00:18:28
posteriormente una vez que han pasado 00:18:30
esos 2 microsegundos 00:18:33
le enviamos ahora a TRIG un valor de 1 00:18:34
con lo cual está activando el valor 00:18:37
de TRIG para que envíe 00:18:39
un pulso 00:18:40
de ultrasonidos 00:18:43
¿cuánto tiempo vamos a enviar ese pulso de ultrasonidos? 00:18:44
aquí tendríamos 00:18:48
que en un principio 00:18:48
con el valor de 0 00:18:51
hacia TRIG 00:18:53
le estamos diciendo que estabilice durante 2 microsegundos 00:18:54
el sensor 00:18:57
posteriormente una vez que han pasado esos 2 microsegundos 00:18:58
lo que hacemos es que ahora le mandamos a TRIG 00:19:01
le mandamos a través de DigitalWrite 00:19:03
le mandamos un 1 o un HIGH 00:19:05
lo que hace que 00:19:07
este trigger funcione 00:19:09
y haga que el sensor envíe una señal 00:19:11
de ultrasonidos, pero ¿cuánto tiempo lo vamos a hacer? 00:19:13
durante 10 microsegundos 00:19:15
te fijas aquí, 10 microsegundos 00:19:17
porque le estamos diciendo que 00:19:19
este valor de 1 se lo proporcione durante 00:19:21
10 microsegundos 00:19:23
una vez que hayan pasado esos 10 microsegundos 00:19:24
ya habrían pasado 12 porque había 2 de estabilización 00:19:26
en 0 y 10 con un valor de 1 00:19:29
cuando haya llegado a 12 microsegundos 00:19:31
sensor deja de emitir 00:19:34
la señal de ultrasonidos 00:19:37
ahora lo único que nos interesa 00:19:39
y porque lo deja de transmitir 00:19:41
porque le hemos puesto aquí después de esos 10 microsegundos 00:19:43
que le ponga otra vez el valor de trig 00:19:45
a un valor 0 00:19:47
entonces ahora que nos quedaría 00:19:48
no nos quedaría nada más que recoger 00:19:50
el valor del eco 00:19:53
o sea el rebote 00:19:55
de la señal, aquí han pasado ya 00:19:56
los 10 microsegundos, al ponerle un 0 00:19:59
en trig, estas líneas desaparecen 00:20:00
ya no hay pulso de salida, ahora lo único 00:20:03
que nos quedaría es recoger 00:20:05
cuando haya rebotado con el objeto 00:20:06
el pulso de llegada que sería 00:20:08
el eco, y el eco es un pin 00:20:11
de entrada en el que lo que va a recoger 00:20:12
es ese pulso a través 00:20:14
de este pin, eso se va a realizar 00:20:16
a través de una función que se llama 00:20:19
pulseIn, vamos a leer el tiempo del eco 00:20:20
y lo ponemos aquí debajo 00:20:22
vale 00:20:24
lo primero que vamos a hacer 00:20:26
es, hemos utilizado una variable 00:20:29
que se llama duración 00:20:30
y en esa variable de tipo long vamos a recoger 00:20:31
lo que venga 00:20:35
el pulso que venga rebotado 00:20:36
eso se hace con una función que se llama 00:20:38
pulseIn 00:20:40
que 00:20:41
tiene dos parámetros, uno sería el eco 00:20:44
lógicamente 00:20:47
y le estamos diciendo, oye ponme 00:20:49
en el eco un 1, ahora 00:20:51
el eco al activar este pin 00:20:53
con un 1 00:20:55
le estamos diciendo que recoja ese pulso 00:20:56
que va a venir rebotado 00:20:59
del objeto, bien una vez que 00:21:01
hemos leído el eco 00:21:03
nos quedaría ahora calcular la distancia 00:21:04
calcular 00:21:07
distancia 00:21:10
en centímetros y eso tenemos otra variable de tipo long que hemos definido arriba que se llama 00:21:12
distancia y donde vamos a recoger la fórmula que hemos puesto aquí esta sería la fórmula de que 00:21:18
nos va a permitir calcular la distancia que ha recorrido ya lo he explicado anteriormente 00:21:26
distancia o espacio es igual a velocidad por tiempo eso es una fórmula básica en física 00:21:31
espacio es igual a velocidad por tiempo por tanto esta sería la la fórmula que 00:21:38
podemos aplicar entonces lo que tenemos que poner aquí primero la velocidad 00:21:49
hemos dicho que la velocidad era centímetros por microsegundo y que 00:21:52
aproximadamente tiene un valor de 0.034 eso es una constante nada más que 00:21:57
puedes saber que es esta y por la duración lo que ha durado o sea por el 00:22:00
tiempo, veis esta es la velocidad por el tiempo y la duración que es lo que ha durado entre que 00:22:05
se envió el pulso y vino, claro hay que dividirlo entre dos porque es una de llamada y una de vuelta 00:22:11
o sea una de ida y una vuelta por eso dividimos la mitad para dividir porque este recorrido si 00:22:17
no pusiéramos dividido entre dos tendríamos que mediríamos la distancia que hay de aquí a aquí 00:22:24
y luego la que hay de aquí a aquí que sería el doble de lo que queremos medir porque nosotros 00:22:29
queremos saber qué distancia hay entre el sensor y el objeto por eso se divide entre dos una vez 00:22:33
que tenemos calculada la distancia que sería este de aquí y que nos quedaría ahora mostrar 00:22:39
el resultado donde vamos a mostrar el resultado en el monitor en serie mostrar un resultado el 00:22:45
monitor en serie era serial el objeto serial y para imprimir el monitor se utilizaba un método 00:22:54
que se llama print el print vamos a poner en principio vamos a poner en distancia distancia 00:23:02
la cadena distancia con un espacio y esto lo vamos a copiar y puesto que vamos a poner tanto 00:23:13
el valor de la distancia copiar y copiar después de distancia tendríamos que queremos que imprima 00:23:21
la variable distancia 00:23:37
que es la variable que hemos 00:23:38
calculado aquí 00:23:41
o sea que imprimiría distancia dos puntos 00:23:42
espacio, luego el valor de la distancia que ha calculado 00:23:45
y por último nos pondría 00:23:47
los centímetros para que 00:23:49
pongamos unidades a esa distancia 00:23:51
dejamos un espacio y ponemos centímetros 00:23:53
y con esto tendríamos 00:23:55
solo nos faltaría poner 00:23:57
aquí 00:23:59
como este método se está repitiendo 00:23:59
infinitas veces 00:24:03
vamos a hacer que eso lo realice cada un cierto tiempo. 00:24:05
Entonces le vamos a poner un delay para que pause la ejecución 00:24:10
cada, por ejemplo, 300 milisegundos. 00:24:13
Y ya estaría el circuito. Vamos a ver si funciona. 00:24:20
Vamos a darle aquí a Iniciar simulación 00:24:24
y nos dice que hay un error. 00:24:27
Dice que la directiva está mal porque he puesto aquí, 00:24:33
si veis, no he puesto define, lo he escrito mal 00:24:36
ahora estaría bien, le damos a ejecutar 00:24:40
y vemos que funciona perfectamente 00:24:45
vamos a poner el esquema aquí 00:24:47
y vamos a seleccionar la distancia 00:24:51
si vamos al monitor en serie, vemos que distancia 00:24:55
pero veis, me lo está poniendo 00:24:59
me lo está poniendo todo de seguido en la misma línea 00:25:01
y yo quiero que aparezca en vertical 00:25:05
que haya un retorno de carro por cada vez que la pone 00:25:07
entonces vamos a pararlo 00:25:11
y aquí serial tiene un método que se llama print 00:25:12
pero tiene otro método que se llama println 00:25:16
ln es que además de imprimir centímetros 00:25:19
luego genera un retorno de carro que iría a la siguiente línea 00:25:23
con eso evitamos que aparezcan todos así 00:25:27
le damos a ejecutar y ahora vamos viendo que nos sale los 112 centímetros 00:25:29
siempre hay un pequeño intervalo de error entre lo que sale aquí y la medida del sensor 00:25:37
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 00:25:43
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:
2
Fecha:
16 de diciembre de 2025 - 9:19
Visibilidad:
Público
Centro:
IES CIFP a Distancia Ignacio Ellacuría
Duración:
26′ 01″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
611.95 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid