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

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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:

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

1 x ZumBloq Joystick

1 x ZumBloq Miniservo

1 x ZumBloq LCD

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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.

Programando los bloques de control- 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!

http://diwo.bq.com/wp-content/uploads/2015/01/ejemplobloquesi.png

Programando los bloques de control- 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

1 x ZumBloq Zumbador

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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:

Para realizar los ejemplos de hoy, necesitarás:

1 x ZumBloq LED

1 x ZumBloq Zumbador

1 x ZumBloq Pulsador

1 x ZumBloq Servo rotación continua

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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!

Para realizar los ejemplos de hoy, necesitarás:

1 x ZumBloq miniservo

1 x ZumBloq Potenciómetro

1 x ZumBloq Sensor de luz

1 x ZumBloq Zumbador

1 x ZumBloq LCD

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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!

Para realizar los ejemplos de hoy, necesitarás:

1 x ZumBloq LED

1 x ZumBloq Zumbador

1 x ZumBloq Pulsador

1 x ZumBloq LCD

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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)

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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

1 x ZumBloq Zumbador

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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 Zumbador

1 x ZumBloq Sensor Ultra Sonido

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

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.

http://diwo.bq.com/wp-content/uploads/2015/06/old_macdonald_had_a_farm_funtions.png

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 un Joystick con bitbloq

¿Qué es un joystick?

Un joystick es una especie de seta que gira 360 grados y que nos permite controlar multitud de aparatos. Se ven en muchos

dispositivos sobretodo en mandos de videoconsolas. ¡Son muy útiles para controlar de forma sencilla nuestros robots u otros proyectos!

¿Quieres aprender como funcionan? ¡Vamos allá!

Aunque parezca un componente muy complicado en realidad no lo es…hagamos una cosa, coge tu joystick y quítale la pieza de

plástico, la seta, que te permite manipularlo, fíjate bien:

¿No te suenan de algo esos dos componentes negros? ¡Se parecen muchísimo a tu potenciómetro! Y es que, literalmente, un joystick

no es más que dos potenciómetros juntos, uno para controlar el eje X, y otro para controlar el eje Y. Además éste joystick tiene también

un pulsador, de forma que si pulsas la seta, puedan ocurrir aún más cosas.

¡Dos potenciómetros y un pulsador! ¡Y podemos programarlos como deseemos! ¡Vamos a descubrir cómo!

Para hoy necesitarás:

Un módulo Joystick

Una pantalla LCD

Una placa controladora ZUM BT 328 o compatible con Arduino UNO

Un cable USB

Ejemplo 1

Mostrar los valores del joystick por pantalla

Vamos a aprovechar la pantalla LCD para mostrar los valores del joystick, tanto del eje X, como del Y de su botón. Para ello conecta el

joystick y el LCD de la siguiente forma:

Ahora fíjate bien en cómo se ha realizado el programa en bitbloq:

Como sucedía con otros sensores que hemos visto anteriormente, debemos asignarle al joystick una variable que almacene sus

valores. En el ejemplo la hemos llamado joystick y es una variable un poco especial… ¡Almacena tres valores! Este tipo de variables

son conocidas como arrays o vectores y sirven para poder almacenar varios valores en una sola variable, cómo las coordenadas x, y,

z de una gráfica, las horas minutos y segundos de un reloj, o en nuestro caso, la coordenada X, Y, y el pulsador de nuestro joystick.

Como ves, declaramos y asignamos la variable al joystick y a continuación empezamos a escribir su información en la pantalla LCD.

Para acceder a la coordenada X, Y o al valor del pulsador del joystick deberemos acceder a uno de los tres elementos de la variable.

Para ello puedes usar el bloque var variable[indice] donde el índice corresponderá al elemento que queremos acceder.

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:

Fíjate en los valores que alcanza tu joystick, en teoría tu joystick te dará, como con el potenciómetro, valores entre 0 y 1023, pero en la

realidad es muy difícil que alcances esos valores, dependerá de tu joystick. Esto se debe a limitaciones físicas del propio joystick. Ten

en cuenta los valores máximos que alcanza tu joystick en caso de que desees hacer un proyecto que requiera gran precisión para

programar mejor tus proyectos.

Hagamos otro ejemplo con el joystick:

Ejemplo 2

Variar la velocidad de parpadeo de un LED con el joystick

¿Recuerdas como variábamos la velocidad de parpadeo con el potenciómetro? Pues bien en aquella ocasión el tiempo de espera tras

el encendido y el parpadeo del LED tenía que ser el mismo… ¡ahora con el joystick tenemos dos potenciómetros en una sola pieza! así

que vamos a hacer un pequeño experimento, y hacer que el tiempo que permanezca encendido el LED dependa del valor X y el tiempo

que permanezca apagado del valor Y.

Conecta el joystick como en el esquema anterior y añade un led al pin digital número 6. ¡Inténtalo tú mismo! Te recomendamos, para

que el efecto sea más evidente, que mapees el valor del joystick entre 0 y 500, aunque no es estrictamente necesario. Cuando quieras

ver la solución baja mas abajo.

¿Lo conseguiste? Debería haberte quedado algo similar a esto:

Como puedes observar, los tiempos de parpadeo varían dependiendo de la posición del joystick, experimenta con las distintas

posiciones, puedes cambiar tambien los valores de mapeo para que sea más rápido o más lento.

Los joystick pueden usarse para multitud de aplicaciones, desde controlar motores, a cualquier otro elemento u aparato, experimenta

con él, pronto será uno de tus componentes favoritos.

- See more at: http://diwo.bq.com/programando-un-joystick-con-bitbloq/#sthash.MbPDEszc.dpuf

Programando un siguelíneas Ya has montado el PrintBot Renacuajo. Ahora vamos a programarlo para que siga una línea negra. ¿Sabes cómo funciona un

siguelíneas? En la siguiente imagen te lo explicamos. El robot, gracias al sensor infrarrojo, sabe cuándo el suelo es blanco o negro, por

lo que es capaz de detectar si está encima de la línea o no y, en función de esta información, puede actuar para seguirla.

Bien, vamos a ir paso a paso viendo cómo se programa en bitbloq

¡Comencemos! Nuestro PrintBot tiene dos sensores infrarrojos que le ayudan a detectar cuándo está encima de la línea negra, así que

vamos a leer el valor de los sensores. Llamaremos a las lecturas ir_derecho e ir_izquierdo. ¡Ojo! “ir” significa infrarrojo, no es el verbo ir.

Además, como puedes ver en el esquema eléctrico de arriba, el servo derecho está conectado al PIN digital 9 y el izquierdo al PIN

digital 6.

Fíjate en que el sensor izquierdo está conectado al pin 3 y el derecho al 2

El sensor infrarrojo nos da un valor 0 cuando detecta negro y 1 en caso contrario. Para acordarnos, vamos a declarar la variable

NEGRO con el valor 0. Las variables son “nombres” a los que asignamos un valor. Mira cómo se hace.

¿Y ahora? Pues ahora tenemos que mover los motores para que el robot siga la línea. ¿Has leído bien la explicación del siguelíneas?

1. Cuando los dos sensores ven la línea negra quiere decir que el robot está sobre la línea, y por lo tanto debe avanzar. Para ello los

dos servos giran.

2. Cuando los dos sensores ven blanco entonces se ha terminado la línea negra o el robot se ha perdido, y lo mejor es pararnos.

3. Cuando el sensor izquierdo ve negro y el derecho blanco quiere decir que el robot se está saliendo por la derecha, y debe girar a la

izquierda. Para girar a la izquierda lo que hago es mover sólo la rueda derecha (prueba en casa, ya verás como tengo razón).

4. Cuando el sensor derecho ve negro y el izquierdo blanco quiere decir que se está saliendo por la izquierda, y debe girar a la derecha.

Para girar a la derecha lo que hago es mover sólo la rueda izquierda (¿ya te has convencido?).

Bien, ¡está claro! Ahora pensemos juntos. Fíjate en los 4 casos y busquemos una regla sencilla.

Siempre que el sensor derecho ve negro, se mueve la rueda izquierda, y si el sensor derecho ve blanco se para la rueda izquierda.

Siempre que el sensor izquierdo ve negro, se mueve la rueda derecha, y si el sensor izquierdo ve blanco se para la rueda derecha.

¡Piensa en ello!

Si has entendido esto hacer el programa es facilísimo:

La pausa de 10 milisegundos que hay en cada servo es porque después de mover un servo siempre es bueno esperar un poquito

Ya sabes programarlo perfectamente, y si no nuestra amiga Berta te lo explica en este vídeo. Es una auténtica robonauta. ¿Te atreves

tú a mandarnos tus propios videos? Escríbenos a diy@bq.com y te los publicaremos.

Descarga

- See more at: http://diwo.bq.com/programando-un-siguelineas/#sthash.C70V1P4R.dpuf