Saltar navegación

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

Programa luces - 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 30 de enero de 2023 por Juan Luis C.

130 visualizaciones

Se codifica y prueba un algoritmo en C para el encendido creativo de las luces

Más información Transcripción

Descargar la transcripción

Bueno, tenemos ya nuestro circuito diseñado al que le hemos puesto un nombre adecuado, hemos realizado ya el algoritmo con nuestro idioma, con nuestro lenguaje para entendernos nosotros y ahora lo que nos queda es traducir ese algoritmo a un lenguaje de programación que entienda el ordenador, en este caso la placa de Arduino. 00:00:00
Así que vamos a ir al código, vamos a seleccionar el código de texto y vamos a ir haciendo nuestro programa y aprendiendo cómo se utiliza el lenguaje de programación C. 00:00:22
voy a hacerlo un poquito más grande para que se vea mejor 00:00:39
ahí está 00:00:41
bueno, por defecto nos aparece 00:00:44
un código que es el de blink 00:00:47
el de parpadear 00:00:49
y bueno, nos puede servir de ayuda para empezar 00:00:50
sobre todo al principio que no tenemos 00:00:53
mucha idea de programar en este lenguaje 00:00:54
yo voy a coger este código 00:00:57
y lo vamos a ir transformando 00:00:59
poco a poco ayudándonos de nuestro algodín 00:01:01
bueno, como comentario 00:01:03
le vamos a poner programa 00:01:05
para juego de luces. Bueno, a continuación, como tenemos 5 LEDs, vamos a crearnos 5 variables de tipo entero, indicando el pin al que tenemos cada LED conectado. 00:01:07
Por ejemplo, empezamos con el primer LED. En el principio le tenemos que decir el tipo de dato de nuestra variable, va a ser IN de entero, el nombre de nuestra variable, 00:01:25
led 1 y a continuación vamos a aprovechar esta línea y le vamos a asignar un valor nuestro 00:01:35
primer led está enchufado al pin 13 con el segundo haríamos lo mismo y led 2 y el segundo sería el 00:01:43
pin 12 y así con todos los leds aquí los tenemos todos para no es difícil verdad bueno a continuación 00:01:53
tenemos que configurar los pines como salida entonces ayudándonos de esta función que tenemos 00:02:03
aquí lo único que tenemos que hacer es cambiar este valor a cada una de nuestras variables así 00:02:11
que le vamos a ir poniendo led 1 copiamos la función aquí ponemos un 2 y así hasta completar 00:02:19
los cinco LEDs. Bueno, hasta aquí no hemos utilizado el algoritmo, porque realmente en los algoritmos 00:02:31
normalmente se ponen aquellas cosas que son un poquito más complicadas. Ahora sí que vamos a necesitar 00:02:37
nuestro algoritmo. Como voy a utilizar funciones de escritura y lectura, en lugar de borrar todo lo que tengo 00:02:42
dentro del loop, que es lo que se va a estar ejecutando todo el rato en Arduino, vamos a comentarlo 00:02:49
con un comentario de bloque. El comentario de bloque empieza con una barra inclinada y un asterisco. 00:02:55
fijaros como cambia el color 00:03:00
y terminan con un asterisco y una barra 00:03:01
entonces todo lo que esté entre esos símbolos es un comentario 00:03:05
fijaros que no es que quiera dejar este comentario 00:03:09
sino que lo dejo así de momento 00:03:12
porque luego voy a utilizar parte del código 00:03:13
y ahora sí que tenemos que hacer uso de nuestro algoritmo 00:03:16
entonces nos venimos para acá y vemos 00:03:22
que tenemos una variable espera 00:03:24
que no la hemos creado, la vamos a crear ahora 00:03:27
y luego tenemos tres procesos, secuencia1, secuencia2 y secuencia3, nos venimos aquí y nos creamos nuestra variable de espera 00:03:29
que va a ser también de tipo entero, así que int espera y le vamos a asignar un valor de 200, esto va a ser un tiempo de espera en milisegundos 00:03:41
Vamos a poner aquí un comentario en línea. Tiempo de espera en mil segundos. Bueno, como ahora vamos a estar programando y no necesitamos el circuito, vamos a hacer esto más grande para verlo mejor. Así. 00:03:54
Bueno, a continuación tenemos tres llamadas a tres procesos, secuencia 1, secuencia 2 y secuencia 3, nosotros las vamos a dejar puestas aquí, secuencia 1 que va a necesitar un parámetro, espera, secuencia 2 que va a necesitar el mismo parámetro y así con todas. 00:04:10
Aquí las tenemos 00:04:34
Ahora bien, si yo ejecutara esto, me va a dar un error 00:04:36
Vamos a hacerlo 00:04:40
Y de hecho aquí abajo, ya nos vamos acostumbrando 00:04:42
Nos da una pista de cuál es el error 00:04:46
Nos dice que secuencia 1 no está declarada en este código 00:04:48
Realmente estas funciones no existen 00:04:54
No forman parte del conjunto de funciones que nos deja Arduino 00:04:56
De hecho, si nos fuéramos a la referencia de Arduino 00:05:00
veríamos que están todas las demás funciones, la función setup, la función loop, la función pinMode, por ejemplo aquí tenemos pinMode 00:05:03
pero no vamos a encontrar nunca la función secuencia1, esa es una función que nosotros nos vamos a crear 00:05:13
¿Cómo nos creamos las funciones? Pues fijaros, aquí realmente ya nos dan pistas de cómo se tiene que crear 00:05:22
Aquí por ejemplo estamos utilizando una función 00:05:28
Y aquí también 00:05:30
Pero sin embargo la función setup es una función que nos estamos creando 00:05:31
Igual que la función loop 00:05:35
Vamos a hacernos una a modo de ejemplo 00:05:37
Lo primero que tenemos que hacer cuando nos creamos una función 00:05:40
Es decir el tipo de dato que devuelven 00:05:43
Hay funciones que devuelven cosas y otras que no 00:05:46
Por ejemplo si yo hiciera una función de sumar 00:05:48
Pues admitiría dos parámetros 00:05:51
Primer sumando y segundo sumando 00:05:52
Y me devolvería el resultado 00:05:54
Por ejemplo un entero 00:05:55
Pero hay otras funciones, como es este caso, en el que no devuelven nada. Hacen cosas pero no devuelven ningún valor. Si no devuelven ningún valor se emplea la palabra void. 00:05:57
Void significa que esa función no va a devolver nada. Va a hacer cosas pero no va a devolver nada. Así que empezamos por void, a continuación el nombre de la función y entre paréntesis los parámetros que necesita. 00:06:07
En este caso vamos a necesitar un parámetro. A la hora de definir los parámetros se definen como si fueran variables, ¿vale? Por lo tanto hay que decir el tipo de dato, en este caso va a ser entero, y el nombre del parámetro. 00:06:20
yo le voy a llamar lapso y por último abrimos llaves y cerramos llaves, todo el código de esta función va a ir entre esas llaves, aquí podemos poner un comentario 00:06:32
si no rellenamos el código ahora mismo de por ejemplo poner aquí el código, bien, si ahora ejecutamos lo que tenemos nos va a aparecer otro error 00:06:45
pero ya no nos aparece aquí el error de secuencia 1, sino el de secuencia 2, lo vemos, ¿no? Así que vamos a hacer lo mismo con el resto de las funciones. 00:06:59
Y para ello no voy a estar perdiendo el tiempo, directamente copio, pego y cambio el valor de 1 por 2 y en este otro caso el valor de 1 por 3. 00:07:07
Si ahora ejecutamos, pues vamos a ver que desaparecen los errores. Si es verdad que mi programa no va a estar haciendo nada porque tenemos las funciones vacías. 00:07:20
Ahora iremos rellenando e iremos viendo lo que hace, pero por lo menos ya no me da error. 00:07:31
Bueno, a continuación vamos a fijarnos en el algoritmo de secuencia 1 00:07:36
Así que nos venimos para acá, bajamos un poquito 00:07:43
Y aquí vemos que el algoritmo de secuencia 1 empieza apagando todos los LEDs 00:07:46
Si yo me vengo a la referencia de Arduino 00:07:53
No voy a encontrar ninguna función que me apague varios LEDs a la vez 00:07:56
Lo tenemos que hacer manualmente 00:08:00
entonces, aunque no hemos hecho un algoritmo específico para apagar todos 00:08:02
porque es muy fácil, es simplemente ir diciendo una a una apagar todos 00:08:07
aquí lo que tenemos que hacer es crearnos una función que apague todos los LEDs 00:08:10
como ya sabemos cómo se crean las funciones, nominamos el código 00:08:13
y voy a copiarlo, voy a ponerlo por aquí por ejemplo 00:08:17
y voy a llamarla a apagar todos 00:08:23
Y en este caso no necesitamos ningún parámetro, así que se queda vacía 00:08:29
Y lo que vamos a hacer es apagar uno a uno todos los LEDs 00:08:34
Para hacerlo vamos a utilizar este de aquí, de DigitalWrite, que lo teníamos comentado 00:08:37
Y donde aparece aquí pone el código, lo quitamos ya 00:08:43
Escribimos DigitalWrite, pero en lugar de poner el pin este por defecto 00:08:47
Ponemos nuestro pin LED1 00:08:53
Fijaros que todo el rato voy a estar copiando y pegando con tu programa 00:08:55
Que escribí a veces cosas, pero sobre todo se trata de ir cogiendo cosas que ya realmente tienes por ahí 00:09:00
O que ya están en la referencia y adaptándolas a tu programa 00:09:06
Ya nos hemos creado la función de apagar todos, pero eso sí, se me ha olvidado 00:09:10
Tengo que venir aquí y llamar a esa función 00:09:14
Para llamar a esa función, emplearía este código de aquí 00:09:17
Lo pongo por abajo y le pongo punto y coma 00:09:22
Bien, seguimos con nuestro algoritmo 00:09:25
Ahora tenemos que esperar ese tiempo, el lapso 00:09:28
Nuestro parámetro 00:09:32
Entonces, como ya tengo aquí una función de esperar 00:09:33
La voy a copiar 00:09:36
Y la voy a poner aquí debajo 00:09:39
Eso sí, donde pone 1000 tengo que poner mi parámetro 00:09:42
Y aquí en el comentario también lo vamos a poner así 00:09:47
Lo podemos traducir al castellano si queremos 00:09:50
Venimos otra vez a nuestro algoritmo 00:09:52
Y ahora vemos que encendemos el LED 1 00:09:54
Venimos aquí 00:09:55
Aquí tenemos una función para encender 00:09:57
DigitalWrite, ya está preparada 00:09:59
La copiamos aquí 00:10:01
Y lo único que cambiamos 00:10:03
El LED este de aquí 00:10:06
Por el LED 1 nuestro 00:10:08
Y bueno, si nos fijamos 00:10:10
Pues ya se va a estar repitiendo 00:10:12
Todo el rato lo mismo 00:10:14
Espero, apago, enciendo, espero 00:10:15
Enciendo, espero, enciendo 00:10:18
Pues vamos a hacerlo aquí, todas las veces 00:10:19
vamos a copiar estas dos cosas 00:10:22
otras cuatro veces más 00:10:24
una, dos, tres y cuatro 00:10:26
y vamos a cambiar los valores 00:10:29
por 00:10:30
los nuestros 00:10:32
de cada uno de los leds 00:10:33
bueno, ya tenemos la secuencia 1 00:10:36
en programación es 00:10:37
muy recomendable escribir un poquito 00:10:39
de código y probarlo 00:10:42
y según no vayan saliendo las cosas 00:10:43
pues vamos haciendo más código 00:10:46
así que vamos a probar esta primera 00:10:47
vamos a ver si funciona 00:10:49
Bueno, ahí está 00:10:50
Evidentemente como loop está repitiendo todo el rato 00:10:54
Pues todo el rato apagamos y vamos encendiendo de izquierda a derecha 00:10:57
Bien, como las funciones secuencia 2 y secuencia 3 00:11:01
Pues las tenemos vacías, no están haciendo nada 00:11:05
Bueno, vamos a detener la simulación 00:11:07
Y vamos a completar las funciones de la secuencia 2 y de la secuencia 3 00:11:08
Para eso nos venimos a nuestro algoritmo 00:11:14
Y ahora vemos que en la secuencia 2 00:11:16
Pues tenemos que encender todos los LEDs 00:11:20
Apagar, esperar, apagar, esperar 00:11:21
Pues nada, no venimos aquí 00:11:24
No tenemos la función de 00:11:25
Encender todos 00:11:28
Tenemos la de apagar todos, no la de encender 00:11:30
Entonces vamos a creárnosla 00:11:32
Para eso me voy a copiar esta de aquí 00:11:34
Vale, le voy a cambiar un poquito el nombre 00:11:36
En lugar de apagar todos 00:11:38
La voy a llamar encender todos 00:11:40
Y en lugar de ponerlo a nivel bajo 00:11:42
Tendré que ponerlo a nivel alto 00:11:46
veis que estoy todo el rato copiando código 00:11:48
como si fuera un juego de lego 00:11:51
cogiendo piezas y poniéndolas en el lugar adecuado 00:11:53
bueno, en este caso 00:11:56
el código se va a parecer mucho al de secuencia 1 00:11:58
pero cambiando cosas, así que para qué voy a escribir 00:12:00
me cojo este de aquí 00:12:02
lo pego 00:12:04
y cambio las cosas 00:12:06
en lugar de apagar todos 00:12:10
pues en nuestro caso era encender todos 00:12:12
en lugar de ponerlo a nivel alto 00:12:14
hay que ponerlo a nivel bajo 00:12:19
porque vamos a ir apagándolo 00:12:20
y si probamos esto 00:12:22
vamos a ver que no va a funcionar tal y como 00:12:31
nosotros queremos, vamos a probarlo 00:12:33
¿vale? porque 00:12:34
se están apagando de izquierda 00:12:39
a derecha y yo quiero de derecha a izquierda, claro 00:12:42
porque no me he dado cuenta cuando he copiado este código 00:12:44
de que en lugar de ser 1, 2, 3 00:12:46
4, 5, tiene que ser 00:12:48
4, 3 00:12:51
1, vamos a probarlo 00:12:55
ahora 00:12:58
Ahora sí 00:12:58
Bueno, y vamos con la última 00:13:02
Secuencia 3 00:13:05
Así que me vengo a mi algoritmo 00:13:07
Y veo que aquí apaga todos 00:13:08
Espera un tiempo, enciende todos 00:13:11
Y espera un tiempo 00:13:13
Venga, vamos a probarlo 00:13:15
Apaga todos 00:13:17
Voy a coger y lo voy a copiar 00:13:20
Que está en plan pago 00:13:21
Espera un tiempo 00:13:22
Copio y lo pego 00:13:27
Enciendo todos 00:13:34
y espero un tiempo 00:13:36
vamos a ver si ahora 00:13:42
quiere funcionar 00:13:51
bien, las dos primeras bien 00:13:52
y perfecto, un parpadeo 00:13:55
bueno, ya tenemos escrito 00:13:57
nuestro código, lo único que esto de aquí 00:13:58
este código que comentamos ya no lo necesitamos 00:14:01
así que lo vamos a limpiar por un poco 00:14:03
de higiene, de que no aparezcan en nuestro 00:14:04
programa cosas que no 00:14:07
se necesitan 00:14:08
y también os quiero mostrar la ventaja de utilizar 00:14:09
funciones, porque yo ahora 00:14:12
por ejemplo, si en lugar de parpadear 00:14:14
una vez cada secuencia, pues quiero que 00:14:16
parpadee dos veces 00:14:18
pues por ejemplo me puedo poner 00:14:20
otra función aquí 00:14:22
fijaros que sencillo, ¿no? 00:14:26
y ahora, antes de empezar 00:14:27
una nueva ronda 00:14:29
pues parpadea dos veces 00:14:31
bueno, y también 00:14:34
os quiero mostrar la ventaja 00:14:36
de utilizar variables, si yo quiero que esto vaya más rápido 00:14:38
pues aquí le cambio el tiempo, le pongo a la mitad 00:14:40
¿no? y automáticamente 00:14:42
todo va a ir más rápido, fijaros, con muy pocos 00:14:44
cambios, como consigo que el 00:14:46
programa funcione de otra manera distinta 00:14:48
bueno, pues nada 00:14:51
ánimo, aquí tenéis trabajo 00:14:52
os van a aparecer errores de compilación, tenéis que ir 00:14:54
viendo donde están los errores y corrigiéndolos 00:14:57
y poquito a poco, pues vamos a ir 00:14:59
cogiendo el truco a esto de la programación 00:15:01
y vamos a poder hacer cosas muy creativas 00:15:02
pues nada, chicos, ánimo 00:15:04
y a programar 00:15:06
Valoración:
  • 1
  • 2
  • 3
  • 4
  • 5
Eres el primero. Inicia sesión para valorar el vídeo.
Idioma/s:
es
Autor/es:
Juan Luis Carrillo Arroyo
Subido por:
Juan Luis C.
Licencia:
Reconocimiento - No comercial
Visualizaciones:
130
Fecha:
30 de enero de 2023 - 11:31
Visibilidad:
Público
Centro:
IES EL ALAMO
Duración:
15′ 09″
Relación de aspecto:
1.78:1
Resolución:
1920x1080 píxeles
Tamaño:
173.65 MBytes

Del mismo autor…

Ver más del mismo autor

EducaMadrid, Plataforma Educativa de la Comunidad de Madrid

Plataforma Educativa EducaMadrid