En esta clase podrás:
Familiarizarse con el Control de Flujo de Facilino, así como la interfaz de programación de Facilino y su configuración.
Hola, soy Leopoldo Armesto y en este vídeo os vamos a enseñar
el uso de las instrucciones de control de flujo en Facilino.
Mirad, las instrucciones de control de flujo permiten gobernar
la forma en la que nuestro programa se va a ejecutar de forma
que vamos a poder realizar iteraciones de forma repetitiva,
es decir, bucles, y mirar la forma en la que estos bucles
se tienen que ir ejecutando. Vamos a poder evaluar determinadas
condiciones para que determinarán el número interacciones
que debemos ejecutar un conjunto de instrucciones. También
vamos a ver instrucciones que tienen que ver con
instrucciones condicionales, es decir, que sí se cumple una determinada
condición debe ejecutarse una parte de código, y si no se cumple
esa condición, debería ejecutarse otra parte de código.
Y finalmente vamos a ver un conjunto instituciones que tienen
que ver, por lo general, con lo que sería esperas, vale, de lo
que sería el flujo del programa de arduido, vale. Mirad,
las instrucciones de control de flujo las tenéis aquí la
categoría control, vale, y tenemos diferentes tipos de instrucciones,
vale. Tenemos unas instrucciones que tienen que ver con
bucles, en este caso es un bucle while, o también tenemos
la condición until, en la que mientras se cumpla una condición
o hasta que se cumpla una condición vamos a hacer lo que las
instrucciones que vamos a agregar aquí dentro, también tenemos
el típico, el tradicional bucle for, de forma que vamos
a iterar con una variable desde un valor hasta otro y ejecutar
esto una cantidad de veces; esta instrucción de aquí nos va
a permitir interrumpir las instrucciones de bucle, es decir,
tiene que utilizarse dentro de este tipo de instrucciones de
forma que nos va a permitir si, a lo mejor, por ejemplo,
se cumple una determinada condición, queremos interrumpir
las iteraciones a partir de ese momento, no queremos seguir
iterando, entonces podremos utilizar esta instrucción. O si
por el contrario si lo que queremos hacer es saltar a la siguiente
iteración también podemos utilizar esta instrucción pero
con su variante que es la del continúa al desplegar aquí este
menú lo veréis. Bueno, otro tipo de instrucciones
que hemos dicho que tenemos aquí es del tipo condicionales,
es decir, if, de forma que si se cumple una condición ejecutamos
una parte de código pero además vamos a poder agregar diferentes
tipos de condiciones de forma que si esto no se cumple pero
se cumple otra condición, pues entonces podemos ejecutar
otra parte de código o al final en caso contrario ejecutar por
defecto otra parte de código, vale, todo esto vamos a poder
modificar con el montador de esta instrucción. Después tenemos
esta instrucción de aquí es..., debería estar siempre
en nuestro programa para poder meter partes de..., o bloques
de código dentro de lo que serían las funciones de setup
y de loop de arduino de forma que todo lo que queramos que
se ejecute al inicio al arrancar nuestro programa arduino debería
ir aquí, mientras que lo que queremos que se ejecute de
forma interactiva debería ir aquí dentro, vale. Esta instrucción
normalmente la vais a tener en todos los programas. Luego aquí
tenemos esta que es muy, muy similar a esta, la diferencia está
en que lo que hace es que primer ejecuta el código y después
evalúa la condición, vale, luego ya pasaríamos a lo que serían
instrucciones que tienen que ver con esperas de tiempos,
vale, y entonces tenemos aquí esta condición que simplemente
nos va vamos a poner aquí un número y esperar una cantidad
de tiempo en milisegundos, tenemos estas instrucciones para
medir el tiempo del reloj de arduino desde el
arranque, desde el inicio, ya sea en microsegundos o milisegundos
en este caso, o tenemos también por ejemplo instrucciones que
lo que hacen es que esperan hasta que el valor este de aquí,
el valor 1, sea igual al valor 2 ó bueno, también tenemos
aquí diferentes condiciones sea diferente, mayor o igual, etcétera.
Vale, entonces vamos a ver algunos de los ejemplos que tengo
preparados aquí para vosotros de forma que..., vamos a empezar
con este primer ejemplo; mira, el objetivo de este primer ejemplo
es ir apretando el botón hasta que se va generando número
aleatorio de forma que hasta que ese número aleatorio supera
el valor 15 pues entonces en ese caso dejaríamos
de requerir, apretar el botón, vale. Para ello lo que estamos
haciendo, fijaos, es hemos declarado una variable de tipo
número, hemos inicializado a cero y estamos haciendo una instrucción
del tipo while, de forma que si el número es menor que 15, en
la primera iteración esto va a ser cierto, por tanto, continua
y ejecuta lo que hay dentro, vale. Entonces lo que va a hacer
es mostrar por con solo un mensaje esperar a que el botón
esté en estado bajo, quiere decir, que lo apretamos, después
esperamos un tiempo esto normalmente es conveniente para el tema
de rebotes, vale, para evitar los rebotes de la señal en los botones
y esperamos de nuevo a que esté en estado alto para asegurarnos
de que realmente lo hemos soltado, vale, y volvemos a esperar.
Entonces, aquí ahora preparándonos para la siguiente iteración,
lo que hacemos es generar el número aleatorio, entre 1 y 20,
en este caso, por ejemplo, y mostramos el valor del número, vale.
Entonces esto se va a ir repitiendo mientras el número generado
sea menor que 15, vale, bueno pues vamos a
a programar este código en arduino y vamos a pasar la
cámara cenital y os muestro lo que tengo.
Montado simplemente es, pues como veis en el código, pues
nada, un botón, que es lo único que necesitamos aquí, conectado
al pin 2 de la entrada de arduino, vale, vamos a pasar de nuevo
a la interfaz de Facilino y os vamos a mostrar lo que
este programa realiza, vale, de forma que al arrancar nos
pide que aprobemos el botón, y, bueno, pues en este caso el número
ha sido 5, 10, 3, hasta que sea mayor que 15, vale.
y entonces en ese momento ya, por más que aprendemos, ya ha salido
del bucle, vale. Bien, vamos a ver un segundo ejemplo,
vale en este caso, en este ejemplo, lo que vamos a hacer es generar
de nuevo en este caso 20 números aleatorios vale, estamos
haciendo un bucle for desde 1 hasta 20 con una variable
que es la que estamos utilizando para iterar, vale, la tenemos
que declarar primero, y utilizamos esta variable para iterar
desde 1 hasta 20, el número de iteraciones que queramos
realizar, vale. Entonces lo que hacemos es que estamos generando
un número aleatorio que representa una temperatura ficticia,
vale, de forma que esta temperatura pues en principio
debe estar comprendida entre 5 y 40 grados, entonces,
si la temperatura es mayor que 30, entonces mostramos que
la temperatura es muy elevada; si la temperatura es menor que
10, mostramos que la temperatura es demasiado fría, y si no
decimos que esta perfecta y que nos encanta estar en ese grado
de temperatura. Entonces, mirad, para este if y poder crear estas
estructuras vosotros cuando lo arrastráis por primera vez,
vale, tiene este aspecto, sin embargo, fijaos que la instrucción
aquí aparece el if, y aparece un else if y un else. Esto lo conseguimos
a base de agregar condiciones aquí con
el mutador de la instrucción, vale, de forma que podemos agregar
tantos casos como queramos, vale. Bien, entonces, vamos a a programar
este ejemplo, vale, aquí no necesitamos botón, vale, así
que directamente vamos a ver el resultado en la interfaz del
del monitor serie de facilino,
un segundo que acaba de programarse,
vale, ya lo tenemos, entonces, nada, pues simplemente vamos a generar
veinte temperaturas y como veis de esos números aleatorios
pues bueno, hemos ido mostrando diferentes valores de temperaturas y
entonces todos aquellos que están comprendidos entre 10,
decíamos y 30, pues pone perfect, si está por encima
de 30 dice que es demasiado caliente y si está por debajo
10 dice que es demasiado frío, vale, que es un poco la condición
que queríamos hacer, simplemente es aquí mostrar que hemos hecho
este bucle 20 veces, vale. Entonces ya, para finalizar, vamos
a simplemente mostramos un tercer ejemplo que es bastante sencillo,
de forma que bueno, aquí lo que estamos haciendo es un while
de nuevo, pero lo estamos haciendo al revés, es decir, aquí
siempre se va a ejecutar esta parte primero y luego vamos a
evaluar la condición. Aquí en este caso lo que estamos haciendo
es declarar una variable y entonces lo que hacemos es incrementar
en cada una de estas interacciones el valor de la variable.
Entonces, mientras el valor de esa variable sea menor que 5,
pues entonces estamos bien y seguimos repitiendo esto, vale.
Aquí concretamente lo único que estamos haciendo es hacer que
el led parpadee, entonces, en este programa lo que va a hacer
es que el led va a estar encendido 500 milisegundos y
apagado otros 500 milisegundos, vale. Y aquí estamos esperando
como podéis ver para poder generar o interrumpir el control
de flujo de este programa. Pues nada, de nuevo lo vamos a programar
y vais a ver que este programa nada más arrancar lo que va a hacer
es hacer parpadear el led 5 segundos o 5 veces, perdón.
Un segundo.
Vale, ya lo tenemos, perdón, vamos a pasar a cámara cenital,
eso es, entonces, yo voy a apretar y el led lo tenemos aquí,
vale, y va a encenderse 5 veces: una
dos, tres, cuatro y cinco, ahí lo tenéis, vale. Y a partir de ahí
ha interrumpido la iteración. Vale, pues nada, simplemente en este
vídeo lo que hemos enseñado es el uso de lo que sería las
instrucciones de flujo y nos vemos en el siguiente vídeo. Muchas gracias.