1. No category

TRABAJANDO CON ARDUINO
UNO
Configuraciones, conexiones y ejemplos
Descripción breve
El presente documento presenta una breve descripción del controlador UNO de Arduino, las
conexiones a sensores analógicos y digitales y sus utilización como elemento de control en un
Sistema de Automatización.
Luis Echeverría Yánez
[email protected]
0
Tabla de contenidos
TABLA DE CONTENIDOS ................................................................................................. 1
EL CONTROLADOR ARDUINO. ........................................................................................ 2
EL ARDUINO UNO .............................................................................................................................................. 2
Alimentación. ............................................................................................................................................. 4
Valores de entrada y de salida. .................................................................................................................. 5
EL ENTORNO DE DESARROLLO DE ARDUINO UNO ...................................................................................................... 6
Descarga e instalación del Entorno. .......................................................................................................... 6
Reconocimiento de la tarjeta o modulo controlador. ................................................................................ 8
PROGRAMANDO EL CONTROLADOR. ...................................................................................................................... 10
Estructura de un programa en Arduino. .................................................................................................. 13
CONECTANDO SENSORES Y ACTUADORES. ................................................................... 15
CONEXIÓN DE INSTRUMENTACIÓN DIGITAL. ............................................................................................................ 15
Simulando sensores digitales ................................................................................................................... 15
Simulando actuadores digitales ............................................................................................................... 17
CONEXIÓN DE INSTRUMENTACIÓN ANALÓGICA. ....................................................................................................... 19
Simulando sensores analógicos ............................................................................................................... 19
Simulando salidas analógicas .................................................................................................................. 20
APLICACIÓN DE INSTRUMENTACIÓN BÁSICA ............................................................................................................ 22
Llenado y vaciado de tanque ................................................................................................................... 22
Llenado y vaciado de tanque, con temporización al llenado. .................................................................. 25
Llenado y vaciado de tanque, con batido de la mezcla al llenado. .......................................................... 26
CONEXIÓN A OTROS INSTRUMENTOS. .................................................................................................................... 29
Servomotores. .......................................................................................................................................... 29
Motor de pasos. ....................................................................................................................................... 35
Display numérico de matriz de puntos LCD.............................................................................................. 43
1
El controlador ARDUINO.
Arduino es una plataforma de hardware libre, basada en una placa con un microcontrolador y un
entorno de desarrollo, diseñada para facilitar el uso de la electrónica en proyectos
multidisciplinares.
El hardware consiste en una placa con un microcontrolador Atmel AVR y puertos de entrada/salida.
Los microcontroladores más usados son: Atmega168, Atmega328, Atmega1280 y ATmega8 que por
su sencillez y bajo coste permiten el desarrollo de múltiples diseños. Por otro lado el software
consiste en un entorno de desarrollo que implementa el lenguaje de programación
Processing/Wiring y el cargador de arranque que es ejecutado en la placa.
Desde octubre de 2012, Arduino usa también microcontroladores CortexM3 de ARM de 32 bits, que
coexistirán con las más limitadas, pero también económicas AVR de 8 bits. ARM y AVR no son
plataformas compatibles a nivel binario, pero se pueden programar con el mismo IDE de Arduino y
hacerse programas que compilen sin cambios en las dos plataformas. Eso sí, los microcontroladores
CortexM3 usan 3,3V, a diferencia de la mayoría de las placas con AVR que generalmente usan 5V.
Sin embargo ya anteriormente se lanzaron placas Arduino con Atmel AVR a 3,3V como la Arduino
Fio y existen compatibles de Arduino Nano y Pro como Meduino donde se puede conmutar el
voltaje.
El entorno de desarrollo integrado es de libre utilización y puede descargarse gratuitamente. Una
característica importante de los controladores Arduino es que pueden tomar información del
entorno a través de sus entradas analógicas y digitales, puede controlar luces, motores y otros
actuadores. El microcontrolador en la placa Arduino se programa mediante el lenguaje de
programación Arduino (basado en Wiring) y el entorno de desarrollo Arduino (basado en
Processing). Los proyectos hechos con Arduino pueden ejecutarse sin necesidad de conectar a un
computador.
Uno de los dispositivos Arduino más utilizados es el Arduino UNO.
EL Arduino UNO
El Arduino Uno es una plataforma electrónica microcontrolada basada en el ATmega328. Dispone
de 14 pines digitales de entrada / salida (de los cuales 6 pueden utilizarse para salidas PWM), 6
entradas analógicas, un resonador cerámico de 16 MHz, una conexión USB, un conector de
alimentación, un conector ICSP, y un botón de reinicio (reset).
2
Botón de reset
Salida Serial (Tx)
Entrada Seroal (Rx)
SCL
SDA
Referencia Analógica
Tierra digital
ICSP para USB
Entradas/Salidas Digitales (2-13)
Con capacidad para
PWM
Conector USB
ICSP para Atmega328
Vin
Tierra
IOREF
RESET
3.3.V
5V
Alimentación externa
de 7 a 12 Vdc
Entradas/Salidas
Analógicas
3
Arduino UNO contiene todo lo necesario para dar soporte al microcontrolador; basta con conectarlo
a un ordenador con un cable USB o alimentar con un adaptador de CA o la batería a CC para empezar
a trabajar con él.
Alimentación.
Arduino puede estar alimentado por dos vías:
 Conexión USB (que proporciona 5 V).
 Conector de alimentación (que normalmente será una pila de 9 V o fuente de alimentación,
que se recomienda entre 7 – 12 V).
Los pines de alimentación de Arduino son para alimentar los circuitos externos de prototipos,
breadboard o protoboard:




3.3 V proporciona una tensión de 3,3 V, y una intensidad máxima de 50 mA.
5 V proporciona una tensión de 5 V, y una intensidad máxima de 300 mA.
GND es la toma de tierra, o nivel 0 V de referencia.
Vin proporciona la tensión máxima con la que está alimentado Arduino.
4
Valores de entrada y de salida.
En función de cómo esté siendo utilizado en pin, tendremos:
Salida y entrada digital:
Los valores de salida pueden ser o 0 V (LOW) o 5 V (HIGH), y se interpretará una entrada de entre 0
y 2 V como LOW y de entre 3 y 5 V como HIGH.
Salida analógica:
Los valores de salida van desde 0 V a 5 V en un rango de 0 a 255 (precisión de 8 bits) valores
intermedios.
Entrada analógica:
Los valores de entrada van desde 0 V a 5 V en un rango de 0 a 1023 (precisión de 10 bits) valores
intermedios.
La intensidad máxima de todos estos pines es de 40 mA.
Normalmente, todo el circuito electrónico que Arduino controlará se monta sobre una placa de
prototipos o breadboard, y el conexionado se realiza con cables tipo jumper (es importante utilizar
este tipo de cables porque no suelen romperse en los zócalos) como los siguientes:
Una aplicación en Arduino UNO aparece como se indica a continuación:
5
El entorno de desarrollo de Arduino UNO
Descarga e instalación del Entorno.
El software del entorno de desarrollo de Arduino UNO, es de libre distribución y puede ser
descargado de:
http://arduino.cc/en/Main/Software
La última versión del IDE de ARDUINO es la 1.0.6. Una vez descargado el ejecutable del instalador,
procedemos a correrlo:
Entonces nos aparece la siguiente secuencia de instalación:
Se verifica el instalador:
Se presenta el acuerdo del licenciamiento de uso:
Se presentan las opciones de instalación:
6
Presionamos Next, e indicamos el lugar donde queremos la instalación, así:
Y a continuación presionamos Install, entonces comienza el proceso de instalación:
Se instalan los drivers de Arduino, aceptando la confianza en el software de Arduino LLC y dando
clic en Instalar:
7
Una vez terminado el proceso podemos presionar Close:
Terminada la instalación aparece el icono de Arduino en el escritorio, similar al siguiente:
Con eso se termina la instalación del IDE de Arduino.
Reconocimiento de la tarjeta o modulo controlador.
Terminada la instalación del entorno de desarrollo, y mediante un cable USB standard procedemos
a conectar el Arduino UNO a un puerto desocupado USB de la computadora, así:
Al hacer efectiva la conexión, la computadora reconoce el dispositivo e instala los drivers, mediante
la secuencia de proceso siguiente:
Reconocimiento del dispositivo e inicio del proceso de instalación del controlador
8
Búsqueda del controlador:
Instalación del software del controlador de Arduino UNO:
Finalización de la instalación y asignación de puerto de comunicaciones:
Para verificar la correcta instalación y reconocimiento del dispositivo, en la ventana del
administrador de dispositivos, en los puertos de comunicaciones, deberá aparecer el Arduino UNO
en COM3 o en el COM que se asigne a tu computadora, así:
9
Programando el controlador.
Al hacer doble clic sobre el icono de Arduino, se abrirá la aplicación:
que presenta una ventana similar a la de la siguiente figura:
10
En la parte inferior derecha de esta ventana se lee el controlador conectado y el puerto que ocupa
en este caso dice Arduino Uno on COM3, esta información no es confiable, pues la misma aparece
incluso si la tarjeta no se encuentra presente, por lo que es necesario seleccionar la tarjeta del
submenú Tarjeta en el menú Herramientas:
Y luego el puerto de comunicaciones del submenú Puerto Serial, en el mismo menú Herramientas:
Entonces ahora si estamos listos para la programación.
11
Al realizar cualquier programa, es necesario considerar el hecho de que este debe ser compilado
(proceso de búsqueda de errores de sintaxis y transformación a programa de bajo nivel reconocible
por el controlador) y luego transferido al Arduino UNO. Estos dos procesos los podemos hacer de
dos formas diferentes. Primero a través de la opción Verificar/Compilar ubicada en Sketch y luego
la opción Cargar del menú Archivo, o a través de los iconos de acceso directo:
Compilar/Verificar
Cargar
El programa a ser compilado y cargado es aquel ubicado en el editor del programa, que es la porción
de la ventana, editable y que se nomina por defecto como sketch_jan20a, que realmente es la unión
de la palabra sketch (boceto) más el mes y día en el que se realiza el archivo y la letra a, en este caso
jan de January (Enero en inglés) y 20 por el día 20.
Área de programación
En el entorno de programación de Arduino pueden coexistir varias áreas de programación en
pestañas diferentes:
12
Estructura de un programa en Arduino.
La estructura básica de programación de Arduino es bastante simple y divide la ejecución en dos
partes: setup y loop.
La función Setup() constituye la preparación del programa y sus parámetros de inicialización y la
función loop() es la ejecución. En la función Setup() se incluye la declaración de variables y se trata
de la primera función que se ejecuta en el programa. Esta función se ejecuta una única vez y es
empleada para configurar el pinMode (p. ej. si un determinado pin digital es de entrada o salida) e
inicializar la comunicación serie. La función loop() incluye el código a ser ejecutado continuamente
(leyendo las entradas de la placa, salidas, etc.), como por ejemplo el código:
void setup()
{
inMode(pin, OUTPUT);
// Establece 'pin' como salida
}
void loop()
{
digitalWrite(pin, HIGH);
// Activa 'pin'
delay(1000);
// Pausa un segundo
digitalWrite(pin, LOW);
// Desactiva 'pin'
delay(1000);
}
Como se observa en este bloque de código cada instrucción acaba con ; y los comentarios se
indican con //. Al igual que en C se pueden introducir bloques de comentarios con /* ... */. Antes
de Setup() es posible definir variables globales, así:
13
// constants won't change. They're used here to
// set pin numbers:
const int buttonPin = 2; // the number of the pushbutton pin
const int ledPin = 13; // the number of the LED pin
// variables will change:
int buttonState = 0;
// variable for reading the pushbutton status
14
Conectando sensores y actuadores.
Como cualquier otro dispositivo controlador el Arduino UNO admite infinidad de instrumentos,
tanto sensores como actuadores, entre los que podemos citar: potenciómetros, interruptores,
motores de pasos, motores AC, motores DC, servos, etc.
Vamos a simular sensores y actuadores mediante dispositivos sencillos fáciles de encontrar en
cualquier almacén de electrónica. Los elementos que se necesitaran son:





Un interruptor y una resistencia de 2.2 KΩ.
Un LED y una resistencia de 220 Ω.
Un potenciómetro de 10 KΩ, un conector de batería de 9 V y una batería de 9 V.
Un multímetro.
Una tableta para prototipos electrónicos (protoboard).
Conexión de instrumentación digital.
Simulando sensores digitales
Un sencillo circuito que opera como un sensor digital del tipo ON/OFF contiene un interruptor, una
resistencia de 2.2 K y una señal de 5 Vdc. La conexión es la siguiente:
En el Arduino UNO quedaría así:
15
16
El software para leer el interruptor, e imprimir su estado es:
const int swpin = 2;
int estadosw = 0;
void setup()
{
Serial.begin(9600);
pinMode(swpin, INTPUT);
}
void loop()
{
int estadosw = digitalRead(swpin);
Serial.println(estadosw);
delay(1000);
}
// entrada a la que está conectado el SW
// variable donde se almacena el estado del SW
//Inicializa comunicación con el IDE
// Establece 'swpin' como entrada
// Lee la entrada swpin
// imprime el estado del interruptor
// Pausa un segundo
Simulando actuadores digitales
Un sencillo circuito, que simula el encendido o apagado de un actuador, lo podemos realizar con un
LED y una resistencia de 220 Ω. La conexión a realizar es la siguiente:
En el Arduino UNO quedaría así:
17
El software para encender el LED es:
const int ledpin = 2;
// salida a la que está conectado el LED
void setup()
18
{
Serial.begin (9600);
pinMode (ledpin, OUTPUT);
//Inicializa comunicación con el IDE
// Establece 'ledpin' como salida
}
void loop()
{
digitalWrite (ledpin, HIGH);
delay(1000);
digitalWrite (ledpin, LOW);
delay(1000);
}
// enciende el LED (HIGH es el nivel alto de voltaje)
// espera de un segundo
// apaga el LED (LOW es el nivel bajo de voltaje)
// espera de un segundo
Conexión de instrumentación analógica.
Simulando sensores analógicos
Para poder simular un sensor analógico, utilizamos el potenciómetro de 10 KΩ y la salida de 5V de
la placa del Arduino, para lo cual armamos el siguiente circuito:
En el Arduino UNO quedaría así:
19
El software para leer el voltaje enviado por el potenciómetro a la entrada analógica 0 será entonces:
int potpin = A0;
int valorpot = 0;
void setup()
{
Serial.begin (9600);
}
void loop()
{
valorpot = analogRead(potpin);
Serial.println (valorpot);
Serial.println (“/r”);
Delay (1000);
}
//Inicializa comunicación con el IDE
// leemos la entrada analógica
// escribimos el valor leído en el monitor
// salto de línea (estilo C)
// espera de un segundo
Simulando salidas analógicas
Podemos programar para que Arduino en un pin determinado coloque un valor de tensión
comprendido entre 0 V y 5 V, pudiendo seleccionar entre 256 valores intermedios posibles (de 0 a
255), empleando la instrucción analogWrite (salida PWM, valor de 0 a 255).
20
Realmente, la señal analógica de salida no es analógica en sí, sino un PWM. Esto significa que la
salida es una señal modulada por pulsos, formada por una serie de pulsos (de valor 5 V) repartidos
durante un tiempo determinado de tal forma que el valor promedio de la señal de salida se hace
coincidir con el de la señal analógica que se persigue imitar. Es importante tener esto presente para
comprender el funcionamiento de Arduino y, por ejemplo, de los transistores conectados a ella. Las
salidas PWM para diferentes valores de salida son:
Con el programa que se indica a continuación controlamos el brillo de un LED conectado a la salida
PWM 11:
Int brillo = 0;
Int incremento = 5;
Int ledpin=11;
voidsetup()
{
pinMode (ledpin,OUTPUT);
}
void loop()
{
analogWrite (ledpin, brillo);
brillo = brillo + incremento;
if (brillo==0 || brillo==255)
{
incremento = -incremento;
}
delay (30);
//declaro la variable brillo, con valor inicial=0
//declaro la variable incremento, con valor=5
//el pin 9 será la salida
//coloca el valor brillo en el pin 9
//brillo aumenta su valor en 5
//si brillo llega a sus límites...
//...pasamos de ir creciendo a pasar...
//...a ir decreciendo y al revés
// esperamos un tiempo para observar la variación de luz
}
21
El circuito para el programa anterior será:
Aplicación de instrumentación básica
Llenado y vaciado de tanque
22
Se necesita desarrollar un sistema de control para que un tanque de almacenamiento de líquido se
llene hasta un valor máximo, y luego se vacié hasta llegar a un valor mínimo, y así sucesivamente.
La altura del tanque es 3 metros y el mínimo corresponde al 3% de la altura y el máximo al 95%.
En cuanto a la instrumentación, hay dos posibilidades, la primera es utilizar dos sensores digitales
ubicados en los niveles mínimo y máximo, y la segunda es utilizar un sensor analógico para comparar
con dos valores referenciales, el mínimo y el máximo.
Solución Digital.
Para la solución digital se requiere de dos interruptores que servirán como el sensor de nivel mínimo
(SMIN) y el máximo (SMAX) y dos leds, uno que representa la válvula de entrada (VE) y otro la de
salida (VS). El interruptor de nivel mínimo deben estar ubicados a 3/100 * 3 m = 0.09 m o sea a 9 cm
de la base del tanque y el interruptor de nivel máximo a 95/100*3m = 2.85 m de la base.
El sistema implementado, simulado con ayuda de Proteus V8.1 y Simulino nos queda así:
Este mismo esquema se lo conecta en la tarjeta real, tal como se indica en el gráfico anterior y los
resultados obtenidos son 100% correctos de acuerdo al simulador.
Y el programa para realizar el control es:
const int smaxpin = 13;
const int sminpin = 12;
const int vspin = 0;
const int vepin = 2;
int smax = 0;
int smin = 0;
int p = 0;
{
void setup()
void loop()
Serial.begin(9600);
pinMode(smaxpin, INPUT);
pinMode(sminpin, INPUT);
pinMode(vspin, OUTPUT);
pinMode(vepin, OUTPUT);
}
23
{
Ojo con la negación
smax = !digitalRead(smaxpin);
smin = !digitalRead(sminpin);
if (smin == 0 && smax == 0)
{
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
p=0;
}
if (smin == 1 && smax == 0 && p==0)
{
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
}
if (smin == 1 && smax == 1)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
p=1;
}
if (smin == 1 && smax == 0 && p==1)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
}
delay (100);
}
Solución Analógica.
Para la solución analógica se requiere de un potenciómetro, que simulara al sensor analógico de
nivel SNIVEL y las dos válvulas de entrada y salida del líquido, indicadas anteriormente (VS y VE).
Para este caso usamos dos referencias de nivel para delimitar lo que se interpreta como nivel
mínimo y nivel máximo, a través de las variables nmin y nmax. Si la señal analógica entre valores
que van de 0 a 1023, para una entrada de voltaje que varía de 0 a 5V, y un nivel que varía de 0 a 3m,
entonces, la referencia mínima de nivel en voltaje será 0.09*5/3 = 0.15V que equivale a 0.15*1023/5
= 30.69 o sea nmin = 31 y para la referencia máxima tenemos que el voltaje será 2.85*5/3 = 4.75V
que corresponde a 4.75*1023/5 = 971.85 o sea nmax = 972.
El sistema implementado, simulado con ayuda de Proteus V8.1 y Simulino nos queda así:
Este mismo esquema se lo conecta en la tarjeta real, tal como se indica en el gráfico anterior y los
resultados obtenidos son 100% correctos de acuerdo al simulador.
24
Y el programa para realizar el control es:
const int snivelpin = A0;
const int vspin = 0;
const int vepin = 2;
int snivel = 0;
int nmin = 31;
int nmax = 972;
int p = 0;
}
if (snivel <= nmin)
{
p=0;
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
}
void setup()
{
Serial.begin(9600);
pinMode(vspin, OUTPUT);
pinMode(vepin, OUTPUT);
}
if (snivel >= nmax)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
p=1;
}
if (snivel < nmax && p==1)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
}
void loop()
{
snivel=analogRead (snivelpin);
if (snivel < nmax && p==0)
{
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
delay(100);
}
Llenado y vaciado de tanque, con temporización al llenado.
El esquema de conexiones es el mismo del ejemplo anterior, lo único que cambia es el programa
donde se inserta la función de temporización delay. El programa quedará entonces de la siguiente
manera:
const int snivelpin = A0;
const int vspin = 0;
const int vepin = 2;
int snivel = 0;
int nmin = 31;
int nmax = 972;
int p = 0;
int t = 0;
int tiempo = 5000;
void setup()
{
Serial.begin(9600);
pinMode(vspin, OUTPUT);
pinMode(vepin, OUTPUT);
}
void loop()
{
snivel=analogRead (snivelpin);
if (snivel < nmax && p==0)
{
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
}
if (snivel <= nmin)
{
p=0;
25
t=0;
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
p=1;
t=1;
}
if (snivel <= nmax && p==1)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
}
}
if (snivel >= nmax && t == 0)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, LOW);
delay(tiempo);
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
delay(100);
}
La temporización en Arduino se la hace simplemente a través de la función delay(tiempo), de tal
manera que el momento que se quiere “congelar la ejecución del programa” o sea detenerlo
temporizadamente, es suficiente insertar este código como el siguiente fragmento del programa
anterior:
if (snivel >= nmax && t == 0)
{
digitalWrite(vepin, LOW);
Apagamos las válvulas
digitalWrite(vspin, LOW);
delay(tiempo);
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
p=1;
t=1;
Temporizamos
Encendemos válvula de salida y apagamos la entrada
}
t es una variable asociada a la temporización que evita que una vez ingresado a ejecutar el if donde
se temporiza, reingrese provocando nuevamente una temporización. Se resetea la variable (vuelve
a 0) al llegar al nivel mínimo.
Llenado y vaciado de tanque, con batido de la mezcla al llenado.
En el proceso anteriormente descrito incorporamos un motor que bate el líquido que ingresa al
tanque de almacenamiento luego que el tanque se ha llenado. El motor de batido da 10 vueltas,
antes de detenerse y habilitar el vaciado del tanque.
26
La simulación en Proteus V8.1 del Arduino e instrumentación es la siguiente:
Finalmente el software para Arduino es:
27
const int snivelpin = A0;
const int vspin = 0;
const int vepin = 2;
const int motorpin = 13;
const int tachopin = 12;
int snivel = 0;
int tacho = 0;
int tachoant = 0;
int nmin = 31;
int nmax = 972;
int p = 0;
int c = 0;
int cont = 0;
int vueltas = 10;
p=0;
c=0;
cont=0;
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
}
if (snivel >= nmax && c==0)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, LOW);
digitalWrite(motorpin, HIGH);
while (cont < vueltas)
{
tacho = digitalRead(tachopin);
if (tacho!=tachoant) if (tacho == 0) cont++;
tachoant=tacho;
}
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
digitalWrite(motorpin, LOW);
c=1;
p=1;
void setup()
{
pinMode(vspin, OUTPUT);
pinMode(vepin, OUTPUT);
pinMode(motorpin, OUTPUT);
pinMode(tachopin, INPUT);
}
void loop()
{
snivel=analogRead (snivelpin);
if (snivel < nmax && p==0)
{
digitalWrite(vepin, HIGH);
digitalWrite(vspin, LOW);
}
if (snivel <= nmin)
{
}
if (snivel <= nmax && p==1)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
}
delay(100);
}
En este caso el conteo no lo logramos a través de una simple instrucción sino en base a un grupo de
ellas. La estructura de conteo será:
while (cont < vueltas)
{
tacho = digitalRead(tachopin);
if (tacho!=tachoant) if (tacho == 0) cont++;
tachoant=tacho;
}
El programa en Arduino entra en el while y solo saldrá cuando el número de pulsos contados por los
ifs anidados hallar superado el número de vueltas previsto en la variable vueltas, para este caso 10.
28
Es importante la última línea del anterior código (tachoant=tacho), pues esta asegura que solo se
contara cuando haya pasado un pulso y venga otro, sin ella en función de cuánto tiempo tenga
presionado el botón que simula el tacómetro, saldrá del while, o sea llagara a la cuenta con un
número menor de pulsos, e incluso podría hacerlo con un solo pulso.
A continuación insertamos el código del contador en la estructura de espera al conteo:
if (snivel >= nmax && c==0)
{
digitalWrite(vepin, LOW);
digitalWrite(vspin, LOW);
digitalWrite(motorpin, HIGH);
Apagamos las válvulas y
encendemos el motor
while (cont < vueltas)
{
tacho = digitalRead(tachopin);
if (tacho!=tachoant) if (tacho == 0) cont++;
tachoant=tacho;
}
digitalWrite(vepin, LOW);
digitalWrite(vspin, HIGH);
digitalWrite(motorpin, LOW);
c=1;
p=1;
}
Contamos las vueltas
Encendemos la válvula de salida, mientras que la
de entrada y el motor se encuentran apagadas
Preparamos variables para no volver a contar y mantener cerrada la
válvula de entrada en el vaciado del tanque
Conexión a otros instrumentos.
Servomotores.
Los servomotores, conocido generalmente como servos, son dispositivos actuadores que tiene la
capacidad de ubicarse en cualquier posición angular, dentro de su rango de operación, y mantenerse
29
estable en ella. Está formado por un motor de corriente continua, una caja reductora y un circuito
de control, y su margen de funcionamiento generalmente es de menos de una vuelta completa.
Los servos se utilizan frecuentemente en sistemas de radiocontrol y en robótica, pero su uso no está
limitado a estas aplicaciones.
La estructura de un servo es la que se indica a continuación:
El componente principal de un servo es un motor de corriente continua, que realiza la función de
actuador en el dispositivo: al aplicarse un voltaje entre sus dos terminales, el motor gira en un
sentido a alta velocidad, pero produciendo un bajo par. Para aumentar el par del dispositivo, se
utiliza una caja reductora, que transforma gran parte de la velocidad de giro en torsión.
El punto de referencia o setpoint, que es el valor de posición deseada para el motor, se indica
mediante una señal de control cuadrada. El ancho de pulso de la señal indica el ángulo de posición,
una señal con pulsos más anchos (es decir, de mayor duración) ubicará al motor en un ángulo mayor,
y viceversa.
Los servos son controlados mediante el envío de un pulso de ancho variable, el cable de control
llevara este pulso. Los parámetros para este pulso son: un pulso mínimo, un pulso máximo, y una
tasa de repetición. Dadas las limitaciones de rotación del servo, el punto neutro o medio se define
como la posición desde donde el servo tiene exactamente el mismo ángulo de rotación en la
dirección de las agujas del reloj como en el sentido contrario. Es importante tener en cuenta que los
servos tendrán diferentes limitaciones en su rotación, pero todos exhiben una posición neutra, y
que la posición es siempre alrededor de 1,5 milisegundos (ms).
El ángulo de giro del servo se determina por la duración del pulso aplicado en el cable de control.
Este proceso es conocido como modulación por ancho de pulso, PWM por su nombre en inglés.
El servo espera recibir un pulso cada 20 ms. La longitud del pulso determinara el ángulo que gira el
motor. Por ejemplo, un pulso de 1,5 ms hará que el motor gire a la posición de 90 grados (posición
neutra).
Cuando a un servo se le ordena ubicarse en una posición, mantendrá esa posición. Si una fuerza
externa trata de sacar al servo del ángulo girado, el servo se resistirá a salir de esta posición. La
30
cantidad máxima de fuerza del servo puede ejercer, para no cambiar su posición se le conoce como
el torque del servo. Los servos no sostendrán su posición por siempre, el pulso de posición se debe
repetir para mantener al servo en la posición requerida.
Cuando se envía un pulso a un servo, inferior a 1.5 ms, el servo girará a una posición antihoraria y
mantiene su eje de salida a un ángulo especifico desde el punto neutral. Cuando el pulso es más
ancho que 1.5 ms ocurre lo contrario. La anchura mínima y máxima de pulso que van a comandar el
servo, para llevarlo a una posición específica, son funciones de cada servo. Distintas marcas, e
incluso diferentes servos de la misma marca, tienen diferentes máximos y mínimos. Generalmente
el pulso mínima será de aproximadamente 1 m de ancho y el pulso máxima será de 2 ms de ancho.
Otro parámetro que varía de servo en servo es la velocidad de giro. Este es el tiempo que se tarda
para cambiar de una posición a otra. El tiempo más extenso cuando el servo está ubicado en la
mínima posición y se le envía a la máxima. Esto puede tardar varios segundos en servos de par muy
elevado.
Los servomotores tienen tres terminales de conexión: dos para la alimentación eléctrica del circuito
y uno para la señal de control. El voltaje de alimentación generalmente es de alrededor de 6 voltios,
pues aunque el motor soporta mayores voltajes de trabajo, el circuito de control no lo hace.
31
El color del cable de cada terminal varía con cada fabricante, aunque el cable del terminal positivo
de alimentación siempre es rojo. El cable del terminal de alimentación negativo puede ser marrón
o negro, y el del terminal de entrada de señal suele ser de color blanco, naranja o amarillo, de
acuerdo a lo que se indica en la siguiente tabla:
Fabricante
Futaba
Dong Yang
Hobico
Hitec
JR
Airtronics
Fleet
Krafr
E-Sky
Hobbyking
Positivo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Rojo
Conectores
Negativo
Negro
Marrón
Negro
Negro
Marrón
Negro
Negro
Negro
Negro
Marrón
Control
Blanco
Naranja
Amarillo
Amarillo
Naranja
Naranja
Blanco
Naranja
Blanco
Naranja
El potenciómetro del sistema de control del servo es un potenciómetro de menos de una vuelta, de
modo que no puede dar giros completos en un mismo sentido. Para evitar que el motor pudiera
dañar el potenciómetro, el fabricante del servo añade una pequeña pestaña en la caja reductora del
motor, que impide que éste gire más de lo debido. Es por ello que los servos tienen una cantidad
limitada de giro, y no pueden girar continuamente en un mismo sentido. Es posible, sin embargo,
realizar modificaciones al servo de modo que esta limitación se elimine, a costa de perder el control
de posición.
Hay dos tipos de modificación realizables:
1) La completa eliminación del sistema de control del circuito, para conservar únicamente el
motor de corriente continua y el sistema de engranajes reductores. Con esto se obtiene
simplemente un motor de corriente continua con caja reductora en un mismo
empaquetado, útil para aplicaciones donde no se necesite del control de posición
incorporado del servo.
2) Cambio en el sistema de control, de modo que se obtenga un sistema de control de
velocidad. Para ello, se desacopla el potenciómetro de realimentación del eje del motor, y
se hace que permanezca estático en una misma posición. Así, la señal de error del sistema
de control dependerá directamente del valor deseado que se ajuste (que seguirá
indicándose mediante pulsos de duración variable). Ambos tipos de modificación requieren
que se elimine físicamente la pestaña limitadora de la caja reductora.
32
Control del Servomotor con Arduino.
1) Controlamos un servo para que se mueva +/- 180°, a travez de un lazo for:
#include <Servo.h>
Servo servo1;
int scontrol = 9;
int pos = 0;
// librería de Arduino para manejar servos
// crea un objeto tipo servo1
// se pueden crear hasta 8 servos, o sea manejar este número de
// actuadores
// salida de la señal al cable de control
// variable para almacenar la posición del servo
void setup()
{
servo1.attach (scontrol); // ajusta la salida del servo al objeto
}
void loop()
{
for (pos = 0; pos < 180; pos += 1) // posiciona la servo de 0 a 180° en pasos de 1°
{
servo1.write (pos);
// le indica al servo ir a la posición indicada por pos
delay (15);
// 15ms para que el servo se ubique
}
for (pos = 180; pos>=1; pos-=1) // posiciona al servo de 180° a 0°
{
servo1.write (pos);
// le indica al servo ir a la posición indicada por pos
delay (15);
// 15ms para que el servo se ubique
}
}
2) Controlamos la posición de un servo a través de un potenciómetro:
33
#include <Servo.h>
// librería de Arduino para manejar servos
Servo servo2;
// crea un objeto tipo servo1
int scontrol = 9;
int potpin = 0;
int potval;
// salida de la señal al cable de control
// pin al que se conecta la señal del potenciómetro
// valor de la señal del potenciometro
void setup()
{
myservo.attach(scontrol); // ajusta la salida del servo al objeto
}
void loop()
{
potval = analogRead(potpin);
// lee el valor del potenciómetro (0 a 1023)
potval = map(potval, 0, 1023, 0, 179); // escala al valor del ángulo del servo (0° a 180°)
myservo.write(potval);
// le indica al servo ir a la posición indicada por potval escalada
delay(15);
// 15ms para que el servo se ubique
}
34
Motor de pasos.
Los motores paso a paso se pueden ver como motores eléctricos sin escobillas. Es típico que todos
los bobinados del motor sean parte del estator, y el rotor puede ser un imán permanente o, en el
caso de los motores de reluctancia variable, un cilindro sólido con un mecanizado en forma de
dientes (similar a un engranaje), construido con un material magnéticamente "blando" (como el
hierro dulce).
La conmutación se debe manejar de manera externa con un controlador electrónico y, típicamente,
los motores y sus controladores se diseñan de manera que el motor se pueda mantener en una
posición fija y también para que se lo pueda hacer girar en un sentido y en el otro.
La mayoría de los motores paso a paso conocidos se pueden hacer avanzar a frecuencias de audio,
lo que les permite girar muy velozmente. Con un controlador apropiado, se los puede hacer arrancar
y detenerse en un instante en posiciones controladas.
Los motores paso a paso tienen un comportamiento del todo diferente al de los motores de
corriente continua. En primer lugar, no giran libremente por sí mismos. Los motores paso a paso,
como lo indica su nombre, avanzan girando por pequeños pasos. También difieren de los motores
de CC en la relación entre velocidad y torque (un parámetro que también es llamado "par motor" y
"par de giro"). Los motores de CC no son buenos para ofrecer un buen torque a baja velocidad sin
la ayuda de un mecanismo de reducción. Los motores paso a paso, en cambio, trabajan de manera
opuesta: su mayor capacidad de torque se produce a baja velocidad.
Los motores paso a paso tienen una característica adicional: el torque de detención (que se puede
ver mencionado también como "par de detención", e incluso par/torque "de mantenimiento"), que
no existe en los motores de CC. El torque de detención hace que un motor paso a paso se mantenga
firmemente en su posición cuando no está girando. Esta característica es muy útil cuando el motor
deja de moverse y, mientras está detenido, la fuerza de carga permanece aplicada a su eje. Se
elimina así la necesidad de un mecanismo de freno.
35
Si bien es cierto que los motores paso a paso funcionan controlados por un pulso de avance, el
control de un motor paso a paso no se realiza aplicando en directo este pulso eléctrico que lo hace
avanzar. Estos motores tienen varios bobinados que, para producir el avance de ese paso, deben
ser alimentados en una adecuada secuencia. Si se invierte el orden de esta secuencia, se logra que
el motor gire en sentido opuesto. Si los pulsos de alimentación no se proveen en el orden correcto,
el motor no se moverá apropiadamente. Puede ser que zumbe y no se mueva, o puede ser que gire,
pero de una manera tosca e irregular.
Esto significa que hacer girar un motor paso a paso no es tan simple como hacerlo con un motor de
corriente continua, al que se le entrega una corriente y listo. Se requiere un circuito de control, que
será el responsable de convertir las señales de avance de un paso y sentido de giro en la necesaria
secuencia de energización de los bobinados.
Un motor paso a paso se define por estos parámetros básicos:
Voltaje: Los motores paso a paso tienen una tensión eléctrica de trabajo. Este valor viene
impreso en su carcasa o por lo menos se especifica en su hoja de datos. Algunas veces puede
ser necesario aplicar un voltaje superior para lograr que un determinado motor cumpla con
el torque deseado, pero esto producirá un calentamiento excesivo y/o acortará la vida útil
del motor.
Resistencia eléctrica: Otra característica de un motor paso a paso es la resistencia de los
bobinados. Esta resistencia determinará la corriente que consumirá el motor, y su valor
afecta la curva de torque del motor y su velocidad máxima de operación.
Grados por paso: Generalmente, este es el factor más importante al elegir un motor paso a
paso para un uso determinado. Este factor define la cantidad de grados que rotará el eje
para cada paso completo. Una operación de medio-paso o semi-paso (half step) del motor
duplicará la cantidad de pasos por revolución al reducir la cantidad de grados por paso.
Cuando el valor de grados por paso no está indicado en el motor, es posible contar a mano
la cantidad de pasos por vuelta, haciendo girar el motor y sintiendo por el tacto cada
"diente" magnético. Los grados por paso se calculan dividiendo 360 (una vuelta completa)
por la cantidad de pasos que se contaron. Las cantidades más comunes de grados por paso
son: 0,72°, 1,8°, 3,6°, 7,5°, 15° y hasta 90°. A este valor de grados por paso usualmente se le
llama la resolución del motor. En el caso de que un motor no indique los grados por paso en
su carcasa, pero sí la cantidad de pasos por revolución, al dividir 360 por ese valor se obtiene
la cantidad de grados por paso. Un motor de 200 pasos por vuelta, por ejemplo, tendrá una
resolución de 1,8° por paso.
Los motores paso a paso se dividen en dos categorías principales: de imán permanente y de
reluctancia variable. También existe una combinación de ambos, a los que se les llama híbridos.
Los de imán permanente son los que más conocemos, utilizados, por ejemplo, en el avance de papel
y del cabezal de impresión de las impresoras, en el movimiento del cabezal de las disketteras, etc.
Como su nombre indica, poseen un imán que aporta el campo magnético para la operación.
36
Los motores del tipo de reluctancia variable, en cambio, poseen un rotor de hierro dulce que en
condiciones de excitación del estator, y bajo la acción de su campo magnético, ofrece menor
resistencia a ser atravesado por su flujo en la posición de equilibrio. Su mecanización es similar a los
de imán permanente y su principal inconveniente radica en que en condiciones de reposo (sin
excitación) el rotor queda en libertad de girar y, por lo tanto, su posicionamiento de régimen de
carga dependerá de su inercia y no será posible predecir el punto exacto de reposo. El tipo de motor
de reluctancia variable consiste en un rotor y un estator cada uno con un número diferente de
dientes. Ya que el rotor no dispone de un imán permanente, gira libremente si no tiene corriente
alimentándolo, o sea que no tiene torque de detención.
Los motores híbridos combinan las mejores características de los de reluctancia variable y de imán
permanente. Se construyen con estatores multidentados y un rotor de imán permanente. Los
motores híbridos estándar tienen 200 dientes en el rotor y giran en pasos de 1,8 grados. Existen
motores híbridos con configuraciones de 0,9° y 3,6°. Dado que poseen alto torque estático y
dinámico y se mueven a muy altas velocidades de pulso, se los utiliza en una amplia variedad de
aplicaciones industriales.
Motores paso a paso de imán permanente.
Los motores paso a paso de imán permanente se dividen a su vez en distintos tipos, diferenciados
por el tipo de bobinado. Existen entonces motores paso a paso de imán permanente unipolares
(también llamados "unifilares"), bipolares (también llamados "bifilares") y multifase.
Cada uno de estos tipos requerirá un diferente circuito de control.
Motores paso a paso unipolares.
Los motores unipolares son relativamente fáciles de controlar, gracias a que poseen devanados
duplicados. Aunque para facilitar el esquema se dibuja este devanado como una bobina con punto
medio, en realidad tienen dos bobinas en cada eje del estator, que están unidas por extremos
opuestos, de tal modo que al ser alimentada una u otra, generan cada una un campo magnético
inverso al de la otra. Nunca se energizan juntas: por eso lo correcto es decir que tienen una doble
bobina, en lugar de decir (como se hace habitualmente) que es una bobina con punto medio. Esta
duplicación se hace para facilitar el diseño del circuito de manejo, ya que permite el uso, en la parte
de potencia, de un transistor único por cada uno de los bobinados.
El bobinado de un motor unipolar es el que se indica en la siguiente figura:
37
En el esquema más común de conexión se unen los "puntos medios" de ambos ejes (a y b en el
dibujo) y se les conecta al positivo de la alimentación del motor. El circuito de control de potencia,
entonces, se limita a poner a masa los bobinados de manera secuencial.
El circuito de control de las bobinas de un motor de pasos lo podemos realizar mediante transistores
así:
Para lograr más fuerza la secuencia es:
Y para obtener medio paso la secuencia es:
38
La secuencia de pulsos de un motor unipolar se puede controlar con un contador binario de dos bits
con un decodificador, como por ejemplo el integrado CD 4017. La parte de potencia puede ser
implementada con un único transistor en cada bobinado. El circuito de control es:
Motores paso a paso bipolares.
Los motores bipolares requieren circuitos de control y de potencia más complejos. Pero en la
actualidad esto no es problema, ya que estos circuitos se suelen implementar en un integrado, que
soluciona esta complejidad en un solo componente. Como mucho se deben agregar algunos
componentes de potencia, como transistores y diodos para las contracorrientes, aunque esto no es
necesario en motores pequeños y medianos.
Como no tienen el doble bobinado de los unipolares (recordemos que en éstos todo el tiempo se
está utilizando sólo una de las bobinas duplicadas, mientras la otra queda desactivada y sin ninguna
utilidad), los motores bipolares ofrecen una mejor relación entre torque y tamaño/peso.
El bobinado de un motor bipolar es el que se indica en la siguiente figura:
39
La configuración de los motores bipolares requiere que las bobinas reciban corriente en uno y otro
sentido, y no solamente un encendido-apagado como en los unipolares. Esto hace necesario el uso
de un Puente H (un circuito compuesto por al menos seis transistores) sobre cada uno de los
bobinados. La secuencia de pulsos para un motor bipolar es:
El que sigue es un circuito de ejemplo para el manejo de una de las bobinas (se necesita otro igual
para manejar un motor completo). Para más detalles en el funcionamiento de un circuito como este,
véase nuestro artículo Puente H:
Motores paso a paso de reluctancia variable.
Los motores de reluctancia variable son los motores paso a paso más simples de manejar. Su
secuencia se limita a activar cada bobinado en orden, como lo indica la figura. Es común que estos
motores tengan un cable común que une todas las bobinas. Estos motores, si se los mueven a
mano, no tienen la sensación "dentada" de los otros motores paso a paso, sino que se mueven
libres, como los motores de corriente continua.
40
Control de posicionado de un motor de pasos con ayuda de un potenciómetro en Arduino.
El esquema de conexiones para un motor unipolar de 6 cables es:
Esquemáticamente tenemos:
Para poder controlar el motor de pasos, requerimos de un elemento adicional, el circuito
integrado ULN2004A, que es un arreglo de transistores Darlington, para alta corriente y alto
voltaje, cuyo diagrama de componentes es el siguiente:
Las conexiones para un motor bipolar de cuatro cables es:
41
Esquemáticamente tenemos:
En este caso necesitamos el circuito integrado SN75441, que es un puente H, como nos indica el
siguiente esquema:
#include <Stepper.h>
42
#define PASOS 100
// número de pasos del motor
Stepper stepper(PASOS, 8, 9, 10, 11); // se crea el objeto stepper y se asigna las conexiones al
circuito
// de control a través de los pines 8,9,10,11
int prev = 0;
//variable que almacena la lectura previa del pot.
int potpin = 0;
// dirección del potenciómetro
int val = 0;
// almacena el valor del potenciómetro.
int velocidad = 30;
// velocidad del motor de pasos
void setup()
{
stepper.setSpeed(velocidad);
}
// asigna la velocidad
void loop()
{
val = analogRead(potpin); // leemos el potenciómetro
stepper.step(val - prev); // movemos un numero de pasos igual a la diferencia de valor del pot.
prev = val;
// almacena el valor previo del motor.
}
Display numérico de matriz de puntos LCD.
Los Display LCD son visualizadores pasivos, esto significa que no emiten luz como el visualizador o
display alfanumérico hecho a base de un arreglo de diodos LEDs.
Muchas aplicaciones requieren mostrar datos de diversas formas. Para ello se puede emplear
fácilmente un display LCD. Estos módulos son la solución ideal en los casos donde se desea mostrar
menús, respuestas a determinadas secuencias de comandos o control, para lo cual el hardware de
control se resume en un par de teclas del tipo cursor. También son muy útiles en sistemas de
mediciones múltiples y simultáneas, donde de otra forma habría que emplear cantidades de
decodificadores BCD y transistores para comandar dispositivos de 7 segmentos convencionales.
Los display alfanuméricos de matriz de puntos, se caracterizan normalmente por el número de filas
y columnas para cada matriz de puntos que lo caracterizan. De ahí que un display de 2 x 16 quiere
decir que puede desplegar 32 caracteres ubicados en dos filas de 16 caracteres por fila, como el que
se muestra en el dibujo anterior.
43
Estos dispositivos vienen gobernados por un microcontrolador, que normalmente va incorporado
sobre la misma placa de circuito impreso que soporta el LCD, en la parte de atrás, como se indica a
continuación:
En el mercado es muy habitual encontrarse con el controlador HD44780 de Hitachi, o afín que se
describe a continuación. El controlador se encarga de la operación del display, desde el punto de
vista físico: polarizar los puntos de la pantalla, generar los caracteres, desplazar la pantalla, mover
el cursor, etc. El usuario necesita simplemente conocer un grupo de instrucciones de alto nivel que
le permitirán limpiar la pantalla, posicionar el cursor, etc., con la finalidad de mostrar textos o
gráficos en la pantalla, de acuerdo a su necesidad. Para comunicarse con el controlador del display
se dispone de un interfaz paralelo al exterior, de fácil conexión a otros microcontroladores o
microprocesadores.
Los caracteres que se pueden representar están formados por una matriz de puntos que vienen
almacenados en memoria ROM dentro del propio controlador. El fabricante reserva una pequeña
zona de memoria RAM donde se pueden definir algunos caracteres especiales, como por ejemplo
la letra ñ que no suele venir, o si se desean, pequeños gráficos.
La conexión del módulo LCD y el circuito que lo utiliza puede realizarse por medio de un cable plano
de 14 hilos, similar al que se emplea en las disketteras o discos duros. Admitiéndose que el display
está conformado por un controlador del tipo HD44780, de la japonesa Hitachi o similar.
Lamentablemente la disposición de los terminales en el LCD aún no están normalizadas, por lo que
el para el montaje se deberá conseguir la hoja de datos al momento de comprar el display y así
poder usarlo. Si bien los terminales no son normalizados, los tipos de señal manejados por ellos son
casi estándar, no presentándose mayor diferencia entre cada uno de ellos. Puede variar uno que
otro comando, pero no el cableado del módulo en lo que a señales se refiere.
Los pines del display son:
PIN
1
2
3
4
5
6
7
Símbolo
VSS
VCC
VEE
RS
R/W
E
DB0
E/S
E
E
E
E/S
Función
0 V (Tierra)
+5V ± 0.25 V (Tensión de alimentación positiva)
Tensión negativa para el contraste de la pantalla.
Selector de dato/instrucción
Selector de Lectura/Escritura
Habilitación del modulo
Dato E/S
44
8
9
10
11
12
13
14
15
16
DB1
DB2
DB3
DB4
DB5
DB6
DB7
LED+
LED-
E/S
E/S
E/S
E/S
E/S
E/S
E/S
E
E
Dato E/S
Dato E/S
Dato E/S
Dato E/S
Dato E/S
Dato E/S
Dato E/S
Encendido del LED de iluminación
Apagado del LED de iluminación
Para sincronizar la velocidad de trabajo del controlador interno con las posibles velocidades de los
sistemas de control a los cuales puede ser conectado, los módulos multi-matrix disponen de dos
registros que pueden ser accedidos por los µC ó µP externos.
Los registros internos de instrucciones (RI) y los de datos (RD) almacenan temporalmente la
información de control y la que deberá mostrarse para poder adecuar los procesos a los tiempos
que la tecnología LCD requiere.
En condiciones de uso normal, las instrucciones más empleadas son las de transferencia con la RAM
interna, las que envían datos al display. Pero como el contador interno incrementa
automáticamente (o decrementa) en una unidad la dirección de la RAM posteriormente a cada
instrucción de escritura de datos, el número final de instrucciones del programa se ve reducido a un
pequeño grupo.
Durante cada operación interna del µC, el bit 7 permanece activo (estado alto), esto es usado
entonces como busy flag ó bandera de ocupado. Asimismo, cuando se desee una velocidad de
operación alta, alrededor de 50KHz, el estado de este bit o bandera deberá ser constantemente
monitorizado, a fin de mantener la sincronización de los sistemas sin pérdida de datos.
Juegos de instrucciones.
Instrucción
Código de Operación
Descripción
Tiempo de
Ejecución
RS R/W B7 B6 B5 B4
B3
B2
B1
B0
Clear display
0
0
0
0
0
0
0
0
0
1
Borra el contenido de la pantalla y retorna el
cursor a la posición “home” (dirección 0).
1.52 ms
Cursor home
0
0
0
0
0
0
0
0
1
x
Retorna el cursor a la posición “Home”. Retorna
también el área de visión a la posición inicial. El
contenido de la DDRAM permanece intacto.
1.52 ms
Entry mode set
0
0
0
0
0
0
0
1
I/D
S
Incrementar/Decrementar dirección (I/D);
Habilitar corrimiento de pantalla (S). Estas
operaciones se realizan al leer o escribir datos
37 μs
Display on/off
control
0
0
0
0
0
0
1
D
C
B
Enciende o apaga el display (D), Cursor encendido
/ apagado (C), destello del cursor (blink) (B).
37 μs
37 μs
37 μs
Cursor/display shift
0
0
0
0
0
1
S/C
R/L
x
x
Selecciona entre desplazamiento de pantalla o de
cursor (S/C), selecciona la dirección de
desplazamiento (R/L). El contenido de la DDRAM
permanece intacto.
Function set
0
0
0
0
1
DL
N
F
x
x
Configurar en ancho de bus (4 u 8 bits) (DL),
Numero de líneas de display (N), y tipo de fuente
(F).
45
Set CGRAM address
0
0
0
Set DDRAM address
0
0
1
1
CGRAM address
DDRAM address
Escribe la dirección de CGRAM. Los datos a
almacenar en CGRAM pueden ser enviados
después de esta instrucción
37 μs
Escribe la dirección de DDRAM. Los datos a
almacenar en DDRAM pueden ser enviados
después de esta instrucción
37 μs
Leer bandera “Ocupado” (Bussy Flag) indicando si
el controlador está realizando alguna operación
interna o está listo para aceptar datos/comandos.
Lee la dirección CGRAM o DDRAM (dependiendo
de la instrucción previa).
0 μs
Read busy flag
&address counter
0
1
Write CGRAM
orDDRAM
1
0
Write Data
Escribe datos a las memorias CGRAM o DDRAM.
37 μs
Read from
CG/DDRAM
1
1
Read Data
Lee datos desde las memorias CGRAM o DDRAM.
37 μs
BF
CGRAM/DDRAM address
Nombres y significado de bits en instrucciones
I/D
0 = disminuir el contador de dirección
1 = incrementar el contador de dirección
S
0 = Sin corrimiento de display
1 = Con corrimiento de display
D
0 = Display Apagado
1 = Display Encendido;
C
0 = Cursor Apagado
1 = Cursor Encendido
B
0 = Parpadeo cursor Apagado
1 = Parpadeo Cursor Encendido
S/C
0 = Mover Cursor
1 = Corrimiento de pantalla
R/L
0 = Mover/Correr a la izquierda
1 = Mover/Correr a la derecha
DL
0 = Interfaz de 4 bits
1 = Interfaz de 8 bits
N
0 = 1 línea
1 =2 líneas
F
0 = 5×8 puntos
1 =5×10 puntos
BF
0 = puede aceptar instrucción
1 = operación interna en progreso
X
No importa el valor
Cuando se envía un carácter ASCII, como por ejemplo el “A”, al módulo LCD, el controlador HD44780
busca en la memoria CGROM (no la CGRAM) interna el patrón que le corresponde y lo muestra en
la pantalla. La CGROM contiene 192 mapas de bits correspondientes al alfabeto, números, signos
de puntuación, caracteres japoneses Kanji, símbolos griegos y otros. La CGRAM es parte del
controlador HD44780 y no puede ser alterada o reprogramada por el usuario. No se pueden
modificar píxeles individuales en el LCD, tan sólo caracteres completos identificados por un código
ASCII.
46
Escribiendo texto en un display con Arduino.
Esquemáticamente seria:
Con el mismo circuito podemos realizar varios programas. El primer programa simplemente
despliega un texto en la pantalla y el segundo desplaza texto en la pantalla.
Primer programa:
#include <LiquidCrystal.h>
// Liberia para manejo de LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
// Creamos el objeto lcd con los pines de conexión como datos
47
void setup()
{
lcd.begin(16, 2);
lcd.print("hola a todos!");
}
//Configuramos el número de filas y columnas
// Presentamos el mensaje
void loop()
{
lcd.setCursor(0, 1); // Ubicamos el cursor en la línea 1, columna 0 (segunda linea)
lcd.print(millis()/1000); //Imprimimos los milisegundos de operación
}
Segundo programa:
#include <LiquidCrystal.h>
// Liberia para manejo de LCD
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
void setup()
{
lcd.begin(16, 2);
lcd.print("hola a todos!");
delay(1000);
}
// Creamos el objeto lcd con los pines de conexión como datos
//Configuramos el número de filas y columnas
// Presentamos el mensaje
void loop()
{
// recorremos todas las columnas de la pantalla desde la izquierda
for (int i = 0; i < 13; i++)
{
lcd.scrollDisplayLeft();
delay(150);
}
// recorremos 29 posiciones (número de caracteres + columnas del display) hacia la derecha
// para mover fuera de pantalla a la derecha
for (int i = 0; i< 29; i++)
{
lcd.scrollDisplayRight();
delay(150);
}
// movemos 16 posiciones scroll 16 positions (número de caracteres + columnas del display) hacia
// la izquierda para mover de Nuevo al centro)to the left
for (int i = 0; i < 16; i++)
{
lcd.scrollDisplayLeft();
delay (150);
}
48
delay (1000);
}
49