El monitor serie (IDE Arduino)

Controlar el display de la tarjeta multifunción sin ninguna ayuda es complicado; por ello, de momento, utilizaremos el monitor serie que tiene el IDE Arduino para visualizar datos. Arduino se comunica con el ordenador a través del cable USB utilizando un puerto serie y podemos transmitir datos del uno al otro.

Para activar el monitor serie hay que tener conectada la tarjeta y seleccionarlo en el menú herramientas, se abrirá la ventana adjunta:

El siguiente programa envía al monitor serie el número 1, después de un segundo la palabra "Hola" y pasados dos segundos se repite el ciclo.

/*
 * monitorSerie.ino
 * Escribimos en el monitor Serie del IDE Arduino el número 1
 * seguido de la palabra Hola, a intervalos de tres segundos.
 */


void setup() {
  Serial.begin(9600);   //fijamos la velocidad de transmisión
                        //en 9600 baudios (bits por segundo)
}

void loop() {
  Serial.print(1);            //escribimos 1
  delay(1000);
  Serial.println("  Hola");   //escribimos y pasamos línea
  delay(2000);
}

Ahora visualizaremos en el monitor serie el estado de los tres pulsadores; es decir, si están presionados o liberados.

/*
 * monitorSeriePulsadores.ino
 * Monitorizamos el estado de los pulsadores en el monitor
 * serie,indicando si están presionados o liberados.
 * Usamos un variante de la instrucción if
 * if condición        si se cumple se ejecutan instruciones1
 *    instrucciones1
 * else                en caso contrario se ejecutan instruciones2
 *    instrucciones2
 */

void setup() {
  pinMode(A1, INPUT);
  pinMode(A2, INPUT);
  pinMode(A3, INPUT);
  Serial.begin(9600);

}

void loop() {
  if(digitalRead(A1) == LOW) {        //si pulsador presionado
    Serial.print("D1 presionado");    //   escribe D1 presionado
  }else{                              //en caso contrario  
    Serial.print("D1 liberado");      //   escribe D1 liberado
  }
  if(digitalRead(A2) == LOW) {
    Serial.print("   D2 presionado");
  }else{
    Serial.print("   D2 liberado");
  }
  if(digitalRead(A3) == LOW) {
    Serial.println("   D3 presionado");  
  }else{
    Serial.println("   D3 liberado");
  }
  delay(1000);
}

Ejercicios propuestos:

1.- Hacer un programa que visualice en el monitor serie vuestro nombre, transcurridos 5 segundos,  la edad (en la misma línea) y pasados otros 5 segundos la dirección (en la línea siguiente). Tras 5 segundos más en ciclo se repite.

Pulsadores (IDE Arduino)

El shield multifunción dispone de tres pulsadores: S1, S2 y S3, conectados a los pines A1, A2 y A3. Para usarlos tenemos que detectar si están presionados o liberados, eso lo podemos hacer con la instrucción digitalRead, que nos devuelve el nivel de voltaje (LOW o HIGH) existente en el pin. Cuando un pulsador está presionado dicho voltaje es LOW y cuando está liberado HIGH. En el programa adjunto, al presionar el pulsador S1 se enciende el LED D1 y al liberarlo se apaga.

/* 
 * pulsadorS1LedD1.ino
 * Al presionar el pulsador S1 (en el pin A1) se
 * enciende el LED D1 (pin 13) y se apaga al liberarlo.
 * Cuando se presiona un pulsador estamos poniendo un
 * voltaje bajo, LOW, en el pin al que está conectado,
 * al liberarlo se queda un voltaje alto, HIGH.
 */
 
void setup() {
  pinMode(13, OUTPUT);      //pin 13 como salida
  pinMode(A1, INPUT);       //pin A1 como entrada
  digitalWrite(13, HIGH);   //apagamos el Led D1
}

void loop() { 
  digitalWrite(13, digitalRead(A1));   //digitalRead(A1) será LOW si
                                       //el pulsador está presionado
                                       //o HIGH si está liberado
}

En este caso, vamos a encender D1 y D2 al presionar el pulsador S1 y los vamos a apagar cuando presionemos el pulsador S2. Para realizar el programa es necesario usar la instrucción if (si), que nos va a servir para comparar dos valores y ejecutar unas determinadas instrucciones sólo en el caso de que sean iguales.

/*
 * pulsadorS1enciendeS2apaga.ino
 * Al presionar el pulsador S1 (pin A1)se encienden D1 (pin 13) y
 * D2 (pin 12), al presionar el pulsador S2 (pin A2) se apagan.
 */
 
void setup() {
  pinMode(13, OUTPUT);        //pin 13 como salida
  pinMode(12, OUTPUT);        //pin 12 como salida
  pinMode(A1, INPUT);         //pin A1 como entrada
  pinMode(A2, INPUT);         //pin A2 como entrada
  digitalWrite(13, HIGH);     //apagamos el Led D1
  digitalWrite(12, HIGH);     //apagamos el Led D2
}

void loop() { 
  if(digitalRead(A1)==LOW) {   //si pulsador S1 presionado
    digitalWrite(13, LOW);     //Led D1 encendido
    digitalWrite(12, LOW);     //Led D2 encendido
  }
  if(digitalRead(A2)==LOW) {   //si pulsador S2 presionado
    digitalWrite(13, HIGH);    //Led D1 apagado
    digitalWrite(12, HIGH);    //Led D2 apagado
  }
}

Ejercicios propuestos:

1.- Escribir un programa para que al presionar el pulsador 1 se encienda el LED 4, al presionar el pulsador 2 suene el  zumbador y al presionar el pulsador 3 se apague el LED y finalice el sonido.

2.- Ahora haremos que los diodos 1 y 2 se enciendan al mantener presionado el pulsador 1 y se apaguen al liberarlo. Además, los diodos 3 y 4 se encenderán al presionar el pulsador 2 y se apagarán al presionar el pulsador 3.

El zumbador (IDE Arduino)

El shield multifunción lleva incorporado un zumbador, conectado al pin 3 de Arduino, con el que podemos emitir sonidos; para ello se utiliza la instrucción tone, indicando el numero del pin y la frecuencia del mismo. También necesitaremos la instrucción noTone para silenciarlo. Además, si no queremos que el zumbador haga ruido es conveniente mantener el pin 3 con un nivel de voltaje alto. El siguiente programa hace que el zumbador suene durante 1 segundo con una frecuencia de 440 Hz y después queda en silencio 5 segundos.

/* zumbador
 * Emite un sonido (nota La) durante 1 segundo,
 * después permanece en silencio 5 segundos.
 * El zumbador está conectado al pin 3 de Arduino.
 * Para evitar que emita ruidos hay que poner un
 * nivel de voltaje alto (HIGH) en dicho pin.
 */

void setup() {
  pinMode(3, OUTPUT);      //pin 3 como salida
  digitalWrite(3, HIGH);   //zumbador sin ruido
}

void loop() { 
  tone(3, 440);            //nota La, frecuencia 440Hz
  delay(1000);             //esperamos 1 segundo
  noTone(3);               //silencio
  digitalWrite(3, HIGH);
  delay(5000);             //esperamos 5 segundos
}

En la siguiente lista tenemos las frecuencias de las notas musicales básicas:

Ahora haremos que suenen las notas Do, Re y Mi durante medio segundo cada una, después permanecerá en silencio 2 segundos y se repetirá el ciclo.

/* zumbadorDoReMi
 * Suenan las notas Do, Re y Mi durante medio
 * segundo cada una, después 2 segundos en silencio
 */

void setup() {
  pinMode(3, OUTPUT);
  digitalWrite(3, HIGH);

}

void loop() {
  tone(3, 262);             //Do
  delay(500);
  tone(3, 294);             //Re
  delay(500);
  tone(3, 330);             //Mi
  delay(500);
  noTone(3);                //silencio
  digitalWrite(3, HIGH);
  delay(2000);
}

En el siguiente programa suenan las mismas notas pero dando un pitido corto de 0'1 segundos.

/* zumbadorDoReMiCorto
 * Suenan unos pitidos cortos (100 mseg) de las notas
 * Do, Re y Mi. Posteriormente, pasados 2 segundos
 * se vuelve a repetir el ciclo.
 */

void setup() {
  pinMode(3, OUTPUT);      //pin 3 como salida
  digitalWrite(3, HIGH);   //zumbador sin sonido
}

void loop() {
  tone(3, 262);           //Do
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  tone(3, 294);           //Re
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  tone(3, 330);           //Mi
  delay(100);
  noTone(3);              //silencio
  digitalWrite(3, HIGH);
  delay(400);
  delay(2000);            //dos segundos de pausa
}

Ejercicios propuestos:

1.- Realizar un programa que haga parpadear un LED y, a la vez, emita dos pitidos cortos.

2.- Conseguir que suene la escala musical completa en el zumbador.

3.- Ampliar el programa del semáforo de la entrada anterior de manera que el zumbador emita unos pitidos cortos para avisar que el tiempo de paso de los peatones se está acabando.

Los diodos LED (IDE Arduino)

El shield multifunción cuenta con cuatro diodos LED, D1, D2, D3 y D4, que están conectados a los pines 13, 12, 11 y 10 de Arduino. Para controlarlos es necesario programar dichos pines como salidas con la instrucción pinMode y, posteriormente, encenderlos o apagarlos con la instrucción digitalWrite, suministrando un voltaje bajo (LOW del orden de 0 voltios) o alto (HIGH unos 5v).

Nuestro primer programa sirve para encender el LED D1. En él vamos a utilizar las instrucciones comentadas anteriormente.

/* 
 * encendidoLedD1
 * Este programa enciende el Led D1, conectado al pin13.
 * Por la manera en la que están conectados en el shield, los
 * diodos Led se encienden con un nivel de voltaje bajo LOW
 * y se apagan con un voltaje alto HIGH.
 */

void setup() {
  pinMode(13, OUTPUT);      //programamos pin 13 como salida
  digitalWrite(13, LOW);    //ponemos un voltaje bajo en pin 13
}

void loop() {                          

}

Ahora vamos a hacer que el LED D1 parpadee a intervalos de 1 segundo. Usaremos la instrucción delay para detener el programa durante el tiempo que deseemos, expresado en milisegundos (1 seg = 1000 mseg).

/* 
 * parpadeoD1
 * Este programa hace parpadear el Led D1, pin 13,
 * a intervalos de 1 segundo.
 * El tiempo hay que expresarlo en milisegundos
 * 1 seg = 1000 mseg.
 */

void setup() {
  pinMode(13, OUTPUT);      //programamos pin 13 como salida
}

void loop() {                          
  digitalWrite(13, LOW);    //encendemos Led D1
  delay(1000);              //esperamos 1 segundo
  digitalWrite(13, HIGH);   //apagamos Led D1
  delay(1000);              //esperamos 1 segundo
}

En el siguiente programa vamos a ir encendiendo los LED de uno en uno a intervalos de 1 segundo. Después se apagan todos durante 2 segundos y vuelve a iniciarse el ciclo.

/*
 * encendidoProgresivoLED
 * Los LED se van encendiendo de uno en uno a intervalos
 * de un segundo. Después se apagan durante dos segundos
 * y vuelve a iniciarse el ciclo.
 */

void setup() {
  pinMode(13, OUTPUT);     //todos los pines salidas
  pinMode(12, OUTPUT);
  pinMode(11, OUTPUT);
  pinMode(10, OUTPUT);
  digitalWrite(13, HIGH);  //apagamos todos los LED
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);  
}

void loop() {
  digitalWrite(13, LOW);   //encendemos D1
  delay(1000);
  digitalWrite(12, LOW);   //encendemos D2
  delay(1000);
  digitalWrite(11, LOW);   //encendemos D3
  delay(1000);
  digitalWrite(10, LOW);   //encendemos D4
  delay(1000);
  digitalWrite(13, HIGH);  //apagamos todos los LED
  digitalWrite(12, HIGH);
  digitalWrite(11, HIGH);
  digitalWrite(10, HIGH);  
  delay(2000);
}

Ejercicios propuestos:

1.- Hacer un programa que provoque el parpadeo alternativo de los LEDs 1-2 y los LEDs 3-4. Es decir, se encienden los LEDs 1 y 2 mientras que los LEDs 3 y 4 permanecen apagados durante medio segundo, posteriormente, se apagan los LEDs 1 y 2 y se encienden los LEDs 3 y 4 durante medio segundo. El ciclo se repite permanentemente.

2.- Ahora tenemos que conseguir un movimiento rápido de sube-baja con un único LED encendido.

3.- Programar un semáforo para coches. El LED D1 sería el rojo, el D2 el ambar y el D3 el verde. Posteriormente, se podría ampliar el programa usando el LED D4 para los peatones, encendido no se puede pasar y apagado si, incluso se puede hacer parpadear para avisar que el tiempo de paso se agota antes de ponerse en rojo.

Arduino + Shield multifunción (IDE Arduino)

Arduino es una pequeña tarjeta programable capaz de hacer unas cosas u otras dependiendo de los programas que nosotros carguemos en su memoria. Se conecta al puerto USB del ordenador y mediante un lenguaje propio se escriben los programas y se suben a la placa. Una vez programada no necesita seguir unida al ordenador, se puede desconectar de él y funcionar de manera autónoma (siempre que la alimentemos con una fuente o batería adecuada).

Arduino cuenta con una serie de pines en los que podemos conectar y controlar elementos externos; luces, motores, sensores, etc:

14 pines digitales (numerados de 0 a 13) que se programan individualmente como entrada o salida y  suministran o leen un voltaje alto (próximo a 5v, HIGH) o bajo (próximo a 0v, LOW). Además, en los pines 3, 5, 6, 9, 10 y 11 se puede obtener una señal analógica (PWM) con una precisión de 8 bit.

6 entradas analógicas (numeradas de 0 a 5) que permiten leer un voltaje comprendido entre 0 y 5v con una resolución de 10 bit (suministran un número entre 0 y 1023). Si se desea, también podemos programarlos como entradas/salidas digitales, en ese caso, se nombran como pines 15,...19.

En lugar de usar una protoboard para cablear y añadir  elementos externos, vamos a utilizar un Shield multifunción (k5864195); se trata de una placa que se pincha directamente sobre Arduino y pone a nuestra disposición cuatro diodos LEDs, tres pulsadores, un potenciómetro, un zumbador y un display de 7 segmentos de cuatro dígitos, además, quedan libres varios pines en los que podemos conectar directamente otros dispositivos, por ejemplo: un sensor de temperatura, micro servos, sensores de ultrasonidos, de infrarrojos (sigue línea) e incluso un circuito bluetooth.

Un aliciente adicional para usarlas es su bajo coste, actualmente, se pueden encontrar por un precio inferior a 10 euros (las dos) en ElectroHobby.

En estas entradas vamos a utilizar como lenguaje de programación el entorno de desarrollo propio de Arduino; en este caso, no se trabaja con bloques, sino que hay que ir escribiendo las instrucciones. Además, en principio, vamos a procurar no usar librerías externas, pretendemos hacerlo todo nosotros sin ayudas.

Descargamos el IDE Arduino del siguiente enlace con la página oficial:

 https://www.arduino.cc/en/Software

Lo instalamos siguiendo las instrucciones y lo ejecutamos, nos aparecerá una ventana similar:

Ya podemos escribir nuestro primer programa. Se trata de hacer encender el LED D1 de la placa multifunción, que está conectado al pin 13 de Arduino:

Ahora enchufamos Arduino al ordenador con el cable USB y comprobamos que ha quedado conectado a uno de los puertos COM. Por último, pinchamos en el icono Subir para cargar el programa en la memoria. Si todo es correcto el LED D1 permanecerá encendido.

En las siguientes entradas iremos utilizando los distintos elementos del shield multifunción y las instrucciones necesarias para su programación.

Puerta corredera

Se trata de una puerta corredera con un sistema piñón cremallera, un servo de rotación continua y dos sensores de infrarrojos (tipo sigue línea). En el vídeo se muestra una posible forma de funcionamiento, al accionar un pulsador la puerta se abre, permanece 10 segundos abierta y se posteriormente se cierra:

El servo va conectado al pin 5 del shield multifunción, el sensor que detecta que la puerta está cerrada al pin 6 y el que  detecta que la puerta está abierta al pin9.

Para su construcción se ha utilizado una impresora 3D, aquí tenéis disponible el archivo stl:

puerta corredera.stl

El programa que hemos utilizado en el vídeo anterior es el siguiente:

Ejercicios propuestos:

1.- Ahora queremos que la puerta se abra al accionar el pulsador 1 y se cierre al presionar el pulsador 2.

2.- Algunos detalles pueden complicar los programas más de lo que uno piensa inicialmente; por ejemplo,  hacer que cuando la puerta se esté cerrando podamos accionar el pulsador de apertura para que se abra. 

Ascensor de 3 pisos

En esta entrada abordamos la construcción de un ascensor de tres pisos.

Hemos usado los tres pulsadores de la tarjeta multifunción, un micro servo de rotación continua y tres sensores de infrarrojos (sigue línea) para detectar la presencia de la cabina en cada uno de los pisos. En la figura adjunta vemos la conexión de estos elementos:

El armazón se ha realizado con una impresora 3D. En el siguiente enlace se puede descargar el archivo stl correspondiente (incluye la cabina, el contrapeso y una polea que se puede acoplar al micro servo). Para evitar problemas con la altura se ha dividido en tres partes que se pueden acoplar y fijar con un poco de pegamento.

Si no se dispone de impresora, existen páginas web que la realizan y la envían en unos días, por ejemplo: imprimakers

Archivo para impresora 3D: ascensor3pisos.stl

En siguientes imágenes se ve el montaje definitivo. Para evitar errores de los sensores hemos pegado dos trozos de cinta aislante, negra y blanca, en el lateral de la cabina (segunda imagen.

Por último, aquí tenemos el programa:

Ejercicios propuestos:

1.- Al accionar el pulsador 1 el ascensor debe subir al piso 3, esperar allí 30 segundos, bajar al piso 2, esperar otros 30 segundos y regresar definitivamente al piso 1.

multibot: control bluetooth ⇦