En este kit se incluye el material necesario para construir 7 modelos de coche diferentes:
- Coche programado
- Coche seguidor de línea
- Coche bluetooth
- Coche bluetooth con dirección
- Coche sumo
- Coche explorador
- Coche seguidor de luz
- Coche control remoto
En este kit se incluye el material necesario para construir 7 modelos de coche diferentes:
Un TSOP es un módulo receptor de señal infrarroja capaz de realizar la lectura de señales emitidas por emisores como los que se encuentran en mandos a distancia.
Conectado a Arduino, podemos realizar la lectura de estas señales e interpretarlas, dando lugar a una acción determinada.
Existen kits que incluyen el módulo TSOP y un mando a distancia que podemos conectar y programar con Arduino.
Cada botón del mando envía una señal diferente al receptor, quedando cada botón identificado inequívocamente.
Para realizar esta práctica necesitaremos el siguiente material
El módulo TSOP tiene 3 pines que conectaremos del siguiente modo
¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
Este ejercicio cuenta con 2 fases. En la primera, tenemos que leer e identificar el código que envían los botones que vamos a utilizar. En la segunda, conocidos estos códigos, crearemos los condicionales necesarios para apagar y encender el led.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Para poder programar el mando a distancia, necesitamos instalar una extensión en Mblock. Descarga la extensión desde el siguiente enlace: Extensión IR Remote
A continuación arrastra el archivo de la extensión dentro del programa Mblock. Una vez instalada aparecerá una nueva sección de bloques llamada «Control IR». Cada vez que cierres el software la extensión desaparecerá y tendrás que volver a instalarla.
Para identificar los códigos de los botones que vamos a utilizar, hacemos un primer programa donde realizamos la lectura de un datos y lo enviamos al puerto serie para identificarlo.
Cuando trabajamos con esta extensión, no podemos utilizar el evento «Al hacer clic en la bandera». Debemos trabajar de forma autónoma.
En lugar de activar el botón «en vivo», debes pulsar el botón «cargar».
Una vez hecho esto, cuando accedas a los eventos verás un nuevo bloque disponible «Cuando Arduino Uno se inicia». Ese es el evento que utilizaremos cuando queramos trabajar con la placa en modo autónomo, como es en este caso.
Arrastra el bloque «Cuando Arduino Uno se inicia» al área de programación. Después, configura el receptor IR en el pin 11 e inicia la comunicación del puerto serie a 9600 baudios. Estos bloques los encontrarás en la nueva sección «Control IR».
Una vez configurado el receptor, introducimos un bucle infinito donde realizaremos la lectura de los códigos del mando. Si se ha recibido un dato, lo enviamos por el puerto serie para poder ver de qué código se trata.
Cargamos el programa en la placa pulsando el botón «conectar» y luego «subir».
Mblock, actualmente, no dispone de un monitor serie para ver los datos que se envían y se reciben, asique utilizaremos Arduino IDE para esta acción. Pulsa en el botón «desconectar» de Mblock y abre el software Arduino IDE. En el menú herramientas, selecciona la placa Arduino Uno y el puerto COM donde esté conectada.
Con la placa conectada al pc, pulsa de nuevo en el menú herramientas y selecciona «Monitor serie». Recuerda que es importante haber pulsado «desconectar» en mblock. Si no lo has hecho, Arduino IDE te indicará que el puerto COM esta ocupado y no podrá activar el monitor serie. Una vez abierto el monitor serie, aparecerá una pantalla como esta:
Fíjate bien que al pie de esta ventana a la izquierda tengas configurado el puerto a 9600 baudios.
Con la placa Arduino conectada al PC, coge el mando a distancia y, orientado al receptor, pulsa el botón 1. Verás que en la ventana del puerto serie aparece un código. Pulsa el botón 2, y verás que aparece un código diferente. Estos códigos identifican a cada uno de los botones.
Ahora que conocemos el código que representa a cada botón, vamos a programar su comportamiento. Cierra el monitor serie y vuelve al programa Mblock.
Modificamos el código incluyendo dos condicionales que analicen el código recibido. Si el código se corresponde con el botón 1, encendemos el led 13, si se corresponde con el botón 2 apagamos el led.
Pulsa en el botón «subir» y el programa se cargará en la placa Arduino. Para comprobar su funcionamiento, coge el mando a distancia y orientado al TSOP, pulsa los botones 1 y 2. Verás como el led amarillo de la placa Arduino se enciende y apaga según el botón pulsado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«. Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Utilizaremos la instrucción analogWrite para enviar la señal a los motores.
void setup(){
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
}
void loop(){
analogWrite(5, 255); // avanza
analogWrite(9, 255);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 0); // retrocede
analogWrite(9, 0);
analogWrite(6, 255);
analogWrite(10, 255);
delay(1000);
analogWrite(5, 255); // gira
analogWrite(9, 100);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 100); // gira
analogWrite(9, 255);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 0); // para
analogWrite(9, 0);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
}
Pulsa en el icono subir, y comprueba el resultado.
Un puente en H es un circuito integrado que permite cambiar la polaridad de la corriente que pasa por un motor, modificando así su sentido de giro. En su interior contiene 4 interruptores para conectar 2 motores.
Para realizar esta práctica necesitaremos el siguiente material
Hemos realizado las siguientes conexiones:
Motor 1:
Motor 2:
¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
Para resolver esta práctica, activaremos los pines PWM en diferentes sentidos para generar el movimiento de un coche.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Para que el coche avance, enviamos la señal 255 a los pines 5 y 9 y 0 a los pines 6 y 10. De esta forma ambos motores girarán en el mismo sentido.
Para que el coche retroceda, enviamos la señal 255 a los pines 6 y 10, y 0 a los pines 5 y 9, cambiando el sentido de giro de ambos motores.
Para que el coche gire a la derecha o a la izquierda, basta con que las ruedas giren a distinta velocidad:
Por último, si queremos parar el coche, los 4 pines deben recibir una señal baja (0).
Pulsa en la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«. Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Utilizaremos la instrucción analogWrite para enviar la señal a los motores.
void setup(){
pinMode(5, OUTPUT);
pinMode(6, OUTPUT);
pinMode(9, OUTPUT);
pinMode(10, OUTPUT);
}
void loop(){
analogWrite(5, 255); // avanza
analogWrite(9, 255);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 0); // retrocede
analogWrite(9, 0);
analogWrite(6, 255);
analogWrite(10, 255);
delay(1000);
analogWrite(5, 255); // gira
analogWrite(9, 100);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 100); // gira
analogWrite(9, 255);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
analogWrite(5, 0); // para
analogWrite(9, 0);
analogWrite(6, 0);
analogWrite(10, 0);
delay(1000);
}
Pulsa en el icono subir, y comprueba el resultado.
Un potenciómetro es una resistencia variable cuyo valor podemos cambiar de forma mecánica.
Si conectamos el potenciómetro a la placa Arduino, éste recibe una corriente de 5V. Conectando la patilla central a una entrada analógica, al realizar la lectura obtendremos la señal que resulta tras aplicar la resistencia a la corriente inicial. Podemos variar esta resistencia moviendo mango del potenciómetro.
Para realizar esta práctica necesitaremos el siguiente material
Conectamos el servomotor a un pin digital 8 de la placa Arduino y el potenciómetro a la entrada analógica A0.
¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
Para resolver esta práctica, debemos realizar la lectura de la entrada analógica A0,k donde está conectado el potenciómetro, y posicionar el motor en el ángulo correspondiente.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
El potenciómetro nos enviará una señal entre 0 y 1023, pero el motor sólo se puede mover entre los ángulo 0 y 180º. Es preciso realizar un cálculo proporcional para obtener el ángulo que podemos enviar al servomotor. Recuerda que para mover el motor tienes un bloque específico dentro de la sección pines.
Para comprobar el resultado, pulsa la bandera verde y mueve el potenciómetro por el mango o con ayuda de un destornillador.
Pulsa en la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«. Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
En este caso, para calcular la proporción entre la señal aportada por el potenciómetro, y el ángulo del servomotor, utilizaremos la instrucción «map».
#include <Servo.h>
int angulo;
int potenciometro;
Servo myServo; // crea el objeto servomotor
void setup(){
myServo.attach(8); // asigna el pin 8 al servo
}
void loop(){
potenciometro=analogRead(A0); // lee la señal del potenciómetro
angulo=map(potenciometro, 0, 1023, 0, 179); // mapea la señal de 0 a 179
myServo.write(angulo); // mueve el servomotor
delay(15);
}
Pulsa en el icono subir, y comprueba el resultado moviendo el potenciómetro por el mango o con ayuda de un destornillador
En esta ocasión vamos a programar un servomotor que se posicione en el ángulo que le indiquemos introduciéndolo por teclado.
Un servomotor es un motor cuya posición podemos controlar y mantener en un punto constante en función de un ángulo de posicionamiento.
El servomotor de 180º que vamos a emplear en esta práctica solo puede girar su eje realizando media vuelta, de 0 a 180º.
Para realizar esta práctica necesitaremos el siguiente material
Conectamos el servomotor a un pin digital de la placa Arduino (no es preciso que sea un pin PWM), por ejemplo el pin 7.
¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: el personaje panda pregunta al usuario en qué posición debe colocar el servomotor. Cuando se recibe el ángulo, la placa posiciona el motor en ese ángulo.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Empezamos programando el objeto panda. Pulsa sobre la pestaña objetos y luego sobre el dibujo del panda. El hacer clic en la bandera, el panda realiza una pregunta (en la sección sensores encontrarás el bloque) incitando al usuario a introducir un ángulo por teclado
A continuación guardamos la respuesta introducida por teclado en una variable que hemos creado para almacenar el ángulo. Redondeamos el ángulo para evitar ángulos con decimales.
Es importante controlar que el ángulo se encuentre entre 0º y 180º, añadimos un bucle que haga repetir la pregunta mientras que el ángulo no esté dentro del rango indicado.
Una vez programada la interacción con el teclado, pasamos a programar el movimiento del motor. Para programar esa acción, pulsamos en dispositivos y en la placa Arduino Uno para empezar a programar.
Al presionar bandera, el programa se quedará a la espera de recibir un ángulo que se encuentre entre los valores 0 y 180º.
Una vez recibido el ángulo correcto posiciona el motor utilizando el bloque «mueve el servo» que localizarás en la sección pines.
Pulsa en la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«. Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Como hicimos en la práctica con display «lectura de números por teclado» vamos a utilizar la comunicación Serie para solicitar el ángulo al usuario y que éste lo pueda introducir.
Para el control del servomotor, utilizamos la librería Servo.h.
Creamos el objeto servo y lo llamaremos myServo. En setup, asignamos el pin 7 al servo con la instrucción myServo.attach(7) y en loop movemos el servo utilizando la instrucción myServo.write(ángulo).
#include <Servo.h>
int angulo;
Servo myServo; // crea el objeto servomotor
void setup(){
myServo.attach(7); // asigna el pin 7 al servo
Serial.begin(9600); // configura el puerto serie
}
void loop(){
if(Serial.available()>0){ // si el puerto serie esta disponible
angulo=Serial.parseInt(); // lee un dato entero por teclado
if(argulo>0 && angulo<181){ // si el ángulo está entre 0 y 180º
myServo.write(angulo); // mueve el servo al ángulo
delay(15);
}
}
}
Pulsa en el icono subir, y comprueba el resultado.
La primera práctica que os proponemos es muy sencilla, consiste en conseguir detectar un obstáculo utilizando un optoacoplador CNY70.
Un cny70 es un dispositivo que integra un emisor y un detector de luz y mide la reflexión de un haz de luz infrarroja sobre un objeto. Podemos emplearlo para detectar objetos cercanos o tonos de color. En los valores extremo (0V – 5V) podemos determinar si estamos sobre una zona blanca o negra, y en los valores intermedios toda la gama de grises posible. En este ejercicio veremos su uso para detectar obstáculos cercanos.
Para realizar esta práctica necesitaremos el siguiente material
Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.
Conectamos el optoacoplador al pin A5 de la placa Arduino y el led al pin 13. ¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: el led debe encenderse cuando el CNY70 detecte un obstáculo cerca. El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación. El cny70 devuelve un valor analógico entre 0 y 1023 en función de si encuentra un objeto más o menos cerca. En el programa que hemos creado, marcamos como umbral un valor 400. Si el optoacoplador nos aporta un valor por debajo de 400, entendemos que el objeto está cerca y por lo tanto encendemos el led. Pulsa en la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«. Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
void setup(){
pinMode(13, OUTPUT); // led - pin de salida
}
void loop(){
if(analogRead(A5)<400){ // si la lectura del optoacoplador es inferior a 400
digitalWrite(13, HIGH); // enciende el led
}
else{
digitalWrite(13, LOW); // si supera 400, apaga el led
}
}
Pulsa en el icono subir, y comprueba el resultado.
Para realizar este circuito necesitas los siguientes materiales:
Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.
Cada patilla del display está conectada a un segmento. La distribución de las patillas viene indicada en las especificaciones del display. En el que hemos utilizado se corresponde con este esquema:
Conectamos el display a los pines de la placa Arduino como se muestra en la imagen.
¡Ya sólo nos queda programar!
Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: conseguir que el display muestre un dígito comprendido entre el 0 y el 9 que previamente introdujimos por teclado.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
El primer paso es realizar la lectura de datos por teclado. Esta lectura se realiza a través de una interacción con los personajes. Pulsa en la pestaña objetos y haz clic sobre el personaje «panda». Será él quien nos pida que introduzcamos un número por teclado.
Pulsa en eventos y arrastra «cuando clic en bandera» a la zona de programación. A continuación pulsa en sensores y arrastra el bloque «pregunta» junto debajo del evento «cuando clic en bandera». Puedes cambiar la pregunta e introducir el texto que quieras. Nosotros hemos puesto «Dime un número». Cuando presionemos la bandera verde, el panda nos pedirá un número y aparecerá una caja de texto donde escribiremos nuestra respuesta.
Cuando el panda recibe una respuesta, procede a comprobar si ésta se encuentra entre los números -1 y 10, ya que son los dígitos que podemos mostrar en el display.
En caso de no estar en este rango, mostramos un mensaje de error utilizando el bloque «decir» que localizarás en la sección apariencia. En caso de que la respuesta esté dentro del rango esperado, procedemos a enviar un mensaje a la placa con el número guardado en la variable «respuesta». Puedes encontrar el bloque enviar en la sección «eventos». Enviamos el número redondeado para evitar el uso de cantidades con decimales.
A continuación pulsamos en dispositivos y volvemos al código de la placa Arduino pulsando sobre la placa. Vamos a utilizar como base el ejercicio anterior, reutilizando el bloque display:
Mantenemos el bloque «cuando clic en bandera» y los bloques que inicializan las variables de los números con su combinación de segmentos.
La placa debe recibir el número que se ha introducido por teclado. En eventos tenemos un bloque que se llama «al recibir». Arrastramos este bloque al espacio de programación, al pulsar sobre «mensaje» podemos introducir un nuevo mensaje. Pulsa sobre nuevo mensaje e introduce el mensaje 0
Cuando reciba el mensaje 0, será por que el usuario introdujo este dígito por teclado. Por lo tanto pasaremos a llamar al bloque display visualizando el dígito 0. Haremos esto para todos los dígitos, del 0 al 9.
Pulsa la bandera verde y comprueba el resultado.
Al trabajar con bloques personalizados, algoritmos y parámetros, hemos podido reutilizar y aprovechar el ejercicio anterior de forma mucho más sencilla.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.
Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Para resolver este ejercicio tenemos que hacer uso de la comunicación Serie. Dentro de setup configuramos el puerto serie: Serial.begin(9600);
En loop, realizamos la lectura del dígito cuyo código ascii debe estar entre 48 y 57. Una vez recibido un dígito correcto, procedemos a realizar la llamada correspondiente a la función display en función del dígito recibido.
int dato = 11;
void setup(){
pinMode(7, OUTPUT); // segmento a
pinMode(8, OUTPUT); // segmento b
pinMode(9, OUTPUT); // segmento c
pinMode(10, OUTPUT); // segmento d
pinMode(11, OUTPUT); // segmento e
pinMode(12, OUTPUT); // segmento f
pinMode(13, OUTPUT); // segmento g
Serial.begin(9600);
}
void display(int a, int b, int c, int d, int e, int f, int g)
{
digitalWrite(7, a); // enciende o apaga un segmento
digitalWrite(8, b);
digitalWrite(9, c);
digitalWrite(10, d);
digitalWrite(11, e);
digitalWrite(12, f);
digitalWrite(13, g);
}
void loop() { // bucle infinito
while(dato<48 or dato>57){
dato=Serial.read(); // leemos un dato del teclado
}
switch (char(dato)){
case '0':
display(1,1,1,1,1,1,0); // escribe 0
delay(1000);
break;
case '1':
display(0,1,1,0,0,0,0); // escribe 1
delay(1000);
break;
case '2':
display(1,1,0,1,1,0,1); // escribe 2
delay(1000);
break;
case '3':
display(1,1,1,1,0,0,1); // escribe 3
delay(1000);
break;
case '4':
display(0,1,1,0,0,1,1); // escribe 4
delay(1000);
break;
case '5':
display(1,0,1,1,0,1,1); // escribe 5
delay(1000);
break;
case '6':
display(1,0,1,1,1,1,1); // escribe 6
delay(1000);
break;
case '7':
display(1,1,1,0,0,0,0); // escribe 7
delay(1000);
break;
case '8':
display(1,1,1,1,1,1,1); // escribe 8
delay(1000);
break;
case '9':
display(1,1,1,0,0,1,1); // escribe 9
delay(1000);
break;
}
dato=11;
}
Pulsa en el icono subir, y comprueba el resultado.
Para realizar este circuito necesitas los siguientes materiales:
Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.
Cada patilla del display está conectada a un segmento. La distribución de las patillas viene indicada en las especificaciones del display. En el que hemos utilizado se corresponde con este esquema:
Conectamos el display a los pines de la placa Arduino como se muestra en la imagen.
¡Ya sólo nos queda programar!
Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: conseguir que el display muestre los números del 0 al 9.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Los números se forman iluminando cada uno de los 7 segmentos que forman el display. Así para mostrar por ejemplo el número 0, tendremos que iluminar los segmentos a b c d e f. Cada segmento está conectado a un pin digital, por lo que para encenderlo pondremos el pin en alto y para apagarlo pondremos el pin en bajo.
A la hora de programar, no existe una solución única, podemos realizar distintos programas y que todos resuelvan el ejercicio planteado. En este ejemplo vamos a ver varias soluciones posibles.
Solución 1:
Para visualizar cada números nos centraremos en ejecutar la combinación de bloques necesaria, utilizando tantos bloques como sean necesarios
Muestra el número 0:
Muestra el número 0 y 1:
Y así sucesivamente iríamos añadiendo la combinación de pines que enciendan y apaguen cada segmento. El objetivo se cumple, pero si quisiéramos mostrar dos veces un dígito tendríamos que duplicar 7 bloques, alargando notablemente el programa. Existen otras formas de programar que facilitan poder reutilizar el código sin duplicar líneas.
Solución 2
Os proponemos resolver este ejercicio creando un bloque personalizado encargado de visualizar un dígito en concreto en función de la combinación de segmentos que reciba.
Comenzamos creando 10 variables que contendrán la combinación de segmentos relativa a cada uno de los dígitos:
Un 0 significa que ese segmento debe estar apagado y un 1, encendido.
A continuación vamos a crear nuestro bloque personalizado. Este bloque se encargará de visualizar cualquier número que se le indique. Pulsa en la sección «mis bloques» y después en «crear bloque».
Asigna un nombre al bloque pulsando sobre él (nosotros lo llamaremos display) y pulsa en añadir una entrada de texto.
Pulsa en aceptar y verás que aparece el nuevo bloque tanto en la sección «mis bloques» como en el espacio de programación. El bloque display recibirá una palabra formada por la combinación de 0s y 1s que enciendan y apaguen los segmentos para formar un dígito. Cuando se ejecute, analizará esa palabra recibida, caracter a caracter, y por cada dígito que encuentre decidirá qué segmento encender o apagar.
Veamos un ejemplo: Si Display debe mostrar el dígito 1, recibirá la palabra 0110000
Display analiza la palabra y actúa como se indica:
Necesitaremos dos variables, una que recorre los pines a encender y apagar, y otra que recorra las posiciones de los caracteres dentro de la palabra:
Los pines que vamos a utilizar van desde el 7 al 13, y las posiciones de los caracteres dentro de la variable segmentos irán desde el 1 hasta el 7. Así inicializamos las variables pin a 7 y posición a 1.
A continuación introducimos un bucle que se ejecute 7 veces. En cada ejecución, se analizará un caracter de la variable segmento y se encenderá o apagará el segmento correspondiente del display.
Dentro del bucle, tendremos un bloque condicional. Si el caracter es un 0, apagará el pin correspondiente, y si es un 1 lo encenderá. Por último no olvides aumentar en una unidad el pin y la posición.
Una vez creado el bloque display, volvemos al bloque «cuando clic en bandera». Tras la definición de las variables que hicimos al inicio, añadimos un bloque display para cada dígito que queramos mostrar.
Pulsa la bandera verde y comprueba el resultado.
Al trabajar con bloques personalizados, algoritmos y parámetros, conseguimos que el programa tenga menos bloques repetidos, sea más corto y se pueda modificar y reutilizar de forma mucho más sencilla.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.
Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Para resolver la actividad, os proponemos realizar una función para visualizar cada dígito. En este caso, la función recibe 7 dígitos que representan el estado de los segmentos. Basta que utilizar ese estado dentro de la función digitalWrite para activar y desactivar cada segmento.
void setup(){
pinMode(7, OUTPUT); // segmento a
pinMode(8, OUTPUT); // segmento b
pinMode(9, OUTPUT); // segmento c
pinMode(10, OUTPUT); // segmento d
pinMode(11, OUTPUT); // segmento e
pinMode(12, OUTPUT); // segmento f
pinMode(13, OUTPUT); // segmento g
}
void display(int a, int b, int c, int d, int e, int f, int g)
{
digitalWrite(7, a); // enciende o apaga un segmento
digitalWrite(8, b);
digitalWrite(9, c);
digitalWrite(10, d);
digitalWrite(11, e);
digitalWrite(12, f);
digitalWrite(13, g);
}
void loop() { // bucle infinito
display(1,1,1,1,1,1,0); // escribe 0
delay(1000);
display(0,1,1,0,0,0,0); // escribe 1
delay(1000);
display(1,1,0,1,1,0,1); // escribe 2
delay(1000);
display(1,1,1,1,0,0,1); // escribe 3
delay(1000);
display(0,1,1,0,0,1,1); // escribe 4
delay(1000);
display(1,0,1,1,0,1,1); // escribe 5
delay(1000);
display(1,0,1,1,1,1,1); // escribe 6
delay(1000);
display(1,1,1,0,0,0,0); // escribe 7
delay(1000);
display(1,1,1,1,1,1,1); // escribe 8
delay(1000);
display(1,1,1,0,0,1,1); // escribe 9
delay(1000);
}
Pulsa en el icono subir, y comprueba el resultado.
Para realizar este circuito necesitas los siguientes materiales:
Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.
Conectamos el led a los siguientes pines de la placa Arduino
¡Ya sólo nos queda programar!
Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: conseguir que el motor avance y pare de forma intermitente.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Utilizamos el bloque «cuando clic en bandera» para iniciar el programa. Dentro ubicaremos el bloque «para siempre» para crear un bucle infinito. En él introducimos los bloques «pon la salida PWM… a …» que cambiarán la luz del led. Al ser un led ánodo común, si enviamos una señal con valor 0, la luz se encenderá en su máxima intensidad. Esta intensidad bajará conforme sube el valor de la señal enviada, apagándose con valor 255.
Si utilizas un led RGB cátodo común funciona al revés, es decir, para iluminar en su máxima intensidad utiliza el valor 255, y para apagar el led, el valor 0.
Si queremos encender la luz …
Pulsa la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.
Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
void setup(){
pinMode(9, OUTPUT); // Rojo
pinMode(6, OUTPUT); // Azul
pinMode(5, OUTPUT); // Verde
}
void loop() { // bucle infinito
analogWrite(9,0); // Rojo
analogWrite(6,255);
analogWrite(5,255);
delay(1000);
analogWrite(9,255); // Verde
analogWrite(6,255);
analogWrite(5,0);
delay(1000);
analogWrite(9,255); // Azul
analogWrite(6,0);
analogWrite(5,255);
delay(1000);
}
Pulsa en el icono subir, y comprueba el resultado.
Para realizar este circuito necesitas los siguientes materiales:
Para trabajar en una protoboard, es importante conocer las conexiones que existen en ella. Puedes utilizar el siguiente enlace para leer información detallada sobre las conexiones de la protoboard.
Conectamos el motor al pin digital 9 y la LDR a la entrada analógica A0 de la placa Arduino
¡Ya sólo nos queda programar!
Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones
El objetivo de este programa es muy sencillo: conseguir que el motor avance y pare de forma intermitente.
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Mblock: primeros pasos« Una vez configurada la tarjeta comenzamos con la programación.
Utilizamos el bloque «cuando clic en bandera» para iniciar el programa. Dentro ubicaremos el bloque «para siempre» para crear un bucle infinito. En él introducimos un bloque condicional «si… entonces… si no…» encargado de evaluar la intensidad de luz detectada por la LDR. Si la luz es mayor a 200, el motor parará, y si es menor de 200 se activará.
Pulsa la bandera verde y comprueba el resultado.
Vamos a realizar el mismo programa, utilizando líneas de código con Arduino IDE
El primer paso es configurar la tarjeta, sigue los pasos que te indicamos en «Arduino IDE: primeros pasos«.
Una vez configurada la tarjeta comenzamos con la programación. Recuerda que al trabajar con código debemos respetar la sintaxis: Cuidado con las letras mayúsculas y minúsculas y con los signos de puntuación. ¡Son importantes!.
Utilizamos la instrucción analogRead para obtener el valor aportado por la LDR, y la instrucción analogWrite para indicar al motor la velocidad a la que debe girar.
void setup(){
pinMode(9, OUTPUT); // motor - pin de salida
}
void loop() { // bucle infinito
if (analogRead(A0)>200){
analogWrite(9, 0); // el motor para
}
else {
analogWrite(9, 255); // el motor gira
}
}
Pulsa en el icono subir, y comprueba el resultado.