Problemas Arduino + AD595

[omalave]

Hola amigos, intento capturar la temperatura con un integrado AD595 y no lo consigo.

Siempre me da valores de 0 grados celcius y estoy 100% que la conexion en el integrado es la correcta.

Lo controlo con un arduino pero al momento de leer las temperaturas tiene un comportamiento muy raro, 0 grados casi siempre y a veces 0.94 grados..

La termocupla esta bien y no creo que se dañe el integrado por que no diera comunicacion con el arduino.

Que se les ocurre que pueda chequear?

[aprendiz]

Ayudanos posteando el circuito que haz construido, asi será más fácil ayudarte............

Saludos y suerte.............

[omalave]

Bueno, el circuito es sencillismo.. ayer logre que me diera temp por el puerto serial pero no es algo instantaneo, tarda un poco para empezar a mostrar temperaturas.. pareciera que no es una toma de temperatura inmediata (algo negativo para controles de temp) la termocupla esta bien, no me da error en el multimetro que tiene termostato..

El integrado es este:



El diagrama es este:



y en el protoboard queda asi:



Pero nada, no me da una toma de muestra inmediata, no se si es que la termocupla no es la adecuada, es tipo K

[Thulsa_Doom]

¿puedes poner el driver del dispositivo?.
¿el driver lo has creado tu o te lo has bajado?
aveces el driver no funciona porque en el código hay un error, puede deberse a que el dato de la temperatura tiene que estar en una variable float y lo tienes en una variable int o char, he encontrado drivers que supuestamente están bien y no me han funcionado y a la hora de revisarlo he encontrado errores

[omalave]

Hola.

El codigo supuestamente esta probado y deberia dar las temp en los dos tipos es decir en celcius y en farenheit..

Código: Seleccionar todo

#include <AD595.h>

AD595 thermocouple;

void setup() {
  Serial.begin(9600);
  thermocouple.init(0);

  Serial.println("AD595 test");
  // wait for AD595 chip to stabilize
  delay(500);
}

void loop() {
  // basic readout test, just print the current temp

   Serial.print("C = "); 
   Serial.println(float(thermocouple.measure(TEMPC)));
   Serial.print("F = ");
   Serial.println(float(thermocouple.measure(TEMPF)));

   delay(1000);
}

y el de la libreria .cpp es este:

Código: Seleccionar todo

/*-----------------------------------------------------------------------------------------------
 * File: AD595.cpp
 * Function: AD595 Thermocouple library
 * Description: AD595 Type-K Thermocouple Library for the Hobbybotics AD595 breakout board.
 * Created by Curtis Brooks, May 13, 2012.
 * Updated: N/A
 * Released into the public domain.
 * 
 * ----------------------------------------------------------------------------------------------*/

// Add necessary include files
#include "AD595.h"
 
/*-----------------------------------------------------------------------------------------------
 * Public Methods
 * ----------------------------------------------------------------------------------------------*/

void AD595::init(uint8_t DO) {
  _DO = DO;
  
  //define pin modes
  pinMode(_DO, INPUT);
}

double AD595::measure(uint8_t type) {
  double value;
  
  switch(type) {
    case TEMPC : value = tempC(); break;
    case TEMPF : value = tempF(); break;
  }
  return value;
}

/*-----------------------------------------------------------------------------------------------
 * Private Methods
 * ----------------------------------------------------------------------------------------------*/
double AD595::tempC() {
  return (5.0 * analogRead(_DO) * 100.0) / 1024.0;
}

double AD595::tempF() {
  return ((tempC() * 9.0/5.0) + 32);
}

y el include .h es este:

Código: Seleccionar todo

/*-----------------------------------------------------------------------------------------------
 * File: AD595.h
 * Function: AD595 Thermocouple library
 * Description: AD595 Type-K Thermocouple Library for the Hobbybotics AD595 breakout board.
 * Created by Curtis Brooks, May 13, 2012.
 * Updated: N/A
 * Released into the public domain.
 * 
 * ----------------------------------------------------------------------------------------------*/
 
#ifndef AD595_h
#define AD595_h

// Keep compatability with Arduino 1.0 and below
#if ARDUINO>=100
#include <Arduino.h>             // Arduino 1.0
#else
#include <WProgram.h>            // Arduino 0023 and below
#endif

enum {
  TEMPC,
  TEMPF
};

class AD595 {
  public:
    void init(uint8_t DO);
    double measure(uint8_t type);
        
  private:
    double tempC();
    double tempF();
    
    int8_t _DO;
};

#endif

El problema es que no entiendo por que tengo que colocar la pistola de aire caliente en 150 grados celcius y ella no detecta esa temperatura automaticamente..

[Thulsa_Doom]

No estoy muy puesto en ardino, yo creo todos mis prototipos en "#C" con el compilador CCS C y con pic, por eso disculpa si no ter ayudo demasiado.

te explico, te quejas de que las lecturas las hace lentas, en el código del ardino (no en el driver ni en el .h) al final del loop tienes un delay(1000); eso es un retraso de 1 segundo de una lectura a otra, baja ese tiempo si quieres mas rapidez, he estado viendo por encima el datsheet del fabricante pero no he encontrado nada referente a si tienes que dejar un tiempo de refresco de una lectura a otra, creo que este dispositivo da la medida en voltaje, es un dispositivo analógico.

en el mismo código veo que llamas a las lecturas en ºc y en ºf, deberías eliminar una de ellas, si quieres en ºc deja ese y el otro lo eliminas


te explico un poco el código.
Al principio antes de todo deberías de definir el pin por el que vas ha capturar la medida

creo que eso lo haces con esta función

Código: Seleccionar todo

void AD595::init(uint8_t DO) {
  _DO = DO;
  
  //define pin modes
  pinMode(_DO, INPUT);
}

creo que deberías de poner el pin del puerto en algún lado del programa principal

una vez definido el puerto pasamos al siguiente paso.


Con esta función:

Código: Seleccionar todo

Serial.println(float(thermocouple.measure(TEMPC)));

estas diciendole al driver que el dato de la temperatura lo (quieres en ºC)

Código: Seleccionar todo

case TEMPC : value = tempC(); break;

que vaya a la función tempc()

Código: Seleccionar todo

AD595::tempC() {

y que el valor resuelto de esta operación matemática:

Código: Seleccionar todo

double return (5.0 * analogRead(_DO) * 100.0) / 1024.0;

el resultado lo cargue en la variable value y será retornada a measure(TEMPC) y desplegado por el puerto serial.

En definitivas cuentas, esta función:

Código: Seleccionar todo

Serial.println(float(thermocouple.measure(TEMPC)));

lee el dato lo convierte a un valor de temperatura en ºC y lo despliega por el puerto serial


lo que creo que te falta es decirle al ardino que puerto del atmega quieres utilizar para tal fin, no sé cómo se define un pin en ardino en CCS es #DEFINE D0 PIN_A1 con esto el pin A1 del pic lo llamo D0 ahora cada vez que nombre a D0 el compilador sabe que es el PIN A1

no sé si te he ayudado pero mis conocimientos en ardino son muy limitados

[omalave]

Correcto, el codigo estoy seguro que esta bien.

El problema parece ser que es electronico, no veo por ningun lado donde diga que la lectura de los datos tiene un retardo significativo, por que para cuestiones de control este debe ser inmediato.

De verdad ya no se que pensar..

[Thulsa_Doom]

Sigo diciendo que te falta configurar el pin en el micro por el que el microcontrolador leerá el dato de la temperatura del AD595.
a parte de esto es posible que en la patilla del micro que se configure para leer el dato, haga falta poner una resistencia de pull-up, se suele hacer con una resistencia de 10k pero lo he visto con valores mayores

[pierremcoll]

/*
Tutorial # 0005 Arduino Academy - Sensor NTC

Conectamos una NTC a una entrada
analógica para controlar cinco salidas
en función de la temperatrura.

Además utilizaremos un ponteciómetro para
controlar la temperatura a partir de la cual
se activarán las salidas

Este proyecto es de dominio público.
*/

//Añadimos la librería math.h
#include <math.h>

//Pines para los LED
int pinLed1 = 8;
int pinLed2 = 9;
int pinLed3 = 10;
int pinLed4 = 11;
int pinLed5 = 12;

//Pines para las entradas analógicas
int analogPin1 = 0;
int analogPin2 = 1;

//Escala de Avisos
int escala = 2;

//Variable para la temperatura de disparo
double tempMin = 0.0;

//Datos para las ecuaciones

float Vin = 5.0; // [V] Tensión alimentación del divisor
float Rfija = 1000; // [ohm] Resistencia fija del divisor
float R25 = 2800; // [ohm] Valor de NTC a 25ºC
float Beta = 3900.0; // [K] Parámetro Beta de NTC
float T0 = 293.15; // [K] Temperatura de referencia en Kelvin

float Vout = 0.0; // [V] Variable para almacenar Vout
float Rntc = 0.0; // [ohm] Variable para NTC en ohmnios

float TempK = 0.0; // [K] Temperatura salida en Kelvin
float TempC = 0.0; // [ºC] Temperatura salida en Celsius

void setup() {

//Comenzamos la comunicación puerto serie
Serial.begin(9600);

//Declaramos pines de salida
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed4, OUTPUT);
pinMode(pinLed5, OUTPUT);

//Y los pines de entrada
pinMode(analogPin1, INPUT);
pinMode(analogPin2, INPUT);

}

void loop()
{
//Primero leemos el pootenciómetro
tempMin = analogRead(analogPin2);
//Lo mapeamos a valores de -100 a 800
tempMin = map (tempMin, 0, 1023, -100, 800);
//Y lo dividimos entre 10 para darle un decimal
tempMin = tempMin/10;

//Y lanzamos el ajuste establecido via serie
Serial.println("-----------------------------------------------");
Serial.println();
Serial.print("AJUSTE DE TEMPERATURA MINIMA A ");
Serial.print(tempMin);
Serial.println(" GRADOS CELSIUS");
Serial.println();
Serial.println("-----------------------------------------------");

//Y ahora calculamos la Temperatura

//Primero la Vout del divisor
Vout=(Vin/1024)*(analogRead(analogPin1));

//Ahora la resistencia de la NTC
Rntc=(Vout*Rfija)/(Vin-Vout);

//Y por último la temperatura en Kelvin
TempK = Beta/(log(Rntc/R25)+(Beta/T0));

//Y ahora la pasamos a celsius
TempC = TempK-273.15;

//Y lo mostramos por puerto serie
Serial.println();
Serial.print("LA TEMPERATURA DE LA NTC ES DE ");
Serial.print(TempC);
Serial.println(" GRADOS CELSIUS");
Serial.println();

//Ahora las comparaciones para las salidas
if(TempC < tempMin)
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC <= (tempMin + escala)) & (TempC > tempMin)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, LOW);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if (((TempC<=(tempMin+(escala*2)))&(TempC>tempMin+escala)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, LOW);
digitalWrite(pinLed5, LOW);
}
else if ((TempC<=(tempMin+(escala*3)))&(TempC>tempMin+(escala*2)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, LOW);
}
else if (TempC > (tempMin + (escala*4)))
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, HIGH);
digitalWrite(pinLed3, HIGH);
digitalWrite(pinLed4, HIGH);
digitalWrite(pinLed5, HIGH);
}

//Un pequeño delay para no volver loco al puerto serie
delay(500);
}


Estamos utilizando una NTC, es decir, una resistencia con coeficiente de temperatura negativo respecto a la variación de su resistencia, esto es que a más temperatura, aumentará la concentración de portadores, lo que hará que su resistencia sea menor.

La manera de conectar este sensor a nuestro circuito va a ser formando un divisor de tensión con su salida a una entrada analógica (podéis ver en este ejemplo como funciona una entrada analógica), en el que nuestra NTC será la resistencia inferior, lo que además nos protegerá de un problema que tienen estos sensores, cuando la corriente que circula por él es baja, no tenemos ningún problema, pues la disipación de calor es casi nula (VxI2) pero si la aumentamos, llegamos a un punto en que esa disipación afecta a la resistencia del sensor, por lo que deducimos que la respuesta de una NTC no es lineal sino hiperbólica, pero al colocarlo como un divisor de tensión la variación de tensión Vout va a ser prácticamente lineal.



En cuanto a la otra resistencia (pull-down) que formará el divisor de tensión, utilizaremos una de 1KΩ, esto es así para aprovechar el rango de muestreo que nos proporciona Arduino con un consumo de corriente limitado, veamos rápidamente el motivo.

[Thulsa_Doom]

Pues veo que has superado el problema, gracias por compartir