Programando en bitbloq

Bitbloq
Programando los bloques de Funciones PIN.................................................................................... 2
Bloques de declaración de pines .................................................................................................... 2
Leer y escribir en pines ................................................................................................................ 3
Programando un LED en bitbloq (I) .................................................................................................. 6
Programando un LED en bitbloq (II).............................................................................................. 9
Comunicación Serie USB con bitbloq......................................................................................... 12
Programando con variables en bitbloq ...................................................................................... 15
Programando los bloques lógicos............................................................................................... 17
Programando los bloques matemáticos .................................................................................... 21
Programando los bloques de control-El bloque Si… ejecutar............................................. 27
Programando los bloques de control-El bloque Si … (switch…case) ............................... 30
Programando los bloques de control-El bloque Mientras..................................................... 32
Programando los bloques de control-El bloque Contar ........................................................ 34
Programando: Introducción a las funciones y funciones sin retorno ............................... 36
Programando: Funciones con retorno y parámetros de entrada........................................ 39
Programando los bloques de texto ............................................................................................. 43
Programando el sensor de luz en bitbloq.................................................................................. 48
Programando un miniservo en bitbloq....................................................................................... 50
Programando un sensor infrarrojo en bitbloq.......................................................................... 53
Construye tu propio semáforo...................................................................................................... 55
Programando el sensor ultrasonido en bitbloq........................................................................ 59
Do, re, mi, fa, sol… Creando melodías con bitbloq................................................................. 64
PrintBot Evolution – Programando un esquiva-obstáculos ................................................. 69
Programando un Joystick con bitbloq ....................................................................................... 76
Programando un siguelíneas ........................................................................................................ 81

Programando los bloques de Funciones PIN
En este post vamos a descubrir qué opciones nos ofrecen los bloques de la pestaña “Funciones PIN” en bitbloq. ¡Comenzamos!
Bloques de declaración de pines
En primer lugar veremos que aparecen los bloques Pin analógico y Pin digital:
Como vemos, éstos bloques te permiten elegir números entre el 0 y el 13 para los pines digitales y entre A0 y A5 para los analógicos.
¿Seguramente ya sabes por qué verdad? Porque en la placa controladora tenemos ese número de pines:

El bloque Pin analógico sirve para ayudarte a declarar en qué pin has conectado un componente analógico… ¡tiene lógica!
De la misma manera, el bloque Pin digital sirve para indicar en qué pin digital hemos conectado un componente digital.
Sin embargo, éste último bloque podrías cambiarlo por un simple número entero como ves en la siguiente imagen. El efecto es el
mismo pero recuerda no usarlo así con los pines analógicos que en principio necesitan tener la letra A.
Leer y escribir en pines
El bloque LED EN LA PLACA estado… sirve para encender/apagar el minúsculo LED integrado en la placa, el llamado “D13” que está
internamente conectado al pin digital 13. Podrías utilizar este bloque pequeño en lugar de usar el bloque de LED habitual:

El bloque Leer el pin analógico PIN#… hace lo que su nombre indica, leer el estado del componente analógico conectado en ese lugar.
Podrías utilizar este bloque pequeño en lugar de usar un bloque habitual de un componente ya definido (como por ejemplo el del
potenciómetro). En código arduino correspondería con la función analogRead()
El bloque Leer el pin digital PIN#… lee el estado del componente digital conectado. En código arduino correspondería con la
función digitalRead()
Del mismo modo que los bloques para leer, existen dos bloques para escribir: El bloque llamado Escribir en PIN digital… el valor
analógico… sirve para generar en ese pin una señal de salida cíclica (PWM) que nos servirá para actuar sobre ciertos componentes
como por ejemplo los Servomotores o el Zumbador. Aquí se puede ver un ejemplo de cómo sería la equivalencia de usar éste bloque o
el bloque de Servo para escribir el ángulo 90:
En código arduino correspondería con la función analogWrite().
El bloque Escribir en PIN digital… estado… escribe un estado ALTO/BAJO (HIGH/LOW o lo que es lo mismo 1/0) en el pin indicado.
En código arduino correspondería con la función digitalWrite()
Ya sólo queda un pequeño bloque que es el que sirve para definir el estado digital ALTO o BAJO directamente, el cual podemos usarlo
por ejemplo para comparar una variable:

¿Por qué usar los bloques de Funciones PIN?
Como hemos visto, hay muchas equivalencias entre los bloques bitbloq habituales de los componentes (pestañas Octopus bloqs, Zum
bloqs…) y los bloques que acabamos de ver. ¿Para qué entonces usar estos últimos?
Los bloques habituales tienen iconos del componente que programan para facilitar su identificación pero en ocasiones podemos querer
hacer el programa más pequeño sin mostrar una imagen de un LED cada vez que lo activemos, o por ejemplo, si queremos conectar
otros módulos, otros componentes distintos.
Si sabemos cómo medir el voltaje leyendo un pin analógico… Ejem… No sé cómo decir esto pero… ¿crees que sabrías hacer un
sensor pimiento?
Un sensor-verdura puede llegar a tener más utilidad de la que piensas… O al menos… ¡ser muy vistoso y divertido!
- See more at: http://diwo.bq.com/programando-los-bloques-de-funciones-pin/#sthash.hplkygMH.dpuf

Programando un LED en bitbloq (I)
¿Qué son los LED?
La palabra LED es el acrónimo de light-emitting diode (en español, diodo emisor de luz). Los LED
son diodos semiconductores que permiten que la corriente circule únicamente en una dirección y
emiten luz cuando se activan. Uno de los usos más comunes de los LED es el de indicadores en
dispositivos electrónicos, sustituyendo a las pequeñas bombillas que se usaban con anterioridad.
Además, dada su capacidad para operar a altas frecuencias, se usan también en tecnologías
avanzadas y de control.
El desarrollo más reciente de los LED ha permitido que se puedan utilizar en el ámbito de la iluminación ambiental. Aunque actualmente
su uso en este campo es limitado, se prevé un aumento de su presencia en los próximos años, pues tienen numerosas ventajas frente
a las lámparas incandescentes y fluorescentes. Algunas de ellas son las siguientes:
 Bajo consumo de energía.
 Vida útil más larga.
 Menor tamaño.
 Mayor robustez.
 Emisión de calor reducida.
 Mayor resistencia a las vibraciones y a los golpes.
¿Quieres aprender a programar un LED usando bitbloq? Te enseñamos mediante ejemplos:
Vas a necesitar
 2 ZumBloq LED
 Una placa controladora ZUM BT 328 o compatible con Arduino UNO
 Un cable USB
 Y, por supuesto, un ordenador con acceso a internet
Vamos a poner varios ejemplos para que aprendas a programar un LED, ¡al grano!
Ejemplo 1
Encender un LED
Es uno de los ejemplos de programación más sencillos. Necesitas conectar la placa controladora al ordenador con el cable USB. A su
vez, conecta el LED a la placa controladora. Al conectar cualquier componente es muy importante que te asegures de que los colores
de los cables 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.
El LED es un componente digital, ya que admite solo dos estados: apagado y encendido. Todos los componentes, ya sean sensores o
actuadores que tengan solo dos estados, serán digitales, otro ejemplo es el botón (pulsador), que puede estar pulsado o no pulsado.
Los pines digitales se corresponden con la ristra larga de pines de la placa, van del 0 al 13, aunque no se recomienda usar los pines 0 y
1, ya que son los mismos que se usan para la comunicación de la placa con el ordenador, y por ello podría darse un comportamiento
inesperado o que nuestros programas no carguen correctamente.
Seguimos los siguientes pasos para resolver el problema.
Conectamos el LED en el PIN digital 8, tal y como se muestra en el siguiente esquema.

Ahora, programamos con bitbloq la placa controladora para que encienda el LED. Para ello, seleccionamos el bloque LED, le
asignamos el pin digital 8 y establecemos la acción que deseamos desempeñar: en este caso, ENCENDER.
Tras programar la placa controladora, si todo ha ido bien, el LED conectado en el pin digital número 8 debería estar encendido. Si no se
enciende, averigua qué puede haber ocurrido haciéndote las siguientes preguntas: “¿He conectado la placa al ordenador?” “¿He
seleccionado correctamente el puerto al que se ha conectado la placa?” “¿Coinciden los colores de los cables del LED con los del pin al
que lo he conectado?” “¿He asignado un pin digital al bloque de LED en bitbloq?” “¿Me he acordado de ENCENDER el LED en el
bloque?
Ejemplo 2
Apagar un LED
A continuación, vamos a programar nuestra placa controladora para que haga lo contrario, es decir, para que apague el LED. No
olvides programar de nuevo la placa al hacer los cambios.
Vamos a complicarlo un poco, ¿qué tal si ahora hacemos parpadear un LED? En esta ocasión podemos dejar que tú lo intentes por ti
mismo. Debes hacer un programa que haga parpadear un LED (encender 1 segundo, apagar 1 segundo).
Esta solución no funciona porque el programa enciende el LED (durante un instante de tiempo que se corresponde con la velocidad del
microprocesador de la tarjeta controladora) e inmediatamente lo apaga durante otro instante. Y, así, una y otra vez. El efecto de este
programa es que parece que el LED está siempre encendido (con un brillo ligeramente más tenue al habitual).
El modo de hacer que funcione correctamente es introducir pausas. Es decir, cuando, explicamos que el LED debe parpadear
entendemos: ENCENDER – APAGAR – ENCENDER – APAGAR – etc. Esto es incorrecto, en realidad habría que decir: ENCENDER –
ESPERAR 1 SEG. – APAGAR – ESPERAR 1 SEG. – ENCENDER – etc.
Para ello deberás utilizar el bloque esperar
Este bloque hace que el programa espere un tiempo determinado. Para indicar el tiempo, puedes usar un bloque de tipo número o una
variable. Puedes encontrar el bloque número en la pestaña Matemáticas.
El programa correcto quedaría entonces del siguiente modo:

Si hemos programado la placa correctamente, nuestro LED debería encenderse durante un segundo, apagarse durante un segundo,
encenderse de nuevo durante un segundo… Y así hasta el infinito, pues el programa se ejecutará en bucle. ¿Por qué durante un
segundo? Porque es el tiempo de espera que hemos fijado para cada estado, pero ese tiempo se puede modificar según nuestras
necesidades. Prueba a cambiar la frecuencia de parpadeo.
Bien, ya sabes lo básico de la programación de un LED. En otra entrada te enseñaremos a programar varios LED a la vez, pero si
quieres puedes ir probando tú mismo.
- See more at: http://diwo.bq.com/programando-un-led-en-bitbloq-i/#sthash.N1ThDqCN.dpuf

Programando un LED en bitbloq (II)
Usando dos LEDs con bitbloq
En la entrada anterior Programando un LED en bitbloq (I) aprendimos a encender un LED mediante bitbloq, así como a apagarlo y
hacerlo parpadear. ¡Hoy usaremos lo aprendido para manejar dos LEDs y hacer poco a poco nuestros programas aún más
interesantes!
Hoy necesitarás:
 2x ZumBloq LED
 Un cable USB
 Y, por supuesto, un ordenador con acceso a internet
¡Empecemos!
Ejemplo 3
Encender dos LEDs
Lo primero que vamos a hacer es encender los dos LEDs simultáneamente. ¿Recuerdas cómo encendimos un LED en el primer
ejemplo? ¡Encender dos LEDs es igual de sencillo!
Seguimos los siguientes pasos para resolver el problema.
Conectamos uno de los LED en el PIN digital 7, el segundo lo conectaremos en el PIN digital 8. ¡Recuerda conectar cada pin a su color
correspondiente! Hazlo tal y como se muestra en el siguiente esquema:
Para hacer el programa, hay que tener en cuenta que esta vez hemos conectado dos LEDs. Por tanto, será necesario añadir un bloque
en bitbloq para cada uno de ellos, asignando a cada uno el pin en el que lo hemos conectado y un estado, que en este caso será
encendido.
Como podemos observar, tras programar la placa ambos LEDs se encienden y permanecen encendidos. ¿Por qué no intentas que
ambos LEDs parpadeen al mismo tiempo?
Ejercicio guiado
Parpadeo de dos LEDs
Programa en bitbloq una aplicación que haga parpadear ambos LEDs esperando 1 segundo entre el encendido y el apagado.
Cuando lo hayas conseguido, mira más abajo para ver la solución.
Es probable que al programar hayas realizado algo similar a esto:

Es importante que recuerdes una cosa: la placa controladora solo puede hacer una cosa a la vez por lo que las acciones que
programes solo pueden ir una detrás de otra. Cuando no hay un tiempo de espera, estas acciones pasan tan rápido que parece que
tengan lugar simultáneamente . Es por tanto recomendable programar siempre evitando bloques en paralelo.
Por lo tanto, la solución correcta es:
Si hemos programado la placa correctamente, los dos LEDs deberían encenderse y apagarse al unísono. ¿Qué ocurre si lo que
queremos es que dos LEDs parpadeen pero que lo hagan alternativamente (es decir, que cuando uno esté encendido el otro esté
apagado y viceversa)? Es muy sencillo, vamos a proponerte otro ejercicio para que realices el programa:
Ejercicio guiado 2
Parpadeo de dos LEDs alternativamente
Hacer parpadear dos LEDs de modo que siempre haya uno apagado y otro encendido (con su segundo de latencia). Es decir: “LED 1
apagado- LED 2 encendido” <-> 1 segundo <-> “LED 1 encendido – LED 2 apagado ” <-> 1 segundo <-> …
Si nos basamos en el programa anterior, únicamente será necesario cambiar los estados de los LED de tal forma que, cuando el
primero esté encendido el segundo esté apagado y viceversa. La solución en este caso será:

Con este ejercicio finalizamos la sesión sobre el LED. Los LEDs pueden parecer elementos muy sencillos, pero pronto verás que tienen
múltiples aplicaciones. En las próximas sesiones los usaremos junto con nuevos componentes para aprender a programar en bitbloq.
¿Por qué no pruebas a crear tus propios juegos de luces mientras tanto?
- See more at: http://diwo.bq.com/programando-leds-en-bitbloq-ii/#sthash.Z2TKtXR7.dpuf

Comunicación Serie USB con bitbloq
En este post os vamos a enseñar cómo realizar una comunicación por puerto serie USB entre vuestro ordenador y la placa
controladora. Lo diré de otra forma más sencilla: transferir información y órdenes a tu placa por el cable USB.
Una comunicación consta siempre de dos partes, un emisor y un receptor. Por tanto, vamos a necesitar dos cosas:
1. Programa dentro de la placa controladora que envíe/reciba datos. (Lo haremos con bitbloq)
2. Programa dentro del ordenador que envíe/reciba datos. (Usaremos el Monitor Serial de la IDE de Arduino)
Abre bitbloq y descarga el IDE de Arduino. Tanto si tienes una placa ZUM BT-328 como una placa FreaduinoUNO, conectala al
ordenador con el cable USB y… ¡Comenzamos!
“”Aquí robonauta llamando a Base Eco, ¿me recibe?””
ESCRIBIR POR PUERTO SERIE
El ejemplo siguiente envía desde la placa controladora la palabra ‘NEGRO‘ cuando un sensor IR detecta ese color. Conecta dicho
sensor al pin digital 3:
Parte 1: EMISOR – Programación en bitbloq
Para programar un envío de un dato desde la placa en bitbloq, tan sólo será necesario el bloque llamado “Imprimir por puerto serie”

Es así sencillo entonces crear un programa en el que se compara cada segundo (1000 ms) el valor del sensor y si éste vale 0 envia la
palabra. Carga este programa en tu placa:
Parte 2: RECEPTOR – Usando el Monitor Serial de Arduino IDE
Como hemos dicho, utilizaremos el Monitor Serial del IDE de Arduino. Con la placa conectada, abre el programa Arduino y cierra
bitbloq.
Ahora selecciona la placa controladora en Herramientas/Tarjeta. En caso de usar la ZUM BT-328 selecciona “Arduino BT
w/ATmega328” y en caso de usar una FreaduinoUNO selecciona “Arduino UNO“.
Selecciona el puerto donde está conectada la placa en Herramientas/Puerto Serial:
Ya podemos abrir el Monitor Serial en Herramientas/Monitor Serial o pulsando aquí:

Se abrirá esta ventana donde debemos comprobar que esté marcada una velocidad de 9600 baudios.
Si el sensor IR de nuestro ejemplo comienza a detectar varias veces, en el monitor irá apareciendo la palabra ‘NEGRO’ sin cesar:
Si queremos ver el resultado un poco más ordenado, podemos utilizar el bloque bitbloq “Imprimir por puerto serie con salto de linea“:
De esta forma conseguiremos una respuesta más separada así:
- See more at: http://diwo.bq.com/comunicacion-puerto-serie-en-windows-7/#sthash.UW7404zf.dpuf

Programando con variables en bitbloq
¿Qué es una variable y para qué sirve?
Una variable es como una “caja” donde guardaremos un dato, un valor que podremos ver y recuperar más adelante durante el resto del
programa. Además, en cualquier momento se puede cambiar ese valor guardado.
Declarando variables:
Al declarar una variable lo que hacemos es crear esa “caja” y guardar por primera vez un dato en ella. En bitbloq el dato que
guardemos puede ser de tipo número o de tipo texto. Al declarar la variable defines de que tipo es, por ejemplo: si lo primero que
guardaste es un número, esa variable va a ser siempre para guardar números (¡no mezcles tipos!)
Puedes renombrar como quieras una variable. Esta cualidad te servirá para identificar en todo momento tu “caja”. Aquí algunos
ejemplos de declaración de variables:
También podemos guardar el valor que nos devuelve directamente un sensor. Este caso lo verás habitualmente en las siguientes
lecciones:
Usando variables:
En bitbloq tienes bloques para “mirar la caja” (mira el valor que hay guardado en ese momento en la variable) y bloques para guardar
un nuevo valor en ella (borrando el anterior).

Diferencia entre variable GLOBAL y variable LOCAL:
Como bien explicamos en las primeras lecciones (ver lección programación LEDs), la placa controladora ejecuta el programa que le
carguemos siguiendo los bloques en orden (de arriba a abajo) y repitiéndolo infinitamente en forma de bucle.
Por este motivo, es importante saber en qué momento del programa usamos y declaramos las variables. En bitbloq se pueden
programar variables LOCALES y GLOBALES.
 Variables GLOBALES: se crean al inicio nada más encender la placa, antes incluso de empezar el bucle del programa.
 Variables LOCALES: se crean justo en el instante de declarar la variable, ya dentro del bucle.
Este es un ejemplo de código erróneo, ya que se intenta usar y comparar la variable local cuando todavía no se había declarado.
Recuerda que el código se va a ejecutar de arriba a abajo.
Esta sería la forma correcta de usarla: primero la declaramos y más adelante la usamos.

Programando los bloques lógicos
Si es igual y/o distinto de no verdadero…
Hoy vamos a aprender como funcionan los bloques de la pestaña Lógica.
Hay cuatro bloques con distintas opciones cada uno. ¡Veamos en que consisten!
Para realizar los ejemplos de hoy, necesitarás:
 1 x ZumBloq LED
 1 x ZumBloq Potenciómetro
 1 x ZumBloq Zumbador
 1 x ZumBloq Pulsador
 1 x ZumBloq Sensor de luz
 Un cable USB
El bloque de comparación
Te suena ¿verdad?. Hemos usado este bloque a menudo junto con el el bloque de control Si…ejecutar .
Este bloque devuelve verdadero o falso según las dos entradas sean:
 = iguales.
 ≠ distintas.
 < la primera menor que la segunda.
 ≤ la primera menor o igual que la segunda.
 > la primera mayor que la segunda.
 ≥ la primera mayor o igual que la segunda.
De esta forma, junto al bloque Si…ejecutar podemos establecer condiciones para que nuestro programa haga unas cosas u otras
según las condiciones que elijamos. Veamos un ejemplo:

Ejemplo con el bloque de comparación
Hacer que se encienda un LED cuando el valor del potenciómetro sea menor que 500
En caso de que el valor del potenciómetro sea menor que 500, es decir, un valor comprendido entre 0 y 499, el LED se encenderá. En
caso contrario, de 500 a 1023 valores (recuerda que el potenciómetro varía sus valores entre 0 y 1023), el LED se apagará.
El bloque Y/O
Este bloque sirve para comprobar varias condiciones al mismo tiempo:
 Opción Y: Deben cumplirse ambas condiciones para que el valor sea verdadero y la acción se ejecute.
 Opción O: Al menos una de las dos condiciones debe cumplirse para que el valor sea verdadero y la acción se ejecute.
Vamos a ver un ejemplo para que experimentes la diferencia entre la opción Y y la opción O:
Ejemplo con el bloque Y/O
Hacer que suene el zumbador cuando se cumplan las siguientes condiciones:

En este caso el zumbador sonará solo en el caso de que se cumplan las dos condiciones, es decir: Si la variable luz es menor o igual
que 300 y presionamos el pulsador, entonces el zumbador sonará. Si cualquiera de las dos no se cumple, la condición no será
verdadera y el zumbador no sonará.
Hagamos una cosa, modifica el programa anterior, y en vez de la opción Y usa una opción O ¿Qué ocurre ahora?
Ahora tu zumbador sonará más a menudo, ya que le estamos diciendo al programa lo siguiente: Si la variable luz es menor o igual que
300 o presionamos el pulsador, que el zumbador suene. Es decir, nos vale con que una de las dos condiciones se cumpla. ¿Ves la
diferencia?
El bloque verdadero/falso
Este bloque nos devuelve el valor verdadero o falso, para entenderlo lo mejor es que hagamos un ejemplo:
Ejemplo con el bloque verdadero/falso
Hacer un programa que haga que, cuando la luz sea mayor o igual que 300, se encienda el LED y que, de lo contrario, se apague.
Recuerdas este programa ¿verdad?. Hoy vamos a hacerlo un poco diferente:
La variable mucha_luz leerá el valor del sensor de luz y si éste es mayor o igual que 300, la variable tendrá un valor de verdadero, en
caso contrario, será falso.
De esta forma podemos comparar el valor de la variable directamente usando el bloque verdadero, si es verdadero significará que
habrá mucha luz y el LED se encenderá.
El bloque No

Este bloque nos permite negar una variable o estado, por ejemplo, si al verdadero le ponemos un bloque No:
Decir no verdadero es lo mismo que decir que algo es falso.
Veamos un pequeño ejemplo:
Ejemplo con el bloque No
Hacer un programa que haga sonar el zumbador si el pulsador está pulsado utilizando el bloque No.
Este programa es una versión modificada de otro que realizamos hace tiempo:
La variable boton_sin_pulsar será verdadero siempre que el pulsador no esté presionada.
Si queremos que el zumbador suene, nuestra condición es: Si no variable boton_sin_pulsar. Es decir, si la negación de botón sin
pulsar es verdadero, o lo que es lo mismo, si el pulsador está presionado, entonces el zumbador sonará.
Como recordaras hay formas mucho más sencillas para realizar este programa, este es solo un ejemplo para que entiendas el
funcionamiento del bloque No. En ocasiones negar el valor de una variable te será de gran utilidad.
La lógica es fundamental para que tu programa vaya bien, si te acostumbras a razonar de forma lógica, las cosas empezarán a
funcionar como por arte de magia. La diferencia será que tu serás el mago y sabrás exactamente donde está y cómo funciona el truco.
Aún así, siempre que empieces un proyecto, recuerda:
“Hay algo más importante que la lógica: es la imaginación”
Alfred Hitchcock
- See more at: http://diwo.bq.com/programando-los-bloques-logicos/#sthash.fWxccNnc.dpuf
- See more at: http://diwo.bq.com/programando-con-variables-en-bitbloq/#sthash.GcR18cmt.dpuf

Programando los bloques matemáticos
9+3 son 12, me llevo una…
Hoy vamos a aprender como funcionan los bloques de la pestaña Matemáticas.
¿Te faltan manos para hacer cuentas? ¡Haz que bitbloq haga el trabajo por ti! Veamos en que consisten los bloques matemáticos:
 1 x ZumBloq LED
 1 x ZumBloq Joystick
 1 x ZumBloq Miniservo
 1 x ZumBloq LCD
 Un cable USB
El bloque número
Este es uno de los bloques que más usaras en bitbloq. Este bloque te permite escribir un valor numérico, por ejemplo para comparar su
valor en un bloque si…ejecutar, o incluso para asignar un elemento a un pin directamente o establecer un tiempo,realizar
operaciones…este bloque tiene una gran cantidad de usos.
El bloque aleatorio entre… y …

Este bloque nos devuelve un valor aleatorio dentro de un intervalo que definamos.
En ocasiones puede ser de gran utilidad tener un valor aleatorio. ¿Por qué no intentas crear un juego de Simon dice usando este
bloque? O a lo mejor deseas que un robot baile o improvise sus movimientos… hay muchas posibilidades.
Ejemplo con el bloque número
Hacer que el zumbador suene durante 300 ms
Hemos usado el bloque número para hacer que el zumbador suene durante 300 ms. A nivel interno, el bloque número es un número
conocido como de tipo entero. Esto significa que no tiene decimales. Recuérdalo ya que es importante cuando estés realizando
operaciones.
El bloque array
¿Recuerdas cómo usábamos este bloque junto con el joystick? Un array no es más que un contenedor o vector que agrupa tres
variables individuales. Cómo por ejemplo las coordenadas X,Y y del botón de nuestro joystick, las horas, minutos y segundos de un
reloj, etc.
Hay algo muy importante que debes tener en cuenta cuando trabajes con vectores. El primer elemento de un vector no corresponde al
índice 1, sino al índice 0. Es decir si quieres acceder al primer elemento de un vector, pondrás un 0 en vez de un 1, si quieres acceder
al segundo, un 1 en vez de un 2, etc, en el siguiente esquema lo entenderás mejor:
Vamos a ver un ejemplo que use el bloque array:

Ejemplo con el bloque array
Mostrar los valores del Joystick por la pantalla del LCD
En este caso verás los valores X,Y además del botón del Joystick, por la pantalla de tu LCD. Usando el bloque array tendrás está
información almacenada de forma ordenada y será siempre muy fácil recuperarla.
Los bloques mapear
Estos bloques sirven para cambiar el rango de un componente y adaptarlo a otra escala. Por ejemplo, el potenciómetro devuelve un
entero entre 0 y 1023, el miniservo, entre 0 y 180 y un LED, entre 0 y 255. Si queremos utilizar un potenciómetro junto a un miniservo,
de forma que al mover el potenciómetro podamos mover el miniservo entre 0 y 180 grados, lo ideal será utilizar el bloque Mapear para
sincronizar ambas escalas.
El primer bloque, nos permite mapear una variable que vaya de 0 a 1023 al rango que deseamos. El segundo bloque nos permite más
libertad, pudiendo seleccionar tanto el rango que tiene la variable de entrada, como el rango de la salida. Veamos porque es tan útil
mapear:

Ejemplo con el bloque mapear
Mapear el potenciómetro para ajustarlo al rango del miniservo (0 – 180 grados)
De esta forma estamos dividiendo el rango del potenciómetro, de 0 a 1023, en 180 partes, de forma que, aproximadamente, cada 6
valores del potenciómetro, avanzaremos un grado en el miniservo. Si no realizáramos este mapeo no podríamos controlar de forma
correcta el miniservo con el potenciómetro.
Este programa es equivalente a este otro usando el otro bloque avanzado de mapeo:
Los bloques de operación +,-,X,/,^
Estos bloques te permiten realizar operaciones matemáticas sencillas, como la suma, la resta, la multiplicación, la división y el
exponencial.
Puedes usar dentro del bloque números o realizar también operaciones con variables.
Ejemplo con los bloques de operaciones
Utilizar el operador suma para que se encienda un LED cuando la suma del valor detectado por el sensor de luz más 20 unidades sea
menor que 100.
Otros bloques de operaciones matemáticas
Hay otro bloque que nos permite realizar operaciones como la raíz cuadrada de un número, su logaritmo neperiano o en base diez, etc.
Veamos un ejemplo:

Ejemplo con otros bloques de operaciones matemáticas
Hacer un programa que devuelva el logaritmo en base 10 de una variable. En algunos programas puede resultar útil realizar alguna
operación matemática para modificar ciertos datos. Por ejemplo, podemos querer que el programa calcule el logaritmo en base 10 del
valor de una variable.
De esta forma obtendremos el logaritmo en base 10 del valor del potenciómetro que tengamos en cada momento.
Bloque resto de…
¿Recuerdas como se hacían las divisiones a mano? Si te acuerdas bien cuando dividías en muchas ocasiones te quedaba un resto, y
tenías que seguir dividiendo saliéndote un número con decimales. Pues bien, este bloque te devuelve el resto de una división. ¿Para
que quiero usar el resto de una división? Observa el siguiente ejemplo:

Ejemplo con el bloque resto de …
Hacer que el programa devuelva el valor del resto de dividir un número aleatorio entre 2 cuando presionemos un pulsador. Si el número
es par (es decir, el resto es igual a cero), se encenderá el LED. Si el número es impar (resto igual a 1), sonará el zumbador.
Se puede averiguar si un número es par o impar dividiendo dicho número entre 2. Si al dividirlo el número tiene un resto igual a cero. El
número será par. Si el resto por el contrario es un uno, el número será impar. Como puedes ver hemos usado también el bloque
aleatorio para generar una serie de números al azar entre 0 y 2000.
Estos son los bloques de matemáticas. Puede que algunos no te parezcan demasiado útiles, o pienses que nunca vas a necesitar
realizar operaciones tan complicadas. Pero conforme seas más y más experto y programes como un auténtico maestro desearas que
haya muchos más… ¡Te lo aseguro!
- See more at: http://diwo.bq.com/programando-los-bloques-matematicos/#sthash.GWNhq5dK.dpuf

Programando los bloques de control-
El bloque Si… ejecutar
La potencia sin control…
Hoy vamos a aprender a cómo usar los bloques de bitbloq de la pestaña Control en concreto el bloque Si… ejecutar
¿Qué aburrido no? ¡Todo lo contrario! ¡Estos bloques son la pieza fundamental para que tú nuevo robot-aniquila ciudades (o
aspiradora, tambien vale) conquiste el mundo! (o bueno, lo deje bien limpito).
¡Vamos alla!
Hoy necesitarás:
1. 1 x ZumBloq LED
2. 1 x ZumBloq Sensor de luz
3. 1 x ZumBloq Pulsador
4. Una placa controladora ZUM BT 328 o compatible con Arduino UNO
5. Un cable USB
El bloque si…ejecutar
Aprendiendo lo que es una sentencia condicional
Un momento, no tan rapido. ¿Una sentencia condicional? ¿Qué es eso?
Una sentencia condicional es una condición, algo que tiene que cumplirse para que se ejecute una parte del programa.
Es muy sencillo, por ejemplo: Si has sido bueno, los reyes magos te traeran regalos. Si no recoges tu habitación, tu madre te
castigará. Si presiono el botón, el LED se encenderá.
Ya hemos usado este bloque durante el curso en multitud de ocasiones ¿recuerdas?, y es que es un bloque fundamental que nos
permitirá decirle a nuestro programa cuando debe suceder una cosa y cuando otra.
¿Cómo funciona? Veamoslo en el siguiente ejemplo:

Ejemplo con el bloque si… ejecutar
Utilizando el bloque Si…ejecutar, hacer que se encienda el LED cuando se pulse el pulsador
En primer lugar, conecta tu zumbloq LED y tu zumbloq Pulsador a tu placa siguiendo el siguiente esquema:
Queremos que, al presionar nuestro pulsador, el LED se encienda.
Es decir:
Si el pulsador está presionado… el LED se enciende
Por tanto, tenemos que usar el bloque Si… ejecutar, el programa quedará del siguiente modo:
Recuerda que dependiendo del típo de pulsador que tengas, al estar presionado puede tener un valor de 1 o 0. Si posees uno de
nuestros kits de robótica, al presionar el botón su valor valdrá 0.
Como puedes observar, al presionar el botón, el LED se enciende, y permanece encendido indefinidamente… y es qué nuestra placa
es muy tonta y… ¡solo hace lo que le decimos! tenemos que decirle que ocurre cuando el pulsador no esté pulsado!
¿Cómo podemos hacer ésto? Fijate en el siguiente programa:
Como puedes ver,el bloque Si …entonces puede tener más opciones como de lo contrario que se ejecutará cuando no se cumpla la
condición, es decir, cuando nuestro pulsador no este presionado. Para añadir la opción de lo contrario pulsa sobre la estrella del bloque
y agrégala:
Además existe una opción más dentro de éste bloque, la opción: en cambio, si. Está opción te permite añadir más condiciones despues
de la primera. Un ejemplo: Si queremos comer tarta, pero no hay tarta, en cambio sí hay helado ¿También nos vale, verdad?
¡Queremos comer helado!! ¡Aunque preferimos la tarta! ¡Eso es muy importante! Solo comeremos helado si NO hay tarta
Vamos a abandonar a nuestro querido pulsador y a hacer un ejercicio con el sensor de luz y la opción en cambio, si:

Ejemplo 2
Hacer que un LED parpadee cuando el sensor de luz detecte poca cantidad de luz, y se encienda cuando este a
oscuras
Voy a confesarte una cosa, tengo miedo a la oscuridad. Por las noches no voy al baño por muchas ganas que tenga hasta la mañana
siguiente, no me gusta nada no tener luz y andar por ese pasillo, a saber que monstruos acechan por ahí, quiza la profe de mates …
Por eso he decidido ponerme manos a la obra e inventarme una alarma de noche. ¡Para no quedarme nunca a oscuras! Estuve
hablando con un reputado luminógrafo y, tras muchas discusiones, llegamos a la conclusión de que mi revolucionaria máquina, que
cambiaría la infancia de la humanidad, tendría que ser de la siguiente forma:
-Si la cantidad de luz es menor que 100-> ¡Ay que está muy negro todo!->ENCIENDE EL LED
-En cambio, si la cantidad de luz es menor que 200, bueno, da un poco de miedo…->¡EL LED PARPADEA!
-De lo contrario, si brilla el sol no te preocupes… ¡Si yo soy muy valiente! ->APAGA EL LED
¡Ríete tú del iphone! ¡Manos a la obra! Lo primero será realizar nuestras conexiones en la placa:
Recuerda que el sensor de luz es un componente analógico.
Por lo que tendrá que ir conectado a los pines analógicos de tu placa.
Ahora que lo tienes todo conectado ¿Por qué no intentas programarlo por tí mismo? Verás como pronto llegas a la solución.
Si todo fue bien deberías haber hecho algo parecido a ésto:
Pronto veremos con más detalle las operaciones lógicas, pero en el caso de que quieras dentro del bloque Si…ejecutar que se cumpla
más de una condición, como por ejemplo, que el pulsador esté presionado y la luz sea menor que 30 puedes hacerlo de la siguiente
forma:
00:00:56
¿Qué te parece? Puede que tengas dudas de cuando usar el bloque. ¡No te preocupes! ¡La práctica hace al maestro! Pronto
descubriras que cuando quieras programar algo, sabrás exactamente como hacerlo. Y el bloque Si… ejecutar será tu mejor aliado.

El bloque Si … (switch…case)
Eligiendo entre varias opciones
El bloque Si… ejecutar que hemos visto en la lección anterior es muy adecuado cuando una variable puede tomar dos valores, por
ejemplo el pulador: Si está pulsado… de lo contrario … . Sin embargo cuando una varible puede tomar una serie de valores, realizarlo
con el bloque Si… ejecutar no es tan sencillo. Por ejemplo. Imaginemos un programa que cuenta el número de veces que pulsas el
botón, y según este valor realiza una acción u otra. Para realizar esto existe el bloque Si, conocido habitualmente comoswitch…case en
el mundo de la programación.
Como hemos dicho antes vamos a hacer un ejemplo que en función del número de veces que pulse el botón haga acciones distintas,
éstas serán:
 Si lo he pulsado 1 vez: Enciendo el LED
 Si lo he pulsado 3 veces: Hago parpadear el LED
 Si lo he pulsado 5 veces: Hago sonar el zumbador
 En cualquier otro caso (es decir: 0, 2, 4, 6 …): Apago el LED
Necesitarás:
1. 1 x ZumBloq LED
2. 1 x ZumBloq Zumbador
3. 1 x ZumBloq Pulsador
4. Una placa controladora ZUM BT 328 o compatible con Arduino UNO
5. Un cable USB
Ahora que ya sabes cómo funciona bitbloq hacer este ejemplo te resultará muy sencillo, aquí tienes el programa ¡Vamos alla!

El bloque Mientras
Mientras no aprendas, repite esta lección
En esta ocasión toca el bloque de Control Mientras…. Este bloque permite que, mientras se esté cumpliendo una condición, se ejecuten
ciertas instrucciones.
¡Vamos allá!
Necesitarás:
 1 x ZumBloq LDR
 Un cable USB
El funcionamiento de este bloque es muy sencillo, vamos a verlo con un ejemplo

En este programa, mientras la lectura del sensor de luz sea mayor de 400 sonará el zumbador, ¡es una alarma de luz excesiva!, este
funcionamiento se suele representar con el siguiente esquema:
Es muy importante notar que la cantidad de luz se debe actualizar en cada iteración del bucle, ya que de lo contrario, una vez que
entramos en el bucle no volveríamos a leer el valor del sensor, y por lo tanto, jamás saldríamos de él.
- See more at: http://diwo.bq.com/programando-los-bloques-de-control-el-bloque-mientras/#sthash.90h1MooA.dpuf

Programando los bloques de control-El bloque Contar
1, 2, 3 probando probando…
Hoy vamos a aprender cómo funciona el bloque Contar.
¡Vamos allá!
Necesitarás:
 1 x ZumBloq LED
 Un cable USB
¿Recuerdas la lección anterior donde aprendiste qué era un bucle y cómo funcionaba el bloque Mientras? Pues bien, este bloque es
también un bucle, pero en vez de repetirse mientras se cumpla una condición, el programa repetirá las órdenes solo un número de
veces determinado.
Para ello hay que decirle al bloque qué contar, desde dónde y hasta dónde. Vamos a ver cómo funciona con un ejemplo muy sencillo:
El programa enciende el LED un tiempo determinado, incrementando ese tiempo cada vez en un segundo. De esta forma, la primera
vez se encenderá un segundo, la segunda dos segundos, la tercera tres, así hasta llegar a diez.
Para ello usamos el bloque contar. En este bloque debes configurar tres valores. El primero, Contar con [valor] es donde debes decir
con que variable vas a contar, en nuestro caso la variable cuenta. El segundo desde [valor] es donde debemos decir desde dónde
queremos empezar a contar. Podemos empezar a contar desde cero, uno, diez, o cualquier otro valor. Por último, hasta [valor] te
permite definir hasta qué valor deseas contar.
Puedes contar hacia delante, incrementando valores… ¡o hacia atrás!, disminuyendo valores. En el caso de que tu valor inicial sea
mayor que el final, por ejemplo contar de 10 a 1, el programa irá restando valores hasta llegar a 1.
El bucle contar tiene un montón de utilidades, pero la mejor de todas es que… ¡no tendrás que usar tus manos nunca más!
¿Se te ocurre alguna otra aplicación? ¿Qué tal si creas una máquina para contar automáticamente jugando al escondite? Podrías hacer
que se ilumine un LED cada segundo y suene un zumbador al llegar a 100… ¡Inténtalo!
- See more at: http://diwo.bq.com/programando-los-bloques-de-control-el-bloque-contar/#sthash.Zi1CoCM0.dpuf

Programando: Introducción a las funciones y funciones
sin retorno
Ejecuten la orden 66…
Hoy vamos a aprender todo lo relacionado con los bloques Funciones. ¿Qué son? ¿Para qué sirven? ¿Porqué tienen tantas palabras
raras? Las respuestas a estas preguntas, a continuación:
Imaginaos que nuestro programa tiene que hacer una cosa muchas veces, por ejemplo, hacer parpadear dos leds en muchos casos, o
hacer que suene una melodía de más de 25 bloques que hemos creado. Si cada vez que quisiéramos que sonase nuestra melodía
tuviéramos que volver a escribirla, ¡acabaríamos con los ojos cuadrados de tanto bloque!
¿Y si pudiéramos de alguna forma crear la melodía una sola vez, darle un nombre a esa acción (como “Hacer sonar la melodía”) y
luego, mediante un único bloque, hacer que suene?
¡En eso consisten las funciones precisamente! Sirven para ahorrarnos tiempo y bloques.
Cuando tenemos una tarea que se repite mucho, o cuando queramos organizar mejor nuestro proyecto, crearemos una función que
realice algo cada vez que la llamemos.
Pero si queréis que las funciones os eviten dolores de cabeza en vez de dároslos, estad muy atentos, pues empezamos:
 1 x ZumBloq LED
 1 x ZumBloq Servo rotación continua
 Un cable USB
Volveré…
Lo primero que hay que explicar es que las funciones en bitbloq pueden ser de dos tipos: Funciones sin retorno y funciones con retorno.
Tranquilos, las funciones sin retorno no se van a escapar y no volver cuando las ejecutes por primera vez, “sin retorno” significa que no
retornan ningún valor al final de su ejecución.

Cuando queramos hacer una función que realice muchas operaciones matemáticas (sumar, luego restar, volver a sumar, multiplicar,
restar y multiplicar, por ejemplo) al final nos interesará que la función nos retorne que valor final ha resultado. Por ello en este caso
usaremos una función con retorno, que nos retornará el valor final de las operaciones.
Pero cuando queramos que nuestra función realice una serie de acciones que nada tienen que ver con un valor final, como hacer sonar
esa larga melodía, usaremos una función sin retorno.
El bloque “función sin retorno” y el bloque “llamar a función sin retorno”
Como hemos explicado justo antes, el bloque función sin retorno (arriba a la izquierda) sirve para agrupar una serie de bloques y
ejecutarlos cuando nosotros llamemos a la función.
Podría decirse entonces que cuando creamos una función estamos creando un mini programa y dándole un nombre, para que, cuando
lo llamemos, el programa principal “entre” en la función, la recorra entera, y salga de la función para continuar con el programa
principal(en este caso, sin retornar ningún valor).
-¡Pero esto qué es! ¿¡Dos columnas de bloques no unidos!? Pero si me dijisteis que tenían que estar todos unidos o no funcionaría
correctamente…
Esto es cierto, tienen que estar todos los bloques unidos en nuestro programa principal. Cuando ponemos un bloque de crear una
función estamos creando al lado otro pequeño programa que estará contenido dentro del programa principal.
Vamos a entender esto mucho mejor cuando analicemos el siguiente ejemplo.

Ejemplo con los bloques de funciones sin retorno.
Programa que hace moverse un servo si pulsamos el botón, avisando con un parpadeo y sonido.
Como a estas alturas ya seréis unos expertos con el bloque de control “Si…ejecutar” y habréis realizado más de una vez el ejemplo de
hacer una cosa si pulsamos el botón y otra si no lo pulsamos, estoy seguro de que entenderéis bastante bien el programa si quitamos
los bloques rosas que pone “Parpadeo_con_sonido” y los bloques de la derecha.
Vamos a empezar viendo la parte derecha del programa. Lo primero que vemos es el bloque “función sin retorno”. Este bloque es el
encargado de empezar a crear una función sin retorno. Cuando lo ponemos en nuestra zona de trabajo lo primero que debemos hacer
es darle un nombre (como hacíamos con las variables). Así se llamará nuestra función y por ese nombre la llamaremos con el bloque
“llamar a función sin retorno” (como vemos en la parte izquierda del programa).
Dentro del bloque “función sin retorno” podemos crear un programa que sepamos que vamos a repetir varias veces. El bloque se irá
haciendo cada vez mas grande para introducir todas los bloques que desees en tu función.
Y cuando queramos que nuestro programa principal haga lo que hemos programado en la función, por larga que sea esta, solo
necesitaremos colocar un bloque de “llamar a función sin retorno” y cambiarla de nombre como hacemos con las variables.
Como vemos en el ejemplo, cada ciclo del programa revisa si el botón esta pulsado para hacer mover el servo o pararlo, pero además,
antes del bloque del servo estamos llamando a la función, de tal forma que cada vez que pasamos por el bloque rosa que pone
“Parpadeo_con_sonido”, estamos ejecutando todos los bloques de la función, de arriba a abajo.
Dos mejor que uno
También podemos realizar programas con más de una función. ¿No os parece un programa principal mucho más bonito?
Al pulsar el botón, se ejecutará la función Parpadeo, luego la función Melodía y luego la función Parpadeo.

Programando: Funciones con retorno y parámetros de
entrada
Los espejos deberían pensárselo dos veces antes de devolver una imagen…
Jean Cocteu
En la lección anterior aprendimos qué era una función y para qué se utilizaba. También nombramos un tipo de función: Las funciones
con retorno, que son en las que profundizaremos en este post. ¿Estáis preparados para dominar aún más el arte de las
funciones?¿Queréis ser unos magos del flujo de programación? ¿O simplemente queréis hacer los programas más bonitos de la
comunidad bitbloq? ¡Vamos a ello!
 1 x ZumBloq miniservo
 1 x ZumBloq LCD
 Un cable USB
El bloque “función con retorno” y el bloque “llamar a función con retorno”
Las funciones con retorno son muy parecidas a las funciones sin retorno pero su diferencia radica en para qué se utilizan.
Las funciones con retorno crean un “mini-programa” que se encarga de obtener, preparar o modificar una variable. La función con
retorno nos devuelve ese valor justo cuando se lo pidamos, sin tenerle que decir una y otra vez al programa como obtener ese dato que
necesitamos. Un ejemplo podría ser una función que se encargue de mapear el valor del potenciómetro y después retorne el valor ya
mapeado del mismo componente, o también se podría hacer una función que según la distancia que viera el sensor de ultrasonidos te
dijera si estás más o menos cerca del objeto que tienes delante (un programita así podría haber salvado el Titanic, por ejemplo).
Estas variables con las que jugamos en nuestras funciones con retorno pueden ser de cualquier tipo: numéricas, de texto o incluso
vectores (esas variables con tres compartimentos que explicábamos en la lección del Joystick).
¿Veis el hueco que hay en el bloque “función con retorno”? Ahí debe ir la variable que la función va a devolver cuando se la llame.
Poned un bloque de variable para indicarle qué es lo que tiene que devolver, aunque a veces puede ser útil poner un número o un texto
que siempre sea el mismo (usando un bloque número o texto) como veremos más adelante.
¿Quién se ha fijado en que el bloque “llamar a una función con retorno” tiene la misma forma que el bloque “usar una variable”?
Exacto, tienen la misma forma porque el bloque de “llamar a función con retorno” encaja en cualquier sitio donde encajaría una variable.
De hecho, si entendéis las variables, las funciones con retorno podrían ser como una variable que, antes de ver qué tienen dentro de la
caja, justo antes de abrir la caja, ocurren cosas dentro de ella y después ya te permite ver el contenido.
Vamos a ver si lo entendemos del todo:

Ejemplo con los bloques de funciones con retorno
Programa que mueve el miniservo con el potenciómetro, en este caso usando una función
¿Recordáis como funcionaba el bloque mapear? Echarle un vistazo al ejemplo del link, os ayudará a entender cómo funciona el
ejemplo.
Como podéis ver, de nuevo tenemos dos columnas de bloques: el programa principal a la izquierda y la declaración de la función
“Recibir_valor_del_potenciómetro” a la derecha. Esta función tiene el cometido que indica su nombre, cuando la llamemos (con el
bloque de “llamar a una función con retorno” del programa principal) va a crear una variable en la que almacenará el valor actual del
potenciómetro. Después va a crear otra variable para guardar el valor del mapeado de la variable potenciómetro entre 0 y 180 (que son
los grados que puede girar el miniservo) y por último, le hemos indicado que tiene que devolvernos el valor de la variable que tiene el
mapeo guardado. De esta forma, cuando en el programa principal usamos el bloque “Recibir_valor_del_potenciometro”, se ejecuta
rápidamente la función de arriba a abajo y ponemos el valor del mapeado en el hueco del servo de “Grados(0-180)”
El bloque “Si…devuelve…”
¿Y si quisiéramos que una misma función nos devolviera algo diferente dependiendo de, por ejemplo, la luz que hubiese en la sala o si
tenemos o no pulsado el botón?
Al igual que en el bloque de control “Si…ejecutar”, tenemos un bloque para dotar de inteligencia a nuestras funciones, para conseguir
que decidan algo en función de otro algo. Este es el bloque “Si…devuelve…”
Este bloque solo puede ir dentro de una función con retorno (tranquilo, bitbloq te lo recordará si se te olvida). En el primer hueco ha de
ir una expresión lógica (de los bloques de lógica), y si esta es verdadera, la función terminará inmediatamente y devolverá el valor que
le hayas puesto en el segundo bloque en forma de variable o un número o texto fijo.
Digo lo del número o texto fijo porque con este bloque tiene un montón de aplicaciones. Seguid con el siguiente ejemplo para ver uno
muy útil.
Ejemplo con el bloque “Si…devuelve”
Antes de analizar el ejemplo, voy a explicaros la gracia del programa. Supongamos que estamos usando un sensor de iluminación que
no es el de “Mi primer Kit de Robótica” (puesto que ya sabemos que éste devuelve valores entre 0 y 500 en función de la luz que incide
sobre el sensor), pero, ¿y si desconocemos ese valor? Ahora supongamos que si te equivocases y el valor del sensor diera más de
500, el servo que esté usando se cortocircuitase y tuvieses que despedirte de tu preciado servo. ¿No creéis que sería perfecto crear
una función que comprobase este valor antes de usar el servo? Vamos a ampliar un ejemplo que ya usamos en la lección del
miniservo.
Programa con sensor de luz y comprobación de errores
Empecemos estudiando la pequeña función de abajo a la derecha. Muy simple ¿no? Si el sensor de luz da un valor mayor o igual que
500, la función devolverá la palabra “ERROR” y si no es así, no ejecutará el bloque “Si…devuelve” y pasará a devolver lo que que le

corresponde por defecto: “CORRECTO”.
A continuación, en el programa principal, podemos ver como consta solo de un “Si…ejecutar…en cambio si…ejecutar” y lo que hay en
las comprobaciones de los bloques de lógica son llamadas a la función de “Comprobación_valor_luz”, así que cuando el programa
llegue a este bloque, se ejecutará la función y devolverá “CORRECTO” o “ERROR”, entrando así al bucle que nos interese: Si es
correcto, moverá el servo, si no, avisará con el zumbador.
Como supongo que vosotros contaréis con un chachi-sensor-de-luz de nuestro kit de robótica, para probar este ejemplo podéis usar el
potenciómetro (que os devolverá valores de entre 0 y 1023)
El bloque “Devuelve…”
Este bloque tiene la misma función que el anterior. Sin embargo, no incluye la expresión lógica, por lo que le da un poco más de
versatilidad. De esta forma, podemos meter el bloque dentro de un condicional “Si..Ejecutar”, pero hacer más cosas antes de devolver
el valor que nos interese. Vamos a ver un ejemplo en el cual creamos una función para saber si tenemos un objeto cerca, a media
distancia o lejos del sensor de ultrasonidos.
Programa avisador de marcha atrás de los coches
En este ejemplo hemos creado una función con retorno que primero lee la distancia del sensor de ultrasonidos y la almacena en una
variable. Tras esto, entra a un bloque “Si…Ejecutar” en el cual, según la distancia que haya en la variable, enciende un LED si esta muy
cerca o lo apaga si esta más lejos. Además, cuando esta cerca devuelve la palabra “Cerca”, si esta a media distancia devuelve “Medio”
y si esta lejos, no entra al condicional y ejecuta el devolver del final de la función, devolviendo “Lejos”.
En el programa principal tenemos únicamente un bloque zumbador, el cual va a sonar y sonar pero esperando un tiempo entre medias,
y este tiempo dependerá de la palabra que nos devuelva la función anterior.
Mejorando las funciones: Funciones con parámetros de entrada
Estoy seguro de que en algún momento os habéis fijado en esa estrellita que acompañan a los bloques de “función con retorno” y
“función sin retorno”. Al igual que en los bloques de control, no esta ahí solo para adornar.
La estrellita nos permite mejorar los bloques de función para hacerlos aún más potentes. Con ella podemos añadir…¡Parámetros de
entrada!
-¿De qué me estás hablando? ¿Qué es eso de parámetros de entrada? ¡Suena a magia negra!
-Tranquilos, perdón, sí que suena difícil, pero vamos a ver que no lo es tanto.
Un parámetro de entrada es una variable de nuestro programa principal que le dejamos usar a la función, de esta forma podemos crear
una función muy inteligente y reutilizable. Por ejemplo, podemos hacer una función que haga varias operaciones matemáticas a partir

de dos valores que le demos como parámetros de entrada. O una función que si le damos como parámetro de entrada un 3 parpadee
un LED 3 veces.
Cuando creamos un parámetro de entrada en el bloque “función con retorno” o “función sin retorno”, a su vez aparece en el bloque
“llamar a función…” (del tipo correspondiente) un hueco para colocar una variable o número, que será la que estemos introduciendo en
la función para ser usada. A su vez, se está creando una variable asociada al parámetro de entrada, que valdrá lo mismo que lo que
pongáis en el hueco del que os acabo de hablar. Es importante saber que estas variable que se han creado con los parámetros de
entrada, solo pueden ser usadas dentro de la función.
También cuando creamos un parámetro de entrada debemos darle un nombre que tenga que ver con lo que va a hacer ese
parámetro en la función, y tenemos que decirle si el parámetro de entrada va a ser un número (int) o texto (string).
Vamos a ver un ejemplo para entenderlo mejor,
Ejemplo con funciones con parámetros de entrada
Programa que hace operaciones con dos parámetros de entrada y muestra el resultado en el LCD
En este ejemplo podemos ver cómo se ha creado una función con retorno y con parámetros de entrada. Los parámetros de entrada son
“entrada_1″ y “entrada_2″ y se ha colocado en los huecos dos variables: “dato 1″ y “dato 2″. Ahora “entrada_1″ vale lo mismo que “dato
1″ y “entrada_2″ lo mismo que “dato 2″, pero ahora podemos usar “entrada_1″ y “entrada_2″ dentro de la función para realizar
operaciones matemáticas con ellas.
Al final, la función devuelve el valor final de la operación al programa principal, donde se imprime en el LCD. (para ver como funciona
ésta última, pincha aquí)
Ahora que ya sabemos la teoría sólo nos queda practicar para acabar de dominarlas del todo. Intentad usarlas siempre que podáis y ya
veréis como empezáis a verlas como una gran ayuda.
- See more at: http://diwo.bq.com/programando-con-funciones-en-bitbloq-2/#sthash.DjdB61x5.dpuf

Programando los bloques de texto
En un lugar de la mancha…
Hoy vamos a aprender como funcionan los bloques de la pestaña Texto.
Los bloques de la pestaña texto te permitirán mostrar mensajes a través del puerto serie o la pantalla LCD. Desde comunicar a tus
robots o máquinas con el mundo, a mostrar el valor de una variable o de un sensor. ¡Aprendamos cómo funcionan!
 1 x ZumBloq LED
 1 x ZumBloq LCD
 Un cable USB
El bloque “…”
El funcionamiento de este bloque es muy similar al del bloque número que vimos en la pestaña de matemáticas. Solo que en este
caso, en vez de escribir un valor numérico nos permitirá escribir una palabra o texto. En programación a una cadena de caracteres o, lo
que es lo mismo, una palabra o frase, se le nombra en ocasiones como un String.
Ejemplo con el bloque “…”
Escribir una frase/String y comprobar que el programa la devuelve mostrandola por una pantalla LCD.
Lo primero que debes de hacer es conectar la pantalla LCD a tu placa. Si no recuerdas como se conectaba fíjate en el siguiente
esquema:

Para escribir una frase por pantalla el ejemplo quedaría de la siguiente manera:
Como puedes ver hemos declarado la variable frase la que le hemos asignado el texto “hola robonautas” y a continuación hemos
mostrado la variable a través del LCD.
NOTA: Recuerda que la pantalla LCD no es capaz de mostrar caracteres especiales tales como acentos o la letra Ñ.
El bloque a…añadirle texto…
Este bloque te permite añadirle texto a un texto o String ya hecho. Cuando juntamos dos frases o Strings en una sola cadena de
caracteres, decimos que estamos concatenando.
Ejemplo con el bloque a…añadirle texto…
Crear dos frases y concatenarle a la primera la segunda
En este ejemplo hemos creado dos frases distintas. Y luego a la frase de la variable a le hemos sumado, o concatenado, el texto de la
frase de la variable b, de forma que al mostrar la variable a por la pantalla del LCD el resultado será: “me encanta la robótica”
Concatenar puede parecer una operación sencilla sin mucha utilidad, pero se usa en multitud de programas para mejorar el manejo y
acceso a la información.

El bloque crear texto con…
Al igual que el bloque anterior, este bloque nos permite juntar o concatenar varias frases o Strings. Solo que en este caso podemos
combinar también variables numéricas así como concatenar varias frases en vez de solo dos. Para ello recuerda pulsar sobre la estrella
para poder añadir todos los nuevos elementos que necesites.
Ejemplo con el bloque Crear texto con
Crear una frase concatenando dos cadenas de caracteres
Como ves este ejemplo es muy similar al anterior, en el hemos creado dos variables con texto, y una tercera variable donde hemos
concatenado las variables anteriores formando una nueva frase: “Me llamo Anita”.
El bloque longitud
Este bloque nos devuelve la longitud de una cadena de caracteres. Es decir, cuanto mide nuestra frase o String, incluyendo los
espacios entre palabra y palabra. Esto puede resultar útil en algunos casos como, por ejemplo, cuando queremos asegurarnos de que
un String tiene menos del límite de caracteres permitidos para un mensaje.
Ejemplo con el bloque longitud
Hacer un programa que encienda un LED al pulsar el botón cuando el número de caracteres de un texto dado es menor de 140.

En este ejemplo utilizamos el bloque longitud para saber el número de caracteres que tiene nuestra frase. Si esta tiene menos de 140
caracteres, y pulsamos el botón, el LED se encenderá, en caso contrario, permanecerá apagado.
El bloque de texto =
Este bloque compara uno a uno todos los caracteres que forman dos Strings y comprueba si coinciden (sin tener en cuenta si están en
mayúsculas o en minúsculas). De está forma, podemos averiguar si dos caracteres, palabras o frases son iguales. Cuando uses
variables con texto, es importante que uses este bloque de comparación y no el que se encuentra en la pestaña de lógica. Aunque
pueda parecer que da igual, para tu placa es muy distinto comparar un número a una frase ¡Recuérdalo!.
Ejemplo con el bloque de texto =
Hacer un programa que compare dos cadenas de caracteres y, en caso de que sean iguales, haga sonar el zumbador 3 veces durante
100 ms cada vez. Si son distintas, que suene una sola vez durante 1000 ms.
Si las dos frases son iguales el zumbador sonará 3 veces, prueba a cambiar una de las frases, como ves el bloque de texto =
comprueba que las frases no son iguales y la condición no se cumple. Por lo que el zumbador sonará solo una vez.

El bloque recortar…desde…hasta…
Este bloque sirve para recortar un String. Resulta muy útil cuando se utiliza la comunicación Bluetooth porque, de esta manera, solo
hace falta enviar toda la información una única vez, recortándola según sea necesario.
Ejemplo con el bloque recortar…desde…hasta…
Devolver por el LCD solo una parte de la variable texto.
Este ejemplo muestra como es posible recortar una frase, mostrando solo a cada momento la parte que nos interesa, en éste caso solo
mostraremos la segunda parte de la frase contenida en la variable texto “Esta es la parte 2″
Los bloques de la pestaña texto te serán de mucha utilidad cuando quieras que tus inventos o robots se comuniquen con el mundo que
les rodea de una forma más sencilla y divertida. Experimenta y muestra distintos mensajes según ocurran unas cosas u otras. ¡Seguro
que ya tienes un montón de ideas!
- See more at: http://diwo.bq.com/programando-los-bloques-de-texto/#sthash.1UhfYiHq.dpuf

Programando el sensor de luz en bitbloq
¿Qué es un sensor de luz?
El sensor de luz, también llamado fotorresistencia o sensor fotoeléctrico, es un sensor que, tal y como su
nombre indica, detecta luz. Una fotorresistencia responde a los cambios en la intensidad de la luz y
modifica su resistencia cuando ésta varía. Cuanto mayor sea la intensidad de la luz, más baja será la
resistencia al paso de la corriente.
Este componente tiene numerosas aplicaciones en aparatos que están presentes en nuestra vida cotidiana como, por ejemplo:
 Puertas de garaje.
 Alarmas antirrobo.
 Ordenadores,teléfonos y televisiones (para controlar el brillo de la pantalla).
 Lectores de código de barras.
El sensor de luz del ZUM Kit devuelve valores comprendidos entre 0 (cuando la oscuridad es total) y 800 (a plena luz del sol en un día
despejado), si tienes un sensor de luz de Mi primer kit de Robótica, este valor oscilara entre 0 y 500, aproximadamente. Se trata de un
componente analógico, ya que devuelve un rango de valores, en contraste con los sensores digitales, que solo pueden devolver dos
valores, como un pulsador (“pulsado” o “no pulsado”). Por ello, deberá conectarse en la ristra de pines analógicos, numerados como A0,
A1, A2, etc.
Este sensor es un dispositivo de entrada, porque sirve para ingresar datos en el programa a diferencia de un LED o un zumbador, que
son dispositivos de salida.
Como puedes ver, el sensor de luz es un componente muy
interesante. ¿Quieres aprender a programarlo? ¡Empezamos!
Necesitarás:
 Un ZumBloq sensor de luz y ZUMBloq LED
 Un cable USB
A continuación haremos distintos ejemplos para aprender a usar este componente ¡Al grano!
Ejemplo 1
Encender un LED cuando el sensor de luz detecte poca cantidad de luz
A partir de ahora vamos a utilizar más de un componente en cada ejercicio, conectados simultáneamente en la placa.
Antes de conectar el sensor de luz recordamos que, al tratarse de un componente analógico, debe conectarse en uno de los pines
analógicos, por ejemplo, el A0. El siguiente esquema nos servirá de guía:
Ahora, programamos con bitbloq la placa controladora para que cuando haya poca luz se encienda el LED.

Empezamos, lo primero tenemos que leer la cantidad de luz, para ello, asignamos la lectura del sensor de luz a una variable. Las
variables son “lugares” donde guardamos datos. Como es la primera vez que usamos la variable tenemos que declararla, esto es
como darle el nombre que usaremos el resto del programa.
Ahora tenemos que comprobar que hay poca luz. Hemos dicho que este sensor de luz da un valor entre 0 y 800, si tienes un sensor de
luz de Mi primer kit de Robótica, este valor oscilara entre 0 y 500, por lo que podemos considerar que ya está oscuro cuando la
variable cantidad_de_luz es menor de 200.
En ese caso, debemos encender el LED, que está conectado en el PIN digital 3.
Pero esto no es todo, prueba a programar la placa y verás que no funciona exactamente como te esperarías, ¿qué falta? El LED no se
apaga cuando vuelve a haber luz. Intenta acabar tú el programa y mira debajo la solución.
Hay que decirle que en caso de que la luz sea mayor de 200 el LED se apague, eso se hace así:
Como ves en la imagen anterior, el bloque si,entonces puede tener más opciones como de lo contrario que se ejecutará cuando no se
cumpla la condición (en este caso, cuando la cantidad de luz sea igual o mayor que 200). Para añadir la opción de lo contrario pulsa
sobre la estrella del bloque y agrégala:
¿Habías acertado? Seguro que sí, y si aún te queda alguna duda pregúntanos. Puedes cargar el programa completo
en bitbloq buscando el proyecto de bq Lámpara nocturna.
¿Te atreves a modificar el programa para que la lámpara nocturna se encienda cuando está oscuro y se apague después de 1 minuto?
Luego ya no debe volver a encenderse hasta que no sea de día otra vez. ¡Inténtalo! Tienes la solución en el proyecto Lámpara noctura
avanzada en bitbloq.
- See more at: http://diwo.bq.com/el-sensor-de-luz/#sthash.xNhol1uv.dpuf

Programando un miniservo en bitbloq
¿Qué es un miniservo?
¡Que no te engañe su tamaño! ¡Adorarás a estos pequeñines!
Un miniservo es un pequeño motor que es capaz de girar entre 0 y 180 grados,o lo que es lo mismo,
la mitad de una circunferencia. En muchos de los inventos y actividades que os proponemos se
utilizan los miniservos para realizar multitud de acciones, desde controlar las pinzas
del printbot beetle a controlar a los fantásticos erizos bailones.
Importante: Siempre que utilices servos y miniservos, recuerda alimentarlos mediante el portapilas,
recibirán mucha más energía a la hora de moverse.
Lo interesante de los miniservos es que nosotros decidimos a que posición o ángulo se
moverá. A continuación realizaremos un par de ejemplos para que aprendas a utilizarlo. ¡A
trabajar!
Necesitarás:
 1 x ZumBloq Miniservo
 1 x ZumBloq Sensor de luz (LDR)
 Un cable USB

¿Tienes todo? Empecemos:
Ejemplo 1
Mover un Miniservo a los ángulos 0,45,90,135 y 180 grados
¡Suena muy complicado! ¡Pero no lo es! Mover el miniservo al ángulo que tu desees es tremendamente sencillo ¡veámoslo! Lo primero
será conectar el miniservo al pin digital 10.
Una vez realizado el programa deberemos ir a la pestaña de bitbloq servos y seleccionar el primero de sus bloques, aquel que tiene la
opción de escribir un ángulo entre 0 y 180 grados.
Como hemos dicho, queremos que el servo se mueva primero al ángulo 0º hasta 180º, pasando por 45º, 90º y 135º. El programa
quedará de la siguiente manera:

El programa repite el mismo bloque para mover el miniservo a cada ángulo. Recuerda que debes seleccionar un valor del ángulo entre
0 y 180 grados, si no, el servo siempre girará o a 0º, o a 180º. Hemos dejado un tiempo de 1000 ms (1 segundo) entre orden y orden
para que al servo le dé tiempo a llegar al ángulo deseado.
Es conveniente que le pongas alguno de los cabezales de plástico al miniservo, si no te será difícil ver cómo se mueve a cada posición.
Ejemplo 2
Crear un medidor de luz con el sensor de luz y el miniservo
En este ejercicio vamos a variar el ángulo del miniservo dependiendo del valor que nos dé el sensor de luz, es decir, indicaremos la
intensidad de la luz moviendo el ángulo del miniservo . Para ello puedes colocarle al miniservo un cabezal que haga las veces de aguja.
¡Vamos a medir la luz!
Para ello tendrás que conectar los componentes de la siguiente forma:
¡Un momento! Antes de que vayas hacia abajo de la pantalla para ver cómo se hace… ¡Inténtalo tú mismo! Ya sabes manejar el sensor
de luz, mapear sus valores y controlar un miniservo así que ¡baja sólo cuando tengas la solución! Recuerda que el sensor de luz te da
valores entre 0 y 500.
¿Lo conseguiste? Seguramente hayas hecho algo así:
Como el sensor de luz da valores entre 0 y 500, y el miniservo solo puede moverse entre 0 y 180 grados, es importante convertir esos
valores, mapearlos. Una vez que están mapeados podemos usar directamente la variable que los contiene, luz, para controlar el
miniservo e indicar de forma analógica la cantidad de luz que recibe el sensor.
Viendo estos ejemplos en movimiento uno se da cuenta de que… ¡Tiene el poder! Puedes hacer que el miniservo se mueva a la
posición exacta que tu desees en cada momento, si lo sumas a otros mecanismos… ¡Las posibilidades son infinitas!
- See more at: http://diwo.bq.com/programando-un-miniservo-en-bitbloq/#sthash.dX2ggs0n.dpuf

Programando un sensor infrarrojo en bitbloq
¿Qué son los sensores infrarrojos?
El sensor infrarrojo, también conocido como sensor IR, es un dispositivo que detecta la luz reflejada
y, por tanto, es capaz de diferenciar entre blanco y negro o claro y oscuro.
Se trata de un componente digital, ya que únicamente devuelve dos valores (0 y 1). Cuando detecta
negro devuelve 0 (el negro absorbe la luz, por tanto la luz reflejada, que es lo que mide el sensor, es
cero) y cuando detecta blanco, 1. Los sensores IR están presentes en objetos cotidianos como:
 Hornos microondas.
 Puertas de garaje.
 Alarmas antirrobo.
 Farolas (se encienden al oscurecer y se apagan cuando se hace de día).
 Automóviles (detectan cuándo es de noche o si hay niebla para que se encienden los faros).
Manos a la obra. Vamos a realizar dos ejemplos que usan el sensor infrarrojo para hacer sonar un zumbador y para encender un
LED.
Vas a necesitar:
 2 x ZumBloq Infrarrojo
 1 x ZumBloq Led
 Un cable USB
Antes de empezar necesitarás ver el vídeo de cómo calibrar los sensores infrarrojos.
¿Ya lo tienes? Vamos.
Ejemplo 1
Hacer sonar el zumbador cuando el sensor IR detecte negro
Como ya hemos visto, el sensor IR es capaz de diferenciar entre blanco y negro. Antes de comenzar con el programa, conectamos los
componentes a la placa controladora como en el siguiente esquema. IR al pin digital 3 y zumbador al pin digital 5.

Una vez conectados el zumbador y el sensor IR a la placa, hacemos el programa. Utilizaremos el socorrido bloque Si… ejecutar.
En este ejemplo hemos declarado una variable llamada color_detectado que representa al sensor infrarrojo. Hemos añadido una
condición (que el color detectado sea negro) para que el zumbador suene. Para probar que funciona podemos colocar el sensor IR a
unos 3 centímetros de una superficie blanca y colocar la mano entre el sensor y dicha superficie. ¿Qué ocurre? ¿Suena el zumbador?
Ejemplo 2
Hacer que se encienda un LED cuando los dos sensores IR detecten negro
Ahora vamos a hacer que se encienda un LED únicamente cuando los dos IR detecten el color negro. Para ello seguimos el
procedimiento de siempre. Conectamos los sensores IR en los pines digitales 2 y 3 y el LED en el PIN 7 como en el esquema:
Programamos la placa controladora para que el LED se encienda cuando ambos
sensores detecten el color negro. En esta ocasión deben cumplirse dos condiciones para que se ejecuten las instrucciones que
queremos (en este caso, que se encienda el LED). Utilizando el bloque “y” del apartado “Lógica” podemos añadir las dos condiciones al
programa.

Construye tu propio semáforo
¿Estás harto de esperar a que se ponga verde el semáforo? ¿Qué pasaría si tú controlaras uno?
En este post podrás encontrar la respuesta, porque… ¡Vamos a construir nuestro propio semáforo! Y aún mejor, ¡vamos a ponerle una
barrera!
Como todos sabemos, un semáforo es un tipo de señal de tráfico que permite o prohíbe el paso a vehículos o peatones según el color
de la luz que emita. Sin ellos, los cruces de las calles serían un auténtico peligro.
Vamos a ello: nuestro semáforo va a tener dos luces y una barrera. ¿Qué tienes en tu electrónica que emite luces? ¿Qué componente
es capaz de mover una barrera? ¡Correcto! Vamos a usar 2 LED y un miniservo, además, claro está, de nuestra placa controladora
ZUM BT-328. En total vamos a necesitar:
 Una cartulina
 Un poco de celofán verde
 Un poco de celofán rojo
 Tijeras
 Cinta adhesiva
 Pegamento
 2x ZumBloq LED
 1x ZumBloq Miniservo
 Cabezal angular del miniservo
 Una placa controladora ZUM BT 328 compatible con Arduino
 Un cable USB
Montaje
Primer paso:
Diseña tu propio semáforo o imprime la plantilla que hemos diseñado y que puedes encontrar en la zona de descargas. Asegúrate de
imprimirla sin escalar, con la opción a tamaño real. Después, recorta la plantilla por las líneas negras y las zonas indicadas.
Una vez recortado todo, dobla el papel por todas las líneas discontinuas que encuentres. Los rectángulos blancos que se ven en la
barrera y el poste, sirven para reforzar la estructura. Deben doblarse de forma que queden hacia dentro.

Segundo paso:
Es hora de poner los cristales a tu semáforo. Para ello, recorta un cuadrado de celofán de color rojo y pégalo con pegamento o cinta
adhesiva por la parte interior del semáforo en el agujero de arriba. Haz lo mismo con un trocito de celofán verde en el agujero de abajo.
Un consejo: como tu LED es azul, cuanto más celofán rojo pongas, más roja será la señal.
Tercer paso:
Ahora tenemos que colocar los LED. Lo primero es identificar de qué color es cada LED. Para ello, crea un programa que encienda los
dos LED tal y como se explica aquí. Tenemos que colocar los LED dentro del semáforo, pegados a la pared trasera tal y como se ve en
la imagen. El LED verde detrás del celofán verde y el LED azul detrás del rojo. Puedes pintar el LED azul con rotulador rojo para darle
un tono más rojizo a la luz (¡asegúrate que el rotulador no sea permanente!).
Usa cinta adhesiva para pegarlos y revisa que los conectores no choquen con la pared. Puedes sacar los cables por un lateral del
semáforo, o si quieres que quede perfecto, prueba a sacarlos por la base del semáforo, atravesando el poste y la base (lo sé, no es
fácil, pero queda muy chulo).
Cuarto paso:
Une el poste a la caja principal ayudándote de las pestañas. Mira la imagen, te será de gran ayuda.
Cierra la caja principal y termina el semáforo añadiendo la base. Usa las pestañas como antes.
Quinto paso:
Vamos con la barrera. Primero dobla y pega la cajita del miniservo e introdúcelo dentro. ¿Ves ese cuadradito que falta en la barrera?
Tienes que pegar el cabezal del miniservo que viste en los materiales de forma que, la parte que se pone en el miniservo quede hacia
fuera y, lo demás, dentro de la barrera. Fíjate en la imagen para saber si lo estás colocando todo bien.
¡Ya tienes tu semáforo! Eso sí, no le pongas aún la barrera al miniservo. Espérate a programarlo y cuando sepas que el semáforo está
en verde, coloca la barrera en la posición correcta.
Sexto paso:
Conexiones: puedes realizar las conexiones ahora, o si lo prefieres, una vez programada la placa.

Programación
Es hora de programar tu semáforo. El programa completo es el siguiente:
Como veis, es un programa relativamente corto, pero lo que vamos a aprender aquí son buenas prácticas de programación. Las buenas
prácticas de programación son muy importantes puesto que ayudan a que cualquier persona que vea tu programa lo entienda mejor.
Son formas de hacer las cosas más comprensibles para todos, según las normas que se han ido estableciendo en la comunidad de los
programadores alrededor del planeta. En nuestro programa veremos dos de ellas:
 Las variables globales: Hemos usado variables globales para escribir unos parámetros que definen el funcionamiento del
programa. Como estas variables se declaran al principio del programa, podemos encontrarlas fácilmente y modificar el tiempo
que queremos que esté el semáforo en verde, parpadeando y en rojo, solamente cambiando los valores de estas variables.
Así no tendremos que buscar entre todo el código dónde están estos tiempos para modificarlos.
 Las funciones: Cuanto más pequeño sea nuestro programa principal, más fácil será de leer. La forma de conseguir esto es
hacer un buen uso de las funciones. Se debe entender qué hace una función solamente leyendo su nombre. De esta forma,
leer el programa principal será pan comido.
Mira otra vez el programa y fíjate solo en el bucle principal (lo que no son funciones ni variables globales). ¿A que se lee fácil? Tan
simple como encender luz verde, esperar tiempo de luz verde, parpadear, encender rojo y esperar tiempo de luz roja. Cualquiera en la
comunidad bitbloq podría leerlo al instante.
La única función algo más compleja es la del parpadeo:

En ella estamos creando un bucle contar para repetir cuatro veces un parpadeo del LED verde. El tiempo del bloque esperar está
dividido entre 8 para hacer que parpadee cuatro veces, elijas el tiempo que elijas en la variable global tiempo_de_parpadeo. Y como ya
estamos esperando aquí, no esperamos en el bucle principal.
¡A jugar!
Ahora sabemos programar un semáforo para que tarde en ponerse verde el tiempo que queramos, pero… ¿Os imagináis tener que
controlar todos los semáforos de una ciudad? Seguid practicando y quizá algún día os parezca sencillo. Y para practicar, anímate a
crear algo como esto:
 Añade una ayuda sonora para las personas ciegas con tu zumbador
 Añadirle la luz ambar y hacer un semáforo para vehículos
 Crear un cruce con varios semáforos sincronizando correctamente los tiempos de forma que los vehículos no se choquen.
Recuerda hacer uso de las buenas prácticas de programación.
¡Hasta pronto!
- See more at: http://diwo.bq.com/construye-tu-propio-semaforo/#sthash.v2in7FzQ.dpuf

Programando el sensor ultrasonido
¿Qué es un sensor ultrasonido?
Los sensores de ultrasonidos son dispositivos que utilizan ondas sonoras de ultrasonidos
para saber a qué distancia está un objeto. Su funcionamiento es sencillo. Se emite una
onda ultrasonido (utilizando algo parecido a una altavoz, y que se llama emisor), Esa
onda se propaga, y al encontrarse un obstáculo rebota. Se utilizan mucho en robots para
que detecten los objetos que tienen delante y no choquen contra ellos.
Los sensores ultrasonidos permiten medir la distancia a los objetos que tienen en frente. Como puedes ver el sensor ultrasonido del
ZUM Kit tiene dos partes, una es el emisor y la otra el receptor. Por una de ellas se emitirá una onda ultrasonido, que tú no podrás oir,
esa onda viajará por el aire, hasta que choque contra algún objeto que tenga delante, entonces rebotará y volverá hasta el robot, y el
receptor la escuchará. Como sabemos la velocidad del sonido (343,2 metros/segundo), midiendo el tiempo que tarda la onda en ir y
volver sabemos la distancia al obstáculo. Gracias a los sensores ultrasonidos podrías realizar proyectos en los que necesites saber la
distancia a los objetos, por ejemplo, tu robot sabrá la distancia a un obtáculo para poder esquivarlo.
Para esta lección necesitarás:
 1 x ZumBloq Sensor Ultra Sonido
 Un cable USB
¿Tienes todo? Empecemos, vamos a hacer un sistema de alarma semejante al que usan los coches cuando están aparcando, que te
avisan cuando estás muy cerca de otro coche.
Ejercicio 1. Programar la placa controladora para que el zumbador suene a medida que se va
acercando a un objeto.
En este ejemplo haremos un programa que haga que el sensor de ultrasonidos actúe de la siguiente forma:
Cuando se acerca a menos de 40 centímetros de un objeto, emite un pitido intermitente. El tiempo de espera entre un pitido y otro
dependerá de la distancia (cuanto más cerca está del objeto, con más rapidez alterna los pitidos).
El funcionamiento es el mismo que el de los sensores de los coches, que se suelen utilizar para aparcar. A medida que me voy
acercando a otro coche o a una pared, suena un pitido que va aumentando su rapidez.
Vamos a paso a paso:
1) Conectar el zumbador en el pin digital 10 y el sensor de ultrasonidos como se indica en el dibujo. ¡Es muy importante
conectar bien los cables! El Echo y el Trigger pin, que en el sensor se llaman ECH (cable rojo) y TRI (cable azul) deben ir conectados a
un pin de señal (en tu bq ZUM BT-328 son de color amarillo), mientras que los otros dos cables se conectan de la siguiente forma:
 Cable negro en cualquier pin negro
 Cable naranja en cualquier pin rojo
El pin de Trigger es aquél que le ordena al sensor ultrasonido que lance la onda. El pin Echo se activa cuando la onda está de vuelta.
Por lo tanto, la distancia en metros será el tiempo que pasa desde que activamos el pin Trigger y la recepción de la onda en el
pin Echo dividida por 343 y dividido por 2(ya que la velocidad del sonido es 343 metros/segundo y es ida y vuelta -> distancia = tiempo /
343 * 1/2)

2) Hacemos el código en bitbloq. Como podemos observar, en el bloque del sensor de ultrasonidos únicamente deberemos indicar en
qué pines hemos conectado el ECHO (ECH) y el TRIGGER (TRI).
Prueba a programarlo en bitbloq y verás que funciona como se espera.
¿Te atreves a modificar tú mismo el programa para que haga lo siguiente?
 Cuando se acerca a menos de 10 centímetros de un objeto, emite un pitido durante 500 milisegundos (como está a punto de
chocar contra un obstáculo, el pitido dura bastante)..
 Cuando se acerca a menos de 40 centímetros de un objeto, emite un pitido intermitente. El tiempo de espera entre un pitido y
otro dependerá de la distancia (cuanto más cerca está del objeto, con más rapidez alterna los pitidos).
- See more at: http://diwo.bq.com/programando-el-sensor-ultrasonido-en-bitbloq/#sthash.51Od4ljy.dpuf

Programando el buscaluz
¿Tienes ya el buscaluz montado pero no consigues que se mueva? ¿Quieres programar algo diferente? Sigue leyendo si quieres
aprender paso a paso cómo programar tu buscaluz.
El programa que vamos a analizar a continuación es un ejemplo de búsqueda de máximos. Como su nombre indica, su función
es buscar entre muchos valores y encontrar cuál es el valor más grande. Vamos a ver el programa:
¿Qué te parece el programa? Si has realizado el curso de programación con bitbloq seguro que te resulta pan comido. Pero si no es
así, vamos a verlo en profundidad.
¿Recuerdas lo que son las variables? En este programa de búsqueda de máximos vamos a usar dos variables donde guardaremos: la
luz máxima y el ángulo donde se encuentra esta luz (llamado en el programa “angulo_maximo“).

Como sabemos, los programas se repiten en bucle. Cada vez que el programa llegue al final y vuelva a empezar, hay que borrar los
datos obtenidos en la búsqueda anterior. A esto se le llama inicialización del programa. En nuestro caso, las variables “luz_maxima” y
“angulo_maximo” se inician a “0”.
En cambio, la variable “angulo” le daremos un valor de “20” ya que ésta será la primera posición que tome el buscaluz para empezar su
baño de sol.
Tras las variables tenemos un bucle “Si…Ejecutar” que tiene como condición pulsar el botón. El buscaluz estará en reposo hasta que
ejecutemos este bucle.
Nota: Si tienes un pulsador de “Mi primer kit de Robótica”, asegúrate de cambiar el 1 por un 0.
Vamos ahora con la parte importante del programa: El movimiento del buscaluz y su búsqueda de máximos
Se trata de un bucle “mientras” que tiene como condición para repetirse que “angulo” sea menor o igual que 160. (Para recordar cómo
funcionan los bucles “mientras”, pincha aquí)
Lo que haremos será recorrer el rango de posiciones de 20 a 160 grados parándonos de 10 en 10. Fíjate en esta cuenta: 20,30,40…
…120,140,160.
En cada parada de esta cuenta lo primero que hacemos es colocar el miniservo en esa posición.
A continuación, hace una lectura de la luz ambiente y empieza la magia: El bucle “Si…Ejecutar” comprueba si la luz que acaba de medir
es mayor que la “luz_maxima” que teníamos guardada. Si esto es correcto ¡habremos encontrado un nuevo máximo!
Si encontramos un nuevo máximo: Recordamos cuál es el nuevo valor de “luz_maxima” y recordamos la posición en la que se ha
encontrado (“angulo_maximo”).
Hayamos encontrado o no un nuevo máximo: sumamos 10 a la variable “angulo” y repetimos el proceso hasta llegar a la parada final de
160.
Gracias al bucle “mientras”, el proceso se repetirá 15 veces (15 paradas) antes de continuar:
Una vez acabada la búsqueda, movemos el buscaluz a ese “angulo_maximo” que hemos encontrado. Y aquí permanecerá quieto
tomando el sol en reposo hasta que volvamos a apretar el botón de nuevo.

Si os habéis quedado con ganas de más, ¿por qué no probáis a mejorar el buscaluz? Te dejo unas ideas para que intentes por tu
cuenta:
 Ponerle el zumbador para hacer sonidos cuando encuentre un nuevo máximo.
 Ponerle la pantalla LCD para ver en todo momento estos valores.
 Moverlo con el potenciómetro o la invención que se os ocurra.
 Y si os sentís realmente osados, podéis probar a montar el Súper Buscaluz, que consta de dos miniservos pegados uno a otro
para poder mover la placa solar mucho más. Podéis obtener alguna pista de como usar dos servos unidos en los comentarios
del bq Invento “Memoria” .
Hagáis lo que hagáis, contádmelo en los comentarios, y lo mismo si tenéis alguna duda.
Bueno, acabas de crear un programa de búsqueda de máximos. Seguro que ahora entiendes el porqué utilizar una variable más es tan
necesario para almacenar los máximos que encontremos. Espero que lo hayas pasado bien y que tu buscaluz te oriente siempre hacia
al lado luminoso de la fuerza…
- See more at: http://diwo.bq.com/programando-el-buscaluz-con-bitbloq/#sthash.pQP7xSv3.dpuf

Do, re, mi, fa, sol… Creando melodías con bitbloq
¿Alguna vez has deseado que tus robots e inventos sean más divertidos? ¿Sabías que puedes crear melodías utilizando simplemente
un zumbador? La música es el alimento del alma… ¡siempre que no desafines! Hoy te enseñaremos algunas herramientas, recursos
para crear melodías e incluso instrumentos usando tan solo bitbloq y tu zumbador. ¿Quieres descubrir cómo? ¡Conéctate a tierra que
empezamos!
bitbloq y los bloques del zumbador
Anteriormente te explicamos cómo funcionaban los bloques del zumbador. ¿Recuerdas cómo eran?

En el bloque básico encontrarás siete notas, del do al si (en escala de do mayor).
Estas notas corresponden a la escala central del piano o a la escala que puedes
tocar con una flauta dulce común.
Pero, ¿qué sucede cuando quieres hacer una melodía que tenga alteraciones
(bemoles b o sostenidos #)?
En el bloque avanzado tú eres el que le dice al zumbador qué frecuencia usar, o lo
que es lo mismo, qué nota sonará. Esto es muy útil para tocar notas especiales con
las que podrás crear melodías más complejas.
¡Dejemos a un lado la teoría y pasemos a la práctica!
En la granja había un… Creando nuestra primera melodía
Vamos a tocar nuestra primera melodía usando el zumbador. Para ello vamos a
usar una canción muy famosa. ¡Seguro que la conoces!
Para ello, utiliza el bloque básico del zumbador y escribe las siguientes notas:
IA IA OOOOOOOOOOOOOOOOO
Como puedes ver en el programa, hemos usado una duración de 400 ms para las
notas negras, por lo que las notas blancas duran el doble: 800 ms. Para la última
nota que tiene un puntillo, por lo que la nota tiene media duración más, hemos
puesto un tiempo de 1200 ms (800 ms + 400 ms).
Sin embargo esta forma de crear melodías puede ser un poco confusa. Son muchas
notas y el programa acaba siendo realmente grande. ¿Por qué no
aprovechamos las funciones para organizar mejor nuestra melodía?
Observa el siguiente programa:
Hemos usado cuatro funciones para escribir las notas de cada compás por
separado. De esta forma es mucho más sencillo escribir melodías a partir de un
pentagrama. Además, si te equivocas, sabrás rápidamente en qué compás está la
nota a cambiar y podrás modificarla fácilmente.

Utilizando notas especiales
Esta forma de realizar melodías es muy divertida pero, ¿qué ocurre si queremos tocar una canción con notas en bemol o sostenido? Si
necesitamos utilizar dichas notas no nos quedará más remedio que utilizar el bloque avanzado y escribir su frecuencia. ¡Pero no te
preocupes! No tendrás que recordar o apuntar cada frecuencia de cada nota, aquí abajo podrás encontrar un traductor de notas a
frecuencias que te ayudará a crear tus melodías avanzadas de forma mucho más sencilla.
Puedes introducir las notas como "do", "re", "mi", etc... O bien en notación anglosajona, donde además podrás escribir notas más
graves o agudas según el número que escribas a su lado. Por ejemplo un do central del piano sería un "C4".
Vamos a tocar una melodía utilizando directamente frecuencias. Fíjate cómo realizaríamos el programa:
¡Bob es-pon-ja!
Como puedes ver, hemos tocado notas que solo serían posibles utilizando el zumbador avanzado. Además, hemos definido variables
globales para definir la duración de las negras, blancas y corcheas, así es mucho más sencillo entender la melodía, ampliarla y
modificarla.
Internet y las melodías
En la red podrás encontrar un montón de melodías ya hechas y preparadas para sonar en Arduino junto a tu zumbador. Si no
encuentras la melodía, busca la partitura, créala tú mismo y compártela con la comunidad. Si lo deseas, dichas melodías pueden
pasarse muy fácilmente a bitbloq, para ello solo tendrás que leer la función tone(), que es la encargada de hacer sonar el zumbador en
lenguaje Arduino, y escribir sus valores en el bloque avanzado de la siguiente manera:

Donde el primer elemento de la función tone() es el pin al que hemos conectado el zumbador (9), el segundo la frecuencia (261), y el
tercero la duración (400).
Además hemos recopilado y preparado una serie de melodías en bitbloq para que las pruebes directamente, podrás encontrarlas en la
sección Descargas e iremos actualizándolas según vayamos creando más. ¡Anímate y crea tus propias melodías! ¡Aceptamos
aportaciones!
¡Ya eres capaz de crear todas las melodías que desees! Tanto en libros como en la red podrás encontrar multitud de partituras e,
incluso, las frecuencias del zumbador o la melodía en Arduino. Pero aún hay más, ¿por qué no pruebas a realizar tu
propio instrumento? ¿Qué tal si creas un robot capaz de tocar un tambor? Practica y verás como pronto serás un gran compositor.
¡Música maestro!
- See more at: http://diwo.bq.com/do-re-mi-fa-sol-creando-melodias-con-bitbloq/#sthash.KiZmu35I.dpuf

PrintBot Evolution – Programando un esquiva-obstáculos
En esta entrada te explicamos cómo programar un esquiva obstáculos. Si tienes un robot con un sensor de ultrasonidos y un miniservo
que lo pueda mover, podrás programarlo de esta forma. El PrintBot Evolution es una herramienta perfecta para realizar esta
programación.
¡Jugar con fuego es peligroso! Aunque tengamos una fantástica piel de dragón, nuestro robot lo que va a hacer es intentar no chocarse
y rodear los objetos que encuentre en su camino.
¿Cómo funciona el esquiva obstáculos?
Hay multitud de formas de programar un robot para que esquive obstáculos, pero te vamos a explicar el funcionamiento de una de ellas.
Estas son las tareas que debe hacer el robot:
1. Tomar medidas
2. Comprobar detección de obstáculo
3. Ejecutar el movimiento correcto
Veamos en detalle cada una de estas tareas:
1) Tomando medidas con el sensor de ultrasonidos
En primer lugar tomaremos 3 medidas con el sensor de ultrasonidos: a la izquierda, al centro y otra a la derecha.
Lo que estamos midiendo es la distancia al objeto que tenga delante el sensor, por tanto bastará ir cambiando la posición del sensor
como cuando nosotros giramos la cabeza para mirar hacia un lado. Este cambio de orientación podemos hacerlo con un miniservo.
2) Comprobar detección de obstáculos para saber cómo actuar
Si no hay ningún obstáculo a
menos de 25 cm por delante
del robot,
haremos que suene un
pitido “Beep” y
podremos avanzar recto
Si en cambio hay obstáculo a
menos de 25 cm,
habrá sonado un pitido de
error “Meec”.
En este caso tenemos que
comprobar si podemos
esquivarlo por algún lateral.
Primero comprobamos si
podemos esquivarlo por la
izquierda.
Si no hay obstáculo a menos
de 25 cm en este lado
podremos girar a la
izquierda.
Si no se puede por la
izquierda, comprobamos a
ver si es posible esquivarlo
por la derecha.

Pero… ¿Qué sucede si las tres
direcciones están bloqueadas?
Pues que haremos sonar un
aviso “Meeec meec ¡Soy un
robot quejándose! ¡Por aquí no
se puede avanzar!“.
Y dado que está atrapado,
debemos hacer retroceder al
robot y a continuación hacer
cambie de rumbo, por ejemplo
que gire a la izquierda.
3) Ejecutar el movimiento correcto
En este último paso, tan sólo tendremos que mover las ruedas del robot para que describa la trayectoria decidida en el paso anterior. ¡A
rodar motores!
Programando en bitbloq para el PrintBot Evolution
Vamos a usar bitbloq para hacer este programa. Además, tomaremos como referencia las conexiones que se proponen en la guía de
montaje del PrintBot Evolution. Si es la primera vez que utilizas este tipo de componentes electrónicos, puedes ver pulsando aquí
unos primeros pasos antes de comenzar la programación.
Para empezar, declaramos las variables que necesitamos:
Las variables “obs_Left, obs_Right y obs_Center” las utilizaremos para guardar un 1 o un 0 si se ha detectado un obstáculo a la
izquierda, derecha o delante respectivamente. Un 1 significa obstáculo en esa dirección.
Las variables “angle_Left, angle_Right y angle_Center” guardan las posiciones del miniservo para que los “ojos” del robot estén
mirando hacia la izquierda, derecha o centro. Recordad que al ordenar al miniservo que se mueva a un ángulo lo que hacemos es girar
y orientar el sensor ultrasonidos.
Una vez definimos las variables, vamos a comenzar a programar el bucle de programa que se repetirá una y otra vez. Lo primero es
hacer que el robot se pare con la función Stop:

Las 3 mediciones de las que hablábamos se pueden programar de esta forma:
La función “search_Obstacle” es la buscadora de obstáculos. Tiene como parámetro de entrada un ángulo y la salida será un 1 o un 0.
Esta completa función se programa así en bitbloq:
Como véis, primero mueve el miniservo a ese ángulo de entrada, después usa el bloque del sensor de ultrasonidos que mide distancia
(en centímetros) y por último el bloque verde de comparación:
– Si la distancia que mide el sensor es menor que 25cm: reproduce sonido de error con el zumbador y devuelve un 1. ¡Hay obstáculo!
– De lo contrario, pitido agudo con el zumbador “beep” que indica zona despejada. Devolverá en este caso un 0. ¡Está despejado!
Ahora viene la elección de cómo debe actuar el robot según los obstáculos detectados. ¿Cómo reaccionar? Ya hemos explicado las 4
posibilidades antes, aquí os dejo cómo se programan con los bloques bitbloq:

Ya sólo nos queda definir cómo son esas funciones de movimiento que estamos ejecutando. Para hacer AVANZAR al robot usamos la
función llamada “go_Fordward“:
Esta función hace sonar unos pitidos con el zumbador avisando de camino despejado. A continuación, mueve las dos ruedas con los
servos de rotación continua: el servo izquierdo (pin 8) gira en sentido horario y el servo derecho (pin 9) gira en sentido antihorario.
[Nota: El sentido de giro se aprecia mirando las ruedas desde el centro del robot]
Para hacer GIRAR al robot usamos las funciones llamadas “turn_Left” si gira a la izquierda y “turn_Right” si gira a la derecha.
Para DETENER al robot usamos la función llamada “Stop” que también usábamos al principio:

Por último, para hacer RETROCEDER al robot usamos la función llamada “go_Backward“:

Esta función es tan larga porque hace tres cosas:
– Emitir unos graciosos sonidos de error (“¡Oh oh oohh, robot
atrapado!”)
– Mover la cabeza-miniservo de un lado a otro (“¡No no noo,
robot confuso!”)
– Retroceder moviendo los servos de rotación continua.
Este sería el programa al completo:
¡Ya tienes el programa completo! Pero… Recuerdo que esta
es sólo una forma sencilla de programar un esquiva-
obstáculos, hay varias cosas que se podrían mejorar:
aumentar la velocidad, la toma de más de 3 medidas para no
dejarse obstáculos sin detectar o, por ejemplo, un cambio en
la prioridad de las acciones (no siempre es mejor avanzar y
girar a la izquierda). ¿Te atreves a mejorar el código?
- See more at: http://diwo.bq.com/printbot-evolution-
obstaculos/#sthash.JXTeDyXb.dpuf

Programando en bitbloq

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Destaque

Destaque (14)

Semelhante a Programando en bitbloq

Semelhante a Programando en bitbloq (20)

Mais de Visemi VI

Mais de Visemi VI (8)

Último

Último (20)

Programando en bitbloq