¡Voltios, voltios que es lo que nos gusta!

Hoy vamos a aprender cómo construir y programar nuestro propio voltímetro.

Un voltímetro es un aparato que nos permite medir la tensión o potencial que cae entre dos puntos de un circuito eléctrico. De esta forma podemos averiguar que está ocurriendo dentro de éste y saber, por ejemplo, si un componente está funcionando bien o no. También te será de gran utilidad para entender cómo funcionan los componentes que uses al construir tus propios circuitos.

Para hoy necesitarás:

• 2x cables finos de distintos colores. Puedes adquirirlos en cualquier tienda de electrónica o ferretería
• Una tijera o pela cables
• 1 x ZumBloq LCD
• 1 x ZumBloq LED
• 1 x ZumBloq Zumbador
• Una placa controladora ZUM BT 328 o compatible con Arduino UNO
• Un cable USB

El voltímetro que vamos a hacer hoy es un poco distinto de otras cosas que hemos programado anteriormente. En este caso vamos a usar también las entradas a los pines tipo hembra (los de color negro) que están situadas en los bordes de la placa. Usaremos dos cables rígidos de 0,5 mm para conectar dichos pines. Para ello es preciso cortar a una longitud cómoda y pelar ambos extremos en cada cable. Puedes ayudarte de tijeras, alicates o pela cables. Intenta que cada cable sea de un color distinto. Más tarde los colores te ayudarán a utilizar correctamente tu voltímetro.

Conexiones:

• LCD
  • SCL->Pin analógico A5->Pin de señal->Color azul
  • Pin analógico A4->Pin de señal->Color Azul
• Un cable rojo o de otro color al pin hembra A0
• Un cable negro o de otro color al pin hembra GND

Esquema para la conexión de la pantalla LCD:

Los dos cables que hemos previamente pelado y conectado a los pines hembra de nuestra placa los utilizaremos para medir la tensión que cae entre dos puntos de nuestro circuito.

Con esto ya tenemos montado nuestro voltímetro. Pasemos ahora a programarlo. Necesitamos que nuestra placa lea la diferencia de tensión entre los dos cables que hemos conectado. Uno de ellos lo hemos conectado a GND o masa, por lo que su tensión se considera como cero. El otro lo hemos conectado al pin analógico A0. ¿Cómo puede nuestra placa saber la tensión que cae en este pin?

En bitbloq podemos leer valores de un pin analógico utilizando el bloque Leer el pin analógico PIN#. Puedes encontrarlo dentro de la pestaña Funciones PIN.

El valor, al igual que ocurría con sensores analógicos como el potenciómetro, estará comprendido entre 0 y 1023.

Por lo tanto la tensión que recibamos puede ser interpretada como con cualquier otro sensor. Solo debes tener en cuenta una cosa: dicha tensión debe estar en un rango de voltaje entre 0 y 5 V.

Sin embargo lo que queremos saber es el valor real en voltios (V). Si sabemos que nuestro PIN A0 nos devuelve valores entre 0 y 1023. Y que nuestra placa es capaz de detectar tensiones entre 0 y 5 V debemos mapear.

El programa por tanto quedaría de la siguiente forma:

El programa lee en primer lugar la tensión que cae entre el pin analógico A0 y el pin GND, guardándolo en la variable lectura.

A continuación solo hay que mostrarlo utilizando el LCD. Mapearemos el valor obtenido entre 0 y 1023 a un rango entre 0 y 500. ¿Por qué entre 0 y 500 en vez de entre 0 y 5 voltios? Dado que bitbloq utiliza números enteros, una forma de poder mostrar los decimales en la medición es multiplicar su valor por 100. De esta forma la primera cifra será la unidad entera, y las otros dos cifras los decimales. Por ejemplo, si el valor es 238, mi voltímetro está midiendo 2,38 voltios.

NOTA: Dependiendo del tipo de pantalla LCD que tengas y su número de columnas y líneas querrás ordenar el texto y el valor del voltímetro de una forma u otra. Tenlo en cuenta a la hora de usar tus bloques de LCD.

Una vez que tengas tu voltímetro montado y programado, para medir la tensión que cae en una pila u otro componente solo tienes que colocar cada uno de los cables en uno de sus extremos (respeta la polaridad en el caso de las pilas GND->negativo, VIN->positivo). Recuerda que tu voltímetro solo puede medir hasta 5V. No midas aparatos conectados a la red eléctrica de tu casa o colegio ¡Es muy peligroso!

Cómo puedes ver podemos utilizar nuestro voltímetro para saber cuanta tensión cae en un LED, medir la tensión de una pila o incluso… ¡Medir la tensión de una naranja! Prueba a medir cuanta tensión cae en distintos objetos.

¿Por qué no hacemos una pequeña modificación al programa anterior para que compruebe si están o no cargadas pilas del típo AAA?

¿Se te ocurre como hacerlo? Coge una pila AAA y mira cuanta tensión tiene. ¡Es muy sencillo! Intenta hacerlo por ti mismo y baja cuando tengas la solución.

Una de las posibles soluciones podría ser la siguiente:

En este programa comprobamos si el valor del voltímetro está entre 115 y 130. Es decir, entre 1,15 y 1,3 voltios. Las pilas recargables AAA suelen tener una tensión de 1,2 V, por lo que si están cargadas el LED se encenderá y el zumbador tocará la nota Sol de forma intermitente. En caso contrario, el zumbador emitirá la nota Do y el LED permanecerá apagado.

Más ejercicios que puedes realizar

Cuando uno programa las posibilidades son infinitas. A continuación te sugerimos otros programas interesantes para hacer con tu voltímetro:

• Muestra el porcentaje de carga de una pila AAA a través del LCD. Recuerda que deberás saber antes la capacidad de tu pila
• Utiliza un miniservo como indicador de carga analógico de forma que si tu voltímetro mide más tensión, el miniservo gire más o menos grados
• Haz que el zumbador emita un tono más agudo o más grave dependiendo del valor que mida tu voltímetro
• Añade un pulsador de forma que el voltímetro solo te muestre la tensión que mide cuando lo presiones

Recuerda que, debido a las limitaciones de tu placa, tu voltímetro solo puede medir hasta un máximo de 5 V. Aún así será suficiente en muchos de los pequeños circuitos que realices. Ya sabes cómo medir la tensión que cae en un pin analógico y por tanto puedes crear tus propios sensores. ¡Aprovéchalo!

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.

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.

Con esta nueva versión de bitbloq (Versión 1.2.0 – CodeName Sapling — 17 Marzo 2015), ya no tendrás que seleccionar el puerto y el tipo de placa controladora. Ahora nosotros lo hacemos por ti con un proceso automático de detección. ¡Olvídate de la antigua ChromeApp Serial Uploader!

Tan solo tendrás que seguir estos pasos:

1. Conecta tu placa al ordenador con el cable USB.
2. Abre bitbloq (v.1.2)
3. Pulsa en Verificar y verás cómo compila el código (puede estar vacío).
4. Pulsa ahora en Cargar y verás cómo salta automáticamente la instalación de la extensión que necesitas. Una vez se haya instalado, vuelve a pulsar Cargar.

Si todo va bien, bitbloq encontrará automáticamente el tipo de placa y el puerto donde la has conectado. Puedes ver el resultado pulsando sobre Historial:

Si es la primera vez que utilizas bitbloq, es posible que tengas que instalar los drivers para que tu ordenador reconozca esa placa cerebro. Te aparecerá un mensaje como este:

Descarga e instala los drivers según el sistema operativo que uses y prueba de nuevo a cargar el programa en tu placa. Si tienes cualquier duda, escríbenos a support-bitbloq@bq.com

¿Te suena el término “Energías Renovables” o “Energía verde”? ¿Qué sabes sobre la energía solar? ¡Sigue leyendo y te cargarás de conocimiento!

El buscaluz

Te presento… ¡El buscaluz! Una casita con una placa solar que es capaz de orientarse hacia donde recibe más luz.

¿Sabías que el sol envía a la tierra 4.500 veces más energía de la que utiliza la humanidad?

La energía que utilizamos nosotros proviene de distintas fuentes como el petróleo, el carbón, el viento o el agua, y sólo en una proporción muy pequeña utilizamos la solar. Las energías que se obtienen de fuentes naturales pertenecen a las llamadas “energías renovables” o “energía verdes”.

El proyecto que vamos a trabajar hoy es un buscaluz. Un buscaluz es un pequeño proyecto electrónico compuesto principalmente por un sensor de luz y un servomotor. El buscaluz irá moviendo el servomotor y leyendo la cantidad de luz recibida en cada posición, para finalmente colocarse donde haya más luz. En nuestro buscaluz, estamos representando una placa solar, que consiste en una superficie cubierta de pequeños compartimentos que captan la luz que recibe del sol y la transforman en energía eléctrica.

Montaje

Descarga la plantilla que encontrarás en la sección de descargas e imprímela, a ser posible en cartulina. También puedes optar por descargar la plantilla en blanco y negro  y colorearla a tu gusto antes de recortarla.

Nota importante: Asegúrate de especificarle a tu impresora “imprimir a tamaño real” para que no quede demasiado pequeño.

Para construir el buscaluz necesitarás: Tijeras Pegamento Celo 1x ZumBloq Sensor de luz 1x ZumBloq Pulsador 1x ZumBloq Miniservo Una placa controladora ZUM BT-328 o compatible Un cable USB

En primer lugar, recorta por las líneas negras continuas y dobla por las líneas negras discontinuas, siempre de forma que la parte coloreada quede hacia el exterior.

Recorta el rectángulo de la placa solar y déjala a un lado.

A continuación, utiliza pegamento para encajar las pestañas y darle la forma final que has visto en la primera foto del post. Ten en cuenta que en la parte superior hay un hueco para introducir el miniservo y que al doblar la plantilla y darle forma de tejado, debe quedar hacia dentro.

¿Tienes ya la estructura? Vamos con el siguiente paso, construir el cabezal del miniservo que te permita girar bien la placa solar.

Une estos dos cabezales del miniservo al sensor de luz como muestra la siguiente imagen. Ayúdate de celo o pegamento para fijarlos.

Ahora, pasa los cables del miniservo y del sensor de luz (pegado al cabezal) por la abertura del tejado, desde el exterior al interior del buscaluz. Luego introduce la placa BQ ZUM en el interior del buscaluz y efectúa las siguientes conexiones:

El siguiente paso es muy importante. Antes de colocar el miniservo tenemos que calibrarlo. Sin colocar el cabezal, tienes que crear un programa en bitbloq que ponga el miniservo en 90 grados:

Tras cargar el programa y ver como el servo cambia a esa posición, coloca el cabezal que hemos preparado con el sensor de luz apuntando lo más hacia arriba posible.

Ya solo queda colocar la placa solar que habíamos recortado. Para ello, tendrás que hacerle un pequeño agujero en el centro del tamaño de tu LDR. Si añades un poco más de celo para que se pegue bien al sensor de luz, tendrás el éxito asegurado.

¡Ya tienes tu buscaluz! Pero espera… ¿funciona? Claro que no. Queda una parte muy importante, la programación.

Programación

Este programa ya no es tan fácil, pero con los conocimientos adquiridos en el curso de bitbloq no tendrás problemas. También te vendrá bien echar un vistazo a los post de bucle “Mientras” y del miniservo.

Antes de empezar el programa en bitbloq y programar la placa, vamos a ver como se debería comportar nuestro buscaluz en este vídeo:

El buscaluz es un claro ejemplo de un programa de búsqueda de máximos. El fundamento de éstos es medir una variable y comprobar si es mayor que otra variable en la que se almacena un valor máximo. Si es mayor, entonces la nueva medida quedará guardada en la variable máxima para recordarla en el futuro y comprobar, de ahora en adelante, utilizando de referencia esta nueva medida.

Por si no te ha quedado claro y necesitas una ayuda extra, aquí tienes una ayuda en forma de puzle para visualizar lo que tienes que programar en bitbloq:

Finalmente, si no has conseguido realizarlo por ti mismo, podrás encontrar el archivo en la sección de descargas con el programa completo para abrir en bitbloq. Además te explicamos cómo programarlo, paso a paso, aquí.

Y si acabas con el buscaluz y te ha sabido a poco, ¿por qué no pruebas a añadirle algunas mejoras? Podrías introducir sonidos con el zumbador, o si te atreves, diseñar el “súper buscaluz” que contenga 2 miniservos y sea capaz de buscar la luz en todas las direcciones.

Bueno amigos, espero que hayáis aprendido tanto sobre la energía solar como sobre programación. Cualquier duda que tengáis, ponedla en los comentarios y estaré encantado de ayudaros.

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?

¿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…

¿Cómo nos comunicábamos a grandes distancias antes de internet? ¿Qué es un telégrafo?

El telégrafo y el código Morse

El telégrafo fue el primer medio de transmisión de mensajes a grandes distancias usando electricidad. Normalmente funciona gracias a un lápiz especial movido por electroimanes que escribe sobre un papel rayas y puntos dependiendo de si recibe corriente o no. Fue ampliamente utilizado en los siglos XIX y XX siendo el medio más importante de comunicación nacional e internacional y, gracias a él, las noticias se transmitían de continente a continente a una velocidad nunca vista.

Pero ¿cómo era posible comunicarse usando solo rayas y puntos? Samuel Morse, inventor del telégrafo, vio que era muy complicado transmitir un mensaje a largas distancias en el lenguaje natural. Era necesario usar un código especial: el código Morse está formado por rayas y puntos que combinados forman las 24 letras del abecedario. Por ejemplo una A seria un punto y una raya. Una B, una raya y tres puntos, etc.

Lo bueno que tiene usar el código Morse es que es muy fácil de transmitir en muchas formas distintas: mediante sonidos, luces, escribiéndolo en un papel… ¿Por qué no pruebas tú mismo usando una linterna? Enciéndela poco tiempo para los puntos, y más tiempo para las rayas. ¡Te dejamos un traductor de código morse para que te sea más fácil generar tus propios mensajes!

Construyendo un telégrafo

Materiales

• Una placa controladora ZUM BT 328 o compatible con Arduino UNO
• 1x ZumBloq LED
• 1x ZumBloq Zumbador
• 1x ZumBloq Pulsador
• 2x Cables finos o jumpers
• Un cable USB

Haciendo un telégrafo simple

Para construir nuestro telégrafo tan solo necesitaremos los componentes de tu kit de robótica. Para ello conecta todos los elementos siguiendo el siguiente esquema.

Conectando dos telégrafos

Si deseas comunicar dos telégrafos necesitarás conectarlos mediante dos cables finos. Conectaremos los cables a dos pines digitales, una servirá para que el telégrafo reciba información y otro para que la envíe. De forma que si queremos comunicar dos telégrafos conectaremos el pin de emisión de mensajes del primero al de recepción del segundo y viceversa. Es muy sencillo, sigue el siguiente esquema para conectarlos.

Programación

Para que nuestro telégrafo funcione correctamente queremos que el LED y el zumbador estén encendidos mientras mantengamos presionado el pulsador. Para ello deberemos usar un bloque condicional. El programa es muy sencillo y podría realizarse del siguiente modo:

Ya tienes un telégrafo simple. Sin embargo los telégrafos transmitían mensajes entre aparatos a grandes distancias, ya fuera mediante cables u ondas de radio. Vamos a complicar un poco más nuestro programa para crear un telégrafo bidireccional capaz de recibir y enviar información. Para ello necesitarás usar dos cables finos que conectaremos a dos pines digitales. Uno de los pines actuará como pin de recepción de datos y el otro como pin de emisión. De esta forma nuestro telégrafo recibirá por un pin los mensajes en código morse que se le manden y mandará por otro pin los mensajes que él genere.

Para poder controlar estos dos pines digitales necesitamos usar los bloques Escribir en el pin digital PIN# y Leer el pin digital PIN#. El primero nos permitirá mandar nuestros mensajes a través del pin emisor mientras que con el segundo sabremos si estamos recibiendo un mensaje a través del pin receptor.

Con estos dos bloques ya podemos hacer que nuestro telégrafo transmita y reciba información. El programa del telégrafo bidireccional podría ser, por ejemplo, así:

En este programa cada vez que presionamos el pulsador, además de encender el LED y hacer sonar el zumbador, ponemos en estado Alto el pin emisor. En el caso de que el pulsador no esté presionado pero el pin receptor esté recibiendo un mensaje de otro telégrafo, apagaremos la señal de emisión del telégrafo y encenderemos el LED y el zumbador para reproducir el mensaje. Por último, en el caso de que ni el botón ni el pulsador esté presionado ni estemos recibiendo un mensaje de otro telégrafo, apagaremos el LED y pondremos en estado Bajo el pin de emisión.

Aún hay más

A continuación te damos más ideas para realizar con tu telégrafo:

• Muestra por la pantalla LCD las pulsaciones cortas (puntos) y largas (rayas) que realices con tu pulsador.
• Modifica el programa para que, en vez de reaccionar ante el pulsador, tu telégrafo se active cuando apuntes con una linterna a tu sensor LDR.
• Usa la botonera para mandar mensajes de código morse predefinidos. Como "S.O.S", "Hola" o "¿Me recibes?".
• Crea un juego que te muestre una letra por el LCD y tengas que reproducirla en código morse.
• Usando los dos telégrafos: usa un telégrafo para mandar un código secreto al telégrafo de tu amigo. Si el código no es correcto, sonará una señal de alarma
• Crea un traductor de lenguaje común a Morse que te permita seleccionar las letras y las vaya mostrando por el LCD.

Ya sabes cómo construir un telégrafo. Si hoy en día podemos comunicarnos mediante internet y los teléfonos móviles es gracias a él. El telégrafo revolucionó las comunicaciones conectando por primera vez continentes de una forma rápida y sencilla.

¿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:

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!

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!

¿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:

Clica en la imagen para ampliar

Hemos usado cuatro funciones para escribir las notas de cada compás por separado. De esta forma es mucho más sencillo escribir melodías a partir de un pentagrama. Además, si te equivocas, sabrás rápidamente en qué compás está la nota a cambiar y podrás modificarla fácilmente.

Utilizando notas especiales

Esta forma de realizar melodías es muy divertida pero, ¿qué ocurre si queremos tocar una canción con notas en bemol o sostenido? Si necesitamos utilizar dichas notas no nos quedará más remedio que utilizar el bloque avanzado y escribir su frecuencia. ¡Pero no te preocupes! No tendrás que recordar o apuntar cada frecuencia de cada nota, aquí abajo podrás encontrar un traductor de notas a frecuencias que te ayudará a crear tus melodías avanzadas de forma mucho más sencilla.

Puedes introducir las notas como "do", "re", "mi", etc... O bien en notación anglosajona, donde además podrás escribir notas más graves o agudas según el número que escribas a su lado. Por ejemplo un do central del piano sería un "C4".

Vamos a tocar una melodía utilizando directamente frecuencias. Fíjate cómo realizaríamos el programa:

¡Bob es-pon-ja!

Como puedes ver, hemos tocado notas que solo serían posibles utilizando el zumbador avanzado. Además, hemos definido variables globales para definir la duración de las negras, blancas y corcheas, así es mucho más sencillo entender la melodía, ampliarla y modificarla.

Internet y las melodías

En la red podrás encontrar un montón de melodías ya hechas y preparadas para sonar en Arduino junto a tu zumbador. Si no encuentras la melodía, busca la partitura, créala tú mismo y compártela con la comunidad. Si lo deseas, dichas melodías pueden pasarse muy fácilmente a bitbloq, para ello solo tendrás que leer la función tone(), que es la encargada de hacer sonar el zumbador en lenguaje Arduino, y escribir sus valores en el bloque avanzado de la siguiente manera:

Donde el primer elemento de la función tone() es el pin al que hemos conectado el zumbador (9), el segundo la frecuencia (261), y el tercero la duración (400).

Además hemos recopilado y preparado una serie de melodías en bitbloq para que las pruebes directamente, podrás encontrarlas en la sección Descargas e iremos actualizándolas según vayamos creando más. ¡Anímate y crea tus propias melodías! ¡Aceptamos aportaciones!

¡Ya eres capaz de crear todas las melodías que desees! Tanto en libros como en la red podrás encontrar multitud de partituras e, incluso, las frecuencias del zumbador o la melodía en Arduino. Pero aún hay más, ¿por qué no pruebas a realizar tu propio instrumento? ¿Qué tal si creas un robot capaz de tocar un tambor? Practica y verás como pronto serás un gran compositor. ¡Música maestro!

La nueva asignatura de la Comunidad de Madrid está dando mucho que hablar. Lejos de tintes políticos, debemos pensar en la utilidad real que pretende aportar esta asignatura.

¿Por qué todos los alumnos tienen que aprender a programar? ¿De qué les va a servir saber programar a todos aquellos que no quieran ser informáticos o, en general, que quieran tener un perfil técnico?

A pesar del rápido aumento de puestos de trabajos en el sector, muchos estudiantes no quieren dedicarse a este tipo de profesiones. La inclusión de esta asignatura pretende acercar a todos a la tecnología, intentando superar la brecha de género que ha habido hasta ahora, y haciendo ver que la tecnología no es magia, que todos podemos comprender cómo se crea y podemos ayudarnos de ella para evitar determinadas tareas repetitivas y odiosas.

Con este propósito el número de estudiantes que quieran dedicarse a profesiones técnicas seguramente aumentará, sin embargo seguirá habiendo un gran número de estudiantes que no se sientan atraídos por este ámbito.

A partir de aquí, debemos intentar ver el lado bueno de aprender a programar en el aula. Podemos ver la programación como un recurso educativo que nos sirve para desarrollar un tipo de pensamiento cada vez más necesario: el pensamiento computacional. Pero, para entender qué es el pensamiento computacional, vamos a empezar por entender para qué es útil emplear un “nuevo pensamiento”.

En la resolución de problemas complejos necesitamos emplear una serie de procesos cognitivos (ver tabla 1), procesos implicados en la construcción del conocimiento. Estos procesos que requerimos en la resolución de problemas, como se ve en la tabla 1, son procesos conocidos y estudiados desde siempre, ya que son necesarios en otros tipos de pensamiento como el analítico, crítico o lógico.

La agrupación de estas características permite abordar todo el proceso de resolución de problemas complejos desde un solo tipo de pensamiento. Lo único novedoso es incluir todos estos procesos dentro de un solo tipo de pensamiento como es el pensamiento computacional. Por tanto, el pensamiento computacional puede entenderse como un nuevo concepto que engloba varias características de siempre.

Aunque la etiqueta “computacional” puede dar a entender que son procesos únicamente relacionados con la computación, como hemos visto incluye procesos útiles para todos los perfiles, ya que la complejidad de los problemas actuales nos obliga a utilizar todos los procesos implicados en este pensamiento.

Si pensamos en la programación como recurso para desarrollar este pensamiento y que nuestros alumnos sean capaces de resolver problemas complejos, vemos como ésta puede ser ideal debida a la gran similitud en los procesos cognitivos que se requieren para ambos. En la siguiente tabla (tabla 2) podemos ver la equivalencia entre cada uno de estos procesos.

Por tanto, la programación puede resultar muy útil para desarrollar este pensamiento y ser capaces de enfrentarnos a los desafíos del siglo XXI.

¿Tienes lo que hay que tener para mantener la calma delante de una bomba? ¿Vencerás a tu contrincante en este juego de sangre fría? ¿Y si aprendemos programación creando un juego súper chulo?

En este post vamos a construir un juego en el que ganará el último que desactive la bomba. Sí sí, el último en desactivarla; competimos para ver quién tiene más aplomo y quién sabe contar mejor de memoria.

Reglas del juego

• La bomba explotará en 30 segundos, a no ser que ambos la desactivéis.
• Cada jugador tiene delante un “Death Panel”, que consta de un sensor (pulsador o IR) que al pulsarlo desactivará la bomba y un LED que se encenderá si has ganado la partida
• Puedes desactivar la bomba cuando quieras (antes de que explote), pero solo puedes pulsar una vez. Después, ninguna pulsación tuya tendrá efecto.
• Si solo un jugador la desactiva, habrá ganado ese jugador.
• Si ambos jugadores la desactivan, ganará el jugador que más se haya arriesgado y le haya dado al botón más tarde.
• Además, para hacerlo más interesante, cuando pulsas el botón bloqueas el botón del contrario durante 1,5 segundos (haciendo sonar el zumbador para indicarlo). Hazlo en el momento preciso para ganar la partida con estilo

Manos a la obra. Lo primero que tenemos que hacer es construir el invento y luego programar el juego.

Guía de montaje

Necesitarás:

Tres cartulinas Goma eva roja Tijeras Cinta adhesiva (roja o negra queda mejor) Pegamento 2x ZumBloq LED 1x ZumBloq Pulsador 1x ZumBloq Sensor IR 1x ZumBloq Zumbador Una placa controladora ZUM BT 328 o compatible con Arduino Un portapilas Un cable USB

Paso 1: Imprimir la plantilla.

Paso 2: Recortar la plantilla.

Recorta por las líneas blancas lisas y no olvides los círculos interiores de los “Death Panel”. Ambos tienen el diseño de un pulsador por si tienes dos, pero nosotros vamos a poner en uno de ellos el IR.

Si tienes goma EVA roja, queda muy bien hacer la dinamita con ella.

Paso 3: Construir la bomba

Dobla las dinamitas hacia dentro e introduce las 4 pestañas tal y como se ve en la imagen. Dobla también la “Death Box” y pega las pestañas para que quede como la imagen de abajo a la derecha. ¡No la cierres todavía, que hay que meter los componentes electrónicos!

Ahora toca embellecerla con la cinta adhesiva roja o negra. Fíjate en la ilustración de la plantilla y haz que quede igual.

Paso 4: Colocar los componentes.

Coloca los componentes pasándolos por las aberturas de la “Death Box” como aparece en la imagen.

Paso 5: Colocar los “Death Panel” y montaje final.

Ahora queda colocar por detrás los componentes en los “Death Panel” y fijar todo con cinta adhesiva (o similares)

Ya tenemos montado nuestro juego. Ahora queda lo más interesante, la programación.

Programación

En la programación de este juego vamos a enfrentarnos a dos nuevos conceptos: Los “Flags” y el “Manejo del tiempo” en un programa

Flags: También llamadas “banderas”. Son variables binarias (es decir, solo admiten dos valores “0-1″ o “Falso-Verdadero”) que sirven para guardar estados o recordar si ha pasado algo o no. Por ejemplo, si me interesa saber si ya se ha pulsado un botón, usaré una flag que guardará falso cuando no se ha pulsado y Verdadero cuando sí. Esto me permitirá más tarde usar como condición en un bloque Si…Ejecutar la variable flag para comprobar si se pulsó el botón o no.

El programa está constituido por el bucle principal y tres funciones:

Lo primero que hacemos en el bucle principal es crear un montón de variables globales, de las cuales varias son flags. Es necesario que sean globales para que no vuelvan a su estado original en cada repetición del bucle ya que, recordamos, los bloques de las variables globales solo se inicializan una vez.

• La variable global Tiempo_bomba guarda el tiempo que debe tardar en explotar la bomba. Si cambias esta variable podrás modificar el tiempo que tarda en explotar la dinamita.
• Tiempo_actual guarda el tiempo que lleva activo el juego en cada momento.
• Jugador_ganador recordará qué jugador ha ganado.
• Boton_1_pulsado y Boton_2_pulsado son flags que recuerdan si ya se ha pulsado el botón del jugador 1 y del 2, puesto que solo pueden pulsarse una vez según las reglas del juego.
• fin_de_juego es otra flag que se activará cuando se acabe el juego.
• Boton_1 y Boton_2 sirven para almacenar el valor del botón, como ya estáis acostumbrados.

Muchas variables, ¿verdad? Pero eso no es malo. Cuanto más organizado tengamos el programa, mejor. Las variables, y en concreto las flags, son herramientas muy útiles para un programador.

Vamos ahora con la parte larga del programa, el bucle Mientras que marca el tiempo:

Lo primero que vemos es que tiene 3 condiciones. Mientras ningún jugador pulse su botón y, si el juego todavía no se ha acabado, el programa se va a quedar dentro del bucle. Es decir, casi todo el rato, ¿no? Solo saldremos del bucle cuando un jugador pulse el botón, y una vez acabado el juego, no volveremos a entrar (porque ya se ha acabado la partida).

¿Y qué es lo que hacemos dentro del bucle? Pues contar cuánto tiempo lleva la bomba encendida (¡cuidado que explota!). Mediante los dos bloques que ves abajo, llevamos la cuenta del tiempo sin bloquear el resto del programa.

Cada 100 ms que esperamos, sumamos 100 a la variable del tiempo actual y dejamos que el programa continúe. Así, el valor que esté dentro de la variable corresponderá al tiempo que hemos esperado en el programa. No hay que preocuparse de todos los demás bloques, ya que se ejecutan muy rápido.

Si por el contrario, para esperar 30 segundos, usáramos un bloque Esperar de 30000 ms estaríamos contando de forma muy precisa, pero no podríamos hacer nada más, puesto que bloquea completamente el programa mientras cuenta.

Además de contar, en este bucle Mientras estamos comprobando los botones y si se ha dado alguna de las dos condiciones de “Fin de juego” para llamar a las funciones que correspondan:

• Que la bomba explote: Si el tiempo actual es mayor que el tiempo de la bomba.
• Que los dos jugadores desactiven la bomba: Ambos jugadores han pulsado el botón.

Vamos ahora a lo que no es el bucle Mientras. Si hemos salido del bucle es porque alguien ha pulsado el botón. En ese caso, dependiendo de quién lo haya pulsado, haremos una u otra cosa mediante los bloques condicionales.

Si lo pulsa el jugador 1 y es la primera vez que lo pulsa (boton_1_pulsado = falso), cambiaremos el estado de boton_1_pulsado a verdadero y diremos (por el momento) que ha ganado el jugador 1. De esta forma, el último jugador que pulse el botón será quien gane, ya que el último que lo pulse será quien guarde en la variable su número de jugador. Además, cada vez que un jugador pulse, avisaremos con un pitido del zumbador durante 1,5 segundos (como decía en las reglas) y sumaremos este tiempo a la variable de tiempo_actual para llevar bien la cuenta del tiempo.

Solo queda ver las funciones.

Desactivar bomba y Explosión bomba son simplemente sonidos, pero Comprobar ganador comprueba quién ha ganado, enciende el LED de su “Death Panel” y cambia el flag de fin_de_juego a verdadero, indicando que el juego ha acabado.

Si lo has entendido todo… ¡es el momento de jugar! Y recuerda, para empezar una nueva partida, presiona el botón de reset de la placa.

Si no sabes cuál es, pincha aquí

En este post hemos creado juntos un invento para jugar con nuestros amigos, hemos aprendido qué son las flags y lo útiles que son para que nuestra placa recuerde cosas, y también hemos aprendido cómo contar tiempo sin detener el programa.

Si quieres mejorar tu invento a la versión “deluxe”, porque no pruebas a:

• Hacer que la manecilla del reloj se mueva de forma aleatoria con el servo de rotación continua.
• Hacer una versión para más jugadores.
• Usar el potenciómetro para elegir el tiempo de estallido.
• Añadir al juego alguna otra divertida norma.

¡Es hora de demostrar quién tiene más nervios de estaño!

Antes de empezar a programar con bitbloq 2 es importante asegurarse que tenemos todo lo necesario para que éste funcione correctamente en nuestro ordenador.

Tan solo tendrás que seguir estos pasos:

1. Conecta tu placa al ordenador con el cable USB.
2. Abre bitbloq 2 en tu navegador Google Chrome.
3. Pulsa sobre la pestaña Placas y arrastra tu placa al recuadro blanco. Si tienes una placa distinta a la que aparece en el listado compatible con la familia UNO, utiliza la placa Arduino UNO.
4. Pulsa en Verificar y verás cómo compila correctamente el programa.
5. Pulsa sobre el botón Cargar, aparecerá un cuadro de dialogo pidiéndote descargar la aplicación Web2board. Selecciona tu sistema operativo, se bajará un archivo a tu ordenador.
6. Si estas utilizando Windows, descomprime el archivo descargado y ejecuta el archivo web2board.exe. En el caso de que estés utilizando Linux descomprime el archivo y ejecuta el archivo Web2Board, se abrirá una aplicación que solicitará que introduzcas tu contraseña de usuario, introdúcela y pulsa intro.
7. Una vez que hayas instalado el programa Web2board es recomendable que reinicies el ordenador.
8. Tras reiniciar el ordenador abre bitbloq 2 selecciona tu placa y pulsa sobre el botón Cargar. se empezará a cargar el programa a tu placa. Tras un momento aparecerá en pantalla el mensaje que te indicará que todo ha funcionado correctamente: Programa subido con éxito.

¿Tienes algún problema?

No tienes instalado el programa Web2board

Si es la primera vez que utilizas bitbloq 2, es posible que tengas que instalar el programa Web2board para que tu ordenador reconozca tu placa controladora. Sigue los primeros pasos de este post para instalarla.

Descarga e instala el programa según el sistema operativo que uses y tras reiniciar el ordenador prueba de nuevo a cargar el programa en tu placa.

Estás utilizando un navegador web no compatible

Bitbloq 2 actualmente solo funciona con el navegador Google Chrome. Si estás utilizando un navegador distinto, por favor utiliza este navegador. Asegúrate de que tu navegador está actualizado a su última versión.

El botón de encendido de tu placa ZUM está en la posición de apagado

Le pasa a los mejores profesionales, si tu robot o proyecto no funciona como esperabas revisa que el botón de tu placa ZUM esté en la posición ON.

Hay un error de compilación

En este caso el error se da porque el programa que has hecho contiene algún error y no está correctamente programado. ¿Por qué no pruebas a revisar los bloques de tu programa? Puede que se te haya pasado algo por alto.

¿Aún tienes problemas?

Si después de seguir estos pasos aún no consigues programar tu placa escribe por favor a support-bitbloq@bq.com indicando:

• Sistema Operativo y versión: por ejemplo Windows 7 64 bits, o Ubuntu 14.10 32 bits, etc.
• Navegador y versión: por ejemplo Chrome 43.0.2357.130 (64-bit).
• Programa que estás intentando cargar en formato .json. Puedes descargarlo desde bitbloq 2 en: Archivo->Descargar proyecto.
• Una captura de pantalla con el error que obtienes En el caso de que no tengas ningún error, dínoslo también.

Nuestro equipo intentará resolver lo antes posible cualquier problema que te pueda surgir.

En este post vamos a conocer qué es y cómo funciona bitbloq 2. Si ya has utilizado la primera versión de bitbloq esta entrada te ayudará a conocer sus novedades, ventajas y diferencias.

Si aún no has instalado la aplicación Web2board necesaria para que tu placa y bitbloq 2 funcionen correctamente, éste es un buen momento. En Antes de empezar con bitbloq 2 encontrarás una explicación paso a paso del proceso.

Conociendo bitbloq 2

Vamos a echarle un vistazo a las opciones de bitbloq 2, para ello dirígete a la página http://beta-bitbloq.bq.com/

Pulsa sobre Empezar a jugar. Si deseas registrarte o ya tienes una cuenta, haz click en Entrar o registrarte y sigue los pasos que te indiquen. La primera vez que entres a bitbloq 2 te ofrecerá la opción de una visita guiada. Realízala para tener una idea clara y rápida del funcionamiento del programa. El programa se divide en tres pestañas principales situadas a tu izquierda: Hardware, donde diremos qué placa, sensores y actuadores utilizamos; Software, donde programaremos nuestro proyecto; e Información del proyecto, donde añadiremos información a éste. Para descubrir su funcionamiento vamos a realizar nuestro primer programa: encender un LED.

IMPORTANTE: bitbloq 2 es un nuevo programa creado desde cero, por lo que si ya posees una cuenta en la primera versión de bitbloq, ésta no será compatible con bitbloq 2.

La pestaña de Hardware: conectando la electrónica

En esta pestaña le diremos a bitbloq 2 qué hardware estamos utilizando. Primero seleccionaremos la placa controladora y, a continuación, le diremos qué componentes usamos y donde los hemos conectado. Clica sobre Componentes y arrastra el LED al recuadro amarillo. Si clicas y arrastras sobre el círculo del componente podrás conectar su cable al Pin digital 13. Por último, y si no lo has hecho aún, conecta tu LED a tu placa controladora, ¡recuerda conectar cada pin en su color!

RECUERDA:Con bitbloq 2 puedes utilizar una placa ZUM, FreeDuino, Arduino UNO y cualquiera de la gran mayoría de sensores, actuadores y placas que hay en el mercado.

La pestaña de Software: programando nuestro proyecto

Ahora que hemos conectado nuestro hardware, es el momento de realizar nuestro programa: encender un LED.

Observa la zona de programación. Está dividida en tres partes:

• Variables globales y funciones: Te permite declarar variables accesibles desde cualquier parte del programa así como crear nuevas funciones. Veremos su utilidad más adelante.
• Instrucciones inciales (Setup): Se ejecuta al inicio del programa, se utiliza para configurar el comportamiento de los pines y otras acciones que queremos que se ejecuten al principio y sólo una vez. En próximas entradas aprenderemos a utilizarlo.
• Bucle principal (Loop): Es el bucle principal del programa y el que usarás más a menudo. Todo lo que se encuentre dentro de él se ejecutará de forma indefinida. Por lo que un programa en bitbloq y Arduino nunca termina.

Abre la pestaña Componentes y arrastra el bloque Encender el LED (…) a la sección Loop. Para que no pierdas tiempo buscando entre componentes y bloques que no vas a utilizar bitbloq 2 solo te mostrará los bloques de los componentes que hayas conectado en la pestaña Hardware. Si necesitas bloques más genéricos clica sobre la opción de Avanzados.

Nuestro programa está listo para funcionar. Pulsa sobre el botón Verificar para que bitbloq 2 compruebe que el programa funciona correctamente. Si el programa es correcto, pulsa sobre Cargar. El programa se instalará en la placa y, tras el mensaje Programa subido con éxito, verás al LED encenderse. ¡Enhorabuena, acabas de crear tu primer programa! Ahora, como buenos programadores solo falta una cosa: documentarlo.

La pestaña de Información del proyecto: documentando nuestro programa

Si deseas compartir tu creación con los demás, así como poder volver a utilizar tu proyecto en el futuro, es tan importante que el programa esté bien hecho como que esté bien documentado.

El primer paso será ponerle un nombre al proyecto y una descripción donde deberás explicar de la forma más clara posible sobre qué trata. Si te gusta mucho tu proyecto y has creado una máquina o robot geniales, puedes añadir un vídeo de youtube en el que muestres cómo funciona. No te olvides tampoco de añadir la imagen principal que acompañará a tu proyecto cuando lo publiques. Por último puedes añadir las etiquetas. Una etiqueta o hashtag no es más que una palabra clave que define tu proyecto. bitbloq 2 añade algunas etiquetas automáticamente para que puedas encontrar, por ejemplo, todos los proyectos publicados que utilicen una placa ZUM y un LED. Además, puedes cambiar el tema de los bloques a color, gris, etc. Poco a poco iran apareciendo nuevos temas asi que selecciona el que mejor se adapte a tí.

¡Ya tenemos todo preparado! Si quieres publicar tu proyecto pulsa sobre la nube: Publicar en Explora. Ahora cualquiera podrá ver, utilizar e incluso crear su propia versión mejorada de tu proyecto. Para acceder a todos los proyectos publicados pulsa sobre el icono verde de bitbloq y a continuación en Explora. ¡Crea y comparte tus ideas con la comunidad!

Felicidades, ya sabes cómo utilizar bitbloq 2. A lo largo de este curso aprenderás a programar tu placa controladora para crear inventos y robots alucinantes. Recuerda que si tienes cualquier duda o sugerencia puedes dejarnos un mensaje en los comentarios.

¿Te animas a continuar con la aventura? ¡Empezamos!

Seguro que estás deseando conectar todo y ponerte a programar pero, antes de empezar a practicar, vamos a conocer algunos conceptos básicos que nos ayudarán más adelante.

¿Qué es un robot?

La palabra robot proviene del checo: robota, que significa trabajo duro o forzado. Se usó por primera vez durante la obra de teatro Rossum Universal Robots de Karel Čapek y su uso se extendió gracias a las obras de ciencia ficción creadas por el escritor Isaac Asimov.

A menudo nos imaginamos a un robot como una máquina con forma humana que camina, habla, gesticula… pero en realidad es algo mucho más sencillo:

“Un robot es una máquina automática programable que es capaz de interpretar información del medio físico para modificar su conducta. Tiene la capacidad de interactuar con el entorno y, en función de ello, realizar unas funciones u otras.”

Todo robot tiene tres tipos de componentes: Sistema de control: como una placa controladora. Sensores: capaces de interpretar información del mundo o del propio robot. Actuadores: producen un efecto sobre el mundo o sobre el propio robot.

Si comparamos un robot con una persona, los sensores serían sus sentidos. Éstos transmiten información a su sistema de control o cerebro, modificando su comportamiento e influyendo sobre el mundo mediante sus actuadores. Además, un robot necesitará una fuente de energía para funcionar y una estructura física para sostener los elementos que lo componen.

El sistema de control: la placa controladora

El cerebro o la placa controladora es como un pequeño ordenador. Básicamente es un microcontrolador al que se le pueden conectar sensores (sentidos), y actuadores (músculos, voz, etc).

La placa ZUM está formada por los siguientes componentes:
• Microprocesador: es el microchip que realiza todas las operaciones necesarias para que tu placa ejecute tu programa.
• Pines digitales: solo pueden tener dos valores: 1 o 0, todo o nada, encendido o apagado.
• Pines analógicos: pueden tener múltiples valores: 0, 1, 34, 255, etc.
• Entrada micro-USB: a través de esta entrada la placa se comunica con el ordenador.
• Entrada de baterías: la placa recibe energía de las baterías o la fuente de alimentación para poder funcionar.
• Bluetooth: permite a la placa comunicarse sin cables con un ordenador, smartphone u otros.
• Botón ON/OFF: quita la energía a los pines de tu placa de forma que puedas programar sin que el robot esté continuamente moviéndose.
• Reguladores de tensión: adaptan la tensión de alimentación al voltaje en que trabaja la placa: 5V.

Los sensores

Un sensor no es más que un componente electrónico que transmite más o menos electricidad en función de un elemento físico, como la luz, el sonido, la distancia, etc. Si queremos conectar un sensor a nuestra placa, tendremos que averiguar primero si el sensor es digital o analógico.

El sensor digital

Un sensor digital solo puede tener dos valores: 1 o 0, todo o nada. Un ejemplo de sensor digital es un pulsador, en el que cuando pulsamos el botón éste vale 1, y cuando no lo pulsamos 0. En una placa ZUM o similar, los sensores digitales irán conectados en los pines digitales D0-D13.

IMPORTANTE: Los pines digitales 0->RX y 1->TX se usan para recibir y enviar información, por lo que si les conectas un sensor o actuador y programas la placa, puede que el programa no se cargue o no funcione correctamente. Además, el pin D13, debido a la existencia del LED D13, no recibe la misma tensión, por lo que puede darte problemas en el uso de algunos elementos. Usa con precaución dichos pines.

El sensor analógico

Un sensor analógico puede tener múltiples estados siendo capaz de transformar la cantidad de luz, temperatura u otros elementos físicos en un valor comprendido entre 0 y 1023. Un ejemplo de sensor analógico es un sensor de luz, donde dependiendo de la cantidad de luz que el sensor recibe dará un valor mayor o menor. En una placa ZUM o similar los sensores analógicos irán conectados en los pines A0-A5.

Los actuadores

Un actuador es un componente electrónico capaz de realizar una acción sobre el entorno. Por ejemplo, un motor que mueve una rueda, un LED que indica que un aparato está encendido, un altavoz que emite un sonido de alerta, etc.

Utilizando una placa ZUM o similares, todos los actuadores que utilicemos irán conectados a un pin digital. Hay actuadores, como un LED, que solo tienen dos estados, mientras otros como un servomotor, pueden tener múltiples posiciones y por tanto ser analógicos. Para este tipo de actuadores nuestra placa, que es digital, se servirá de un truco o método conocido como señal PWM. De momento no te preocupes por ella, veremos su utilidad más adelante.

¿Cómo piensa una placa controladora?

A veces crearás un proyecto o un robot que no se comportará como habías pensado. Recuerda que tu placa controladora es el cerebro de tu máquina, pero es mucho más limitado que un cerebro humano.

La placa controladora… Piensa (procesa) las cosas de una en una, no puede hacer dos cosas a la vez. Piensa y repite acciones muy rápido, tanto que a veces no podemos ni ver lo que está haciendo y hay que decirle que espere un poco. Nunca hace nada que no le hayas dicho. Hay que programar todo lo que quieras que haga y darle las órdenes de una en una. Normalmente, cuando la placa acaba su lista de órdenes, vuelve a empezar de nuevo, repitiendo su programación una y otra vez.

A lo largo de este curso conoceremos y aprenderemos a utilizar un montón de sensores y actuadores que te serán de gran utilidad. Recuerda que el secreto no es la cantidad, sino conocer bien lo que tienes para darle usos increíbles. Vuelve a esta página siempre que tengas una duda o déjanos un comentario si te cuesta comprender algún concepto.

¿Empezamos a programar cosas? ¡Vamos allá!

¿Qué es un LED?

Un LED (light-emitting diode) es un diodo, un componente que solo deja pasar la electricidad en un sentido y la bloquea en el otro. En el caso de los LED, cuando circula electricidad emiten luz. Los LED son baratos, gastan muy poca energía y pueden llegar a ser muy luminosos. Se utilizan mucho en sistemas electrónicos y están sustituyendo a la iluminación tradicional.

Encendiendo y apagando un LED

En el post anterior, aprendimos que nuestros componentes podían ser actuadores o sensores, así como analógicos o digitales. El LED es un componente que emite una luz para actuar sobre el mundo, por lo que es un actuador. Además, solo tiene dos estados: encendido u apagado, por lo que es digital.

Al ser un actuador digital, deberemos conectarlo a uno de los pines digitales de nuestra placa. En nuestro caso vamos a conectarlo al pin digital 13.

Vamos a realizar la programación. Ve a la pestaña Software y pincha sobre Componentes. Allí encontrarás el bloque Encender/Apagar el LED nombre_led. Arrástralo dentro del bloque loop.

Ahora solo queda Compilar el programa. Una vez compilado y, por tanto, comprobado que el programa no tiene problemas, pulsa sobre Cargar. El programa se cargará a la placa y, gracias a la magia de la programación, tu LED se encenderá. ¡Prueba ahora a apagarlo!

RECUERDA: La placa, y no el ordenador, es la que almacena y ejecuta cada programa que realizamos. Cada vez que realices una modificación en tu programa, deberás subirlo de nuevo a tu placa para ver su efecto. Para ello pulsa sobre el botón Cargar.

¡Hola mundo! Haciendo parpadear un LED

En programación se llama “Hola mundo” al primer programa que se realiza cuando se está aprendiendo un lenguaje de programación. Cuando se programa una placa controladora, el “Hola mundo” consiste en hacer parpadear un LED para comprobar que todo funciona correctamente.

Lo primero es encender el LED, como nuestra placa controladora piensa muy rápido, si le decimos que apague el LED tras darle la orden de encendido pasará de una orden a otra demasiado rápido y te dará la sensación de que el LED está encendido siempre (pruébalo). Para solucionarlo hay que esperar un tiempo mediante el bloque “Esperar” que encontrarás en la pestaña de Control. El bloque hace esperar al programa el número de milisegundos que decidas, como queremos que el LED parpadee con una cadencia de un segundo hemos puesto 1000 milisegundos. Tras la espera podemos apagar el LED y, como el programa se repite indefinidamente, deberemos esperar otro segundo antes de volver a empezar.

El resultado es el siguiente:

Aún hay más

A continuación te proponemos un par de ideas para seguir practicando:
• Usa dos o más LED para que parpadeen a la vez.
• Haz que dos o más LED parpadeen de forma alterna.
• Crea tus propias luces navideñas programando una secuencia de luces utilizando varios LED y los bloques de esperar.

Ahora que sabes cómo encender un LED seguro que tienes cientos de ideas para utilizarlos. Puedes utilizar tantos LED como pines digitales tengas. Recuerda que puedes usar tanto los componentes del kit ZUM como cualquier otro. ¡No te cortes y conecta todos los que tengas!

En este post aprenderemos la base de la programación: las sentencias condicionales. Para ello utilizaremos un pulsador.

¿Qué es una sentencia condicional? El bloque Si…ejecutar

Una sentencia condicional es plantearse una pregunta para actuar de una forma u otra según la respuesta. Por ejemplo, si llueve, abriré el paraguas. Si por el contrario no llueve, lo cerraré. Si hace frío, me pondré el abrigo. Si hace calor, me lo quitaré. Si es de noche, encenderé una luz. Si por el contrario es de día, la apagaré.

¿Qué es un pulsador?

Un pulsador es un sensor digital que al presionarlo se activa (1 o verdadero) y al dejar de pulsarlo se desactiva (0 o falso). En nuestra vida diaria estamos rodeados de pulsadores, desde los botones del ascensor a los botones de stop de los autobuses o las teclas del ordenador. Junto con las sentencias condicionales serán de gran utilidad para controlar nuestras máquinas y robots.

IMPORTANTE: Existen dos tipos de pulsadores en el mercado, los normalmente abiertos (Pulsado->1, No pulsado->0) y los normalmente cerrados (Pulsado->0, No pulsado->1). Si tienes un pulsador de Mi primer kit de Robótica o cualquier otro del mercado probablemente sea normalmente cerrado y los programas aquí descritos funcionen justo a la inversa, cambia el 1 por el 0 y viceversa a la hora de realizar tus programas.

Si se hace de noche… enciende la luz. Controlando un LED con el pulsador

Vamos a aprender a controlar un LED utilizando el pulsador. Conecta el LED al pin digital 13 y el pulsador al pin digital 7.

Queremos que el LED se encienda cuando presionemos el pulsador, y se apague cuando dejemos de pulsarlo:

En la pestaña Control encontrarás el bloque Si…ejecutar. Si presionamos nuestro pulsador, es decir, si el valor que devuelve el bloque Leer Boton_1 es igual a 1, encenderemos el LED. Recuerda que tu placa controladora nunca hace nada que no le hayas dicho. Hay que programar todo lo que quieras que haga. Si solo programas que cuando el botón valga 1, el LED se encienda, y no le dices cuando debe apagarse, el LED nunca se apagará. Por ello el bloque Si…ejecutar dispone de dos opciones más: en cambio, si y de lo contrario, ejecutar

En cambio, si…

En cambio, si permite añadir más condiciones después 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. En el caso de nuestro LED, queremos comprobar si el pulsador está pulsado y vale 1. Si no vale 1 pero en cambio sí vale 0, apagaremos el LED.

De lo contrario, ejecutar

El bloque de lo contrario, ejecutar se ejecutará cuando no se cumpla ninguna de las condiciones anteriores, es decir, cuando nuestro pulsador no esté presionado.

Aún hay más

A continuación te proponemos un par de ideas para seguir practicando:
• Conecta dos LED y haz que uno se encienda y el otro se apague y viceversa, según el estado del pulsador.
• Crea un semáforo que esté en color rojo. Puedes usar un LED de otro color si no tienes uno rojo. Cuando pulses el botón, espera cinco segundos, apaga el rojo y enciende el verde. A los veinte segundos apaga el verde y vuelve a encender el rojo.

Ahora que sabes cómo funcionan las sentencias condicionales y el pulsador ¡puedes empezar a hacer un montón de proyectos! En las siguientes entradas descubriremos poco a poco más sensores y actuadores. ¡Permanece atento!

¿Qué es el puerto serie?

El puerto serie es el medio que tiene tu placa controladora para comunicarse con otro aparato como el ordenador o tu móvil. Es muy útil para comprobar de un vistazo el valor de un sensor o una variable, ver el estado de tu programa y, en definitiva, corregir y entender mejor los posibles errores que éste tenga.

Para usar el puerto serie con el ordenador deberás conectar tu placa mediante un cable USB. En la pestaña Hardware selecciona el icono del puerto serie y arrástralo, se conectará automáticamente al puerto USB de tu placa. El baudrate es la cantidad de información que se transmite en un segundo y se mide en baudios (bits/segundo). Durante el curso utilizaremos el baudrate por defecto: 9600 baudios.

¡Hola otra vez! Enviando mensajes

Normalmente, cuando programamos, lo primero que hacemos es mostrar un mensaje por pantalla. Vamos a saludar a nuestro ordenador utilizando el puerto serie.

Dentro de la pestaña Comunicaciones encontrarás el bloque enviar. Este bloque te permitirá enviar información mediante el puerto serie a tu ordenador. Clica sobre la pestaña Texto y selecciona el bloque texto. Escribe el mensaje ¡Hola mundo!, añade una espera de un segundo y carga el programa en tu placa.

Utilizando el monitor del puerto serie

Para poder visualizar que los mensajes llegan correctamente necesitas utilizar el Monitor serie. Clica sobre Ver->Mostrar serial monitor, verás como aparece el mensaje que estamos enviando de forma muy rápida. Cambia la opción Con salto de línea a Sin salto de línea y observa como cada mensaje se escribe uno seguido de otro. Puedes pausar el serial monitor, borrar todo lo escrito e, incluso, enviar información desde el ordenador a la placa.

Recibiendo mensajes en la placa mediante el puerto serie

Vamos a hacer un pequeño ejemplo de cómo enviar un mensaje a la placa, que ésta lo reciba, y repetirlo como si fuera un eco escribiéndolo mediante el puerto serie.

Utilizamos el bloque Serial_Port Recibir para almacenar la información que recibamos por puerto serie en la variable mensaje. Una variable es un contenedor, un sitio donde podemos almacenar la información que necesitemos más adelante. Si el mensaje es distinto que una palabra vacía, es decir, si hemos enviado algo, devolveremos la información almacenada en la variable mensaje para verla por el monitor serie.

Este ejemplo te será útil en muchas ocasiones. Si deseas que el programa solo reaccione ante una palabra, modifica el programa anterior introduciendo la palabra clave dentro del bloque de texto.

Aún hay más

A continuación te proponemos un par de ideas para seguir practicando:
• Imita a un reloj de pared de forma que por el puerto serie haga tic y luego tac con una frecuencia de un segundo.
• Envía a la placa el mensaje ON para encender un LED. Envía OFF para apagarlo.
• Crea un reloj que cuente los minutos que pasan y los muestre por el puerto serie.
• Crea una casa domótica que controle las luces y otros elementos mediante puerto serie.

El puerto serie es muy importante para realizar un buen programa y entender el funcionamiento de tus sensores y actuadores. Lo utilizaremos muy a menudo por lo que pronto descubrirás todas sus posibilidades.

¿Qué es una variable?

Una variable es un valor que guardamos y que podremos recuperar cuando lo necesitemos. Digamos que es como una caja donde guardamos un dato, como por ejemplo… un espárrago. Este valor que guardamos en nuestra caja, lo podremos ver y reutilizar más adelante. Si no guardamos ese dato en una variable no podremos reutilizarlo, ya que el programa no lo recordará. Además, como veremos más adelante, en cualquier momento podremos cambiar el valor guardado en la variable.

Declarar una variable Al declarar una variable en nuestro programa lo que hacemos es crear esa caja y guardar por primera vez un dato en ella. Para identificar en todo momento nuestra variable (o nuestra caja) debemos ponerle un nombre.

En el momento en que declaras una variable defines de qué tipo es. Por ejemplo: si lo primero que guardaste es un número, esa variable siempre va a guardar números, pero si lo primero que guardaste es una palabra o texto, solo podrá guardar texto.

Otro dato interesante a tener en cuenta, es que también podemos guardar como variable el valor que nos devuelve un sensor.

Diferencia entre variable global y variable local

En bitbloq 2 se pueden programar variables locales y globales, pero de forma diferente a como se hace en bitbloq 1.

Variables globales: se crean al inicio del programa y son universales. Lo que significa que pueden utilizarse en cualquier momento que se requiera en nuestra programación. Variables locales: se pueden crear en las Instrucciones iniciales (Setup) o bien en el Bucle principal (Loop), dependiendo de si queremos que se ejecute una sola vez al inicio del programa (Setup) o si por el contrario, queremos que se ejecute continuamente (Loop). A diferencia de las variables globales, solo se pueden utilizar dentro de la función donde han sido declaradas (Loop o Setup). Esto es una ventaja, puesto que así, cuando dejan de hacer falta, son borradas dejando espacio en la memoria del robot.

Programando un contador

Si quisiéramos programar un contador para, por ejemplo, controlar el aforo de un estadio de fútbol:

• Declaramos la variable global numero igual a 0. De esta forma, cada vez que iniciemos el programa, comenzaremos a contar desde 0.
• Por otro lado, declaramos la variable local boton igual a 1 o pulsado, y utilizando un condicional, programamos que cada pulsación sume una persona más. Como queremos que se ejecute continuamente, esta variable es local y se ubica en el Bucle principal.

Para visualizar nuestro contador podemos incluir el bloque de Comunicación del puerto serie.

Aún hay más

A continuación te proponemos un par de ideas para seguir practicando:
• Crea una variable que permita visualizar en el puerto serie si el botón está o no pulsado.
• Crea un programa similar al anterior, pero añadiendo que se encienda un LED si el botón está pulsado.
• Crea un cronómetro que inicie la cuenta atrás desde 10, de manera que transcurridos 10 segundos se encienda el LED.

Ahora que sabes cómo crear una variable y para qué sirven, te habrás dado cuenta de lo enormemente útiles que son. No dudes en seguir practicando. Poco a poco irás aprendiendo otras formas de utilizar las variables y descubriendo todas las posibilidades que te ofrecen. ¡Vamos allá!

¿Qué es un algoritmo?

Un algoritmo es un conjunto de instrucciones muy concretas y ordenadas que hay que seguir para realizar una tarea. Algunos ejemplos de algoritmos muy sencillos son: seguir una receta del médico, lavarse los dientes, poner una lavadora, etc.

Otro algoritmo podría ser una receta de cocina, donde te pone paso por paso cómo cocinar el plato que quieras. Volviendo con el espárrago. Para cocinarlo debemos seguir unas instrucciones: Poner aceite en la sartén. Poner la sartén al fuego. Esperar a que el aceite esté caliente. Echar el espárrago a la sartén. Cocinar hasta que esté listo. Apagar el fuego y retirar la sartén. Echar el espárrago en un plato.

Una forma sencilla de representar un algoritmo es mediante diagramas de flujo.

¿Qué es un diagrama de flujo?

Los diagramas de flujo son una forma sencilla para representar de forma gráfica un proceso, como el de un algoritmo. Los elementos básicos que podemos encontrar en ellos son:

	Representa el inicio y el final del proceso.
	Representa el proceso o acción que se ejecuta a partir de unos datos, que pueden ser de entrada, salida o resultado de algún proceso anterior.
	Representa los datos de entrada y los datos de salida.
	Representa una condición o pregunta que puede tener varios caminos: si/no, verdadero/falso, mayor que/menor que, igual a/diferente a, etc.
	Indican el sentido de los procesos.

Programando un contador

En un concurso de televisión necesitan crear un pulsador para cada concursante. De este modo, una vez que el presentador hace una pregunta, los concursantes que sepan la respuesta deberán presionar el pulsador y una luz nos ayudará a identificar quién fue más rápido. Una vez soltado el pulsador, la luz deberá apagarse.

Primero, deberemos pensar en nuestro algoritmo, para posteriormente crear nuestro diagrama de flujo: Comenzar el concurso. Comprobar el estado del pulsador. Si está pulsado, encender LED. Si no está pulsado, apagar LED. Volver a comprobar el estado del pulsador.

CONSEJO: Desarrolla el diagrama de flujo de los ejercicios propuestos antes de programar. Comprobarás cómo te resulta mucho más sencillo resolverlos.

Aún hay más

A continuación te proponemos algunas ideas para seguir practicando:
• Escribe en un papel un algoritmo sencillo de alguna acción cotidiana (enviar una carta, llamar a alguien por teléfono, prepararte para ir al trabajo, etc.)
• A continuación, reescribe el mismo algoritmo, pero con las instrucciones al máximo detalle, de manera que lo pueda realizar otra persona.

Cada vez que te enfrentes a un problema, plantéate estas dos preguntas: ¿qué tengo que hacer? y ¿cómo puedo hacerlo? Los algoritmos y diagramas pueden ser de mucha ayuda para esquematizar la solución a un problema. Así que ya sabes, ¡ten siempre a mano lápiz y papel!