Untitled

Tema 1. Placa Controladora. Componentes Digitales y Analógicos.
Sensores y
actuadores 3
1.1. Introducción y objetivos 3
1.2. La placa controladora 3
1.3. Sensores y actuadores 7
1.4. Componentes digitales y analógicos. Placa Zum Core 8
1.5. Primeros pasos con Bitbloq 12
1.6. Cómo programar la placa controladora con Bitbloq 19
1.7. Nuestro primer reto: ¡Hola mundo! 22
Tema 2. Programación I: Condicionales y Bucles 27

2.2. Las sentencias condicionales 27
2.3. Encender un LED al pulsar un botón 29
2.4. Lámpara nocturna con sensor de luz 31
2.5. Algoritmos y diagramas de flujo 33
2.6. El bucle Repetir 35
2.7. El bucle Mientras (While) 36
2.8. Mostrar valores por monitor puerto serie 38
Tema 3. Programación II: Variables y funciones 42

3.2. Las variables 42
3.3. Las funciones 45
Tema 4. Programación III: Máquinas de Estados y Bloques Avanzados 51

4.2. Máquinas de estados 51
4.3. Bloques avanzados. Melodías avanzadas 57
4.4. Bloques avanzados. El bucle Contar (For) 59
4.5. Bloques avanzados. Mapear 60
4.6. Bloques avanzados. Obtener tiempo de ejecución 64
4.7. Bloques avanzados. Condicionales compuestos 68
4.8. Bloques avanzados. Funciones con argumentos 74
Referencias bibliográficas 80
Anexo I. Preguntas frecuentes Bitbloq 81
RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Tema 1. Placa Controladora. Componentes Digitales y
Analógicos. Sensores y actuadores
1.1. Introducción y objetivos
En este tema conoceremos qué es una placa controladora y cuáles son sus partes
principales, así como los tipos de componentes que podremos conectarle. Además,
aprenderemos cómo empezar a programarla y la herramienta de programación que
utilizaremos a lo largo de todo el curso.
Los objetivos que se pretenden conseguir son:
▶ Conocer los elementos fundamentales de una placa controladora.

▶ Aprender a diferenciar entre sensores y actuadores.
▶ Conocer los componentes que acompañan a la placa Zum Core.
▶ Aprender a diferenciar entre digital y analógico.
▶ Aprender a programar una placa controladora.
▶ Conocer la herramienta Bitbloq, cómo instalar los drivers y registrarte.
▶ Empezar a programar la placa controladora.
1.2. La placa controladora
Una placa controladora es un dispositivo que almacena un programa y que,

mediante periféricos de entrada y salida, interactúa con el entorno que la rodea.
La placa recibe información del entorno a través de los sensores que se le conectan,
tal como hacen nuestros sentidos. A su vez actúa sobre su entorno mediante los
actuadores. Ambos componentes se conectan a la placa controladora a través de

sus pines o conectores. Estos pines o conectores son las entradas y salidas de casi
toda la información que pasa por la placa.
Figura 1. Esquema flujo de información en la placa controladora.
El elemento fundamental de una placa controladora es el microcontrolador. Es el

encargado de controlar el sistema, como un cerebro. El microcontrolador (o
simplemente micro) es el circuito integrado más importante y complejo de un
sistema informático. Es un elemento programable, capaz de realizar operaciones
matemáticas a una velocidad extraordinaria.
Figura 2. Detalle del microcontrolador.
Para que el microcontrolador pueda leer la información de los sensores y actuar a

través de los actuadores, debemos darle una serie de órdenes, es decir,
programarlo. Un programa es una serie de instrucciones que definen el
comportamiento de la placa controladora. Ésta obtiene información a través de los
sensores y realiza las acciones dictadas por el programa en función de dicha
información.

En este curso vamos a trabajar con la placa controladora Zum Core, la cual está
basada en la tecnología Arduino, habiendo sido adaptada para su uso educativo.
La familia electrónica Arduino conforma un proyecto libre, cuyo objetivo es el de

democratizar el uso y aprendizaje de la electrónica, haciéndola accesible a cualquier
persona, independientemente de sus conocimientos previos.
Arduino(™) es además una marca registrada de electrónica libre, creada por la

empresa Arduino en 2004. Utilizando microprocesadores de la marca Atmel crearon
varios modelos de placas controladoras muy fáciles de programar gracias al entorno
de desarrollo creado por la misma empresa y conocido como ArduinoIDE. Muy
rápidamente se creó una vasta comunidad de usuarios, formada por cientos de
miles de personas, que contribuyeron al proyecto creando bibliotecas para trabajar
con una gran variedad de periféricos.
Por su naturaleza libre (diseñado para que cualquiera pueda usarlo, entenderlo,
aprender de él, modificarlo y redistribuirlo) surgieron además empresas que
realizaron modificaciones a las placas, adaptándolas a otras necesidades y creando
nuevos periféricos que pudieran usarse con ellas.
Esta proliferación de usuarios y empresas es la que ha conseguido que la familia

Arduino sea la más extendida en el mundo educativo, así como el conocido como
DIY (Do it yourself o Hazlo tú mismo).
Por todo ello, para trabajar en este curso la robótica y la programación, utilizaremos
el kit Zum Kit Advanced, que está adaptado para Secundaria, teniendo la placa y los
componentes electrónicos visibles (no encapsulados) y adaptados para una
conexión mediante pines.

Placa Zum Core
La placa Zum Core posee 20 pines de entrada o salida distribuidos entre pines
digitales y pines analógicos. Más adelante veremos el tipo de componentes que
podemos conectar a cada uno de ellos.
En esta placa, podemos ver el microcontrolador, donde se almacena el programa

para poder ejecutarlo. Cargaremos este programa a través de la entrada Micro USB.
El botón Reset nos sirve para reiniciar el programa y que este vuelva a comenzar
desde el principio.
Para alimentar energéticamente a la placa también utilizamos la entrada Micro USB

o la entrada de baterías, de entre 6 y 17 Voltios. El interruptor On/Off nos permite
cortar el paso de corriente a toda la placa, aunque esté conectada a una fuente de
alimentación.
Por último, el componente Bluetooth integrado, permite comunicar a la placa (sin

cables) con otros dispositivos que tengan este tipo de comunicación: ordenadores,
smartphones, etc.
Figura 3. Zum Core 2.0 - Placa de la familia Arduino optimizada para robótica.

1.3. Sensores y actuadores
La palabra robot proviene del checo: robota, que significa trabajo duro o forzado. Se
usó por primera vez durante la obra de teatro Rossum Universal Robots de Karel
Čapek y su uso se extendió gracias a las obras de ciencia ficción creadas por el
escritor Isaac Asimov.
A menudo nos imaginamos a un robot como una máquina con forma humana que
camina, habla, gesticula… pero en realidad es algo mucho más sencillo:
“Un robot es una máquina automática programable que es capaz de interpretar
información del medio físico para modificar su conducta. Tiene la capacidad de
interactuar con el entorno y, en función de ello, realizar unas funciones u otras.”
Todo robot tiene tres tipos de componentes:
▶ Sistema de control: como una placa controladora.

▶ Sensores: capaces de interpretar información del mundo o del propio robot. Son
dispositivos que pueden leer las condiciones del entorno y transformarlas en
señales eléctricas. Transmiten más o menos electricidad en función del elemento
físico: luz, sonido, distancia, etc.
▶ Actuadores: producen un efecto sobre el mundo o sobre el propio robot. Un
actuador es un dispositivo capaz de transformar señales eléctricas en un proceso
físico, como luz, sonido o movimiento con la finalidad de realizar un cambio
sobre el mundo. Por ejemplo, un motor que mueve una rueda, un LED que indica
que un aparato está encendido, un altavoz que emite un sonido de alerta, etc.
Si comparamos un robot con una persona, los sensores serían sus sentidos. Éstos
transmiten información a su sistema de control o cerebro, modificando su
comportamiento e influyendo sobre el mundo mediante sus actuadores. Además,
un robot necesitará una fuente de energía para funcionar y una estructura física
para sostener los elementos que lo componen.

El cerebro o la placa controladora es como un pequeño ordenador. Básicamente es
un microcontrolador al que se le pueden conectar sensores (sentidos), y actuadores
(músculos, voz, etc).
Figura 4. Comparativa robótica y cuerpo humano.
1.4. Componentes digitales y analógicos. Placa Zum Core
Los componentes asociados a la placa controladora tipo Zum Core, se pueden

clasificar en dos categorías, digitales y analógicos. Podemos conectar estos
componentes a la placa controladora a través de sus pines que, como ya hemos
visto anteriormente, están divididos en pines digitales y pines analógicos. Vamos a
ver sus diferencias:

▶ Componentes digitales: son aquellos componentes que sólo pueden tener dos
valores, 0 o 1. Pueden ser tanto sensores como actuadores y los conectamos a
los pines digitales de la placa. En las placas Zum Core existen 14 pines digitales
diferenciados por los colores negro, rojo y blanco.
Figura 5. Pines digitales placa Zum Core.
• Si conectamos un sensor, éste enviará un valor de 0 Voltios (0 lógico) o 5

Voltios (1 lógico) a la placa. Un ejemplo de sensor digital es un botón que
cuando lo pulsamos manda un 1 y cuando no lo pulsamos manda un 0.
• Si conectamos un actuador, es la placa la que escribirá el valor de 0 Voltios

o 5 Voltios y hará que se encienda o se apague el actuador
correspondiente. Un ejemplo de actuador digital es un LED que cuando la
placa le envía un 1, este emite luz y cuando le manda un 0, este deja de
emitir luz.
IMPORTANTE. Los pines digitales numerados en la placa con 0 y 1 se usan para

recibir y enviar información, por lo que si conectamos un componente y
programamos la placa, puede que el programa no se cargue o no funcione
correctamente. Además, el pin digital número 13 no recibe la misma tensión, por lo
que puede dar problemas en el uso de algunos elementos. Debemos usar con
precaución dichos pines si la placa los tiene habilitados para su uso.
▶ Componentes analógicos: son aquellos componentes que pueden tener todo un

rango de valores. Se conectan a los pines analógicos de la placa que, en este
caso, sólo se utilizan como entradas, es decir, sólo podemos conectar sensores.
Estos pines, en lugar de leer solamente los valores de 0 Voltios o 5 Voltios,

pueden leer cualquier valor comprendido entre ellos, por ejemplo, podrían leer
un valor de 3 Voltios. Estas lecturas se traducen al microcontrolador con un valor
entre 0 y 1023. Es decir, si lee 0 Voltios, al micro le llega un 0. En cambio, si lee 5
Voltios, le llega un 1023. Un ejemplo de sensor analógico es un sensor de luz,
donde dependiendo de la cantidad de luz que el sensor recibe enviará un valor
mayor o menor. En las placas Zum Core existen 6 pines analógicos diferenciados
por los colores negro, rojo y azul.
Figura 6. Pines analógicos placa Zum Core.
Vamos a ver los distintos componentes que podemos utilizar con la placa Zum Core
divididos entre sensores y actuadores:
Sensores
Es un sensor digital que se activa cuando se

pulsa, permitiendo que circule por él la
corriente, y se desactiva cuando se deja de
pulsar.
Se pueden programar distintas acciones

asociadas a su estado:
Botón - pulsado (1 ó verdadero)
- no pulsado (0 ó falso)
Se encuentra en numerosos dispositivos que

utilizamos a diario, como timbres de puerta,
batidoras, calculadoras, teclados de
ordenador, lavadoras, ascensores, etc.
Es un sensor analógico compuesto por una

resistencia que modifica su valor cuando hay
más o menos luz. Cuanto mayor sea la
Sensor de luz intensidad de luz, más baja será la resistencia
o al paso de la corriente.
LDR (Light-Dependent
Resistor) Devuelve un rango de valores comprendidos
entre 0 (cuando la oscuridad es total) y 800 (a
plena luz del sol en un día despejado).

Es un sensor digital que emite una luz
infrarroja detectando la cantidad de luz
reflejada. De esta forma, es capaz de
diferenciar entre el color blanco y el negro, o
de detectar objetos próximos.
Sensor de infrarrojos
Devolverá un 1 ó verdadero cuando detecte
blanco (o un objeto sobre el que refleja la luz)
y un 0 ó falso cuando detecte negro.
Sensor digital capaz de medir la distancia a un

obstáculo a través de ondas sonoras.
Este tipo de sensores tienen dos partes, una
es el emisor que emite la señal y la otra el
receptor que recibe la señal si ésta rebota
Sensor de ultrasonidos sobre algún obstáculo cercano.
Este sistema es el mismo que utilizan los

murciélagos para orientarse, y se aplica de
forma similar en robótica para detectar
obstáculos y medir distancias.
Sensor analógico que se compone de una

resistencia variable, es decir, un componente
que permite regular la intensidad de la
corriente eléctrica de un circuito.
Se utilizan en muchos dispositivos, como en

Potenciómetro
lámparas para regular la intensidad de luz o
en equipos de música para ajustar el
volumen.
El potenciómetro devolverá valores entre 0 y

1023.
Tabla 1. Sensores kit Zum Core.
Actuadores
El LED emite luz cuando circula la electricidad

a través de él y es un componente digital ya
que solo puede tener dos estados: encendido
y apagado.
LED Los LED son baratos, gastan muy poca energía

y pueden llegar a ser muy luminosos. Se
utilizan mucho en sistemas electrónicos y
están sustituyendo a la iluminación
tradicional.

Es un motor que permite controlar la
Servo de rotación dirección de su giro. Es muy utilizado en
continua electrónica, por ejemplo, en ascensores,
escaleras mecánicas, lectores de DVD, etc.
Permite elegir a qué posición o ángulo debe

Servo
moverse, de entre 0 y 180 grados, .
Es un componente digital capaz de reproducir

sonidos a diferentes frecuencias.
Zumbador Son utilizados en multitud de sistemas para

producir sonidos o alarmas como
despertadores, timbres, electrodomésticos,
etc.
Tabla 2. Actuadores kit Zum Core.
1.5. Primeros pasos con Bitbloq
La plataforma elegida para programar la placa será Bitbloq, que es un entorno de

desarrollo basado en Scratch, primera herramienta en proponer la programación
por bloques para que los niños se iniciasen en el mundo de la programación.
Mientras Scratch se utiliza para programar videojuegos o animaciones en pantalla,
Bitbloq sirve para programar placas controladoras y, por ello, son dos complementos
perfectos.
Al ser un lenguaje de programación por bloques, no hace falta escribir complicadas

líneas de código, aunque sí permite visualizar cómo quedaría el código que vamos
programando para facilitar el paso de bloques a código.

El objetivo principal de Bitbloq es aprender los conceptos básicos de programación,
como las variables, los bucles o los condicionales, de manera que cuando
aprendamos cómo piensa una máquina, podamos programar cualquier cosa.
Como ya hemos comentado antes, Bitbloq es una herramienta que permite la

programación por bloques de placas basadas en Arduino, como las placas Zum Core.
Registro
Bitbloq permite trabajar en su plataforma de dos formas: como invitado o con una
cuenta de usuario. Esta última opción tiene la ventaja de que se pueden guardar los
proyectos que se van creando, descargarlos, verlos o modificarlos cuando se quiera
y compartirlos con la comunidad. Para crear una cuenta de Bitbloq debemos tener
un correo electrónico propio y tener al menos 14 años.
Accedemos a https://bitbloq.cc/, desde el navegador Google Chrome, y

seleccionamos la opción Crear una cuenta, que se encuentra en la esquina superior
derecha.
Figura 7. Registrarse en Bitbloq.
IMPORTANTE. Bitbloq está optimizado para su funcionamiento en la última versión

de Google Chrome o Chromium, por lo que aconsejamos la utilización de estos
navegadores.
A continuación, introducimos los siguientes datos personales: nombre de usuario,

email, contraseña y fecha de nacimiento. También podemos registrarnos utilizando
el perfil de una cuenta de Microsoft o de Google. Para finalizar, debemos aceptar las
condiciones activando la casilla He leído y acepto las condiciones generales y
políticas de privacidad, y pulsar en el botón Guardar.

Figura 8. Datos personales.
Tras este paso, podemos elegir si añadir o no el Plan Docente de Bitbloq.

Seleccionamos la opción y luego hacemos clic en Crear cuenta.

Figura 9. Registro: Plan Docente
A continuación, tendremos que acceder a nuestro correo electrónico para validar la

cuenta.
Una vez completado el registro podemos iniciar sesión en Bitbloq yendo a su página
principal y haciendo clic en Entrar.
Figura 10. Entrar
Tras esta acción, nos aparecerá la página de Mis documentos. Aquí podemos crear
nuevos documentos de diversos tipos o ver los ya creados.

Figura 11. Mis documentos
Dentro de nuestra cuenta, en Mis documentos, podemos buscar o cambiar el orden

en el que se ordenan los documentos.
Figura 12. Orden de documentos
También podemos crear nuevas carpetas, para ordenar los documentos como
necesitemos.
Figura 13. Nueva carpeta
Para empezar a programar con esta herramienta, hacemos clic en Nuevo documento
/ Bitbloq Robotics.

Figura 14. Abrir un nuevo documento
IMPORTANTE. Los alumnos menores de 14 años utilizarán Bitbloq sin haberse

registrado previamente. Pueden hacer clic en Nuevo documento y elegir bitbloq
Robotics o bien hacer clic en Ir al ejercicio e introducir el código de un ejercicio ya
creado en una cuenta con Plan Docente.
Instalación de los drivers
Para el correcto funcionamiento de Bitbloq y comunicar la placa con el ordenador

para cargar programas, es muy importante tener en cuenta:
Tener la última versión del navegador Google Chrome. Se puede comprobar la

versión instalada pulsando sobre los 3 puntos del navegador (esquina superior
derecha), y seleccionando la opción Configuración y después Información de
Chrome.
Si se está trabajando con Sistema Operativo Windows, se deben descargar los

drivers de la placa controladora pulsando aquí.

Los ordenadores con Linux, no necesitan drivers, para Sistemas Operativos Mac
podemos encontrar los drivers aquí.
Una vez completada la instalación es recomendable que reiniciemos el ordenador.
Para comprobar que se ha completado la instalación correctamente, debemos

conectar la placa a nuestro ordenador, volver a abrir Bitbloq, arrastramos la placa
controladora en la pestaña Hardware, vamos a la pestaña Bloques y pulsamos en
Cargar.
Figura 15. Cargar un programa.
Tras cargar el programa en la placa, aparece en la pantalla el mensaje “Cargada con

éxito”, que nos indica que todo ha funcionado correctamente.

Figura 16. Programa subido a la placa.
Si no ha funcionado correctamente, consultaremos el Anexo I. Preguntas frecuentes

Bitbloq.
1.6. Cómo programar la placa controladora con Bitbloq
Para comenzar a programar accedemos a https://bitbloq.cc/, nos logueamos si

tenemos cuenta, hacemos clic en Nuevo documento y a continuación en Bitbloq
Robotics. En la pestaña Hardware seleccionamos la placa controladora con la que
estemos trabajando, los componentes que vamos a utilizar y los pines o conectores
de la placa a los que los vamos a conectar.
Para ello, desde la pestaña Placas, arrastramos nuestra placa hasta el espacio
marcado. Desde la pestaña Componentes, arrastramos los elementos hasta la zona
blanca que rodea la placa. Podemos cambiar el nombre del componente si lo
deseamos. Será conveniente cuando tengamos más de un componente del mismo
tipo, por ejemplo, dos LED. Conectamos el componente a la placa controladora
haciendo clic en el punto verde que se encuentra en la parte inferior del mismo y
arrastrando hasta el pin o conector deseado. Es importante conectar los
componentes en Bitbloq en los mismos pines o conectores que en la placa física.

Figura 17. Interfaz pestaña Bloques en Bitbloq.
En la pestaña Bloques, se construye la programación arrastrando los bloques desde

la categoría correspondiente hasta el área de programación. Este área está dividida
en tres partes:
● Variables globales y funciones: permite declarar variables y funciones, que
utilizaremos más adelante.
● Instrucciones iniciales (Setup): permite configurar las acciones que queremos
ejecutar al principio y solo una vez.
● Bucle principal (Loop): es la parte en la que programamos más a menudo.
Todo lo que se encuentre dentro se ejecuta en bucle de forma indefinida.
Los bloques estarán bien colocados cuando se coloreen.
Debemos saber que la programación en Bitbloq es secuencial, es decir, que la placa

controladora lee y ejecuta la programación de arriba a abajo. Si además esta
programación la colocamos en el Bucle principal (Loop), el programa se repetirá una
y otra vez.

Una vez realizado el programa hacemos clic en Verificar para comprobar que todo
está correcto y posteriormente en Cargar, para programar la placa controladora.
En este momento aparecerá una ventana emergente indicándonos que

seleccionemos el puerto serie donde tenemos conectada la placa. Hacemos clic en
el correspondiente y seguidamente en Conectar.
Figura 18. Seleccionar una placa.
Cuando termine de cargarse la programación en la placa controladora, aparecerá el

mensaje “Cargada con éxito” y se ejecutarán las instrucciones programadas.
IMPORTANTE: La placa, y no el ordenador, es la que almacena y ejecuta cada

programa. Cada vez que realizamos una modificación en el programa, debemos
cargarlo de nuevo en la placa para ver su efecto. La placa puede almacenar
solamente un programa a la vez, de modo que cada vez que cargamos uno nuevo, el
anterior desaparece. Este programa permanecerá aunque desenchufemos la placa
de la fuente de alimentación.
Debajo de la pestaña Bloques podemos encontrar la pestaña Diagramas, que nos

permitirá ver el diagrama de flujo del programa que hayamos creado con los
bloques y lo contrario, realizar un diagrama de flujo y ver el programa que se ha

generado. En la sección 2.5 de este documento se especifica brevemente en qué
consisten los diagramas de flujo y de qué partes constan.
Finalmente, en la pestaña Información del proyecto, se puede documentar el

proyecto añadiéndole una descripción, un enlace a un vídeo, una imagen etc.
1.7. Nuestro primer reto: ¡Hola mundo!
Empezamos por el programa más simple que podemos realizar, nuestro ¡Hola
mundo!
En programación se llama “Hola mundo” al primer programa que se realiza cuando

se está aprendiendo un lenguaje de programación. Cuando se programa una placa
controladora, el “Hola mundo” consiste en hacer parpadear un LED para comprobar
que todo funciona correctamente.
Encender un LED
Vamos a conectar la placa controladora al ordenador con el cable USB y un LED a la

placa. Es importante que nos aseguremos de que los colores de los cables del
componente coinciden con los colores del pin al que lo vamos a conectar: el negro
con el negro, el rojo con el rojo y el amarillo o blanco con el amarillo o blanco. En
este caso lo conectaremos en el pin 5.
Figura 19. Componente LED conectado a la placa controladora Zum Core.
Una vez conectado físicamente abrimos un documento nuevo en Bitbloq Robotics y

en la pestaña Hardware colocamos la placa y el LED, en la misma posición que lo
habíamos colocado físicamente.

Ahora nos dirigimos a la pestaña Bloques, donde programaremos el proyecto. Desde
la categoría Componentes, seleccionamos el bloque Encender/Apagar el LED y lo
arrastramos dentro de la zona Bucle Principal (Loop).
Figura 20. Bloque encender/apagar el componente LED.
En la parte superior derecha, hacemos clic en Verificar para comprobar que todo
está correcto y posteriormente en Cargar.
Cuando aparezca el mensaje “Cargada con éxito”, se ejecutará el encendido del LED.
Haciendo parpadear el LED
Ahora vamos a ver cómo podemos hacer que el LED parpadee.
Primero debemos recordar que la programación en Bitbloq es secuencial, lo que va

a implicar que el programa se va a ejecutar de arriba a abajo y, si está colocado en el
Bucle principal (Loop), se repetirá una y otra vez.
Sabiendo esto, podemos pensar que las instrucciones que debemos dar a la placa
para hacer el parpadeo son Encender LED - Apagar LED, dentro del bucle para que
se repitan indefinidamente. Sin embargo, nuestra placa controladora piensa muy
rápido, si le decimos que apague el LED tras darle la orden de encendido pasará de

una orden a otra demasiado rápido y dará la sensación de que el LED está
encendido siempre.
Para solucionarlo tenemos que hacer esperar un tiempo mediante el bloque Esperar
que encontramos en la categoría de Control, en la pestaña Básicos.
Figura 21. Bloque Esperar.
Este bloque hace esperar al programa el número de milisegundos que decidamos.
En nuestro caso vamos a hacer que el LED parpadee con una cadencia de un
segundo, por lo que escribiremos 1000 milisegundos. Tras la espera podemos
apagar el LED y, como el programa se repite indefinidamente, deberemos esperar
otro segundo antes de volver a empezar.
La secuencia de acciones para que parpadee un LED (con una espera de 1 segundo)
será entonces: Encender - Esperar 1 segundo - Apagar - Esperar 1 segundo -
Encender - etc.
El programa quedaría de la siguiente manera:

Figura 22. Programa parpadeo LED.
Haciendo parpadear dos LED. Acciones secuenciales que parecen

simultáneas
¿Cómo podemos hacer que dos LED se enciendan a la vez y se apaguen a la vez?
Como ya sabemos, la programación en Bitbloq es secuencial y la placa controladora

solo puede hacer una cosa a la vez, por lo que las acciones que programemos solo
pueden ir una detrás de otra. Sin embargo, también hemos visto ya, que nuestra
placa realiza las acciones a mucha velocidad y, cuando no hay un tiempo de espera,
estas acciones pasan tan rápido que parece que tengan lugar simultáneamente.
Vamos a ver entonces cómo realizar el parpadeo.
En este caso conectaremos dos LEDs a nuestra placa controladora indicando en la

pestaña Hardware a qué pines los hemos conectado.
Al conectar dos componentes del mismo tipo, nos será más fácil programarlos si le
ponemos un nombre a cada uno para diferenciarlos. Pero si no lo hacemos, Bitbloq
generará un nombre específico automáticamente. Este nombre nos permitirá
seleccionar en el bloque sobre qué LED queremos actuar.
La programación quedará de la siguiente manera:

Figura 23. Programa parpadeo dos LED.
Si hemos programado la placa correctamente, los dos LED deberán encenderse y

apagarse al unísono.
IMPORTANTE. A veces creamos un proyecto que no se comporta como habíamos

pensado. Recuerda que la placa controladora es el cerebro de nuestra máquina,
pero es mucho más limitado que un cerebro humano.
La placa controladora:
▶ Piensa (procesa) las cosas de una en una, no puede hacer dos cosas a la vez.
▶ Piensa y repite acciones muy rápido, tanto que a veces no podemos ni ver lo
que está haciendo y hay que decirle que espere un poco.

▶ Nunca hace nada que no le hayamos dicho. Tenemos que programar todo lo
que queramos que haga y darle las órdenes de una en una.

▶ Normalmente, cuando la placa acaba su lista de órdenes, vuelve a empezar
de nuevo, repitiendo su programación una y otra vez.

Tema 2. Programación I: Condicionales y Bucles
En este tema, aprenderemos qué son las sentencias condicionales y los bucles y
como puedo programarlos con Bitbloq. Seremos capaces de leer los valores que le
llegan a nuestra placa desde los sensores y veremos cómo pueden ayudarnos los
diagramas de flujo a entender la estructura de un programa.
▶ Conocer las sentencias condicionales simples y su aplicación.

▶ Aprender a realizar algoritmos y diagramas de flujo.
▶ Conocer los distintos tipos de bucles y sus diferencias.
▶ Aprender a mostrar valores a través del puerto serie.
2.2. Las sentencias condicionales
En una sentencia condicional nos planteamos una pregunta para actuar de una
forma u otra según la respuesta a la misma. Por ejemplo, si llueve, abrimos el
paraguas. Si por el contrario no llueve, lo cerramos. Si hace frío, nos ponemos el
abrigo. Si hace calor, nos lo quitamos. Si es de noche, encendemos una luz. Si por el
contrario es de día, la apagamos.
Para programar un condicional en Bitbloq utilizaremos los bloques de programación

que se encuentran en la categoría de Control de la pestaña Bloques.

La pregunta que vamos a plantear la construimos con el bloque Si y, para las
distintas respuestas o condiciones, completamos con los bloques en cambio si o de
lo contrario:
▶ Utilizamos el bloque en cambio si para programar que se comprueben varias
condiciones.
▶ Utilizamos el bloque de lo contrario para indicar que, si no se cumple la
condición o condiciones, se ejecute otra acción o acciones.
Figura 24. Bloques condicionales.
Estos dos bloques podemos encontrarlos tanto en la categoría de Control como en

las sugerencias que aparecen al pulsar la bombilla que se muestra cuando situamos
el cursor en la parte inferior del bloque Si.
Figura 25. Bombilla de sugerencias en el bloque

condicional Si.

2.3. Encender un LED al pulsar un botón
Empezamos practicando las instrucciones condicionales con un reto: encender un

LED cuando pulsamos un botón.
Nuestro programa tendrá las siguientes partes:

▶ si pulso el botón, el LED se encenderá
▶ si dejo de pulsar el botón, el LED se apagará.
Comenzamos, colocando en la pestaña Hardware los componentes que

necesitamos:
● Placa controladora
● Botón
● LED
Figura 26. Componentes LED y Botón conectados a la placa controladora Zum Core.
Pasamos a la pestaña Bloques y situamos el bloque Si de la categoría de Control,

pestaña Básicos, en el Bucle principal. Rellenamos los huecos vacíos con el bloque
Leer botón de la categoría de Componentes y el bloque Verdadero/Falso (categoría
Lógica) o el bloque número (categoría Matemáticas) que nos van a indicar los
estados del botón (recordemos que estamos utilizando un sensor digital):
▶ Para la condición de botón pulsado utilizaremos “1” ó “Verdadero”.

▶ Para la condición de botón no pulsado utilizaremos “0” ó “Falso”.

En nuestro caso queremos que el LED se encienda si pulsamos el botón, por tanto
igualamos la lectura del botón a “1” ó “Verdadero”.
Figura 27. Bloque condicional para botón pulsado.
Dentro del bloque Si colocamos el bloque con la acción que queremos que ocurra,
en este caso Encender el LED. Y a continuación situamos un de lo contrario, para que
cuando no se cumpla esta condición el LED se apague.
Figura 28. Programa encender/apagar un LED con un botón.
Recuerda que nuestra placa controladora nunca hace nada que no le hayamos
dicho. Debemos programar todo lo que queramos que haga. Si solo programamos
que cuando el botón esté pulsado el LED se encienda y no le decimos cuándo debe
apagarse, el LED nunca se apagará.

2.4. Lámpara nocturna con sensor de luz
Vamos a ver otro reto en el que tengamos que utilizar las sentencias condicionales:
realizar una lámpara inteligente que encienda un LED cuando esté oscureciendo.
Nuestro programa tendrá las siguientes partes:

- si el sensor de luz detecta que está oscureciendo, el LED se encenderá
- si el sensor de luz detecta que hay suficiente luminosidad, el LED se apagará.
Ya hemos visto cómo utilizar las sentencias condicionales con un sensor digital, el
botón, por lo que vamos a practicarlas ahora con un sensor analógico, el sensor de
luz.
Empezamos colocando en la pestaña Hardware los componentes que necesitamos:
● Placa controladora Zum Core

● Sensor de luz
● LED
Figura 29. Componentes LED y Sensor de luz conectados a la placa controladora Zum Core.

Recordamos que el sensor de luz es un elemento analógico, por lo que debemos
conectarlo en la ristra de pines analógicos, haciendo coincidir los colores de su cable
con el de los pines.
Pasamos a la pestaña Bloques y volvemos a utilizar las sentencias condicionales de

la categoría de Control. En este caso debemos elegir un valor de cantidad de luz, de
forma que cuando el sensor de luz detecte valores inferiores a este (simulamos
noche), el LED se encienda, y cuando los valores sean superiores (simulamos día), el
LED se apague. Teniendo en cuenta el rango del sensor de luz (0 - 800
aproximadamente), elegiremos un valor de 200 (este valor lo podemos ajustar
después según el entorno donde nos encontremos).
El programa quedaría entonces de la siguiente manera:
Figura 30. Programa control LED mediante Sensor de luz.
IMPORTANTE. Debemos cerciorarnos de que colocamos el símbolo de comparación

correcto en el bloque Si. En este caso hemos usado la comparativa menor que (<). Si
mantenemos la igualdad (=) sería un error en este caso, ya que es muy complicado
conseguir un valor fijo o constante en la medida del sensor de luz. Recordemos que,
al situar esta programación en el apartado del Bucle principal (Loop), la placa está
revisando, indefinidamente, el valor que le está llegando de este sensor.

2.5. Algoritmos y diagramas de flujo
En los anteriores apartados, nos hemos enfrentado a diferentes retos y hemos

tenido que ir analizando cómo podríamos solucionarlos paso a paso. En
programación, cada vez que nos enfrentamos a un problema nos va a ser de mucha
utilidad plantearnos preguntas que nos ayuden a obtener unas instrucciones claras,
del tipo: ¿qué tengo que hacer? y ¿cómo puedo hacerlo? Estas instrucciones son lo
que llamamos un algoritmo.
Un algoritmo es un conjunto de instrucciones muy concretas que hay que seguir en

orden para realizar una tarea, como por ejemplo seguir paso a paso una receta de
cocina, un manual de instrucciones, poner una lavadora, etc.
Una forma sencilla de representar estos algoritmos es mediante diagramas de flujo,

que nos ayudan a visualizar de forma gráfica un proceso.
Los símbolos fundamentales para construir diagramas de flujo son:
Representa el inicio y el final del proceso.
Representa el proceso o acción que se ejecuta a partir de unos datos, que pueden ser de
entrada, salida o resultado de algún proceso anterior.
Representa los datos de entrada y los datos de salida.
Representa una condición o pregunta que puede tener varios caminos: si/no,
verdadero/falso, mayor que/menor que, igual a/diferente a, etc.
Indican el sentido de los procesos.
Tabla 3. Elementos de un diagrama de flujo.

Estos símbolos podemos encontrarlos en las categorías del lateral derecho, los
cuales tienen su equivalente de tipo bloque.
Figura 31. Pestaña Diagramas.
A la derecha podemos encontrar las diferentes categorías de símbolos, que a su vez

están divididas en pestañas (Junior, Básicos y Avanzados).
En la sección central de la interfaz encontraremos el Área de creación de diagramas
subdividido en en tres secciones al igual que en la pestaña Bloques.
En la parte inferior de la pantalla está el Área de configuración del símbolo, que
aparece cuando seleccionamos un símbolo con el ratón y permite establecer o
modificar diferentes atributos.
Para el caso del reto encender un LED al pulsar un botón, el diagrama de flujo que
representa el algoritmo es el siguiente:

Figura 32. Diagrama de flujo del algoritmo encender un LED al pulsar un Botón.
Es una buena práctica tanto para nosotros, como para nuestros alumnos y alumnas,
desarrollar el diagrama de flujo de los ejercicios que propongamos antes de
programarlos. Les ayudará a simplificar el problema y les resultará más sencilla su
resolución.
2.6. El bucle Repetir
Un bucle es una parte del programa que se repite mientras se cumpla una
condición.
El bucle Repetir se encuentra en la categoría de Control y, como su nombre indica,

repite una serie de acciones el número de veces que le indiquemos.
Figura 33. Bloque Repetir.

Por ejemplo, si queremos que al pulsar el botón el LED parpadee 5 veces, podemos
incluir este bucle. Este sería el resultado:
Figura 34. Programa ejemplo repetición de acciones con el bloque Repetir.
2.7. El bucle Mientras (While)
Como hemos comentado antes, un bucle es una parte del programa que se repite
mientras se cumpla una condición. El bucle Mientras o While repite una serie de
acciones mientras una condición sea verdadera. Por ejemplo, mientras llueva no
saldremos a la calle y leeremos un buen libro. Cuando la condición deja de ser
verdadera, el programa sale del bucle y continúa con la siguiente instrucción.
La estructura del bloque Mientras es muy similar a la del bloque condicional Si. La
diferencia en este caso es que cuando la condición sea verdadera, la programación
permanecerá en ese bucle Mientras, realizando las instrucciones que se han
introducido en él y paralizando el Bucle principal, hasta que la condición deje de
cumplirse. En el caso del bloque Si, cuando la condición se cumpla, se realizarán las
instrucciones, saldrá del bloque Si y continuará con la siguiente instrucción que haya
dentro del Bucle principal.

Vamos a ver otro reto con el que practicaremos esta instrucción: una alarma que
nos avise si se ha fundido una bombilla de una zona que queremos tener siempre
iluminada en nuestra casa.
Analizamos el problema y vemos que queremos que, mientras la luminosidad de la
habitación sea inferior a un cierto nivel, nuestra alarma no deje de sonar.
Empezamos colocando en la pestaña Hardware los componentes que necesitamos:
● Sensor de luz
● Zumbador
Figura 35. Componentes Zumbador y Sensor de luz conectados a la placa controladora Zum Core.
Pasamos a la pestaña Bloques y vamos a colocar el bloque Mientras de la categoría

de Control en el Bucle principal. Para rellenar el bloque, elegimos un valor de
cantidad de luz que nos informe de que no es la luminosidad suficiente, en este caso
pondremos el valor de 100. Si la condición se cumple haremos que el zumbador
suene con la nota Do durante 500 milisegundos (0,5 segundos). Este bloque lo
podemos encontrar en la categoría de Componentes.

A continuación, ponemos una espera de otros 500 ms con el bloque Esperar de la
categoría de Control, simulando así un sonido intermitente, como el de una alarma.
Figura 36. Ejemplo con el bucle Mientras.
2.8. Mostrar valores por monitor puerto serie
El monitor puerto serie es el medio que tiene la placa controladora para

comunicarse con otro aparato como el ordenador. Es muy útil para comprobar el
valor que le está llegando a la placa de un sensor, de una variable, etc. Esto nos
ayudará a delimitar mejor nuestros valores en las condiciones o bucles que
programamos y corregir y entender los posibles errores de un programa.
Para usar el monitor puerto serie con el ordenador debemos mantener conectada la
placa controladora mediante el cable USB. En la pestaña Hardware seleccionamos el
componente USB serie y lo arrastramos a la parte gris que rodea la placa, se
conectará automáticamente al puerto USB de esta. El baudrate es la cantidad de
información que se transmite en un segundo y se mide en baudios (bits/segundo).
Utilizaremos el baudrate que aparece por defecto: 9600 baudios.

Figura 37. Componente USB serie conectado a la placa controladora Zum Core.
Nuestro primer ejemplo va a consistir en mostrar un mensaje por pantalla. Para ello,
en la pestaña Bloques, en la categoría Componentes, encontramos los bloques de
comunicación: Recibir, Recibir número y Enviar. Elegimos el bloque Enviar y lo
situamos en el apartado Bucle principal (Loop). Seleccionamos la opción USB_serie
en el desplegable y dejamos la opción Con salto de línea para mostrar los mensajes
en líneas diferentes. En caso de que queramos que nos los muestre en la misma
línea, elegiremos Sin salto de línea en el desplegable.
Figura 38. Bloque enviar por monitor puerto serie.
A continuación, añadimos el bloque “Texto” de la categoría Texto y escribimos en él

el mensaje que queremos mostrar, en este caso ¡Hola mundo!
Situaremos después un bloque Esperar para visualizar el mensaje cada segundo.
Figura 39. Ejemplo de envío de mensaje por monitor puerto serie.

Cargamos el programa en la placa y, a continuación, hacemos clic en Ver y
seleccionamos Monitor Puerto Serie.
Figura 40. Mostrar el Monitor Puerto Serie.
Se abrirá una ventana nueva donde aparecerá el mensaje que hemos escrito, con
una cadencia de 1 segundo. Puedes cambiar a la opción de Sin salto de línea para
visualizar un mensaje seguido del otro, pero es importante que, si vas a realizar un
cambio en la programación, primeramente, cierres el Monitor Puerto Serie, a
continuación cargues el programa y, una vez cargado a la placa, vuelvas a abrir el
Monitor Puerto Serie.
Al igual que hemos hecho con el mensaje de texto, podemos mandar la lectura de
cualquier sensor a través del Monitor puerto serie.
Leer el valor de un sensor con Placa Zum Core
Vamos a leer los valores que el sensor de luz está enviando a la placa.
Colocamos en la pestaña Hardware los elementos necesarios:
● USB_serie
● Sensor de luz
Figura 41. Componentes USB serie y sensor de luz conectados a la placa controladora Zum Core.

En la pestaña Bloques, en la categoría Componentes, Básicos, elegimos el bloque
Enviar y lo situamos en el apartado Bucle principal (Loop). Seleccionamos la opción
USB_serie en el desplegable y dejamos la opción Con salto de línea para mostrar los
mensajes en líneas diferentes.
A continuación, añadimos el bloque Leer sensor_de_luz de la categoría

Componentes.
Situaremos después un bloque Esperar para visualizar el mensaje cada segundo.
Figura 42. Ejemplo de leer el valor de un sensor.
Para poder ver los valores, como hemos comentado antes, cargamos el programa en
la placa y, a continuación, hacemos clic en Ver y Mostrar Monitor Puerto Serie.
Figura 43. Valores del Sensor de luz en el Monitor Serie.

Tema 3. Programación II: Variables y funciones
En este tema aprenderemos qué son las variables y qué son las funciones, para qué
se utilizan y cómo podemos implementarlas en los programas que realizamos.
▶ Aprender qué es una variable, cómo declararla y cómo modificarla.

▶ Conocer los tipos de variables.
▶ Aprender qué es una función y para qué se utiliza.
▶ Diferenciar entre funciones sin retorno y funciones con retorno.
▶ Implementar las funciones en las programaciones.
3.2. Las variables
Una variable es como una “caja” donde guardamos un dato. Este valor que
guardamos lo podremos consultar y utilizar siempre que lo necesitemos. Si no lo
guardásemos el programa no lo recordaría. Además, como veremos más adelante,
en cualquier momento podremos cambiar el valor guardado en la variable.
Figura 44. Ejemplificación de variables.

Un ejemplo de variable es la edad de una persona, cuyo valor varía cada año al
sumarle 1 a los años que ya se tenían acumulados, o la puntuación de un juego.
Declaración de variables
Al declarar una variable en nuestro programa lo que hacemos es crear esa caja y
guardar por primera vez un dato en ella.
Para identificar en todo momento nuestra variable (o nuestra caja) debemos

ponerle un nombre. Los nombres de las variables solo pueden estar compuestos por
letras, dígitos, guiones o guiones bajos. No pueden llevar espacios en blanco, ni
puntos, comas, tildes, etc. Además, nunca debemos nombrarlas como algún
elemento que ya exista en el programa, por ejemplo LED, zumbador, botón, etc.
En el momento en que declaramos una variable definimos de qué tipo es. Por
ejemplo, si lo primero que guardamos es un número, esa variable siempre va a
guardar números, pero si lo primero que guardamos es una palabra o texto, solo
podrá contener texto.
- Variable numérica: si lo que

guarda es un número.
- Variable textual: si guarda un

texto.
- Variable lógica: si guarda un dato

lógico (verdadero o falso).
También podemos guardar en una variable el valor que nos devuelve un sensor.

Figura 45. Bloques de declaración de variables según su tipo.
Variables globales y variables locales
Al declarar una variable, también será importante decidir si queremos utilizar una
variable global o una variable local.
● Variables globales. Se crean al inicio del programa, en el apartado Variables

globales y funciones, y son universales, lo que significa que pueden utilizarse
en cualquier momento que se requiera en nuestra programación.
● Variables locales. Se pueden crear en las Instrucciones iniciales (Setup) o en
el Bucle principal (Loop). A diferencia de las variables globales, solo se
pueden utilizar dentro de la función donde han sido declaradas (Loop o
Setup).
Lectura y modificación de los valores de las variables
Una vez declarada la variable, podemos realizar dos acciones con ella:
- leer el valor almacenado en la misma
- modificar el valor que posee
Realizamos un ejemplo para ver todo el proceso. Nuestro reto es programar un

contador de personas para controlar la entrada a un estadio de fútbol. Contaremos
cada persona pulsando un botón. Los pasos que vamos a realizar son:

- Declaramos la variable global número y la igualamos a 0 (para que cada vez
que se inicie el programa comience a contar desde 0).
- Programamos un condicional en el Bucle principal (Loop) para que con cada
pulsación del botón sume una persona más a la variable número.
- Añadimos una pequeña espera para que, si mantenemos el botón pulsado,
no cuente personas de más.
Figura 46. Ejemplo de programación con variables.
3.3. Las funciones
Una función es un fragmento de programa diseñado para ser reutilizado en

múltiples ocasiones. Es uno de los elementos más importantes de la programación,
puesto que permite agrupar una serie de tareas en una sola instrucción. De esta
forma podemos reutilizar un programa que ya hayamos escrito y nuestro código
será menos repetitivo. Normalmente una función realiza una o varias tareas
pudiendo, al terminar, devolver un valor (numérico, textual, lógico o de otro tipo)

que será utilizado por el programa principal (funciones con retorno) o no devolver
nada (funciones sin retorno).
Funciones sin retorno
Por ejemplo, una tarea que hemos realizado varias veces en otros ejercicios es hacer
parpadear un LED, lo cual implica una serie de pasos (encender, esperar, apagar…).
Podría resultarnos útil y cómodo no tener que escribir todos los pasos cada vez, sino
tener una función parpadeo que lo automatice.
Lo primero que tenemos que hacer es definir qué hace nuestra función, es decir,
qué tarea o conjunto de tareas realiza. Esto siempre lo tenemos que escribir en el
apartado Variables globales y funciones de nuestro programa. Para ello utilizamos la
pestaña función1, donde debemos cambiarle el nombre haciendo clic en los tres
puntos y con ello quedará declarada. Al igual que con las variables, debemos
nombrarlas siguiendo las mismas reglas. Después, siempre que queramos utilizarla,
tendremos que ejecutarla en el Bucle principal (Loop) con el bloque Ejecutar de la
categoría Funciones:
Figura 47. Declaración y ejecución de una función.
Imaginemos ahora que queremos tocar una pequeña melodía varias veces en
distintos momentos del programa y encender un LED presionando un botón.
Normalmente deberíamos repetir todos los bloques de la melodía cada vez que
queramos usarla. Al final tendríamos un programa largo y difícil de entender y

modificar. ¿Por qué no reutilizar siempre los mismos bloques? Vamos a crear una
función que contenga la melodía para más tarde utilizarla siempre que la
necesitemos. Para ello usaremos el zumbador, un botón y un LED.
De nuevo, para poder utilizar una función, primero hay que crearla dentro de la
zona Variables globales y funciones.
Figura 48. Ejemplo de declaración de una función.
Una vez creada, es necesario ejecutarla dentro del Bucle principal (Loop). Las
funciones no se ejecutan a no ser que las llamemos mediante el bloque Ejecutar.
Figura 49. Ejemplo de ejecución de una función dentro de una estructura de programación.

Si no utilizásemos la función el programa quedaría de la siguiente manera:
Figura 50. Comparativa de programación sin el uso de funciones.
Como podemos ver, el programa es mucho más corto usando funciones, siendo
mucho más rápido y fácil de crear. Además, si por alguna razón queremos modificar
la melodía, solo tendremos que cambiarla en la función y no en cada parte del
programa.

Funciones con retorno
Vamos a ver un ejemplo con el siguiente reto: necesitamos realizar un medidor de

distancia que nos devuelva el valor de la misma en metros.
Utilizaremos para este reto el componente ultrasonidos que nos va a medir la

distancia aproximada en centímetros. Por tanto, podemos realizar una función con
retorno que devuelva el valor de haber realizado la operación de conversión de la
magnitud:
𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 (𝑐𝑚) / 100 (𝑐𝑚/𝑚) = 𝑑𝑖𝑠𝑡𝑎𝑛𝑐𝑖𝑎 (𝑚)
Después, mostraremos este valor por el Monitor Puerto Serie.
Declaramos la función en el apartado de Variables globales y funciones.
Figura 51. Declarar una función.
Damos un nombre a la función (en nuestro caso distancia_metros) y en su interior,

declaramos la variable que va a contener la operación matemática, nosotros la
hemos llamado distancia y la igualamos a dicha operación.
En el Bucle principal (Loop), utilizamos el bloque Enviar de la categoría de

Componentes, para mandar por monitor puerto serie el valor que devuelve la
función tras haberla ejecutado, por lo que utilizaremos para rellenarlo el bloque
Ejecutar.

Figura 52. Bloque ejecutar función con retorno.
Y añadimos también una pequeña espera de 0,5 segundos para poder ver mejor los
valores en el Monitor Puerto Serie.
Figura 53. Ejemplo de programación de funciones con retorno.
IMPORTANTE. Si declaramos una variable, dentro de una función, esa variable será
local y solo podrá ser utilizada dentro de dicha función.

Tema 4. Programación III: Máquinas de Estados y
Bloques Avanzados
En este tema, aprenderemos a crear y utilizar máquinas de estados y conoceremos

nuevos bloques de programación más avanzados que nos permitirán realizar
programaciones más complejas.
▶ Aprender qué es una máquina de estados, cuál es su estructura y para qué

podemos utilizarlas.
▶ Aprender a programar melodías sin restricción de notas musicales.
▶ Aprender un nuevo bucle, el bucle Contar.
▶ Aprender a mapear.
▶ Aprender a utilizar el bloque Obtener tiempo de ejecución.
▶ Conocer qué es la lógica booleana y aprender a realizar condicionales
compuestos.
▶ Aprender qué son y cómo se utilizan las funciones con argumentos.
4.2. Máquinas de estados
Una máquina de estados es un programa que reacciona de una forma u otra

dependiendo no solo de lo que está sucediendo, sino también de su estado anterior.
Es por tanto, un programa que no solo depende de sus entradas y salidas, también
tiene memoria, estados que influyen en su comportamiento.

El programa tendrá una serie de estados, cada uno de los cuales tendrá un
comportamiento diferente. Para cambiar de estado existirá uno o varios eventos
posibles. Cuando suceda alguno de estos eventos, se producirá un cambio de
estado.
Vamos a analizar en qué estados pueden estar dos LED. Consideramos que cada LED
puede estar apagado o encendido. Al tener dos LED, podemos tener cuatro estados
diferentes.
LED 1 LED 2
Estado 0 (S0) ON OFF
Estado 1 (S1) OFF ON
Estado 2 (S2) ON ON
Estado 3 (S3) OFF OFF
Tabla 4. Estados para dos LED.
El modo de nombrar y ordenar los estados es a nuestra elección.
Ahora vamos a pensar que el evento que va a originar el cambio de estado va a ser
la pulsación de un botón. Cada vez que pulsemos el botón cambiaremos al siguiente
estado y del estado final (S3) volveremos al inicial (S0). Podemos ver la
representación del cambio de estados en en el siguiente diagrama de estados,
siendo EV el evento que origina el cambio:
Figura 54. Diagrama de estados.

En un programa con una máquina de estados hay siempre dos partes. Una es la
ejecución de cada estado (las acciones que se realizan en cada uno) y la otra el
cambio entre estados (los eventos que originan el cambio).
Reto con máquinas de estados. Las luces de Navidad
Vamos a ver un reto donde aplicar esta estructura de programación:
“Este año he tenido mucho tiempo libre, así que he decidido comprar un montón de
LED para crear las luces de mi árbol navideño. Me he fijado en luces ya hechas y,
normalmente, tienen tres estados: los LED apagados, los LED que parpadean al
mismo tiempo y los LED que parpadean alternativamente. Voy a basarme en ese
comportamiento de forma que cada vez que presione el botón pasaré al siguiente
modo de luz.”
Vamos a simular el problema con dos LED y un botón, que va a hacer que pasemos
al siguiente estado, el evento.
En el primer estado, S0, se apagan ambos LED. En el segundo estado, S1, parpadean
al mismo tiempo y en el tercer estado, S2, parpadean alternativamente.
LED 1 LED 2
Estado 0 (S0) OFF OFF
Estado 1 (S1) ON-OFF ON-OFF
Estado 2 (S2) ON-OFF OFF-ON
Tabla 5. Estados para dos LED y un botón.
Empezamos por la parte del programa que realiza el cambio entre estados.
Queremos que cada vez que presionemos el botón pasemos al siguiente estado,
para lo cual, lo primero que vamos a realizar es declarar una variable global, que

vamos a llamar “estado”, que nos permitirá almacenar el estado de cada momento.
Será, por tanto, una variable numérica.
Figura 55. Declaración de la variable estado.
Cambiaremos de estado cada vez que presionemos el botón, lo que implica sumar 1
a la variable, excepto cuando estemos en el estado 2 y presionemos de nuevo el
botón, que volveremos al estado inicial, 0.
Cuando presionamos el botón, el programa puede detectar varias pulsaciones, es lo

que se conoce como el efecto rebote. Para evitarlo, utilizaremos un bucle Mientras
que no contenga nada en su interior, es decir, que mientras se cumpla la condición
de que el botón siga pulsado, el programa no haga nada. Será cuando soltemos el
botón, cuando seguirán ejecutándose el resto de instrucciones.
La programación de la parte de cambios de estado quedaría entonces de la

siguiente manera:
Figura 56. Programación que realiza el cambio del valor de la variable estado.

Continuamos por la parte del programa que ejecuta las acciones que han de
realizarse en cada estado.
Queremos que los LED se comporten de una forma u otra según el valor que tenga
la variable estado. Para ello utilizaremos el bloque Comprobar cuál es el valor de
que se encuentra en la categoría de Control. Este bloque comprueba el valor que
tiene la variable que le indiquemos en el desplegable y lleva asociados los bloques si
es igual a, ejecutar y en otro caso, ejecutar. Utilizaremos cada uno de ellos igual que
los bloques condicionales, introduciendo las instrucciones a realizar en cada uno de
los valores de la variable o estados.
Figura 57. Bloques Comprobar valor.
En el primer estado, el número 0, apagamos ambos LED. El segundo estado o estado

1, les hacemos parpadear al mismo tiempo y mientras que el tercer estado o estado
2 los hace parpadear alternativamente.
El programa quedará entonces de la siguiente manera.

Figura 58. Programación que realiza las acciones según el valor de la variable estado.
Podemos comprobar que cada vez que pulsamos el botón vamos cambiando de
estado y los LED se comportan de distinta manera.

4.3. Bloques avanzados. Melodías avanzadas
En el apartado 3.7. hemos visto cómo hacer uso del zumbador.
En el bloque básico que ejecuta su sonido, aparte del tiempo de duración, podemos
elegir entre unas notas predeterminadas. Sin embargo, es muy habitual que los
alumnos y alumnas necesiten otras notas que no aparecen en dicho bloque para
poder crear una melodía proveniente de una partitura.
Para ello, utilizaremos el bloque de la pestaña Avanzados de la categoría

Componentes.
Figura 59. Bloques avanzados Sonar zumbador.
Primeramente debemos saber que el zumbador genera un sonido al vibrar en la

frecuencia de la señal eléctrica que recibe y que el valor de esa frecuencia va a
determinar el tono o la nota de la escala musical, ya que las notas musicales son
vibraciones del aire a una frecuencia determinada.
Por ejemplo, en la escala que habitualmente utilizamos, el valor de la frecuencia de

la nota Do es 262, el de la nota Re es 294, el de la nota Mi es 330, el de la nota Fa es
349, etc. Son las frecuencias de las notas correspondientes a la 4ª octava y son las
que vienen predeterminadas en el bloque básico Sonar zumbador.
A partir de ahí, si queremos notas más agudas, nos iremos a octavas superiores y si
las queremos más graves, nos iremos a octavas inferiores.
En la siguiente tabla podemos ver las frecuencias correspondientes a cada nota en

cada octava.

Frecuencia de las notas musicales en Hércios (Hz)
Octavas
1ª 2ª 3ª 4ª 5ª 6ª 7ª 8ª
Do 33 65 131 262 523 1046 2093 4186
Do#/Reb 35 69 139 277 554 1109 2217 4435
Re 37 73 147 294 587 1175 2349 4699
Re#/Mib 39 78 156 311 622 1244 2489 4978
Mi 41 82 165 330 659 1318 2637 5274
Fa 44 87 175 349 698 1397 2794 5588
Fa#/Solb 46 92 185 370 740 1480 2960 5920
Sol 49 98 195 392 784 1568 3136 6272
Sol#/Lab 52 104 208 415 831 1661 3322 6645
La 55 110 220 440 880 1760 3520 7040
La#/Sib 58 116 233 466 932 1865 3729 7459
Si 62 123 247 494 988 1975 3951 7902
Tabla 6. Frecuencias notas musicales (Hz)
Para introducir dichas frecuencias, rellenaremos los huecos del bloque avanzado
Sonar zumbador con dos bloques de número e introduciremos en el primero la
frecuencia de la nota musical y en el segundo el tiempo de duración de la nota.
Así por ejemplo, si deseamos hacer sonar el zumbador con un Do agudo, que se
corresponde con la 5ª octava, durante 1 segundo, rellenaremos el bloque de la
siguiente manera:
Figura 60. Ejemplo de cómo rellenar los bloques avanzados Sonar zumbador.

4.4. Bloques avanzados. El bucle Contar (For)
El bucle Contar o For repite una serie de acciones un número concreto de veces.
Ya vimos la versión más sencilla de este bloque en el apartado 3.6. con el bloque
Repetir. La diferencia fundamental en este caso es que el bloque Contar nos
permitirá modificar ciertos parámetros y utilizar el resultado de la operación (sumar
o restar) dentro de una variable.
Figura 61. Bloque Contar con.
Vamos a verlo con un ejemplo: el reto consiste en hacer parpadear un LED cada vez
más lento.
Primero vamos a declarar una variable global numérica y la nombraremos tiempo.

En ella iremos guardando el valor de la cuenta, que en este caso será ir sumando 1,
de forma reiterada, desde 0 ms hasta 5000 ms. Después indicaremos estos valores
en el bloque, quedando por tanto de la siguiente manera:
Figura 62. Ejemplo de cómo rellenar el bloque Contar con.
Dentro del bucle, introduciremos las instrucciones a realizar, que en este caso será
hacer parpadear un LED. Tendremos en cuenta que el tiempo de espera no será fijo
esta vez, sino que dependerá de la variable. Para lograr esto, utilizaremos el bloque
Esperar que se encuentra en la pestaña Avanzados de la categoría de Control.

Figura 63. Bloque Esperar avanzado.
El programa quedará de la siguiente manera:
Figura 64. Ejemplo de programación con el bloque Contar con.
El bucle Contar repetirá el parpadeo de 0 a 5000 veces y la variable tiempo, irá

aumentando su valor en cada repetición, consiguiendo que el LED parpadee cada
vez más lento.
4.5. Bloques avanzados. Mapear
Mapear es convertir un rango de valores en otro distinto.

Encontramos los bloques con los que podemos realizar un mapeado en la categoría
de Matemáticas, uno en la pestaña Básicos y otro en la pestaña Avanzados.
Figura 65. Bloques Mapear.
Para poder entender cómo utilizar estos bloques, vamos a realizar algunos ejemplos
con un servo. Recordamos primeramente que el servo es capaz de posicionarse en
el lugar que le indiquemos de la escala de 0 a 180 grados y permanecer en esa
posición hasta que le indiquemos otra.
IMPORTANTE. Todos los servomotores del mercado

pueden experimentar vibraciones en los ángulos 0 o
180 grados. Esto se produce debido a las tolerancias
de fabricación y puede acortar la vida del motor. Si
notamos que el servo vibra en estos ángulos
programaremos que se mueva a ángulos cercanos
como 5 o 175 grados. Además, debemos evitar
cambios de dirección bruscos ya que podríamos llegar
a quemarlo. Podemos protegerlo usando esperas. Figura 66. Movimiento Servo
Vamos a controlar la posición del servo con un potenciómetro, de forma que a

valores más bajos del mismo el servo se mueva a ángulos más pequeños y al
contrario, a valores más altos del potenciómetro, ángulos mayores en el servo.
El rango de medida del potenciómetro es de 0 a 1023, mientras que las posiciones

del servo irán desde 0 hasta 180 grados. Para que tenga sentido, tendremos que

transformar la escala del potenciómetro y adaptarla a la del servo. Esto podemos
conseguirlo mapeando sus valores.
Primeramente, vamos a declarar una variable que contenga ese mapeado. La

declararemos en el apartado de Variables globales y funciones, llamándola
mapeado_pot y la igualaremos a 0, ya que va a contener un número.
En el apartado Bucle principal (Loop), le daremos el valor a la variable añadiendo el

bloque Mapear de la pestaña Básicos de la categoría de Matemáticas.
Figura 67. Bloque Mapear básico.
En el primer hueco situaremos aquella medida que queremos mapear, para nuestro
ejemplo la lectura del potenciómetro. En el segundo hueco situaremos hasta qué
valor va a llegar la nueva escala, en nuestro caso 180. Como podemos observar, el
primer valor de la escala no podemos elegirlo en el bloque básico Mapear, sino que
viene fijado a 0.
A continuación, situaremos el bloque Mover servo a que se encuentra en la pestaña

Avanzados de la categoría Componentes.
Figura 68. Bloque Mover servo avanzado.
Este bloque tiene un hueco en el que introduciremos la lectura de la variable, que

contiene el valor del mapeado.
La programación quedará entonces de la siguiente manera:

Figura 69. Ejemplo del uso del bloque Mapear básico.
Cargando el programa a la placa podremos comprobar que cuando giramos el

potenciómetro a sus diferentes valores, también lo hará el servo pasando grado a
grado por toda su escala.
Hemos comentado anteriormente que es recomendable evitar los valores límites del
servo, es decir los grados 0 y 180 por lo que podemos reducir el rango a 5 - 175
grados. Pero con el bloque básico Mapear no podríamos realizarlo, ya que el valor 0
viene fijado. Vamos a utilizar para ello el bloque Mapear de la pestaña Avanzados.
Figura 70. Bloque Mapear avanzado.
Este bloque deja abierta la posibilidad de elegir cualquiera de los dos rangos que
vamos a referenciar.

La programación entonces quedaría de la siguiente manera:
Figura 71. Ejemplo del uso del bloque Mapear avanzado.
4.6. Bloques avanzados. Obtener tiempo de ejecución
En muchos de los programas que hemos ido realizando hemos incluido alguna
espera con el bloque Esperar para simular la parada del bucle. Pero este bloque
puede darnos muchos problemas cuando queremos que nuestro programa realice
más acciones. La orden Esperar detiene toda la programación de la placa mientras
dure el tiempo indicado, por lo que no podremos realizar ninguna otra acción hasta
que esta termine.
En determinados programas, utilizar el bloque Esperar puede hacer que nuestro

programa no funcione como nosotros pretendemos. Podemos comprobarlo en el
siguiente ejemplo.
Realizaremos un programa con dos LED y un botón con las siguientes

especificaciones:

- El primer LED parpadeará continuamente estando dos segundos encendido y
dos segundos apagado.
- El segundo LED se encenderá cuando pulsemos el botón y se apagará cuando
dejemos de pulsarlo.
En una primera lectura puede parecernos un programa sencillo, ya que son dos
acciones fáciles de programar por separado, por lo que podemos realizar la
siguiente programación dentro del apartado Bucle principal (Loop):
Figura 72. Ejemplo de programación.
Sin embargo, esta programación no sería la más adecuada, ya que durante las
instrucciones Esperar la placa estará detenida. Mientras la placa está detenida no se
comprobará si el botón está pulsado o no, por lo que el segundo LED no se
encenderá si no tenemos el botón pulsado entre parpadeo y parpadeo.
Para que programas como el del ejemplo anterior funcionen correctamente

necesitamos otro modo de calcular el tiempo transcurrido sin detener la placa.

El bloque Obtener tiempo de ejecución que se encuentra en la pestaña Avanzados
de la categoría de Control nos proporciona el tiempo que ha transcurrido desde que
se encendió la placa en milisegundos.
Figura 73. Bloque Obtener tiempo de ejecución.
No podemos modificar este reloj, ni inicializarlo durante el programa, tan solo

podemos leer el tiempo que ha transcurrido. De este modo, podemos realizar otras
tareas mientras esperamos a que transcurra un tiempo determinado.
Un modo de resolver el ejemplo anterior puede ser, al iniciar el programa, en las
Instrucciones iniciales (Setup) almacenaremos en una variable, que llamaremos
tiempoDeEspera, el tiempo de ejecución y le sumaremos 2000. Como el tiempo de
ejecución está avanzando continuamente, pero la variable se mantiene fija porque
adquirió el valor al inicio del programa, cuando transcurran los 2000 milisegundos,
el tiempo de ejecución superará a la variable tiempoDeEspera. Por lo tanto, cuando
el tiempo de ejecución sea mayor que la variable, el LED deberá encenderse o
apagarse.
El problema ahora es que sabemos que tras 2000 milisegundos hay que encender el
LED o apagarlo, pero no sabemos en qué estado está dicho LED, por lo que es
necesario almacenar su estado en otra variable a la que llamaremos estadoLed.
Transcurrido el tiempo, tendremos que comprobar en qué estado está el LED, si

estaba encendido lo apagaremos y cambiamos la variable estadoLed a cero. Si el
LED estaba apagado, lo encendemos y cambiamos la variable estadoLed a uno.
Por último, tras cambiar el estado del LED, volvemos a situar la variable
tiempoDeEspera 2000 milisegundos por encima del tiempo de ejecución, para que
vuelva a cambiar el estado del LED 2000 milisegundos más tarde.
La programación queda entonces de la siguiente manera:

Figura 74. Ejemplo de programación utilizando el bloque Obtener tiempo de ejecución.

4.7. Bloques avanzados. Condicionales compuestos
A la hora de realizar condicionales en programación, es posible que queramos hacer

múltiples comparaciones para realizar una acción, como, por ejemplo, una alarma
que funcione al detectar movimiento, pero que solamente funcione de noche, o un
timbre que pueda funcionar con dos botones diferentes, sonando cuando se pulsa
cualquiera de los dos.
Cuando en programación actúa un condicional simple, lo que hace es comprobar si
la condición que contiene es verdadera o falsa. Pero si queremos múltiples
comprobaciones, utilizaremos la lógica booleana, la cual define unas operaciones
para este tipo de conjuntos.
La lógica booleana. Operaciones and, or, no
La lógica booleana es la base de cualquier aparato digital, desde circuitos

electrónicos básicos, hasta móviles u ordenadores, y se denomina así en honor a
George Boole, matemático inglés del siglo XIX, que fue el primero en definirla.
La lógica booleana se basa en preguntas que solo tienen dos respuestas posibles:
sí/no o verdadero/falso.
Si contamos con varios datos de tipo booleano, estos se pueden combinar en

expresiones lógicas mediante los operadores: and (y), or (o) y no (distinto de).
La operación booleana “y” se utiliza cuando queremos que el resultado sea

verdadero, cuando dos condiciones son verdaderas. Se puede resumir su función
con la siguiente tabla:

Operación “y”
Falso y Falso Falso
Falso y Verdadero Falso
Verdadero y Falso Falso
Verdadero y Verdadero Verdadero
Tabla 7. Operación “y”.
Podemos ver que la única manera de obtener un resultado verdadero, es teniendo

las dos condiciones verdaderas.
Figura 75. Bloque operación booleana y.
La operación booleana “o” se utiliza cuando queremos que la condición sea

verdadera cuando cualquiera de las entradas sea verdadera. Su función se resume
en la siguiente tabla:
Operación “o”
Falso y Falso Falso
Falso y Verdadero Verdadero
Verdadero y Falso Verdadero
Verdadero y Verdadero Verdadero
Tabla 8. Operación “o”.
En este caso el resultado solo será falso si ambas entradas son falsas, y será
verdadera si una de las entradas, o ambas, son verdaderas.
Figura 76. Bloque operación booleana o.

La operación booleana “no” se utiliza cuando queremos invertir o negar la
condición. Es decir, si el resultado es verdadero, el resultado de su negación será
falso.
Figura 77. Bloque operación booleana no.
En programación, podemos encontrar los operadores booleanos en la categoría

Lógica, pero para utilizarlos, no podemos usar el condicional habitual, si no que
debemos acudir a los bloques de la pestaña Avanzados en la categoría Control. Ahí
podemos encontrar un bloque Si, ejecutar que deja abierta la construcción de la
condición compuesta:
Figura 78. Bloque condicional compuesto Si.
Vamos a ver un ejemplo.
Operación “y”
Imaginemos que queremos instalar un sistema de entrada en un aparcamiento para

coches que quiere evitar que se abra la barrera si pasa una persona, de modo que
únicamente lo haga cuando dos sensores infrarrojos situados a cierta distancia
detecten la parte delantera del coche y la parte trasera del mismo a la vez.
Empezaremos colocando en la pestaña Hardware los siguientes elementos:

● Sensor Infrarrojos 1
● Sensor Infrarrojos 2
● Servo
Figura 79. Componentes Sensor infrarrojo 1, Sensor infrarrojo 2 y Servo conectados a la placa controladora
Zum Core.
En la pestaña Bloques, colocaremos en el Bucle principal (Loop) el bloque Si ejecutar

de la pestaña Avanzados de la categoría de Control. Lo primero que colocamos para
rellenar la condición será la operación que vamos a realizar, en este caso es un “y”,
que lo encontramos en la categoría Lógica. En cada uno de los huecos de este
bloque situaremos dos bloques =, que se encuentran en la misma categoría. Vamos
a crear entonces las dos igualdades que se tienen que cumplir:
- que el IR 1 detecte, es decir que sea igual a Verdadero o a 1

- que el IR 2 detecte, es decir que sea igual a Verdadero o a 1
Una vez construida la condición compuesta, en su interior colocamos las

instrucciones a ejecutar si se cumplen ambas:
- Mover el servo a la posición de apertura, 95 grados

- Esperar unos segundos para que pueda pasar el coche
- Mover el servo a la posición de cierre, 5 grados
Por último, si no se cumple la condición anterior, moveremos el servo a la posición

de barrera bajada.

Figura 80. Ejemplo de programación con la operación booleana y.
Operación “o” y “no”
Imaginemos que queremos instalar un sistema de control de iluminación eficiente

en el que queremos que la luz se encienda si un sensor de infrarrojos detecta
presencia o si pulsamos un botón, pero que esto no ocurra si la luz ambiente es
elevada, es decir, si es de día.
En este caso, apagaremos el LED siempre que la luz ambiente sea alta o si ésta es
baja pero no está pulsado el botón, ni se está detectando presencia. Encendemos el
LED cuando la luz ambiente es baja y el botón se ha pulsado o el sensor infrarrojo
detecta presencia o ambas cosas a la vez.
Empezaremos colocando en la pestaña Hardware los siguientes elementos:

● Sensor infrarrojos
● Sensor de luz
● Botón
● LED
Figura 81. Componentes Botón, Sensor de infrarrojos, LED y Sensor de luz conectados a la placa
controladora Zum Core.
En la pestaña Bloques, situaremos en el Bucle principal (Loop) el bloque Si ejecutar

de la pestaña Avanzados de la categoría de Control. Lo primero que colocamos para
rellenar la condición será la operación que vamos a realizar, en este caso es un “o”,
que lo encontramos en la categoría Lógica.
En el primer hueco de este bloque situaremos un bloque =, que se encuentran en la

misma categoría, y formamos la primera condición: que la luminosidad sea mayor
de 100 (ambiente con luz).
Si nos fijamos, sólo nos queda un hueco en el que podremos formar una condición,
pero en nuestro ejemplo necesitamos formar dos más. Para poder realizarlo,
anidaremos un bloque “y”, como puedes ver en la imagen, en el hueco que nos
queda libre.
Figura 82. Estructura de bloques anidados.

En el segundo hueco formamos la segunda condición, que el botón no esté pulsado.
Una forma fácil de realizarlo es utilizando el bloque no de la categoría Lógica. La
condición quedaría no Leer botón y, si se cumple, lo que envía a la placa es un
verdadero.
En el tercer hueco formamos la condición restante, que el sensor infrarrojos no esté

detectando. Al igual que con el botón, la condición quedaría no Leer IR y, si se
cumple, lo que envía a la placa es un verdadero.
Una vez construida la condición compuesta, en su interior colocamos las

instrucciones a ejecutar, en este caso apagar el LED.
Por último, si no se cumplen las condiciones descritas, encenderemos el LED.
Figura 83. Ejemplo de programación con las operaciones booleanas o y no.
4.8. Bloques avanzados. Funciones con argumentos
Una característica muy útil de las funciones es que pueden utilizar variables creadas
específicamente para ellas. A estas variables las llamamos argumentos.
Los dos tipos de funciones que hemos visto hasta ahora, sin retorno y con retorno,
pueden a su vez llevar argumentos que las definan. Los bloques para usar este tipo

de funciones y sus asociados, los encontramos en la pestaña Avanzados de la
categoría de Funciones.
Para declararlas vamos a la pestaña Variables globales y funciones, hacemos clic en

función1 y la renombramos. Los argumentos se añaden haciendo clic en los tres
puntos y seleccionando Activar argumentos en el menú desplegable.
Figura 84. Bloques para declarar funciones con argumentos.
Cuando definimos una función con argumentos, tenemos que especificar sus
variables asociadas (argumentos), es decir, declararlas y definir de qué tipo son y
cómo se llaman. Estas variables sólo existirán dentro de la función y su valor lo
especificaremos cada vez que la ejecutemos.
Figura 85. Bloque para la definición de un argumento.
Podemos elegir entre los siguientes tipos de variables a la hora de definirlas:
● Entero. Para declarar una variable numérica que sólo admite valores enteros.
● Decimal. Para declarar una variable numérica que admite valores decimales.
● Texto. Para declarar una variable que admite textos. Podemos introducir un
número, pero este será interpretado también como un texto, no podremos
realizar operaciones matemáticas con él, como sumarlo o restarlo.

● Carácter. Para declarar una variable que admita un carácter, como, por
ejemplo, una letra.
● Valor lógico (Boolean). También conocido como variable booleana. Para
declarar una variable que solo pueda tener dos estados, verdadero o falso.
Vamos a ver distintos ejemplos de este tipo de funciones.
Funciones sin retorno, con argumentos
Imaginemos que queremos que un LED parpadee a distintas frecuencias que van a
depender del valor de un potenciómetro.
Para comenzar, colocamos en la pestaña Hardware los componentes que

necesitamos. En este caso vamos a utilizar un LED y un potenciómetro, que es un
sensor analógico y se colocará en dicha ristra de pines, en nuestro caso en el A0.
Figura 86. Componentes LED y Potenciómetro conectados a la placa controladora Zum Core.
A continuación, en la pestaña Bloques, en el apartado de Variables globales y

funciones, declaramos una función con argumentos y sin retorno. La nombraremos
parpadeo y rellenaremos el hueco con una variable de tipo entero que llamaremos
tiempo.

Esta función va a contener el parpadeo del LED con una cadencia que dependerá de
la variable tiempo, quedando de la siguiente manera:
Figura 87. Ejemplo de declaración de función con argumento y sin retorno.
Por último, en el apartado Bucle principal (Loop), ejecutamos la función, dándole el

valor a la variable tiempo, que en este caso será la lectura del potenciómetro.
Figura 88. Ejemplo de ejecución de una función con argumentos.
De esta manera, la variable tiempo incorporará los valores que el potenciómetro le

esté haciendo llegar a la placa.
Funciones con retorno, con argumentos
Pongamos un ejemplo. Imaginemos que queremos calcular la hipotenusa de

triángulos rectángulos de distintos tamaños. Tal como dice el Teorema de Pitágoras
la hipotenusa de un triángulo rectángulo es:
ℎ² = 𝐶𝐴² + 𝐶𝐵²

O lo que es lo mismo:
ℎ= 𝐶𝐴² + 𝐶𝐵²
En primer lugar definimos la función en la pestaña Variables globales y funciones.

Hacemos clic con el ratón en la pestaña función1, y después en los tres puntos que
quedan a su derecha, ahí podemos cambiar el nombre y activar los argumentos de
entrada.
Como hemos visto, para calcular la hipotenusa necesitamos saber el valor de sus
catetos. Podemos introducirlos en la función como argumentos, “cateto_A” y
“cateto_B”, siendo ambos de tipo decimal. Para introducir los dos en la función
usaremos el bloque coma, que se encuentra en la pestaña Avanzados de la categoría
de Funciones, y lo ponemos en el hueco destinado para ello.
Figura 89. Bloque coma para más de un argumento.
A continuación, realizamos las siguientes acciones:

- Declaramos una variable numérica a la que llamaremos “hipotenusa”. Será
en ella donde guardemos el valor del cálculo de la misma.
- Daremos valor las variables “cateto_A” y “cateto_B”, que será el cuadrado de
ellas mismas.
- Damos valor a la variable “hipotenusa”, conteniendo la operación
matemática del teorema.

Figura 90. Ejemplo de declaración de función con argumentos y retorno.
Por último, la función devolverá el valor de la variable “hipotenusa”.

En el Bucle principal (Loop) ejecutaremos la función dándole los valores de los
argumentos, los catetos de nuestro triángulo, y mostraremos por el monitor puerto
serie dicha ejecución, de forma que en el Monitor Puerto Serie veremos
directamente el valor calculado de la hipotenusa.
El programa completo quedaría de la siguiente manera:
Figura 91. Ejemplo de programación de función con argumentos y retorno.

Referencias bibliográficas
▶ Educación Primaria (s.f.). Recuperado de

http://www.educacionyfp.gob.es/contenidos/estudiantes/educacion-primari
a.html
▶ Hernández Martín, A. y Olmos Migueláñez, S. (2011). Metodología de
aprendizaje colaborativo a través de las tecnologías. Salamanca: Ediciones
Universidad de Salamanca.
▶ Ministerio de Educación y Formación Profesional. (2018) Programación,
robótica y pensamiento computacional en el aula. Recuperado de
http://code.intef.es/wp-content/uploads/2018/10/Ponencia-sobre-Pensamie
nto-Computacional.-Informe-Final.pdf
▶ Pinto Salamanca, M.L., Barrera Lombana, N. y Pérez Holguín, W.J. (2010). Uso
de la robótica educativa como herramienta en los procesos de enseñanza.
Ingeniería Investigación y Desarrollo I2+D, 10(70), pp. 15-23.
▶ Ruiz-Velasco Sánchez, E. (2007). Educatrónica: innovación en el aprendizaje
de las ciencias y la tecnología. Madrid: Ediciones Díaz de Santos.

Anexo I. Preguntas frecuentes Bitbloq
Listado de problemas que pueden surgir durante la utilización de Bitbloq.
No carga la programación a la placa
1. Conectamos la placa al ordenador con el cable USB y abrimos Bitbloq en el navegador

Google Chrome.
Figura 92. Conexión de la placa al ordenador.
2. Dentro del programa, en la pestaña Hardware, seleccionamos en el apartado Placas la

placa controladora de la que dispongamos y la arrastramos hacia el recuadro blanco. Si
tenemos una placa distinta a la que aparece en el listado compatible con la familia UNO,
utilizaremos la placa Arduino UNO.
Figura 93. Pestaña Hardware.

3. Hacemos clic en la pestaña Bloques y pulsamos sobre el botón Cargar. Aparecerá un
cuadro de diálogo, hacemos clic en el botón Sí, pero le he dado a “Cancelar” igualmente.
Figura 94. Cuadro de diálogo, No has seleccionado ninguna placa.
4. Aparecerá el siguiente cuadro de diálogo, en el cual debemos hacer clic en Sí, está
conectada.
Figura 95. Cuadro de diálogo No hay placa conectada.
5. En el siguiente cuadro de diálogo, hacemos clic en No, instalar los drivers.

Figura 96. Cuadro de diálogo Instalar Drivers.
6. Aparecerá una ventana de descarga y guardaremos el archivo en la carpeta que

queramos de nuestro ordenador. Una vez completada la descarga, descomprimimos y
realizamos la instalación mediante el asistente.
Figura 97. Ventana de descarga.
7. Para Sistemas Operativos Linux, todos los pasos realizados son iguales excepto el 5 y el
6, que son sustituidos por:
Una vez le hemos dicho que la placa está conectada, nos aparece la siguiente ventana:

Figura 98. Ventana de permisos en Linux.
Abrimos la Terminal y ejecutamos el comando que nos indica en la ventana (es muy
importante respetar mayúsculas y minúsculas). Cuando nos lo pida introduciremos la
contraseña de nuestro equipo y pulsaremos la tecla Intro.
No aparecen todas las opciones de Bitbloq
Esto ocurre cuando se utiliza un navegador diferente a Google Chrome, puesto que
Bitbloq solo es compatible al 100% con este navegador.
En los demás navegadores puede funcionar, pero es muy probable que no aparezcan
todas las opciones.
No funciona nada en Bitbloq
Si Bitbloq no se carga correctamente, puede deberse a los siguientes motivos:

- que la conexión a Internet no es estable;
- no se esté usando el navegador Chrome en su última versión.

No se abre la pestaña Bloques
Si en la pestaña Hardware se pueden añadir y conectar todos los componentes, pero al ir

a la pestaña Bloques esta no se abre, puede ser que no haya una conexión a Internet
estable.
Para trabajar con Bitbloq se debe disponer de una conexión a Internet lo más estable
posible.
Bitbloq devuelve un error al intentar cargar el programa a la placa
Para comprobar si el error está en la programación o en el proceso de carga de la placa, se

debe pulsar en Verificar. Si da error significa que el fallo se debe a la programación, por lo
que será necesario revisar que:
● no haya bloques con huecos vacíos.

● no se hayan guardado letras en variables numéricas o viceversa.
● no se utilicen variables o funciones que no estén declaradas correctamente.
● todos los componentes y variables tengan nombres válidos y no repetidos.

Figura 99. Mensaje de error en Bitbloq.
Problemas con la placa Zum Core 2.0/Zum Core y los componentes del kit
Zum Advanced
Listado de problemas que pueden surgir con la placa Zum Core 2.0/Zum Core y los
componentes del kit de robótica Zum Advanced.
No detecta la placa
Si la placa Zum Core 2.0 está correctamente conectada al ordenador a través del cable
USB pero Bitbloq no detecta la placa, lo más probable es que el interruptor de la placa
esté en modo OFF. Para solucionarlo, se debe revisar la placa y cambiar el interruptor a
modo ON.
Sin embargo, la placa Zum Core, cuando está en modo OFF, sí permite que el programa se
cargue a la placa, aunque este no se ejecuta. Para que se ejecute hay que cambiar el
interruptor a modo ON.

El programa se carga en la placa, pero algunos componentes no hacen nada
En primer lugar, se debe comprobar que los componentes están bien conectados, es decir,
que los cables coinciden con los colores de los pines a los que está conectado el
componente.
A continuación, será necesario comprobar que los componentes están conectados en los
mismos pines tanto físicamente (en la placa) como en el apartado Hardware de Bitbloq.
Si sigue sin funcionar, se deberá comprobar que el componente no está estropeado
probándolo de forma aislada en un programa sencillo.
El servo de rotación continua gira cuando debería estar parado (solo para los
servos que poseen dicha funcionalidad)
Esto sucede porque el servo de rotación continua no está bien calibrado.

Para calibrarlo, se debe ejecutar un programa en el que se dé la instrucción de parar al
servo y utilizar un destornillador para calibrarlo hasta conseguir que se pare.
Figura 100. Bloque Parar servo continuo.
Si tras programar que se pare el servo de rotación continua se sigue moviendo, es

necesario calibrarlo.
Para ello, en la parte trasera del componente hay un tornillo que se debe girar con el
destornillador (preferentemente plano) poco a poco hasta que el servo permanezca
quieto.

Hay que tener en cuenta que, al girar el tornillo en uno de los sentidos, se frenará el servo
de rotación continua; si se gira en el otro sentido, se acelerará.
Figura 101. Calibración servo continuo.
Otras consideraciones sobre la placa y los componentes
Para evitar estropear el kit de robótica, deben tenerse en cuenta estas consideraciones:
● Si se fuerza el giro de los servos o se utilizan para mover algo con demasiado peso,
pueden romperse.
● Si la placa Zum Core está conectada y los puntos de soldadura contactan con algún
material metálico, puede producirse un pequeño cortocircuito e inutilizar la placa.


Untitled

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Untitled

Cargado por

Copyright:

Formatos disponibles

Tema 1. Placa Controladora. Componentes Digitales y Analógicos.

Tema 2. Programación I: Condicionales y Bucles 27

Tema 3. Programación II: Variables y funciones 42

Tema 4. Programación III: Máquinas de Estados y Bloques Avanzados 51

Anexo I. Preguntas frecuentes Bitbloq 81

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

1.1. Introducción y objetivos

Los objetivos que se pretenden conseguir son:

▶ Conocer los elementos fundamentales de una placa controladora.

1.2. La placa controladora

Una placa controladora es un dispositivo que almacena un programa y que,

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Figura 1. Esquema flujo de información en la placa controladora.

El elemento fundamental de una placa controladora es el microcontrolador. Es el

Figura 2. Detalle del microcontrolador.

Para que el microcontrolador pueda leer la información de los sensores y actuar a

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

La familia electrónica Arduino conforma un proyecto libre, cuyo objetivo es el de

Arduino(™) es además una marca registrada de electrónica libre, creada por la

Esta proliferación de usuarios y empresas es la que ha conseguido que la familia

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

En esta placa, podemos ver el microcontrolador, donde se almacena el programa

Para alimentar energéticamente a la placa también utilizamos la entrada Micro USB

Por último, el componente Bluetooth integrado, permite comunicar a la placa (sin

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Todo robot tiene tres tipos de componentes:

▶ Sistema de control: como una placa controladora.

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Figura 4. Comparativa robótica y cuerpo humano.

1.4. Componentes digitales y analógicos. Placa Zum Core

Los componentes asociados a la placa controladora tipo Zum Core, se pueden

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Figura 5. Pines digitales placa Zum Core.

• Si conectamos un sensor, éste enviará un valor de 0 Voltios (0 lógico) o 5

• Si conectamos un actuador, es la placa la que escribirá el valor de 0 Voltios

IMPORTANTE. Los pines digitales numerados en la placa con 0 y 1 se usan para

▶ Componentes analógicos: son aquellos componentes que pueden tener todo un

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Figura 6. Pines analógicos placa Zum Core.

Es un sensor digital que se activa cuando se

Se pueden programar distintas acciones

Se encuentra en numerosos dispositivos que

Es un sensor analógico compuesto por una

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Sensor digital capaz de medir la distancia a un

Este sistema es el mismo que utilizan los

Sensor analógico que se compone de una

Se utilizan en muchos dispositivos, como en

El potenciómetro devolverá valores entre 0 y

Tabla 1. Sensores kit Zum Core.

El LED emite luz cuando circula la electricidad

LED Los LED son baratos, gastan muy poca energía

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Permite elegir a qué posición o ángulo debe

Es un componente digital capaz de reproducir

Zumbador Son utilizados en multitud de sistemas para

Tabla 2. Actuadores kit Zum Core.

1.5. Primeros pasos con Bitbloq

La plataforma elegida para programar la placa será Bitbloq, que es un entorno de

Al ser un lenguaje de programación por bloques, no hace falta escribir complicadas

RetoTech_Fundación_Endesa Didáctica de la Robótica con Bitbloq

Como ya hemos comentado antes, Bitbloq es una herramienta que permite la

Accedemos a https://bitbloq.cc/, desde el navegador Google Chrome, y

Figura 7. Registrarse en Bitbloq.