Página a revisar.

'''Falta definir traduccion: Thermistor, Pull Up Resistor

Capítulo 6: Usando los pines analógicos

Como se mencionó anteriormente en este libro, el mundo real no es digital y, a veces, no puedes traducir los cambios en el entorno en lecturas digitales. Por ejemplo, la temperatura no cambia sólo de frío a caliente, cambia en un rango valores distintos y, normalmente, estos cambios ocurren muy lentamente. Éste es el motivo por el cual, a menudo, utilizamos sensores analógicos para leer los parámetros del entorno tales como, la temperatura, la luz, o el movimiento. Esta información resultante es almacenada como datos digitales secuenciales. Dado que Arduino no puede manejar la información como los humanos, necesitamos traducir los datos analógicos para que Arduino pueda entenderlos.

Los sensores analógicos pueden transformar los datos del entorno en un valor de voltaje comprendido entre 0V y 5V. Estos valores son distintos de los HIGH o LOW que utilizan los sensores digitales. Para los pines digitales, HIGH y LOW significan 5V y 0V respectivamente, y nada más. Sin embargo los pines analógicos pueden diferenciar cualquier valor intermedio.

La resolución entre los valores máximos y mínimos difieren de un microprocesador a otro. Arduino únicamente puede distinguir 1024 niveles en rango de 0V a 5V.

1: La cremallera analógica

La cremallera analógica es diferente a la cremallera digital del capítulo anterior. La cremallera digital sólo podía estar HIGH o LOW (5V o 0V). sin embargo, la cremallera analógica, puede darte un rango de valores entre 0V y 5V.

Para hacer una cremallera analógica necesitas una cremallera normal, algo de hilo conductor y una resistencia de 10kΩ. Comience cosiendo la resistencia en su lugar. Después cose un cable rojo en uno de los terminales de la resistencia, y un cable azul en el otro terminal. Los colores de los cables son para que recuerdes dónde va cada cable. Desde donde empieza el cable azul, cóselo entre cada diente de la cremallera. Cuando llegues al final de un lado de la cremallera, haz lo mismo en el otro lado y baja de nuevo.

Asegurate de que el hilo está intacto a lo largo de la cremallera o no funcionará. Una vez hayas llegado al final de la cremallera por el otro lado, une un cable negro y coselo en su lugar. Ahora la cremallera está lista y podemos empezar a escribir nuestro código para leer qué valores nos proporciona la cremallera. Para poder mostrar qué valores nos da la cremallera, necesitamos usar la comunicación serie, de modo que Arduino pueda conectarse al equipo y mostrarnos los datos en el monitor:

int analogPin = 2;
        /* Aquí declaramos que queremos usar el pin analógico 2, y lo llamaremos analogPin */

int myZipper=0;
                /* Aquí declaramos un entero que actuará como variable temporal, donde podremos almacenar los valores que nos proporcione la cremallera */

void setup(){
        Serial.begin(9600);
                /* Esto configurará tu comunicación y la fijará a 9600 baudios (9600 bits por segundo) */
}

void loop(){
        myZipper = analogRead(analogPin);
                /* Aquí hacemos una lectura analógica de analogPin y guardamos el valor en la variable myZipper */
        Serial.println(myZipper);
                /* Este comando enviará el valor almacenado en myZipper a través del puerto serie y después hace una pausa de 200 milisegundos */
        delay(200); //pausa de 200 milisegundos
}

Lo primero que hacemos en void loop() es una lectura analógica del pin analógico 2. El valor es almacenado en la variable myZipper. Después imprimimos este valor por el puerto serie y, cualquier aparato conectado a Arduino (por ejemplo, un PC) recibirá el valor almacenado en la variable. Lo ultimo que hacemos es añadir una pausa en nuestro programa, ya que, aunque Arduino es pequeño, todavía se comunica más rapidamente que un ordenador normal, así que la pausa permite sincronizarse con Arduino. Ahora podemos subir nuestro código a la placa Arduino. Una vez que el código está subido, conecta el cable rojo en el puerto que indica 5V, el cable negro a uno de los puertos de GND, y el último cable al pin analógico 2. Si declaras tu analogPin en tu programa como cualquiero otro pin que no sea el 2, tendrás que colocar el cable azul en ese pin analógico:

Una vez que hayas subido el código y conectado los cables, abre el monitor serie, que es el botón más a la derecha de tu IDE de Arduino. Ahora aparecerán los valores en el monitor y, si abres y cierras la cremallera, los valores irán cambiando. Si no puedes ver ningún número en tu monitor, asegurate que la velocidad de comunicación fijada en el IDE de Arduino es la misma que en tu programa (9600 en el ejemplo). Cada cremallera te dará unos valores diferentes, puesto que no es algo exacto; pequeñas diferencias afectarán en los resultados. Este tipo de sensor analógico casero es lo suficientemente bueno como para ser usado en la mayoría de prototipos que necesiten un dispositivo de entrada oculto.

2: Usando un sensor de luz LDR

El siguiente esquema muestra como coser una LDR y una resistencia en un trozo de tela y dónde deben conectarse los cables en el Arduino: '###################################### The resistor used in the example is what is called a “pull up resistor”. We sometimes use pull up resistors to ensure we won’t get 5V straight back in the Arduino. A pull up resistor is the same as a normal resistor but is used to lower the output voltage from a power source. The combination of a resistor with the LDR is also necessary for another reason: without it we wouldn’t be able to get analog values from the LDR. This configuration is called a voltage divider and it changes the voltage on the Arduino input depending on the changes in the LDR. '#######################################

La resistencia usada en el ejemplo es lo que llamamos una resistencia "Pull up". A veces usamos resistencias pull-up para asegurarnos que no recibe los 5V en sentido contrario el Arduino. Una resistencia Pull up es una resistencia normal pero usada para reducir el voltaje de salida de una fuente de tensión. La combinación de una resistencia con la LDR es necesaria por otra razón: sin ella no seríamos capaces de obtener valores analógicos de la LDR. Ésta configuración se conoce con el nombre de divisor de tensión y cambia el voltaje a la entrada del Arduino dependiendo de los cambios en la LDR. Conecta un cable rojo a una de las patillas de la resistencia y a los 5V de Arduino. Entre la resistencia y la LDR ponemos un cable que conecte a nuestro pin analógico. La misma conexión va a una patilla de la LDR. No importa que patilla conectes. De la otra patilla de la LDR cose un cable que conecte con el puerto GND del Arduino. Cuando hayas conectado todo prueba el siguiente código y observa los valores que proporciona la LDR:

int analogPin = 2;
        /* el pin analógico que usaremos en Arduino */
int myLDR = 0;
        /* variable temporal para almacenar los valores de la LDR */

void setup(){
        Serial.begin(9600);
        /* configurando la conexión y la velocidad */
}

void loop(){
        myLDR = analogRead(analogPin);
        /* leemos el valor de la LDR y lo almacenamos */
        Serial.println(myLDR);
        /* mostramos el valor almacenado en myLDR */
        delay(200);
}

En el ejemplo anterior leemos el valor, lo almacenamos y lo mostramos en el ordenador. No olvides abrir tu monitor serie en el IDE de Arduino y configurarlo a 9600 baudios para poder ver los valores captados por Arduino. Una vez que todo funcione, prueba a tapar la LDR con tu mano y comprueba que el valor que devuelve Arduino. Recuerda este valor y prueba el siguiente código de ejemplo.

int analogPin = 2;
        /* el pin analógico que usaremos en Arduino */
int myLDR = 0;
        /* variable temporal para almacenar el valor de la LDR */
int myDarkNumber = 100;
        /* el umbral de oscuridad, sustituir por el valor obtenido tapando la LDR con la mano */
int ledPin = 13;

void setup(){
        Serial.begin(9600);
        /* configurando la conexión y la velocidad */
        pinMode(ledPin,OUTPUT);
        /* declaramos ledPin como Salida */
}

void loop(){
        myLDR = analogRead(analogPin);
        /* leemos el valor de la LDR y lo almacenamos */
        if (myLDR <= myDarkNumber){
        digitalWrite(ledPin,HIGH);
        }else{
        digitalWrite(ledPin,LOW);
}
}

En este ejemplo la variable "myDarkNumber" es el valor que obtuviste al tapar la LDR con la mano en el ejemplo anterior. En mi caso es 100, pero tú debes cambiarlo por tu valor. Este programa leerá el valor de la LDR y lo comparará con la variable del umbral (myDarkNumber) y si la LDR es menor o igual al umbral el LED interno de la placa Arduino se ecenderá, de no ser así permanecerá apagado.

3: Usando un sensor de temperatura NTC

El código siguiente, para leer un termómetro, es el mismo que para la LDR. Ambos funcionan bien por tratarse de sensores analógicos:

int analogPin = 2;
        /* el pin analógico que usaremos en Arduino */

int myNTC= 0;
        /* variable temporal para guardar los valores del termómetro */

void setup(){
        Serial.begin(9600);
        /* configurando la comunicación y la velocidad */
}

void loop(){
        myNTC = analogRead(analogPin);
        /* lee el valor del NTC y lo almacena */
        Serial.print(myNTC);
        /* muestra el valor almacenado en myNTC */
        delay(200);
}

Ahora conecta todo como muestra la siguiente ilustración y carga el código en tu placa Arduino. Una vez que todo esté en su lugar, abre tu monitor serie e intenta calentar tu termómetro con las manos. Debes poder observar variaciones frente al valor original, cuando comenzó el programa. Aunque los termistores no sean los mejores sensores para obtener la temperatura exacta, son una manera fácil y barata de diferenciar entre frío y caliente. Si estás usando altas corrientes en tus prendas, o materiales que se calienten como "muscle wires", los termistores son una manera de comprobar si tu prenda está demasiado caliente (antes de que empiece a arder).

Share