Donde esta el error...

Necesito otra ayuda, la variable float me da solo con dos decimales, para calibrar las sondas necesito 3 o 4 si se pudiera, como se puede hacer?

Yo usé int, porque en realidad, la lectura que devuelve será siempre un número entero entre 0 y 1023

Creo que puedes obviar los ( ) externos y debería funcionar también.

int pin0read = analogRead (analogInPin);
int pin1read = analogRead (analogInPin1);

Pero bueno, si esos 2 ya te dan valores distintos, entonces vamos por buen camino y confirmas que si, que los inputs están funcionando correctamente.

CesarCarlos:
Necesito otra ayuda, la variable float me da solo con dos decimales, para calibrar las sondas necesito 3 o 4 si se pudiera, como se puede hacer?

Prueba con:

int sensorValue = 500; //Lo pongo yo a mano, para la prueba, tu valor llegaría desde el A0 o A1

Serial.println(sensorValue); //Lo vemos en pantalla

float newValue = sensorValue/1024.00; //Al parecer para dividir un float, se debe usar el .00 sino dará error

Serial.println(newValue,6); //Esto nos imprime el valor con 6 decimales en pantalla.

Serial.println(newValue); //Esto nos imprime el valor con 2 decimales en pantalla.

float otherValue = newValue*1000.00; //Lo multiplico por 1000 (de nuevo pongo el .00)

Serial.println(otherValue,6); Acá compruebo que aunque por pantalla nos salga con sólo 2 decimales por defecto, en realidad todos los decimales están ahí al momento de usarlo en otras ecuaciones.

Lo que esto me devuelve es:

500
0.488281
0.49
488.281250

Osea que aunque en pantalla veamos el 0.49 al hacer su llamada común, el float igualmente tiene todos sus decimales ahí para cuando lo usemos.

Ya están andando 4 sondas dando valores aceptables, el problema es que al parecer redondea en las cuentas y no salta de grado en grado de temperatura o fracción de este, me salta de a 2 o mas.
Con los datos que me diste ya veo 3 o mas dígitos en el monitor, pero no logro darme cuenta porque los grados saltan

Bueno, pasa como te quedó el código final, a ver si se me ocurre algo.

Quizás se podría implementar que antes de hacer la ecuación y mandar la temperatura, haga 10 lecturas y saque un promedio.

Algo así hice yo para que los movimientos de un potenciómetro sean más estables y me ha resultado perfectamente.

Así quedó el codigo

const int analogInPin = A0; 
const int analogInPin1 = A1;
const int analogInPin2 = A2;
const int analogInPin3 = A3;
const int analogInPin4 = A4;
int sensorValue = 0; 
int sensorValue1 = 0;
int sensorValue2 = 0;
int sensorValue3 = 0;
int sensorValue4 = 0;

void setup() {
 // initialize serial communications at 9600 bps:
 Serial.begin(9600); 
 //pinMode (13, OUTPUT);
}
void loop() {
  
  // read the analog in value:
  float pin0read = (analogRead (analogInPin));
 float pin1read = (analogRead (analogInPin1));
  float pin2read = (analogRead (analogInPin2));
   float pin3read = (analogRead (analogInPin3));
    float pin4read = (analogRead (analogInPin4));
float sensorValue = ((pin0read/1023)*4.9);
float sensorValue1 = ((pin1read/1023)*4.9);
float sensorValue2 = ((pin2read/1023)*4.9);
float sensorValue3 = ((pin3read/1023)*4.9);
float sensorValue4 = ((pin4read/1023)*4.9);

float temperatura = (-(541*sensorValue) +360.19); //357.30); // convierte a grados
float temperatura1 = (-(541*sensorValue1)+360.19);
float temperatura2 = (-(541*sensorValue2)+360.19);
float temperatura3 = (-(541*sensorValue3)+360.19);
float temperatura4 = (-(541*sensorValue4)+360.19);

 // print the results to the serial monitor:
 
 //Serial.print ("pin0read ");
 //Serial.print (pin0read); 
 //Serial.print(" Pin1read = " ); 
 //Serial.print(pin1read ); 
 //Serial.print("  sensorValue = " ); 
 //Serial.print(sensorValue);
 //Serial.print("  ");
 //Serial.print (" sensorValue1 ");
 //Serial.print(sensorValue1);
 Serial.print (" Temp0 = ");
 Serial.print (temperatura,3);
 Serial.print (" Temp1 = ");
 Serial.print (temperatura1,3);
 Serial.print (" Temp2 = ");
 Serial.print (temperatura2,3);
 Serial.print (" Temp3 = ");
 Serial.print (temperatura3,3);
Serial.print (" Temp4 = ");
 Serial.println (temperatura4,3);

 delay(1000); 
}

Pero no es por la precisión de lectura el problema, hay algún error porque los saltos de una temperatura a otra siempre son de 2.59, tiene que haber alguna falla en los cálculos

El problema es que

const int analogInPin = A0;

Esto da valores enteros del orden de los 130
Acá

float pin0read = (analogRead (analogInPin));

cada unidad de analogInPin me varía en 2,59 en el resultado de pin0read
Alguna idea como solucionarlo??

Hola, hice este nuevo código mucho mas simple para ajustar las sondas

float termometro1= 0;
float termometro2= 0;
float termometro3= 0;
float termometro4= 0;

void setup() {
 
 Serial.begin(9600); 

}
void loop() {
  int val = analogRead(0);
  int val1 = analogRead(1);
  int val2 = analogRead(2);
  int val3 = analogRead(3);
   termometro1 = map(val,99,140,100,0);
   termometro2 = map(val1,101,140,100,0);
   termometro3 = map(val2,99,140,100,0);
   termometro4 = map(val3,99,140,100,0);
Serial.print (" Term 1 ");   
Serial.print (termometro1,2);
Serial.print (" Term 2 ");
Serial.print (termometro2,2);
Serial.print (" Term 3 ");
Serial.print (termometro3,2);
Serial.print (" Term 4 ");
 Serial.println (termometro4,2);
 delay(100); 
}

El problema es que no va de grado en grado salta de a 2 por vez. Ni hablar de los decimales de grado siempre .00

en la imagen se ve que la sonda del termómetro 3 cambia de 20 a 22 sin pasar por el 21, en todas hace ese problema, se salta de a 2 y a veces de a 3 grados, no marca los intermedios

En el último código, el problema está en tu mapeo

termometro2 = map(val1,101,140,100,0);

estás variando sólo 39 valores, para que se repartan entre 0 y 100 pega saltos de 2 y 3 cada vez que algo cambia.


¿Me dices el nombre de lo que tienes conectado en los Analog inputs, me gustaría saber eso, sino no puedo hacer nada más, porque cada vez que subes una fórmula para calcular la temperatura, siempre son diferente.

float temperatura = (-(541*sensorValue) +360.19); //357.30); // convierte a grados

¿Qué es eso ahora?

Este código, y ojalá te sirva, me tira estos valores.

No se como funciona tu sensor así que ni idea, pero esa ecuación es la que tu querías lograr.

const int analogIn0 = A0; 

int pinRead0 = 0;

float sensorValue0 = 0; 

float temp0 = 0;


void setup() {
  Serial.begin(9600); 
}


void loop() {
 
  pinRead0 = analogRead(analogIn0);
  
  Serial.println (pinRead0);

  sensorValue0 = (pinRead0*4.9)/1023;

  Serial.println (sensorValue0,4);

  temp0 = (-(541*sensorValue0) +360.19); //357.30); // convierte a grados
  
  Serial.print ("Temp0 = ");
  Serial.println (temp0,4);

  delay(1000);

}
124
0.5939
Temp0 = 38.8688
126
0.6035
Temp0 = 33.6862
130
0.6227
Temp0 = 23.3210
132
0.6323
Temp0 = 18.1384
141
0.6754
Temp0 = -5.1833
138
0.6610
Temp0 = 2.5906
138
0.6610
Temp0 = 2.5906
133
0.6370
Temp0 = 15.5471

Ya descubrí el tole tole American, te comento que el sensor que uso es un simple diodo 1N4148 con el catodo a negativo y el ánodo a input con una resistencia de 2K2 a +5v. El problema es que el salto de milivoltios entre los 0° y los 100° son solo 40 mV, por tanto la relación 40/100 son 2 y pico, que es el salto que me hace. Lo que hice fue poner un transistor cualunque que amplifique y santas pascuas ahora va de lujo.
Lo de los números

float temperatura = (-(541*sensorValue) +360.19); //357.30); // convierte a grados

lo eliminé todo, usando la función map que resulta mucho mas simple para calibrar la sonda, pones la sonda en hielo y lees el valor de analogRead ese es el valor de mapeo inferior, que mapea a 0°, luego en agua hirviendo lees el valor de analogRead y es el valor de mapeo superior correspondiente a 100°. Mucho mas fácil para calibrar que sacar la función y demás que tenía el otro programa.
En unos días pongo el trabajo completo con circuitos y demas en el blog y acá por si a alguien le sirve.
Muchísimas gracias me sirvió de mucho las indicaciones

Lo del transistor tuve que sacarlo, la propia juntura del mismo provocaba variaciones muy grandes asi que hice una pequeña reforma al código cambiando la referencia interna a 1,1V con
analogReference(INTERNAL)
este truco dejó las sondas muy bien y muy exactas.
Puse un tutorial en mi blog para el que le interese.
Muchisimas gracias American Cheyenne y los que aportaron su granito para que el proyecto se realizara.

El código quedó definitivamente asi

// termometro múltiple fácil de calibrar
int termometro1= 0;// entrada A0
int termometro2= 0;// entrada A1
int termometro3= 0;// entrada A2
int termometro4= 0;// entrada A3, se pueden poner mas sondas en A4 y 5
int termometro5= 0;


void setup() {
 
 Serial.begin(9600); 
analogReference(INTERNAL);// pone como referencia iterna 1.1V
}
void loop() {

   termometro1 = map(analogRead(0),452,632,100,0); // a 0°C la lectrura de analgRead es 140 y a 100°C es 99
   termometro2 = map(analogRead(1),459,630,100,0);// calibrar cada sonda por separado y poner los valores correspondientes en map   
   termometro3 = map(analogRead(2),450,629,100,0);
   termometro4 = map(analogRead(3),449,628,100,0);
   termometro5 = map(analogRead(4),473,641,100,0);
   // para ver en el monitor
Serial.print (" Term 1= ");   
Serial.print (termometro1);
Serial.print ("        Term 2= ");
Serial.print (termometro2);
Serial.print ("        Term 3= ");
Serial.print (termometro3);
Serial.print ("        Term 4= ");
Serial.print (termometro4);
Serial.print ("        Term 5= ");
Serial.println (termometro5);
 delay(1000); 
}

:astonished: ¿Entonces con un diodo, una resistencia y un transistor te inventaste un sensor de temperatura?

Interesantísimo está esto, le echaré un vistazo y veré si me hago tiempo en la semana para probarlo.

¿Servirá con otro diodo que no sea exactamente ese?

Hombre, no lo inventé yo, solo el diodo y la resistencia son necesarios, el transistor que amplificaba lo saqué porque la propia juntura de él, variaba la temperatura, con cualquier diodo y la resistencia puede funcionar. Me queda en el tintero ver si puedo ponerle al menos un dígito decimal.
Fijate en el link que puse en el otro post y vas a ver lo simple que es. Cualquier semiconductor funciona, incluso la jutura entre base y colector o base y emisor de un transistor cualquiera va a responder.
Un abrazo

Dale, lo pruebo en la semana y hago mi código.

No tenés decimales, por esto.

termometro1 = map(analogRead(0),452,632,100,0);

la función mapeo no devuelve decimales.

En lugar de mapeo, vuelve a la función con cuentas matemáticas, ya que te servirá, para el caso que la lectura sea superior a los 100ºC o inferior a los 0ºC

(¿Aunque igual, no esta pensado para ese rango cierto? El diodo se freiría imagino :stuck_out_tongue: ya bastante que aguanta el agua a 100º jejeje)

Lo del mapeo me parece adecuado por la facilidad en la calibración, lo de la función se pone mas complicado, igual se podria hacer lo que me indicaste antes, hacer 50 lecturas y sacar la media, siempre voy a tener un mejor acercamiento al valor real.
Los diodos pueden aguantar bien hasta 200 o mas grados.
Saludos y espero tus pruebas.

:stuck_out_tongue: Bueno, me hice un tiempito para hacer unas pruebas rápidas, usando un termómetro como referencia, po puse en agua con hielo, obtuve 1º, luego en agua caliente a 54º y de ahí saqué estos valores y este código.

const int numReadings = 10;

int inputPinP1 = A0;

int readingsP1[numReadings];
int indexP1 = 0;
int totalP1 = 0;
int averageP1 = 0;

void setup()
{
  Serial.begin(9600);                   
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readingsP1[thisReading] = 0;
  }

}

void loop() {
  // subtract the last reading:
  totalP1 = totalP1 - readingsP1[indexP1];
  // read from the sensor:
  readingsP1[indexP1] = analogRead(inputPinP1);
  // add the reading to the total:
  totalP1 = totalP1 + readingsP1[indexP1];
  // advance to the next position in the array:
  indexP1 = indexP1 + 1;

  // if we're at the end of the array...
  if (indexP1 >= numReadings) {
    // ...wrap around to the beginning:
    indexP1 = 0;
  }

  // calculate the average:
  averageP1 = totalP1 / numReadings;
  
  //Send to Serial
  
  //mapeo
  
  int temperatura = map(averageP1,879,903,1,54);
  
  //PLAYER 1
  Serial.print("P1: ");
  Serial.print(averageP1);
  Serial.print(" Temperatura: ");
  Serial.println(temperatura);
  
  delay(250); // delay in between reads for stability
}

Lo mismo el "problema" es que para una lectura de un rango de 53 grados, el analog read sólo cambia en 24. Por lo que es inevitable el salto de 2 a 3 grados en las lecturas.

Imagino que lo que hay que buscar, es que el diodo reaccione más o algo así, que nos dé un rango más amplio de lecturas.

Tendré que ver lo que tu comentaste del ARef usando otro voltaje como referencia, quizás se obtengan más lecturas.

Tenes que agregar esta linea

analogReference(INTERNAL);

eso pone automaticamente una referencia interna de 1,1V que por defecto es 5, asi es que tendras unas 5 veces mas rango.
Saludos

Si, algo de eso vi que habías hecho, pero no entendí por que te funcionó :stuck_out_tongue:

Digamos que mi lectura del sensor era de por redondear, 512, eso serían 2.5 Volts, si ponía eso del INTERNAL me iba a marcar siempre 1023

No se de donde se me ocurrió que el Diodo, podía actuar como una resistencia de 160ohms, entonces lo usé como un "Voltage divider" e hice esto.

Con este esquema, si me pasaba como en tu código, que al aumentar la lectura, era al momento de poner en agua fría, y los números bajaban al ponerlos en agua caliente (Con lo que hice siguiendo tu blog era al reves)

Bueno, luego usé este código (Lo pongo, pero no es bonito, falta depurarlo muchísisisimo)

const int numReadings = 10;
const int tempnumReadings = 10;


int inputPinP1 = A0;

int readingsP1[numReadings];
int indexP1 = 0;
int totalP1 = 0;
int averageP1 = 0;

int tempreadingsP1[tempnumReadings];
int tempindexP1 = 0;
int temptotalP1 = 0;
int tempaverageP1 = 0;


void setup()
{
  Serial.begin(9600);
  
  //Lenamos los arrays con ceros
  for (int thisReading = 0; thisReading < numReadings; thisReading++) {
    readingsP1[thisReading] = 0;
  }
  for (int thisReading = 0; thisReading < tempnumReadings; thisReading++) {
    tempreadingsP1[thisReading] = 0;
  }  
  
  analogReference(INTERNAL);

}

void loop() {
  // subtract the last reading:
  totalP1 = totalP1 - readingsP1[indexP1];
  // read from the sensor:
  readingsP1[indexP1] = analogRead(inputPinP1);
  // add the reading to the total:
  totalP1 = totalP1 + readingsP1[indexP1];
  // advance to the next position in the array:
  indexP1 = indexP1 + 1;

  // if we're at the end of the array...
  if (indexP1 >= numReadings) {
    // ...wrap around to the beginning:
    indexP1 = 0;
  }

  // calculate the average:
  averageP1 = totalP1 / numReadings;
  
  int tempe = map(averageP1,660,563,400,5900);
  
  //Creamos el array de temperaturas
  
    // subtract the last reading:
  temptotalP1 = temptotalP1 - tempreadingsP1[tempindexP1];
  // read from the sensor:
  tempreadingsP1[tempindexP1] = tempe;
  // add the reading to the total:
  temptotalP1 = temptotalP1 + tempreadingsP1[tempindexP1];
  // advance to the next position in the array:
  tempindexP1 = tempindexP1 + 1;

  // if we're at the end of the array...
  if (tempindexP1 >= tempnumReadings) {
    // ...wrap around to the beginning:
    tempindexP1 = 0;
  }

  // calculate the average:
  tempaverageP1 = temptotalP1 / tempnumReadings;
  
  
  
  
  
  
  
  //Send to Serial
  
  float temperatura = tempaverageP1/100.00;
  
  int voltage = map(averageP1,0,1023,0,110);
  
  float volts = voltage/100.00;
  
  //PLAYER 1
  Serial.print("P1: ");
  Serial.println(averageP1);
  Serial.print("Volts: ");
  Serial.println(volts);
  Serial.print("Temperatura: ");
  Serial.println(temperatura);
  
  delay(500); // delay in between reads for stability
}

Este código hace 10 lecturas y saca un promedio, y también almacena 10 temperaturas y saca un promedio (estos números se pueden modificar)

También obtengo decimales, ya que en lugar de "mapearlo" entre 4º y 59º (son las temperaturas que usé en su calibración) lo mapeo de 400 a 5900 y luego divido por 100. Claro que tampoco obtengo resultados de 0.01 para cada cambio, pero al entrar 10 valores y luego sacar un promedio, entonces si, la salida es más estable y bonita.

Prometo depurar el código y ponerlo una vez listo :slight_smile:

Espero que puedas sacar algo en limpio de mi método, y me corrijas en lo que haya hecho mal.

PD: La R1 en el esquema es una de 1000 ohms (1 Kohms) (marrón - negro - rojo)