Medir señales analógicas es una de las técnicas más usadas en electrónica. esto es hecho normalmente por conversores análogos para digital (adc). Señales analógicas son representadas por voltaje o tensión eléctrica e indican un nivel de una medición. muchos sensores de temperatura, humedad, presión, etc., entregan en su salida una tensión análoga a la magnitud que están midiendo. En este articulo aprenderemos a conectar potenciómetros, resistencias dependientes de luz o LDR y sensores de temperatura. También leer y procesar sus señales analógicas con microcontroladores de la placa Arduino uno.
La Figura 1 muestra la tarjeta Arduino Uno y su Ambiente de Desarrollo (IDE) el cual puede ser bajado de la página web de Arduino. Esta tarjeta contiene un microcontrolador ATmega328P, el cual posee 6 canales analógicos que pueden ser leídos a través de un conversor Análogo para Digital o ADC con resolución de 10 bits. La Figura 2 muestra los pines donde están ubicadas las entradas analógicas en la placa Arduino Uno. La Figura 3 muestra el diagrama en bloques del conversor análogo para digital (ADC) del microcontrolador.
Las principales características del ADC son:
- Resolución de 10 bits.
- Tiempos de conversión entre 13 y 260 micro segundos.
- 6 canales de entrada multiplexados.
- Canal de entrada con sensor de temperatura.
- Opcional ajuste de lectura hacia la izquierda.
- Rango de voltaje de 0 hasta Vcc.
- Voltaje de referencia de 1.1 Volts para el ADC.
- Modo de conversión único o libre.
- Interrupción cuando la conversión sea completada.
- Cancelación de ruido en modo de bajo consumo ( SLEEP ).
En este artículo veremos que entender y usar el ADC de la tarjeta Arduino es muy fácil. Para esto vamos a usar potenciómetros, resistencias dependientes de luz o LDR y el sensor de temperatura LM35. La Figura 4 se muestra estos componentes electrónicos. Códigos ejemplos pueden ser encontrados en el Menú Archivo->Ejemplos->03.Analog. Vea la Figura 5.
Muchos fenómenos físicos son captados o medidos como niveles de una magnitud o rango. Por ejemplo la temperatura nos indica si algo esta frio o caliente, más si queremos saber la medida exacta de temperatura debemos usar un sensor y leer o medir su salida para conocer la temperatura. Una vez que el sensor nos da una tensión o voltaje análogo a magnitud que se desea medir, es necesario conectarlo algún circuito que convierta esta medida en un valor digital. Debido al gran desarrollo de los procesadores y microcontroladores los circuitos usados para la conversión de tensión o voltaje, en un valor binario, son los ADC o Conversores Análogos Para Digital.
CONECTANDO POTENCIOMETROS A LA PLACA ARDUINO UNO.
En esta práctica conectaremos un potenciómetro a la placa Arduino Uno y leeremos su nivel de tensión como muestra la Figura 6. El código fuente para esta práctica puede ser encontrado en el Menú Archivo->Ejemplos->03.Analog->AnalogInput:
int sensorPin = A0; // select the input pin for the potentiometer int ledPin = 13; // select the pin for the LED int sensorValue = 0; // variable to store the value coming from the sensor void setup() { // declare the ledPin as an OUTPUT: pinMode(ledPin, OUTPUT); } void loop() { // read the value from the sensor: sensorValue = analogRead(sensorPin); // turn the ledPin on digitalWrite(ledPin, HIGH); // stop the program for milliseconds: delay(sensorValue); // turn the ledPin off: digitalWrite(ledPin, LOW); // stop the program for for milliseconds: delay(sensorValue); }
En el inicio del programa configuramos sensorPin para estar en la entrada analogía '0'. Para esto utilizamos la siguiente línea de código:
int sensorPin = A0;
También configuramos ledPin para la salida digital número '13', en la cual se encuentra el LED que la propia tarjeta Arduino tiene para pruebas. Para esto utilizamos la línea de código:
int ledPin = 13;
La variable sensorValue la usamos para almacenar el valor de nivel de tensión leído desde el potenciómetro. Para esto utilizamos la siguiente línea de código:
int sensorValue = 0;
En la función setup() declaramos que el pin ledPin va a ser salida digital (OUTPUT). Las entradas analógicas por defecto están configuradas como entrada analógicas, por ese motivo no es necesario declarar que el pin sensorPin es una entrada. El código para la funcion setup() es:
void setup() {
pinMode(ledPin, OUTPUT);
}
En la función loop() primero leemos la entrada analógica '0' a través de la instrucción analogRead(sensorPin); y el resultado lo almacenamos en la variable sensorValue. Después encendemos el LED con la instrucción digitalWrite(ledPin, HIGH); Enseguida retardamos por la magnitud o nivel leído desde el potenciómetro y que su valor fue almacenado en sensorValue. Pasado ese tiempo, apagamos el LED y retardamos nuevamente. Así se repite indefinidamente el programa. Como se podrá observar, de acuerdo al nivel de tensión leído en la entrada analógica '0', el LED parpadeara u oscilara.
La Figura 7 muestra el diagrama de flujo para este programa. El código para la función loop() es el siguiente:
void loop() { sensorValue = analogRead(sensorPin); digitalWrite(ledPin, HIGH); delay(sensorValue); digitalWrite(ledPin, LOW); delay(sensorValue); }
DETECTANDO LUZ CON FOTORESISTENCIA O RESISTENCIA DEPENDIENTE DE LUZ ( LDR ).
Una fotorresistencia o fotorresistor es un componente electrónico que varía su resistencia eléctrica en función del nivel de luz que recibe. En una fotorresistencia, cuanto mayor es la cantidad de luz recibida, su resistencia interna disminuye. Este componente es útil para medir el nivel de luz en un ambiente o lugar. En esta práctica aprenderemos como conectar una fotorresistencia a la placa Arduino Uno y como procesar el valor leído de luminosidad (luz), para ejecutar alguna acción.
La Figura 8 muestra la conexión eléctrica de la fotorresistencia a la placa Arduino. La resistencia de 1 KOhms puede ser variada para 10 KOhms dependiendo de la fotorresistencia usada. El siguiente es el programa ejemplo para esta práctica:
// variable to hold sensor value int sensorValue; // LED pin const int ledPin = 13; void setup() { Serial.begin(9600); } void loop() { //read the input from A0 and store it in a variable sensorValue = analogRead(A0); //send to serial monitor Serial.print("Light = "); Serial.print(sensorValue); //check light nivel if(sensorValue < 300 ){ Serial.println(" - Low"); }else if ( sensorValue < 600 ){ Serial.println(" - Middle"); }else{ Serial.println(" - High"); } // wait for a moment delay(1000); }
En el inicio del programa definimos la variable sensorValue para almacenar la cantidad de luminosidad recibida en la entrada '0' (A0) del conversor análogo para digital. El valor de ledPin es usado para definir el LED de la tarjeta Arduino que se encuentra conectado en el pin 13.
La función setup() configura el puerto serial para transmitir a 9600 bits por segundo. En esta práctica usaremos el puerto serial para comunicarnos con la computadora y mostrar los valores que están siendo leídos del ADC en una ventana monitor. Para acezar el Monitor Serie vaya el menú: Herramientas->Monitor Serie o de click en el botón Monitor Serie.
Vea la Figura 9. El código para la función setup() es:
void setup() {
Serial.begin(9600);
}
En la función loop(), primero leemos el canal '0' (A0) del ADC y almacenamos este valor en la variable sensorValue. Este valor es enviado pare el monitor serie a través de la instrucción:
Serial.print(sensorValue);
Después el código evalúa la variable sensorValue para determinar el nivel de luz o luminosidad que hay en el ambiente. El código para esta evaluación es:
if(sensorValue < 300 ){
Serial.println(" - Low");
}else if ( sensorValue < 600 ){
Serial.println(" - Middle");
}else{
Serial.println(" - High");
}
Aquí hacemos uso de la instrucción Menor Que la cual es representada por el símbolo o carácter
Dependiendo del nivel de luz enviamos al monitor serie un texto que lo indica. Para esto usamos la función Serial.println. Finalmente retardamos por un segundo el programa. En la Figura 11 podemos observar el diagrama de flujo para el programa de esta práctica.
TERMOMETRO CON EL LM35 Y ARDUINO UNO.
El LM35 es un circuito integrado sensor de temperatura. Su salida es analógica y por cada 0.1 grado centígrado su salida analógica se incrementa 1 milivolts, es decir que a cada 1 grado centígrado, el voltaje se incrementa en 10 milivolts. El circuito esta calibrado para grados centígrados y esto se hace cuando el circuito integrado es fabricado. La Figura 12 muestra el cómo conectar el LM35 a la tarjeta de Arduino. El siguiente es el código para leer la temperatura ambiente:
void setup() { Serial.begin(9600); } void loop() { //read the input from A0 and store it in a variable int temperature = analogRead(A0); // send to serial monitor Serial.print(temperature); Serial.print(" > "); // sensor output is 10mV per degree Celsius float millivolts = (temperature / 1024.0) * 5000; float centigrades = millivolts / 10; // send to serial monitor Serial.print(centigrades); Serial.print(" Centigrades "); // wait for a moment delay(1000); }
En el inicio del programa encontramos la función setup(), la cual se encarga de inicializar la comunicación del puerto seria para 9600 bauds. Después encontramos la función loop(), la cual lee la entrada '0' (A0) del conversor análogo para digital y lo almacena en la variable temperature y envía su valor para el monitor serial. Luego calculamos el valor de grados centígrados en función de los milivolts leídos y enviamos el resultado para el monitor serial. Finalmente retardamos por un segundo para que el bucle se vuelva a repetir. En la Figura 13 podemos observar el diagrama de flujo o actividad de esta práctica.
MAPEANDO O ESCALANDO LOS VALORES ADQUIRIDOS EN EL ADC.
El compilador de Arduino posee una función llamada map, la cual puede ser usada para mapear o escalar los valores adquiridos en ADC, para cualquier otro rango de valores. Por ejemplo, queremos representar el porcentaje en el cual se encuentra un potenciómetro. Para esto podemos usar la siguiente instrucción:
percent = map(potValue, 0, 1023, 0, 100);
En la línea código anterior podemos observar que el valor leído del potenciómetro es almacenado en la variable potValue, la escala de entrada va de 0 hasta 1023 y la escala de salida de 0 hasta 100. El valor retornado es el resultado de la conversión de escalas que debe ser un valor proporcional de 0 hasta 100. Esta función es muy útil porque en electrónica es común representar o convertir valores en diferentes escalas.
El prototipo o definición de la función es:
map(value, fromLow, fromHigh, toLow, toHigh)
Podemos ver que la función toma 5 parámetros como sigue:
value: valor a mapear.
fromLow: valor más bajo de la escala de entrada.
fromHigh: valor más alto de la escala de salida.
toLow: valor más bajo de la escala de salida.
toHigh: valor más alto de la escala de salida.
return: el valor mapeado.
El valor retornado por la función, será el valor de la escala de salida que se desea mapear.
El siguiente es un código ejemplo para mapear una entrada analógica para un valor de 8 bits:
/* Map an analog value to 8 bits (0 to 255) */
void setup() {}
void loop()
{
int val = analogRead(0);
val = map(val, 0, 1023, 0, 255);
analogWrite(9, val);
}
Como podemos notar en el presente artículo, leer las entradas analógicas del ADC es una tarea sencilla. La función usada para esto es analogRead la cual recibe un solo parámetro, indicando el canal de entrada a leer y retorna su valor entero.