Introducción

En esta unidad vamos a aprender cómo funcionan las señales analógicas, a crear una usando un potenciómetro, y a leerla con el conversor analógico-digital de Arduino.

Las señales analógicas

En lecciones anteriores hemos visto cómo funcionan las señales digitales, que son aquellas que pueden tomar dos valores, 0 y 1 (representando valores que normalmente con Arduino serán 0 y 5V).

Además, hay otro tipo de señales, llamadas analógicas. Lo que hace especial a las señales analógicas es que éstas pueden tomar cualquier valor.

El núcleo de Arduino (y de cualquier procesador) funciona puramente en digital. Por suerte, Arduino incluye un dispositivo llamado “conversor de analógico a digital” (ADC, por sus siglas en inglés) que convierte la señal analógica en un número binario para que pueda ser procesada por nuestro programa Arduino.

El ADC de ARDUINO

Arduino tiene 6 pines analógicos, etiquetados de A0 a A5. Todos estos pines están conectados al ADC y pueden leer señales analógicas.

El ADC de Arduino UNO funciona en un rango de 0 a 5V, dividido en 1.024 valores diferentes, de 0 a 1.023, correspondiendo el valor 0 del ADC a 0V, y 1.023 a 5V de señal. Esto quiere decir, por ejemplo, que el ADC leerá 204 cuando la señal de entrada esté a 1V, 408 cuando esté a 2V…

El potenciómetro

El potenciómetro, también conocido como resistencia variable, es un dispositivo que sirve para dividir un voltaje según la posición de una rueda que podemos ajustar manualmente.

En el caso de Arduino vamos a conectar el potenciómetro a 0 y 5V, y vamos a ver cómo ajustando la rueda obtenemos una señal que varía entre esos voltajes. Para ello, vamos a obtener usando la consola serie el valor leído por el ADC según ajustemos la rueda del potenciómetro.

 

Explora

Comprendiendo la lectura analógica con el potenciómetro

Para ver cómo funciona la lectura de una señal analógica y el funcionamiento del potenciómetro, construimos el siguiente circuito conectando los pines exteriores del potenciómetro a 0 y 5V (no importa el orden), y el central al pin A0 de Arduino.

¡Vamos a programar!

Programando un potenciómetro en Arduino IDE

Lo que vamos a hacer es leer el potenciómetro y sacar el valor por el monitor serie.

A diferencia de los pines digitales, los pines analógicos no requieren configuración, por lo que en la función void setup() lo único que necesitamos es inicializar las comunicaciones del monitor serie.

void setup() {
  Serial.begin(9600);  // Inicializa el monitor serie
}

En el bucle principal, función void loop(), enviamos la lectura del potenciómetro (conectado al pin A0) al monitor serie. Al final del bucle se introduce un delay de 1 milisegundo para espaciar las lecturas.

void loop() {
  Serial.println(analogRead(A0));    // Imprime en el monitor serie la lectura del potenciómetro
  delay(1);                          // Espera 1 milisegundo entre lectura y lectura
}

Nuestro sketch ha quedado:

void setup() {
  Serial.begin(9600);  // Inicializa el monitor serie
}
void loop() {
  Serial.println(analogRead(A0));    // Imprime en el monitor serie la lectura del potenciómetro
  delay(1);                          // Espera 1 milisegundo entre lectura y lectura
}

Carga el programa y abre el monitor serie para ver la salida. Mueve la rueda del potenciómetro y observa cómo el valor obtenido en la consola varía en cada iteración del programa.

Usando el potenciómetro para ajustar la frecuencia de parpadeo de un LED

Todos hemos usado un potenciómetro alguna vez en dispositivos que usamos a diario. Podemos encontrarlo en ellos para ajustar el volumen, la sintonización de la radio, la temperatura de un horno, etc.

Ahora que sabemos leer el estado del potenciómetro usando los pines analógicos de Arduino, vamos a utilizarlo para ajustar la frecuencia con la que parpadea un LED.

Construimos este circuito:

Vamos a emplear un LED, por lo que necesitamos inicializar el pin al que lo hemos conectado, yo lo he hecho en el pin 8. Los pines analógicos no requieren configuración, por lo que la función void setup() solo necesita la instrucción que configura el pin digital del LED como salida.

void setup() {
  pinMode(8, OUTPUT);  // Inicializa el pin 8 (LED) como salida
}

En el bucle principal, la frecuencia de parpadeo del LED va a depender de la lectura del potenciómetro. Entonces enciende el LED, y lo mantiene encendido por el valor que ha leído el ADC. Transcurrido ese tiempo, apaga el LED y lo mantiene apagado durante el mismo intervalo, antes de volver a empezar con una nueva lectura del ADC:

void loop() {
  digitalWrite(LED, HIGH);             // Enciende el LED
  delay(analogRead(POTENCIOMETRO););   // El tiempo de espera es el valor del potenciómetro
  digitalWrite(LED, LOW);              // Apaga el LED
  delay(analogRead(POTENCIOMETRO););   // El tiempo de espera es el valor del potenciómetro
}

Nuestro sketch ha quedado:

void setup() {
  pinMode(8, OUTPUT);  // Inicializa el pin 8 (LED) como salida
}

void loop() {
  digitalWrite(LED, HIGH);             // Enciende el LED
  delay(analogRead(POTENCIOMETRO););   // El tiempo de espera es el valor del potenciómetro
  digitalWrite(LED, LOW);              // Apaga el LED
  delay(analogRead(POTENCIOMETRO););   // El tiempo de espera es el valor del potenciómetro
}

Carga el programa y observa lo que ocurre al mover la rueda del potenciómetro.

El sensor de luz LDR

La fotorresistencia LDR (del inglés, Light-Dependent Resistor) es un sensor de luz de tipo resistivo.

Es un tipo de resistencia especial que cambia su valor según la cantidad de luz que incide sobre ella.

Vamos a utilizar este sensor para activar un LED de forma automática cuando detectemos poca luz. Pero antes debemos conocer qué es el divisor de tensión.

Divisor de tensión

Las entradas analógicas de Arduino sirven para medir voltajes entre 0 y 5V, pero no pueden medir la resistencia del LDR. Para poder medir la cantidad de luz usando un LDR necesitamos convertir su resistencia a un voltaje que medir con Arduino.

El circuito más sencillo para ello es el divisor de tensión, también conocido como divisor de voltaje.

Este circuito consiste en dos resistencias conectadas en serie, a las que se aplica un voltaje en sus extremos, Vin. Al conducirse corriente a través de estas dos resistencias, se produce un voltaje en el punto donde se unen, Vout, cuyo valor puede determinarse con la fórmula:

LDR en un divisor de tensión

En nuestro caso con el sensor LDR, construiremos un divisor de tensión donde R1 es nuestro propio LDR, y R2 es una resistencia que seleccionamos nosotros.

A este circuito le aplicamos los 5V de nuestro Arduino en Vin, generando un voltaje en Vout que podemos leer con sus entradas analógicas. Al variar la resistencia del LDR, también lo hace el voltaje Vout que recoge nuestro Arduino, y de esta forma podemos detectar la cantidad de luz que hay en el ambiente.

 

Explora

Comprendiendo la lectura analógica con el sensor de luz LDR

Para comprender el comportamiento del circuito con nuestro LDR, vamos a construirlo en la breadboard:

¡Vamos a programar!

Programando el sensor de luz LDR en Arduino IDE

De la misma forma que hicimos con el potenciómetro, vamos leer el voltaje de salida del circuito, Vout, y los mostraremos en el monitor serie. Para hacer más cómoda su lectura, vamos a poner el retardo de cada iteración a 250ms.

En la función void setup() inicializamos el monitor serie:

void setup(){
  Serial.begin(9600);  // Inicializamos el monitor serie
}

En la función void loop() mostramos en el monitor serie la lectura del pin al que está conectado el sensor de luz LDR:

void loop(){
  Serial.println(analogRead(A0));   // Imprime en el monitor serie la lectura del pin A0
  delay(250);                       // Espera 250 milisegundos 
}

Nuestro sketch ha quedado:

void setup(){
  Serial.begin(9600);  // Inicializamos el monitor serie
}

void loop(){
  Serial.println(analogRead(A0));   // Imprime en el monitor serie la lectura del pin A0
  delay(250);                       // Espera 250 milisegundos 
}

Veremos que recibimos el valor de Vout en nuestro ordenador. Prueba a tapar poco a poco la luz que incide sobre el LDR con la mano y observa cómo varía. Tanbién puedes usar la linterna de tu teléfono móvil para inidirle más luz.

Encendido de un LED automáticamente con la oscuridad

Ahora que sabemos cómo detectar la cantidad de luz que tenemos en el ambiente, vamos a hacer que un LED se encienda automáticamente cuando ésta sea muy tenue.

¡Construye el siguiente circuito en tu breadboard!

¿Lo tienes? ¡Vamos a programarlo!

Lo primero que tenemos que hacer antes de escribir nada en nuestro código es decidir el umbral a partir del cual decidimos apagar o encender el LED. Como el LDR es un componente analógico y el rango ADC es 0-1023, podemos coger el valor intermedio 512 (este valor puede ser modificado según nuestro criterio).

En la función void setup() inicializamos el monitor serie y el LED:

void setup() {
  Serial.begin(9600);       // Inicializa el monitor serie
  pinMode(13, OUTPUT);      // Inicializa el pin digital 13 como salida
}

En la función void loop() vamos a construir un programa que cuando el sensor analógico tenga un valor menor que 512 el LED se encienda, y viceversa:

void loop() {
  Serial.println(analogRead(A0));  // Imprime en el monitor serie el valor del sensor
  
  if(analogRead(A0) < 512) {       // Si la luz está por debajo del umbral
    digitalWrite(13, HIGH);        // Enciende el LED
  } else {                         // De lo contrario, si la luz está por encima del umbral
    digitalWrite(13, LOW);         // Apaga el LED
    }
  
  delay(250);                      // Espera 250 milisegundos
}

Nuestro código ha quedado:

void setup() {
  Serial.begin(9600);       // Inicializa el monitor serie
  pinMode(13, OUTPUT);      // Inicializa el pin digital 13 como salida
}

void loop() {
  Serial.println(analogRead(A0));  // Imprime en el monitor serie el valor del sensor
  
  if(analogRead(A0) < 512) {       // Si la luz está por debajo del umbral
    digitalWrite(13, HIGH);        // Enciende el LED
  } else {                         // De lo contrario, si la luz está por encima del umbral
    digitalWrite(13, LOW);         // Apaga el LED
    }
  
  delay(250);                      // Espera 250 milisegundos
}

Sube el sketch a Arduino y vuelve a reducir la luz sobre el LDR con las manos para observar qué ocurre:

 

Sigue explorando

Barra de indicación de ajuste con potenciómetro

Realiza un circuito utilizando varios LEDs que formen un indicador en la que los éstos se enciendan según la posición del potenciómetro. Para probar tu destreza con la programación de Arduino, puedes tratar de hacerlo de dos formas:

  • Según la posición del potenciómetro se enciende un único LED.
  • Según la posición del potenciómetro se van encendiendo cada vez más LEDs haciendo de “indicador de nivel”.

Detector de nivel de luz

Conecta varios LEDs y, con varios umbrales de oscuridad, iluminarlos poco a poco según el nivel de luz detectado con el LDR.

Deja un comentario