CONTROL DE MOTORES CON PUENTE EN H

Utilizando un circuito integrado puente en H, vamos a controlar el sentido de giro de un motor.    

  1. ¿Qué es un puente en H?
  2. Circuito: Cómo conectar un puente en H a Arduino
  3. Programación con Mblock
  4. Programación con Arduino IDE

1.  ¿Qué es un puente en H?

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.

2. Circuito: Cómo conectar un puente en H a Arduino

Para realizar esta práctica necesitaremos el siguiente material

Vamos a realizar las conexiones paso a paso para evitar errores. En cada imagen os indicaremos los cables a conectar.

Hemos realizado las siguientes conexiones:

Motor 1:

  • Pin 5: Podemos enviar una señal entre 0 y 255. En función de este valor, el motor avanzará mas deprisa o más despacio
  • Pin 6:  Podemos enviar una señal entre 0 y 255. En función de este valor, el motor retrocederá mas deprisa o más despacio

Motor 2:

  • Pin 9: Podemos enviar una señal entre 0 y 255. En función de este valor, el motor avanzará mas deprisa o más despacio
  • Pin 10:  Podemos enviar una señal entre 0 y 255. En función de este valor, el motor retrocederá mas deprisa o más despacio

¡Ya sólo nos queda programar! Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3.  Programación con Mblock

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.

4.  Programación con Arduino IDE

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.

MOVIENDO UN SERVOMOTOR CON UN POTENCIÓMETRO

Utilizando un potenciómetro, guiaremos el movimiento de un servomotor.    

  1. ¿Qué es un potenciómetro?
  2. Circuito: Cómo conectar un servomotor a Arduino
  3. Programación con Mblock
  4. Programación con Arduino IDE

1.  ¿Qué es un potenciómetro?

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.

2. Circuito: Cómo conectar un potenciómetro a Arduino

Para realizar esta práctica necesitaremos el siguiente material

Conectar potenciómetro y servomotor a Arduino

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3.  Programación con Mblock

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.

4.  Programación con Arduino IDE

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

MOVIENDO UN SERVOMOTOR

 

En esta ocasión vamos a programar un servomotor que se posicione en el ángulo que le indiquemos introduciéndolo por teclado.    

  1. ¿Qué es un servomotor?
  2. Circuito: Cómo conectar un servomotor a Arduino
  3. Programación con Mblock
  4. Programación con Arduino IDE

1.  ¿Qué es un servomotor?

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º.

2. Circuito: Cómo conectar un servomotor a Arduino

Para realizar esta práctica necesitaremos el siguiente material

Conectar servomotor a Arduino

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3.  Programación con Mblock

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

El personaje pregunta…

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.

Guarda la respuesta

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.

Repite la pregunta

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º.

Espera hasta que se cumpla la condición

Una vez recibido el ángulo correcto posiciona el motor utilizando el bloque «mueve el servo» que localizarás en la sección pines.

Mueve el servo

 Pulsa en la bandera verde y comprueba el resultado.

4.  Programación con Arduino IDE

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.

CNY70 – DETECTOR DE OBSTÁCULO

La primera práctica que os proponemos es muy sencilla, consiste en conseguir detectar un obstáculo utilizando un optoacoplador CNY70.

  1. ¿Qué es un optoacoplador cny-70?
  2. Circuito: Cómo conectar un cny-70 a Arduino
  3. Programación con Mblock
  4. Programación con Arduino IDE

1.  ¿Qué es un optoacoplador CNY-70?

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.

2. Circuito: Cómo conectar un CNY70 a Arduino

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3.  Programación con Mblock

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.

4.  Programación con Arduino IDE

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.

LECTURA DE NÚMEROS POR TECLADO

El objetivo de esta práctica es visualizar en un display de 7 segmentos un dígito del 0 al 9 que se haya introducido previamente por teclado.

 

1. Circuito: Cómo realizar el circuito

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3. Programación con mBlock

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.

4. Programación con Arduino IDE

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.

 

DISPLAY 7 SEGMENTOS

El objetivo de esta práctica es visualizar los dígitos del 0 al 9.

1. Qué es un display de 7 segmentos

Un display de 7 segmentos es un operador que puede visualizar los dígitos del 0 al 9 iluminando algunos de los 7 segmentos que lo forman.

2. Circuito: Cómo realizar el circuito

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3. Programación con mBlock

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:

  • En la posición 1 encuentra un 0, procede a apagar el segmento a
  • En la posición 2 encuentra un 1, procede a encender el segmento b
  • En la posición 3 encuentra un 1, procede a encender el segmento c
  • En la posición 4 encuentra un 0, procede a apagar el segmento d
  • En la posición 5 encuentra un 0, procede a apagar el segmento e
  • En la posición 6 encuentra un 0, procede a apagar el segmento f
  • En la posición 7 encuentra un 0, procede a apagar el segmento g

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.

4. Programación con Arduino IDE

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.

LED RGB

El objetivo de esta práctica es iluminar un led RGB con la secuencia rojo – verde – azul.

1. Led RGB

Un Led RGB combina luces de color rojo, verde y azul el cualquier tonalidad, pudiendo generar una luz de cualquier tono de la gama de colores. 
Cuenta con 4 patillas, 3 de las cuales estarán asociadas a un color (rojo, verde, o azul).

2. Circuito: Cómo realizar el circuito

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

  • 9 – Rojo
  • 6 – Azul
  • 5 – Verde

¡Ya sólo nos queda programar!

Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

2. Programación con mBlock

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 …

  • Roja, pondremos el valor 0 en el pin 9, y valor 255 en los pines 5 y 6
  • Verde, pondremos el valor 0 en el pin 5, y valor 255 en los pines 9 y 6
  • Roja, pondremos el valor 0 en el pin 6, y valor 255 en los pines 5 y 9

Pulsa la bandera verde y comprueba el resultado.

3. Programación con Arduino IDE

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.

VENTILADOR AUTOMÁTICO

El objetivo de esta práctica es mover un motor DC cuando se detecte la falta de luz.

1. Circuito: Cómo realizar el circuito

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

2. Programación con mBlock

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.

3. Programación con Arduino IDE

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.

MOVIMIENTO DE UN MOTOR

El objetivo de esta práctica es mover un motor DC de forma intermitente.

1. Motor: sentido de giro

En esta práctica vamos a trabajar con un motor DC y veremos que sólo gira en un sentido. Para cambiar el sentido de giro, es preciso cambiar la polaridad de la corriente que lo atraviesa. Este cambio debe hacerse físicamente, y para su control necesitaríamos un módulo puente en H o un controlador de motores. En próximas prácticas os hablaremos de él.

2. Circuito: Cómo realizar el circuito

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

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

3. Programación con mBlock

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 encargados de accionar y parar el motor. Vamos a utilizar el bloque «pon la salida PWM … a…». Con este bloque podemos controlar la velocidad de giro del motor, pudiendo ser un valor desde 0 hasta 255.

  • 0 – El motor quedará parado
  • 255 – El motor girará a la mayor velocidad posible.

Podemos utilizar cualquier valor intermedio entre 0 y 255, haciendo girar el motor a velocidades más lentas.

Pulsa la bandera verde y comprueba el resultado.

4. Programación con Arduino IDE

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

   analogWrite(9, 255);        // el motor gira rápido 
   delay(1000);                // pausa
   analogWrite(9, 0);          // el motor para
   delay(1000);                // pausa
                
}

Pulsa en el icono subir, y comprueba el resultado.

ENCENDIDO NOCTURNO

El objetivo de esta práctica es encender un led cuando una LDR detecte poca luz ambiente.

1. Circuito: Cómo realizar el circuito

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 los componentes a los siguientes pines de la placa Arduino:

  • 12   – Led rojo
  • A0 – LDR

¡Ya sólo nos queda programar!

Para programar la placa Arduino puedes utilizar diferentes lenguajes. Nosotros nos vamos a centrar en dos opciones

  • MBlock – programación basada en bloques
  • Arduino IDE – programación basada en líneas de código

2. Programación con mBlock

El objetivo de este programa es muy sencillo: conseguir que los leds emulen la secuencia de un semáforo y emita un sonido cuando el tráfico esté detenido.

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 condicional «Si… entonces…sino…» para evaluar el nivel de luz. La lectura de la LDR se realiza a través de un pin analógico, por lo que utilizaremos el bloque «leer pin analógico» para conocer la luz que está detectando. Si la lectura del pin analógico es menor que 200, encendemos el led, y si no lo mantenemos apagado.

Pulsa la bandera verde y comprueba el resultado.

3. Programación con Arduino IDE

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(12, OUTPUT);          // led rojo - pin de salida
} 
  
void loop() { // bucle infinito     

    if (analogRead(A0)<200){             // si ldr < 200   
        digitalWrite(12, HIGH);          // enciende el led
    }
    else {
         digitalWrite(12, LOW);         // si no apaga el led
   } 
                
}

Pulsa en el icono subir, y comprueba el resultado.