sábado, 14 de febrero de 2015

Calculando la temperatura

Calculando la temperatura


Hola de nuevo. Siguiendo la línea de interactuar con nuestro Arduino y el entorno, vamos a hablar de los sensores de temperatura, y de cómo ensamblarlos con nuestro Arduino.

Un sensor de temperatura es un tipo de dispositivo que transforma un cambio de temperatura en un cambio en sus características ( resistencia, caída de voltaje, etc), que podemos medir con un equipo electrónico.
Hay varios tipos de distintos de sensores, en función de si varían su resistencia en función de la temperatura, (PTC, NTC, RTD), o si transforman el calor en diferencias de tensión como el termopar.
Para el ejemplo vamos a usar un económico, y fácil de encontrar TMP-36. Este semiconductor actúa parecido a un diodo Zener. Cuando se le somete a una diferencia de potencial entre dos de sus terminales, varía la caída de tensión en el tercero en función de la temperatura. Y esto será lo que mediremos en el conversor ADC de nuestro Arduino.

Aún hay más…. Entre las bondades del TMP-36 está que es completamente lineal en su rango de trabajo , -40°C a 150°C, y que su salida es en grados Celsius. Pero ,¿cómo haremos para medir la temperatura? Bien, el montaje es muy sencillo, conectaremos el terminal correspondiente a 5V, otro a GND, y el de en medio a una entrada analógica del Arduino. Tal que así:


El montaje en la protoboard  no podría ser más sencillo:




Después, y si nos dirigimos al datasheet del fabricante, encontraremos lo siguiente:


A nosotros nos interesa la curva b, señalada en rojo. Vemos que corta los 0°C en 0.5V, y que gana 10mV por cada incremento de 1°C. Por lo tanto la fórmula matemática que rige el comportamiento de este dispositivo sería:

T = ( V-0.5)*100

Donde :

T : es la temperatura en C, y
V: es la tensión en Volts.

Para este primer ejemplo  con las temperaturas, usaremos para visualizarlas el monitor serie del IDE. 

Con lo que el algoritmo para nuestro ejemplo, sería:

-Abrir la comunicación serie con el Arduino,
- Realizar la lectura del voltaje en el pin del sensor,
- Convertirla en grados Celsius,
- Mostrarla en pantalla.

Mi propuesta para este ejemplo es la siguiente:



/* Lectura de temperatura
Con un TMP-36
 */

// Declaración de constantes
const int sensorPin = A0; // Pin conectado al TMP36
float voltaje; //variable para calcular la tensión 
float temperatura; //variable para almacenar la temperatura;

void setup()
{
  // Empezamos la comunicación con el puerto serie
  // para mostrar los valores en el serial monitor
  Serial.begin(9600);
}


void loop(){
  // Leemos el valor de tensión en el pin
  // donde está conectado el sensor TMP36
  int sensorVal = analogRead(sensorPin);

  // Convertimos el valor de la lectura digital
  // en voltaje
  float voltaje = (sensorVal/1024.0) * 5.0;

  // Mostramos el valor del voltaje en pantalla
  Serial.print(", Volts: ");
  Serial.print(voltaje);
  
  // Convertimos el valor de tensión en temperatura
  // en grados Celsius. Para ello usamos la formula
  // explicada en http://arduinopractico.blospot.com.es
  // restando al voltaje el offset de 0.5V que tiene el sensor
  // e incrementando la temperatura en 1ºC por cada 10 mV
  // T = (V-0.5)*100 , siendo V el voltaje leido
  
  Serial.print(", Temperatura en C: "); 
  float temperatura = (voltaje - .5) * 100;
  Serial.println(temperatura);
  
   delay(1000);
}


Lo podeis descargar desde aquí.

Se trata de un ejemplo muy sencillo, con pocas particularidades. Quizás convenga resaltar, que para ganar precisión hemos usado variables del tipo float para hacer los cálculos, pues del tipo integer no obtendríamos decimales en las operaciones necesarias.


Este caso tan solo tenemos que cargarlo en el IDE, y enviarlo a nuestra placa.

Activar el monitor serie, está dentro de la pestaña herramientas. Aquí obtendremos las temperaturas con la cadencia que hayamos marcado.




En la siguiente entrada trabajaremos con otras alternativas para visualizar valores.

Nos vemos!


miércoles, 4 de febrero de 2015

Calibración de sensores (II) Uso de un pulsador

Calibración de sensores (II) .

En esta entrada vamos a explicar varios conceptos que serán de gran utilidad a la hora de realizar proyectos de mayor envergadura.

En concreto y siguiendo con nuestro montaje con el sensor LDR, queremos calibrar nuestro sensor cuando pulsemos un interruptor. De esta manera no interferimos en el resto de procesos que pudiera estar realizando nuestro montaje.

Para ello volveremos a hacer uso de la instrucción While, y haremos uso por primera vez de los procedimientos.


Podríamos modificar nuestro ejemplo anterior y hacerlo por tiempo en el void setup, pero lo que queremos es iniciar el proceso de calibración con la pulsación del pulsador-interruptor. Como siempre , antes de seguir con el programa mostramos el circuito del montaje.



A continuación vamos a definir el algoritmo de nuestro programa:
  • Leemos el valor del LDR
  • Mapeamos la lectura y mandamos la señal PWM equivalente al led de salida
  • Leemos el estado del pulsador, si esta pulsado salvamos los valores máximos y mínimos leídos, de lo contrario, reiniciamos el bucle.
Con la máxima de usar un bucle del tipo While para resolver el ejemplo el sketch podría quedar de la siguiente manera:

/* Ejemplo para calibrar un LDR con un pulsador 
  haciendo uso de la instruccion While
  El circuito analiza el valor en el LDR, y mapea la 
 salida en funcinn de la lectura obtenida.
 Este ejemplo se basa en un adaptacion del que podeis encontrar en

 http://arduino.cc/en/Tutorial/WhileLoop
 
 Mas informacion en castellano en :
 http://arduinopractico.blogspot.com.es
 
 */

// Definicion de constantes
const int ldrPin = A0;       // pin conectado al LDR
const int ledPin = 9;           // pin conectado al LED
const int calibracionLedPin = 13; // Led para indicar el proceso de calibracion
const int pulsador = 2;        // pin concectado al pulsador


// Definicion de Variables
int sensorMin = 1023;  // Valor minimo del sensor
int sensorMax = 0;     // Valor maximo del Sensor
int sensorValor = 0;   // VAlor leido por el sensor

void setup() {
  // set the LED pins as outputs and the switch pin as input:
  pinMode(calibracionLedPin, OUTPUT);//o usaremos para indicar cuando esta calibrando
  pinMode (ledPin, OUTPUT);
  pinMode (pulsador, INPUT);
}

void loop() {
  // Leemos el pulsador y pasamos a calibrar si pulsado
  while (digitalRead(pulsador) == HIGH) {
    calibrado(); 
  }
  // Apgamos led13 cuando acaba el calibrado
  digitalWrite(calibracionLedPin, LOW);  

  // Leemos el sensor
  sensorValor = analogRead(ldrPin);

  // MApeamos el valor del sensor, con los valores
  // obtenidos de la calibracion
  sensorValor = map(sensorValor, sensorMin, sensorMax, 0, 255);

  // Descartamos los valores fuera del rango obtenido en la calibracion
  //restringiendo a la horquilla que heos medido
  sensorValor = constrain(sensorValor, 0, 255);

  // 
  analogWrite(ledPin, sensorValor);
}

void calibrado() 
{
  // Encendemos led 13, para indicar que estamos calibrando
  digitalWrite(calibracionLedPin, HIGH);
  //Leemos el valor del LDR
  sensorValor = analogRead(ldrPin);

  // Grabamos el valor maximo obtenido
  // si supera el que habia grabado
  if (sensorValor > sensorMax) {
    sensorMax = sensorValor;
  }

  // Grabamos el valor minimo obtenido
  //si es inferior al que habia grabado
  if (sensorValor < sensorMin) {
    sensorMin = sensorValor;
  }
}


Lo podeis descargar de aquí.

Las diferencias con ejemplos anteriores las tenemos en la siguiente parte:

// Leemos el pulsador y pasamos a calibrar si pulsado
  while (digitalRead(pulsador) == HIGH) {
    calibrado();


Antes de comenzar el bucle leemos el pulsador, y si está presionado llamamos al procediemiento        "calibrado". Cada vez que comience el bucle y el pulsador continue pulsado ejecutará la rutina de calibrado.
La rutina de calibrado, es exactamente igual a las realizadas hasta ahora. Leemos el valor del sensor, y grabamos los valores máximo y mínimo en las variables sensorMax y sensorMin. Respectivamente.

Ejemplo con dos LEDs fade-in y fade-out


Por último y para acabar de momento con el LDR, propongo otro ejemplo, esta vez con dos LEDs,    comportándose de forma antagónica. Es decir, si bien hasta ahora el LED era proporcional a los          valores de luz leídos, a mayor luz incidente en el LDR, mayor luminosidad del LED, ahora queremos
que uno de los actué de manera inversamente proporcional a la luz incidente.

El montaje consiste en añadir un led más:



Mi propuesta es muy sencilla. Es esta:

/* Ejemplo para calibrar un LDR con un pulsador 
  haciendo uso de la instruccion While
  El circuito analiza el valor en el LDR, y mapea la 
 salida en funcinn de la lectura obtenida.
 Un led sera proporcial (a mas luz mas brillo) y el 
 otro inversamente proporcional, a mayor luz, menor
 brillo.
 Mas informacion en castellano en :
 http://arduinopractico.blogspot.com.es
 
 */

// Definicion de constantes
const int ldrPin = A0;       // pin conectado al LDR
const int ledPin = 9;           // pin conectado al LED
const int led2Pin = 10;           // pin conectado al segundo LED
const int calibracionLedPin = 13; // Led para indicar el proceso de calibracion
const int pulsador = 2;        // pin concectado al pulsador


// Definicion de Variables
int sensorMin = 1023;  // Valor minimo del sensor
int sensorMax = 0;     // Valor maximo del Sensor
int sensorValor = 0;   // VAlor leido por el sensor
int sensorValor2 = 0;  // VAlor para el 2 LED

void setup() {
  // set the LED pins as outputs and the switch pin as input:
  pinMode(calibracionLedPin, OUTPUT);//o usaremos para indicar cuando esta calibrando
  pinMode (ledPin, OUTPUT);
  pinMode (led2Pin, OUTPUT);
  pinMode (pulsador, INPUT);
}

void loop() {
  // Leemos el pulsador y pasamos a calibrar si pulsado
  while (digitalRead(pulsador) == HIGH) {
    calibrado(); 
  }
  // Apgamos led13 cuando acaba el calibrado
  digitalWrite(calibracionLedPin, LOW);  

  // Leemos el sensor
  sensorValor = analogRead(ldrPin);

  // MApeamos el valor del sensor, con los valores
  // obtenidos de la calibracion
  sensorValor = map(sensorValor, sensorMin, sensorMax, 0, 255);

  // Descartamos los valores fuera del rango obtenido en la calibracion
  //restringiendo a la horquilla que heos medido
  sensorValor = constrain(sensorValor, 0, 255);
  sensorValor2 = 255 - sensorValor; // Una vez adaptado el valor,
  //lo invertimos con este truco
  // 
  analogWrite(ledPin, sensorValor);
  analogWrite(led2Pin, sensorValor2);

}

void calibrado() {
  // Encendemos led 13, para indicar que estamos calibrando
  digitalWrite(calibracionLedPin, HIGH);
  //Leemos el valor del LDR
  sensorValor = analogRead(ldrPin);

  // Grabamos el valor maximo obtenido
  // si supera el que habia grabado
  if (sensorValor > sensorMax) {
    sensorMax = sensorValor;
  }

  // Grabamos el valor minimo obtenido
  //si es inferior al que habia grabado
  if (sensorValor < sensorMin) {
    sensorMin = sensorValor;
  }
}



La diferencia, a parte de definir los nuevos elementos que intervienen, es la invertir, uno vez rescalado el valor que daremos al Led 2 con este sencillo truco:

sensorValor2 = 255 - sensorValor; // Una vez adaptado el valor,
  //lo invertimos con este truco


Por cierto podeis obtener este último ejemplo desde aquí.
Un video con el funcionamiento de este último. No olvidéis calibrarlo primero pulsando el interruptor y sometiéndolo a los valores de luz máximo y mínimo.



Nos vemos.