3.- ANALÓGICO CON
ARDUINO
INDICE:
0.- TEORÍA: SEÑALES ANALÓGICAS. EL MAPEADO. EJERCICIOS.
- CIRCUITO SERIE vs PARALELO.
- MONITORIZACIÓN LED-POTENCIÓMETRO.
- UN LED Y SU UMBRAL DE FUNCIONAMIENTO.
- EL COCHE FANTÁSTICO Y SU VARIACIÓN CON POTENCIÓMETRO.
0.-TEORÍA:"LAS SEÑALES ANALÓGICAS"
LOS SENSORES
Los sensores son dispositivos que captan del mundo real las variaciones de una magnitud física y las convierte en variaciones de una magnitud eléctrica (resistencia, tensión o intensidad eléctrica).
Son como los cinco sentidos de nuestro cuerpo (vista, olfato, tacto y gusto) pero adaptados a una magnitud físca específica: luz, presión, velocidad, distancia, temperatura, humedad, etc.
En el mundo digital, sólo hay dos posibles estados, el 0 o el 1 (encendido o apagado). Sin embargo, en el mundo real nos encontramos magnitudes físicas que presentan múltiples valores. Piensa por ejemplo en la temperatura de una habitación. Un sensor que mida la temperatura nos dará varias tensiones eléctricas proporcionales a los cambios de temperatura que le corresponden.
Nuestra placa de arduino no puede trabajar directamente con tensiones analógicas, por lo que tiene que convertirlas a un valor digital mediante unos circuitos llamados CONVERTIDORES ADC (analogico-digital convertidor) conectados a las entradas analógicas de nuestra placa A0,A1, ....A5.
La mayoría de las magnitudes físicas analógicas (temperatura, luz, posición, velocidad) varían lentamente en el tiempo,por lo que la frecuencia de muestreo de arduino de 100 microsenguntos es más que suficiente para que la señal digital se parezca a la señal analógica en el tiempo.
ENTRADAS ANALÓGICAS EN ARDUINO:
Recordemos que en DIGITAL utilizábamos la instrucción: digitalRead(pin); en cualquiera de los pines digitales de arduino que previamente habíamos configurado como puerto de entrada: pinMode(pin,INPUT);Ahora en analógico tenemos unos pines específicos que funcionan exclusivamente como analógicos:
A0, A1, A2, A3, A4, A5
Aunque sean puertos exclusivamente de entrada, seguiremos con la buena constumbre de seguir definiendolos previamente como pines de entrada:
pinMode(pin, INPUT);
analogRead(pin);
"LA RESOLUCIÓN"
Todos los ordenadores trabajan en digital, por lo que la entrada de nuestro sensor analógico debe ser convertida a digital para ser procesado por nuestro procesador. Esta labor la hace el convertidor analógico digital DAC que en nuestro arduino tiene una resolución de 10 bits, es decir, que oscila en la escala de entre el 0 y el 1023 correspondientes a 2^10.
Además como estamos trabajando con valores de entrada, estos debemos guardarlos en alguna variable, previamente definida para poder trabajar con ellas a posteiori.
valor= analogRead(A0); //valor entre 0 y 1023
De esta forma, culquier señal analógica se somete a una escala que va de 0 a 5v, es decir, de 0 a 1024 bits con un valor discreto mínimo de 5mV.
Así, si por ejemplo usamos un sensor de temperatura que tuviera un rango medible de 0ºC a 70ºC, su resolución en la entrada digital que produciría en arduino sería la siguiente:
Así, si por ejemplo usamos un sensor de temperatura que tuviera un rango medible de 0ºC a 70ºC, su resolución en la entrada digital que produciría en arduino sería la siguiente:
00.00ºC-00.06ºC = 0.00 mV = 0 decimal = 00 0000 0000 binario
00.07ºC-00.13ºC = 0.05 mV = 1 decimal = 00 0000 0001 binario
00.14ºC-00.27ºC = 0.10 mV = 2 decimal = 00 0000 0010 binario
00.28ºC-00.33ºC = 0.15 mV = 3 decimal = 00 0000 0011 binario
...
35.00ºC-35.06ºC = 2.5 mV = 512 decimal = 10 0000 0000 binario
...
69.93ºC-70.00ºC = 5 mV = 1023 decimal = 11 1111 1111 binario
En arduino podemos utilizar algunos pines digitales como salidas analógicas, estas son aquellas que están serigrafiadas con el símbolo ~:
~3, ~5, ~6, ~9, ~10, ~11
Para mandar una señal analógica a estos pines se utiliza la técnica conocida como MODULACIÓN DE ANCHO DE PULSO (PWM).
El valor que que mandamos como salida es el correspondiente a una onda cuadrada de valor comprendido entre 0 voltios y 5 voltios. Para decir qué tensión queremos usamos una relación lineal con los valores comprendidos entre [0,255], mediante la instrucción:
analogWrite(pin, valor); //valor entre 0 y 255
Arduino manda al puerto de salida analógio una onda cuadrada de dos únicos valores discretos 0 y 5 voltios.
En este caso "valor" actua como modulador del ancho de pulso de esta onda cuadrada.
Si el dato de salida valor=255, modulamos de forma constante la onda a su valor máximo y si damos el valor=0 entonces la onda mantendrá el valor 0 de una forma constante.
Pero si ponemos:
a) Valor=128 entonces la onda cuadrada estará el 50%, es decir, la mitad de su ciclo en alto (5voltios) y la otra mitad a 0voltios. Lo que equivaldría a una media de 2.50Voltios. Esto es así porque 256/128=2, es decir, la mitad).
a) Valor=64, es decir 256/64= 4, una cuarta parte del total posible, entonces Arduino mantendrá la salida digital en HIGH un 25% del tiempo respecto al tiempo que mantendrá en LOW. Lo que vendría a ser una cuarta parte de 5voltios, es decir, 1.25Voltios
b) Valor= 192. En este caso es equivalente al 75% con el pulso en HIGH. 3.75Voltios.
EL MAPEADO EN ARDUINO:
Cuando queremos sacar directamente una valor que hemos leído en la entrada anlógica por la salida analógica de arduino y dado que trabajan a distinta escalas debemos hacer una relación lienal entre ellas utilizando la siguiente instrucción:
ValorSalida= map(ValorEntrada,0,1023,0,255);
En ocasiones, en vez de utilizar esta instrucción, lo que se hace es usar un simple cálculo que proporciona esta dos escalas que como se puede ver es de un cuarto.
valor=analogRead(pinA0);
valor/=4; // o en su lugar se usa la instrucción valor=map(valor,0,1023,0,255)
analogWrite(pin5,valor);
EJERCICIOS DE MAPEADO:
1º.- Entrada analógica PIN_A0 y mapeado para su posterior salida analógica en un LED PIN11. (en este caso si no ponemos ningún sensor en el pinA0, los valores que Arduino cogerá serán aleatorios).
int pinLed = 11; //pin con PWM
int pinAnalog = 0;
int ValorLeido; //variable para el pin A0
int ValorConvertido; //varaible para conversión de escala
void setup() {
Serial.begin(9600);
}
void loop() {
ValorLeido = analogRead(pinAnalog);
ValorConvertido=map(ValorLeido,0,1023,0,255);
analogWrite(pinLed, ValorConvertido);
Serial.print("El valor leido es: ");
Serial.println(ValorLeido);
Serial.print("El valor convertido es:");
Serial.println(ValorConvertido);
Serial.println();
delay(2000);
}
2º.- "FADE": Incremento y decremento del brillo de un LED mediante la modulación de onda de salida (PWM).
int ledPin=11; //pin con PWM
int i=0;
void setup() { }
void loop() {
for (int i=0; i<=255; i+=20) {
analogWrite(ledPin,i); //incremento brillo según "i"
delay(100);
}
for (int i=255; i>=0; i-=20) {
analogWrite(ledPin,i); //decremento según "i"
delay(100);
}
}
3º.- "FADE": Incremento y decremento del brillo de un LED mediante una variable "incremento".
int PINLED=11; //pin en salida PWM
int INCREMENTO=5;
int BRILLO=0;
void setup() {
pinMode (PINLED,OUTPUT);
}
void loop(){
analogWrite(PINLED,BRILLO);
BRILLO=BRILLO+INCREMENTO; //incremento de 5 en 5
if BRILLO==0 || BRILLO=255 { //cuando llegamos a los límites
INCREMENTO=-INCREMENTO; //hacemos -5 y decrementamos
}
delay(50); //damos un tiempo para apreciar el cambio
}
1.- CIRCUITOS SERIE vs PARALELO.
1.1.- RESISTENCIAS EN SERIE.
Montaje serie de dos resistencias en una entrada analógica y un led en una salida analógica.
Elige dos resistencias de cualquier valor para los montajes en serie pero procura que sean de valores muy distintos. Para ello utiliza la tabla con los códigos de colores o bien mide los valores directamente con un polímetro (medida de ohmios). Carga el programa y coloca un cable en la patilla 2 analógica y otra a 5V.
Usa la protoboard para intercalar, entre los extremos del cable, las resistencias que elegiste y prueba distintas combinaciones en serie quitando y poniendo resistencias. Debes observar que la luminosidad del led varía.
CÓDIGO:
pinMode(3,OUTPUT); //conectamos el led en el pin3~ PWM
pinMode(A2,INPUT); //conectarmos las dos resistencias en serie, entre 5v y el pinA2
int valor=0;
void setup() {
}
void loop() {
valor=analogRead(A2)/4; //ajustamos el valor entre 0 y 255.
analogWrite(3, valor);
}
ACTIVIDADES:
1.- ¿Cómo afecta el valor de las resistencias en serie a la iluminosidad de un LED? Según la ley de Ohm, cuanto mayor sea el valor de la resistencia eléctrica, menor será el valor de la intensidad que por ella circule. Por tanto, el LED lucirá menos.
2.- Realiza varios cálculos del valor de intensidad de corriente eléctrica de un circuito serie con varios valores resistivos.
1.2.- RESISTENCIAS EN PARALELO
Montaje de dos resistencias en paralelo en una entrada analógica y un led en una salida analógica.
Este ejercicio es similar al anterior, puedes usar las mismas resistencias y el mismo programa.
Une ahora uno de los extremos de las resistencias conectadas en paralelo al pin 2 analógico y el otro extremo a +5V. Prueba a quitar alguna de las resistencias y obtén conclusiones de lo que ocurre.
1.3.- EL POTENCIOMETRO.
Ahora montaremos un potenciómentro en el pin analógico A3 para controlar de forma variable el tiempo de parpadeo de un led conectado en el la salida digital Pin13.
CÓDIGO CON SALIDA DIGITAL
int pinPot=5; // pin de entrada analógica A5 para el potenciómetro
int valorPot=0; //asignamos inicialmente el valor de 0 al potenciómentro
int pinLed =13; // pin digital de salida para el LED
void setup() {
pinMode (13, OUTPUT); // declara el pin13 digital como salida
pinMode(A5, INPUT); //declara la entrada analógica como entrada
}
void loop( ) {
digitalWrite (pinLed,HIGH); //encendemos el led
pinMode (13, OUTPUT); // declara el pin13 digital como salida
pinMode(A5, INPUT); //declara la entrada analógica como entrada
}
void loop( ) {
digitalWrite (pinLed,HIGH); //encendemos el led
valorPot= analogRead (pinPot);
delay (valorPot); // tiempo de espera variable según el potenciómetro
delay (valorPot); // tiempo de espera variable según el potenciómetro
digitalWrite(pinLed,LOW); //apagamos el led
delay (analogRead (pinPot)); // vuelve a esperar
}
OTRA FORMA DE CÓDIGO
En esta ocasión variaremos el brillo del led conectado en una salida analógica PWM y el potenciómentro nos dará una tiempo de espera variables.
int ledPin = 9; // Salida analógica PWM para conectar el led
int analogPin = 5; // resistencia variable para el poteniómentro A5
void setup( ){ } // no es necesario configurar entradas y salidas
void loop() {
for (int i=0; i<=255; i++) { // incremento de valor de i
analogWrite(ledPin, i); // configura el nivel brillo con el valor de i
delay(delayVal()); // espera un tiempo
}
for (int i=255; i>=0; i--) { // decrementa el valor de i
analogWrite(ledPin, i); // configura el nivel de brillo con el valor de i
delay(delayVal()); // espera un tiempo
}
}
int delayVal() { //declaramos un función de retardo de tiempo variable
int v; // crea una variable local para controlar el tiempo
v = analogRead(analogPin); // lee valor analógico
v /= 4; // convierte el valor leído de 0-1024 a 0-256
return v; // devuelve el valor v
}
2.- LED+POT.: Brillo y Monitorización.
Montaremos un potenciómetro en la entrada analógica A0 y un led en la salida analógica pin11.
En
esta práctica montaremos un led en una salida analógica de tal forma
que su salida no será sólo la de encencido (5voltios) o apagado
(0voltios) sino que presentará valores intermedios.
Para modificar
los distintos valores de luminosidad intermedios utilizaremos un
potenciómetro en una de las entradas analógicas.
Debemos tener en
cuenta que al utilizar el led en una salida analógica, tenemos que
conectarlo a una salida PWM (Pulse WIDTH Modulation).
Los valores
que nos dé el potenciómetro oscilan en el rango de 0 a 1023. Pero, como
en la salida analógica sólo podemos enviar valores entre 0 y 255, no
existe una relación directa de valores entre los obtenidos en el pin de
entrada analógica del potenciómetro y el pin de salida analógica del
led. Para solucionar esta diferencia de escalas usaremos la instrucción
map() con la que convertiremos el rango de valores de entrada entre los
valores que nos hace falta de 0 a 255.
Otra novedad es que en este caso además de declarar variables, vamos a declarar constantes. Para ello, usaremos cons int.
CÓDIGO:
const int pinPot=0; // pin A0 como entrada analógica para el potenciometro
const int pinLed=11; // pin9 de salida analógica del tipo PWM (tren de pulsos)
int valorPot=0; //valor en entrada analógica del potenciometro
int brilloLed=0; //valor de salida de brillo que mandaremos al led
void setup() {
pinMode(pinPot, INPUT); //configuramos este pin como entrada
pinMode(pinLed, OUTPUT); //configuramos este pin como salida
Serial.begin(9600); //habilitamos el puerto serie a 9600baudios
}
void loop() {
valorPot=analogRead(pinPot); //leemos y guardamos el valor del potenciometro
brilloLed=map(valorPot,0,1023,0,255); //mapeamos el valor
analogWrite(pinLed,brilloLed); //damos intensidad al led
Serial.println(brilloLed); //monitorizamos el valor del brillo del led
delay(500); //esperamos 0.5seg y repetimos ciclo
}
En este ejemplo, vemos como monitorizar operaciones o
eventos en Arduino, gracias al Puerto Serie (una técnica que nos permite mandar datos o acciones a otros dispositivos o programas).
3.- LED: SU UMBRAL DE FUNCIONAMIENTO
Vamos a estudiar la curva I-V de un diodo de tal manera que comprobaremos que al aplicar un cierto voltaje el diodo conduce y no conduce (estado en corte) si estamos por debajo de ese voltaje o diferencia de potencial. En el caso específico de un diodo led la diferencia de potencial a superar es de 0,7 V; a partir de ese valor conduce la corriente eléctrica y, por lo tanto, se ilumina.
La descripción de la práctica es la siguiente:
La regulación del potenciómetro provocará una variación de voltaje en el pin de entrada analógico 0 de Arduino. Se realizará una conversión analógica-digital en el que los valores de tensión analógicos entre 0 y 5 V se transforma a un rango discreto de valores de 0 a 1023. Para modificar la intensidad del led rojo le se enviará una señal pseudoanalógica PWM utilizando la salida 5 digital de Arduino. Para ello se enviará un valor de 0 a 255 que marcará el ciclo de trabajo de la onda cuadrada PWM. Previamente habrá que realizar un mapeo (instrucción map) para asignar valores desde el intervalo [0, 1023] al [0, 255].
Copia y carga este código en tu placa Arduino:
float val = 0; void setup(){ Serial.begin(9600); } void loop(){ val = analogRead(A0); //leemos el potenciómetro (0-1024) val = val/204,6; //mapeamos los valores para que sean de 0 a 5V Serial.print (val); //vemos por pantalla el valor en Voltios Serial.println(“V”); delay(1000); }
Conecta la punta de prueba en la patilla 0 de Analog In y otro cable a masa tal y como muestra la imagen. El siguiente paso es hacer este montaje en tu placa protoboard y usar como alimentación los dos cables que pusimos en Arduino. Mira como queda...
Abre el Monitor serial de Arduino y verás el voltaje que está ofreciendo Arduino al montaje que has hecho. Mueve el potenciómetro y verás que el valor va cambiando. Intenta averiguar cual es la tensión umbral a partir de la cual tu led empieza a emitir luz.
Nota: inicialmente la corriente puede ser muy baja por lo que debes fijarte bien cuando empieza a iluminarse.
4.- EL COCHE FANTÁSTICO CON FRECUENICA VARIABLE MEDIANTE UN POTENCIÓMETRO.
Vimos como controlar el parpadeo de un LED en nuestro primer programa. A continuación haremos un ejemplo con varios LEDs donde controlaremos el parpadeo de los mismos (su frecuencia), en cascada (uno después de otro), por medio de un potenciómetro y también un programa en donde seleccionaremos qué LED parpadea separadamente con una frecuencia constante.
En
este programa se lee el valor analógico entre 0[V] – 5[V] que nos
entrega el potenciómetro, arduino traduce este valor a un número entero
entre 0 – 1023 el cual es guardado en la variable frec luego se ejecuta
la función ledSecuense() la cual va encendiendo los 6 LEDs uno después
de otro con la frecuencia antes asignada.
1º. CÓDIGO. "COCHE FANTÁSTICO". Frecuencia de barrido de leds con POT.
#define NLed 5
int led[NLed]={9,10,11,12,13};
int frec = 500;
void setup() {
Serial.begin(9600);
for(int i=9; i <= 13; i++){
pinMode(i,OUTPUT);
Serial.println(i);
}
}
void loop() {
frec = analogRead(A0);
for(int i=0; i <= 5; i++){
digitalWrite(led[i],HIGH);
delay(100);
digitalWrite(led[i-1],LOW);
delay(frec);
}
Serial.println(frec);
}
int led[NLed]={9,10,11,12,13};
int frec = 500;
void setup() {
Serial.begin(9600);
for(int i=9; i <= 13; i++){
pinMode(i,OUTPUT);
Serial.println(i);
}
}
void loop() {
frec = analogRead(A0);
for(int i=0; i <= 5; i++){
digitalWrite(led[i],HIGH);
delay(100);
digitalWrite(led[i-1],LOW);
delay(frec);
}
Serial.println(frec);
}
2º. CÓDIGO PARA SEGÚN POT. SE ENCIEDA UNO U OTRO LED.
Selecciona por medio de un potenciometro el LED a parpadear Arduino
*/
#define maxleds 4 //creamos la variable maxleds de 6 elementos
#define pot A0 //creamos la variable pot con el pin A0
int led[maxleds] = {10,11,12,13}; //creamos un vector para los pines a utilizar
int frec = 500;
void setup () {
Serial.begin(9600);
for (int i=0;i<maxleds;i++) {
pinMode(led[i],OUTPUT); // El pines seran de salida
}
}
void loop() { // se ejecuta siempre como un ciclo
int valor = analogRead(pot); // lee el valor del potenciometro
int i=map(valor, 0, 1023, 10, 13); // Convierte el intervalo 0-1023 a 10-13 equitativamente
digitalWrite(i, HIGH); //led esta encendido
delay(frec); //tiempo de encendido
digitalWrite(i, LOW); //led esta apagado
delay(frec); //tiempo de apagado
Serial.println(i);
}
