Para controlar un servo motor de giro continuo, debemos conectar el motor a la placa del microcontrolador en función de las indicaciones del manual del motor. Servomotor: EMAX ES08MA II
Las tres conexiones que debemos realizar son las siguientes: VCC (Cable Anaranjado) GND (Cable Negro) Señal (Cable Amarillo) Para el control del motor, conectaremos el cable identificado como “señal” al puerto 9 del Arduino UNO. Para nuestro ejemplo, utilizamos un sensor Shield para Arduino UNO. El sensor Shield, es una placa auxiliar que se coloca sobre el Arduino y nos permite hacer las conexiones hacia los sensores, interruptores y en nuestro caso a los motores de una forma mas sencilla.
Una vez realizadas las conexiones, debemos incluir en el programa del Arduino, la librería servo.h
Esta librería nos permitirá controlar el servo de una manera muy sencilla. La librería servo.h ya viene incluida en el ide de Arduino, por lo que no será necesario descargar otra librería para efectuar el control del servomotor. Luego debemos declarar el objeto que estará asociado al control de este motor.
Esto lo hacemos mediante la siguiente instrucción: miservo.attach(9) donde el argumento de la función, corresponde al pin en donde estará conectado el cable identificado como “Señal” del motor. Para nuestro ejemplo, hemos conectado el cable de control al pin 9 del Arduino UNO. Por ultimo debemos escribir la instrucción con la cual controlaremos el ángulo del servomotor. Se trata de la instrucción miservo.write()
Como estamos trabajando con un servomotor de giro limitado, El argumento de esta función corresponderá a la posición del eje del servomotor. Si utilizamos (0) como argumento, el motor girara y se posicionara en 0 grados. Si utilizamos (90), el motor girara y se posicionara en 90 grados. Si utilizamos (180), el motor girara y se posicionara en 180 grados.
El programa hará que el eje del motor se posicione en 0 grados, haga una pausa de 1 segundo, luego se posicionara en 180 grados, hará una pausa de 1 segundo, luego regresa a 0 grados, haga una pausa de ½ segundo, luego se posicionara en 45, 90, 135, 180 y regrese a 135, 90, 45 y 0 grados. Volviendo a realizar el ciclo. Como pueden observar, es muy fácil controlar un servomotor utilizando un Arduino.
Ya queda algo lejos la Navidad, pero siempre vuelve… así que queremos compartir con vosotros el proyecto de Mae, un árbol programado con arduino con luces y canciones navideñas. Os compartimos el paso a paso del proyecto debajo del video, esperamos que os guste 🙂
CONECTANDO EL ALTAVOZ A LA PLACA DE ARDUINO:
Conectar el cable de tierra que sale del altavoz a GND de Arduino.
El otro cable conectarlo al pin 5.
CONECTANDO LOS LEDS:
Nuestra tira de leds funciona a 12 voltios y Arduino sólo proporciona 5 voltios por lo que son necesarios tres transistores (uno por cada uno de los colores básicos de la tira:Rojo Verde y Azul) que funcionen como amplificadores.
Para simplificar el proyecto, partimos de los transistores ya implementados por lo que únicamente es necesario realizar las siguientes conexiones:
// Para distinguir las notas, establecemos un tiempo mínimo entre ellas.
// la duración de la nota + 30% funciona bien:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// deja de sonar el tono
buzz(melodyPin, 0, noteDuration);
}
} else {
Serial.println(” ‘Jingle Bells'”);
int size = sizeof(melody) / sizeof(int);
for (int thisNote = 0; thisNote < size; thisNote++) {
// Para calcular la duración de una nota, dividimos un segundo entre el tipo de nota
int noteDuration = 1000 / tempo[thisNote];
buzz(melodyPin, melody[thisNote], noteDuration);
// Para distinguir las notas, establecemos un tiempo mínimo entre ellas.
// la duración de la nota + 30% funciona bien:
int pauseBetweenNotes = noteDuration * 1.30;
delay(pauseBetweenNotes);
// deja de sonar el tono
buzz(melodyPin, 0, noteDuration);
}
}
}
void buzz(int targetPin, long frequency, long length) {
//inicializamos las variables para los colores de los leds
int ColorR = 0;
int ColorG = 0;
int ColorB=0;
digitalWrite(13, HIGH);
//Los colores los generamos aleatoriamente
ColorR=random(0,255);
ColorG=random(0,255);
ColorB=random(0,255);
//Enviamos el valor de los colores básicos para generar el color final
analogWrite(green, ColorG);
analogWrite(red, ColorR);
analogWrite(blue, ColorB);
long delayValue = 1000000 / frequency / 2; // calcula el valor de espera entre transiciones
long numCycles = frequency * length / 1000; //calcula el número de ciclos
for (long i = 0; i < numCycles; i++) { //bucle para el número de ciclos que hemos obtenido
digitalWrite(targetPin, HIGH); // enviamos el valor high al zumbador
delayMicroseconds(delayValue); // esperamos el tiempo calculado
digitalWrite(targetPin, LOW); //enviamos el valor low al zumbador
delayMicroseconds(delayValue); // esperamos el tiempo calculado
}
digitalWrite(13, LOW);
}
No olvides copiar el fichero pitches.h a Arduino/libraries
Comprueba que el altavoz reproduce correctamente los villancicos y se encienden los leds.
Puedes probar a cambiar los colores de los LEDS en lugar de generarlos aleatoriamente. Para ello, puede ser útil la página https://www.colorspire.com/rgb-color-wheel/ (Donde, dado un color nos indica la cantidad de Rojo, Verde y Azul necesario).
Para controlar un servo motor de giro continuo, debemos conectar el motor a la placa del microcontrolador en función de las indicaciones del manual del motor. Las tres conexiones que debemos realizar son las siguientes: VCC, GND y Señal. Una vez realizadas las conexiones, debemos incluir en el programa del Arduino, la librería servo.h
Esta librería nos permitirá controlar el servo de una manera muy sencilla. La librería servo.h ya viene incluida en el ide de Arduino, por lo que no será necesario descargar otra librería para efectuar el control del motor. Luego debemos declarar el objeto que estará asociado al control de este motor.
Esto lo hacemos mediante la siguiente instrucción: miservo.attach(9) donde el argumento de la función, corresponde al pin en donde estará conectado el cable del motor que corresponde a la señal de control. Para nuestro ejemplo, hemos conectado el cable de control al pin 9 del Arduino UNO.
Por ultimo debemos escribir la instrucción con la cual controlaremos la velocidad del motor. Se trata de la instrucción miservo.write() Como estamos trabajando con un servomotor de giro continuo, El argumento de esta función corresponderá a la velocidad con la cual girara el motor. Si utilizamos (0) como argumento, el motor girara a máxima velocidad hacia un sentido. Si utilizamos (90), el motor de detendrá. Si utilizamos (180), el motor girara en sentido contrario.
Como estas instrucciones están escritas en el void loop (), estas se ejecutaran en forma continua.
El motor girara en un sentido a máxima velocidad por 2 segundos, luego se detendrá por 2 segundos, el motor girara a máxima velocidad y en sentido opuesto por 2 segundos, luego se detendrá por 2 segundos, y se repetirá continuamente mientras el microcontrolador este energizado. Ustedes pueden experimentar utilizando otros valores entre los señalados y comprueben que ocurre con la velocidad del motor.
Antes de escribir un programa para controlar una salida analógica del Arduino,
debemos empezar por identificar que puertos del Arduino están dispuestos para
generar una señal en base a un PWM y en segundo lugar explicaremos que es una señal
PWM.
PWM PINS: 3, 5, 6, 9, 10, 11
¿Qué es PWM y cómo funciona? La modulación por ancho de pulsos (también conocida como PWM, siglas en inglés de pulse-width modulation) de una señal o fuente de energía es una técnica en la que se modifica el ciclo de trabajo de una señal periódica (una senoidal o una cuadrada, por ejemplo), ya sea para transmitir información a través de un canal de comunicaciones o para controlar la cantidad de energía que se envía a una carga. El ciclo de trabajo de una señal periódica es el ancho relativo de su parte positiva en relación con el período. Expresado matemáticamente:
D es el ciclo de trabajo es el tiempo en que la función es positiva (ancho del pulso) T es el período de la función
Para las salidas analógicas se usan los pines que están marcados como PWM y es que en realidad las salidas analógicas no dan una señal continua a un nivel determinado, sino que mediante pulsos consiguen obtener un nivel de tensión promedio proporcional al ancho de estos pulsos.
Como se puede ver en la imagen superior, variando en ancho del pulso, podemos obtener una señal promedio equivalente. Para la primera señal, cuyo ancho de pulso es del 10%, nos daría una señal analógica de 0.5v (el 10% de 5V). Para la segunda una señal, cuyo ancho de pulso es del 50%, nos daría una señal analógica de 2.5v. Y para la tercera señal obtendríamos una señal, cuyo ancho de pulso es del 90%, obtendríamos un valor equivalente de 4.5v. Instrucciones para controlar la salida analógica en un Arduino. La instrucción que debemos implementar es la siguiente:
analogWrite
Sintaxis: analogWrite(pin, value)
Parámetros: pin: el pin Arduino para escribir. Tipos de datos permitidos: int. value: El ciclo de trabajo: entre 0 (siempre apagado) y 255 (siempre encendido). Tipos de datos permitidos: int.
Programa de ejemplo: Para modificar el valor del voltaje en la salida PWM seleccionada (pin 6), solo basta con modificar el argumento (value) de la función analogWrite. Value, solo permite un valor entre 0 y 255. Con value igual a 255, obtendremos aproximadamente 5 Vdc en el pin seleccionado, para el ejemplo (pin 6).
Con value igual a 127, obtendremos aproximadamente 2.3 Vdc
Con value igual a 0, obtendremos 0 Vdc.
De esta forma podemos controlar el nivel de voltaje que deseamos sobre el pin 6. Para
medir el voltaje utilizamos un multímetro. Recuerden que el parámetro value, solo
admite valores entre 0 y 255.
Para value = 0, El voltaje será 0 Vdc
Para value = 255, el voltaje será 5 Vdc.
Un proyecto que trata de implementar un riego por goteo.
El agua almacenada en un depósito será extraída a través de un tubo de riego por la acción de una bomba alimentada con una batería.
Por su parte, la bomba será activada a través de un relé conectado a una placa Arduino UNO.
A partir del código, encendemos o apagamos la bomba enviando una señal HIGH o LOW al relé que abrirá o cerrará el circuito (el valor correcto dependerá del fabricante).
En esta versión, hemos realizado una codificación sencilla en la que la bomba se activa y desactiva cada 5 segundos.
Este proyecto, se podrá ampliar utilizando sensores de humedad que determinaran la activación de la bomba, incluir una fuente de luz, un sensor de temperatura que puede determinar la activación de un ventilador etc. en otra versión mejorada iremos viendo los avances del mismo. Os compartimos el código sencillo realizado y el video explicativo para ver el resultado.
/*
Semillero riego automatico 1.0
RGG 2019
1 Relé
1 Bomba
Se trata de accionar la bomba de agua a partir de un relé conectado a Arduino
*/
//Indicamos el pin donde está conectado el Relé
const int pinRL = 9;
void setup() {
// put your setup code here, to run once:
//Indicamos los pines de Salida
pinMode(pinRL, OUTPUT);
//Abrimos una conexión serie con el PC
Serial.begin(9600);
}
void loop() {
// put your main code here, to run repeatedly:
//Enviamos un valor HIGH al pin del Relé
digitalWrite(pinRL, HIGH);
Serial.println (“Enviamos un High”);
//Esperamos 5 segundos
delay(5000);
//Enviamos un valor LOW al pin del Relé digitalWrite(pinRL, LOW); Serial.println (“Enviamos un LOW se activa el relé y la bomba”); //Esperamos 5 segundo delay(5000); }
Realizamos una caja que recree una escena dando la impresión de tres dimensiones. Para ello, hemos impreso una caja y tres paneles con los siguientes planos:
primer plano vegetación
segundo plano: ciervo y arbolado
tercer plano: horizonte de casas
Con Arduino le hemos dotado de iluminación. Los ficheros stl para la impresión los hemos descargado de THINGIVERSE: Los paneles: https://www.thingiverse.com/thing:2746834 (el último panel de montañas no lo hemos impreso para que el resultado no fuera demasiado opaco)
Hemos preferido esta caja porque a diferencia del proyecto ‘Winter in 3D’ de donde hemos elegido los paneles de la escena, la pared posterior no es maciza.Una vez descargados, con la aplicación CURA hemos generado los ficheros gcode realizando las modificaciones necesarias para que los paneles se puedan insertar en la caja: 72x74x1.1 mm.
La calidad de impresión la hemos rebajado para que fuera viable imprimirlos en clase (altura del filamento para el primer plano: 015, segundo 02 y tercero 03. Relleno al 100%).
Respecto a la iluminación, hemos implementado en una placa protoboard dos leds conectándolos a un Arduino UNO y realizando la codificación para encenderlos durante 10 segundos. Posteriormente, se mantienen apagados durante otros 10 segundos.
Adjuntamos el código para un led, se podría modificar para incluir más leds.
/*
LED 1.0 para la caja de sombras
Daniela 2019
1 LED
Encendido de un led y apagado transcurrrido un tiempo
*/
//Indicamos el pin donde está conectado el LED
const int ledPIN = 13;
void setup() {
// put your setup code here, to run once:
//Indicamos que el pin del LED es de Salida
pinMode(ledPIN , OUTPUT);
}
void loop() { // put your main code here, to run repeatedly: digitalWrite(ledPIN , HIGH); // enviamos al Pin el valor HIGH delay(10000); // esperamos 10 segundos digitalWrite(ledPIN , LOW); // enviamos al Pin el valor LOW delay(10000); // esperamos 10 segundos }
Y aquí podéis ver el resultado y la explicación del propio alumno, esperamos que os guste 🙂
En la mayoría de los sistemas automatizados, utilizamos sensores para supervisor el mundo exterior. Estos sensores nos entregan una señal analógica. Como ejemplo mas practico podemos citar el caso de los sensores de:
Temperatura
Distancia
Presión
PH
Intensidad de corriente en un circuito
Caudal de agua en una tubería
Velocidad de un coche
% de Humedad
Para leer este tipo de señales continuas, necesitamos un convertidor analógico a digital (o ADC por sus siglas en ingles) y que nos permite leer el valor de una señal analógica en un momento dado. Estos convertidores toman una muestra del valor actual de la señal y nos entregan su valor instantáneo, medido en Voltios. Mediante la lectura repetida de muestras a lo largo del tiempo podemos reconstruir la señal original con mayor o menor precisión, dependiendo de la exactitud de nuestra medida y de la velocidad a la que pueda tomar esas muestras.
¿Cómo usar el Arduino UNO para leer señales Analógicas?
Arduino UNO dispone de seis convertidores analógico a digital, nominados de A0 hasta A5, rotuladas como ANALOG IN:
Los convertidores de Arduino UNO y Mega son de 10 bits de resolución por lo que nos devolverá valores entre 0 y 210 = 1.024 para tensiones entre 0 y 5V.
Asegúrate de no usar sensores que puedan dar más de 5V máximo (con Arduino UNO y Mega), ya que dañarías el chip principal de Arduino.
Para usar las entradas analógicas, utilizaremos un potenciómetro en vez de un sensor, el cual conectaremos como se indica el siguiente circuito. Aplicaremos tensión de 5 Vdc a los extremos del potenciómetro y conectamos el pin central (cursor o variable) a la entrada del puerto A5 del Arduino.
Escribimos el siguiente programa:
Observación:
No necesitamos declarar en el setup() que vamos a usar una puerta analógica. Y la segunda es que para tomar una muestra (leer) del pin A5, usaremos la instrucción:
int sensorValue = analogRead(A5);
Luego de descargar el programa sobre la placa, arrancamos la consola serial y veras que a medida que giras el cursor del potenciómetro, las lecturas varían de forma continua reflejando la posición del potenciómetro, las lecturas reflejan la caída en voltios sobre la resistencia del potenciómetro. Con esto hemos logrado leer el valor de una señal analógica.
Ya vimos como configurar el IDE de Arduino, preparar la placa seleccionada, cargar un programa ejemplo (Blink) y descargar este programa en el microcontrolador.
Ahora, le daremos un vistazo al programa y explicaremos las instrucciones que se han utilizado.
Programa de Ejemplo: BLINK
Empezamos con el contenido de la función “void setup”:
En esta función, debemos escribir las instrucciones necesarias para configurar el hardware del microcontrolador. Para el ejemplo, debemos utilizar una salida digital para energizar al LED.
Esto lo logramos utilizando la instrucción
pinMode ( )
Descripción:
Configura el pin especificado para que se comporte como entrada o salida.
Sintaxis:
pinMode(pin, mode)
Parámetros:
pin: el número de pin Arduino a utilizar.
En el ejemplo han utilizado el LED que ya viene conectado por defecto en la placa, este pin es llamado LED_BUILTIN y el compilador del Arduino reconoce que se trata del pin 13.
mode: INPUT, OUTPUT, or INPUT_PULLUP
Como queremos que se comporte como una salida digital y de esa forma energizar al LED, debemos indicar que el “modo” debe ser OUTPUT.
Por lo tanto, la instrucción debe escribirse de la siguiente forma:
pinMode(LED_BUILTIN, OUTPUT);
De esta forma pin digital 13 (LED_BUILTIN), queda configurado como salida.
Luego, analizaremos la función void loop( ):
En esta función, debemos escribir las instrucciones que se deben ejecutar en forma cíclica.
En el ejemplo han utilizado dos instrucciones dentro de la función void loop, estas son digitalWrite y delay.
digitalWrite ( )
Descripción:
Con esta instrucción se escribe un valor ALTO o BAJO en el pin digital. Si el pin se ha configurado como una SALIDA con pinMode (), su voltaje se establecerá en el valor correspondiente: 5V (o 3.3V en placas de 3.3V) para ALTO, 0V (tierra) para BAJO.
Sintaxis:
digitalWrite(pin, valor)
Parámetros:
pin: el número de pin de Arduino.
valor: ALTO o BAJO.
delay ( )
Descripción:
Pausa el programa por la cantidad de tiempo (en milisegundos) especificado como parámetro.
Sintaxis:
delay(ms)
Parámetros:
ms: el número de milisegundos para pausar.
Si observamos el código escrito, vemos que la primera instrucción escribirá un “UNO Lógico” en el pin 13. Esto significa que si medimos con un multímetro, tendremos 5 vdc en el pin 13 correspondiente a la placa Arduino, con lo cual se encenderá el LED_BUILTIN.
digitalWrite(LED_BUILTIN, HIGH);
Luego se ejecuta la instrucción delay , lo cual ejecutara una pausa con duración de 1000 milisegundos, lo cual es equivalente a 1 segundo.
delay(1000);
Luego, se ejecuta la tercera instrucción digitalWrite(LED_BUILTIN, LOW), con lo cual se escribe un “Cero Logico” en el pin 13. De forma que el LED_BUILTIN se apagara.
Luego se ejecuta nuevamente la instrucción delay, manteniendo apagado al led por el tiempo establecido por el argumento de la instrucción, lo cual es equivalente a 1 segundo.
Como explicamos anteriormente, las instrucciones escritas dentro de la función void loop, se repetirán cíclicamente, por lo tanto el led se encenderá durante un segundo y se apagara durante un segundo y se volverá a encender cíclicamente.
Con la instrucción delay, podemos modificar el tiempo de duración de encendido y apagado que tendrá el Led.
Los invito a modificar el valor del argumento utilizados en las instrucciones delay (1000).
Con delay (100) aumentamos velocidad del parpadeo, debido a que el tiempo de encendido y apagado se han reducido.
Para continuar con el encendido del LED utilizando un Arduino UNO, debemos ahora pasar a la fase de programación del microcontrolador. Por lo tanto, debemos aprender a utilizar el IDE de programación su configuración.
IDE de Programación:
1.- Iniciamos el IDE de Arduino.
Este tendrá el siguiente aspecto.
Encabezado. Contiene el nombre del archivo que se esta modificando.
Barra de Herramientas. Contiene los nombres de las diferentes ventanas con opciones que permitirán la configuración del IDE a utilizar en relación a la placa Arduino a utilizar.
Comandos Rápidos. Botones con varios comandos de acceso rápido muy útiles durante la programación del microcontrolador. Verificación del código, Subir código al microcontrolador, Nuevo boceto, Abrir boceto, Salvar boceto.
Barra de Estado. Mensajes del IDE de Arduino hacia el usuario y códigos de errores luego de la verificación del programa.
Abriremos nuestro primer archivo.
Hacemos clic sobre “File” contenido en la barra de herramientas, luego en “Examples”, seleccionamos “01.Basics” y luego “Blink”
Con esto tendremos cargado el siguiente código en la IDE de Arduino.
Para proceder a cargar este programa en el microcontrolador, debemos realizar los siguientes pasos:
1-. Seleccionar el tipo de tarjeta que vamos a utilizar, para este ejemplo Arduino UNO. Hacemos clic sobre “Tools”, luego en “Board” y seleccionamos la tarjeta “Arduino/Genuino Uno”.
2-. Seleccionamos el puerto USB que utilizara el IDE de Arduino para comunicarse con la placa del microcontrolador. Hacemos clic nuevamente sobre “Tools”, luego en “Port” y seleccionamos el puerto que el sistema ha seleccionado al microcontrolador, para este ejemplo el “COM6 (Arduino/Genuino Uno)”.
3-. Subimos el programa al Microcontrolador. Hacemos clic sobre el botón “UPLOAD” ubicado en la barra de comandos rápidos y esperamos unos segundos hasta que aparezca el mensaje “Done uploading” en la barra de estado.
La siguiente entrada explicaremos al detalle el programa de ejemplo “Blink” y las modificaciones que podemos hacer para energizar el LED que vimos en la parte 4.
