Arduino Forum

International => Italiano => Software => Topic started by: LOLLO65 on Sep 09, 2020, 03:02 am

Title: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 09, 2020, 03:02 am
salve A tutti, gli Arduiniani
dopo qualche mese mi sono cimentato in nuovo proggettino per leggere la temperatuta del motore della  moto e indicarla con due led 7seg per ragioni di spazio sul cruscotto.
Girando sul web ho trovato un schema semplice che fa al caso mio ed ancke lo sketch.
Originariamente lo sketch aveva qualche errore che ho eliminato.
Ora lo sketch funziona correttamente con imprecisione di +- 1 ° almeno sul simulatore proteus8.1
 
Quando misura temperature (es 15° e 16°) li indica come 19 e 18, mentre il 17 torna ad indicarlo corretamente, se imposto una temperatura a 18° rimane ad indicare 17°,
Che una erronea conversione AD di un grado mi sta anche bene ma non che mi indichi un numero sballato. Questa erronea indicazione si ripete per ogni decade dei numeri rappresentati allego qualche foto dove si vede la temp a 44° 45, 46, 47.

ho provaro anche  aseguire un suggerimento di usare il Aref per aumentare un po di èpiù la precisione di lettura ma nulla cambia rimene sempre quella indicazione anomala.

 
Qui di seguito trovate anche lo sketch.
ci sto sbattendo da 1 gg ma non riesco a caprire dove sia l'errrore di conversione o di rappresentazione.
Ho visto anche che ci sono circuiti che utilizzano dei 74hc595 per pilotare i led 7seg in multiplex che andrò sicuramente ad usare ma prima voglio capire, se mi aiutate vi rinhrazio, dov'è l'errore   


Un sentito grazie a tutti coloro che mi diano suggerimenti.

Code: [Select]

int analogPin = A0;     // sensore TM36 applicato al analog pin A0
float temp =0;         
int val = 0;           // variabile di lettura temp

byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };
 
    void setup()
{
  Serial.begin(9600);          //  setup serial
  /*pinMode(0, OUTPUT);  //unita a primo led
  pinMode(1, OUTPUT);  //unita b
  pinMode(2, OUTPUT);  //unita c
  pinMode(3, OUTPUT);  //unita d
  pinMode(4, OUTPUT);  //unita e
  pinMode(5, OUTPUT);  //unita f
  pinMode(6, OUTPUT);  //unita g
  pinMode(7, OUTPUT);  //decine A 2ndo led
  pinMode(8, OUTPUT);  //decine B
  pinMode(9, OUTPUT);  //decine C
  pinMode(10, OUTPUT); //decine D
  pinMode(11, OUTPUT); //decine E
  pinMode(12, OUTPUT); //decine F
  pinMode(13, OUTPUT); //decine G
  */
  DDRD=0b11111111;
  DDRB=0b00111111;
//utilizzando l'istruzione analogReference
 //indico al convertitore AD che deve impiegare
 //la tensione presente sul pin AREF come
 //valore di riferimento per la conversione
 analogReference(EXTERNAL);  // 3.3V

}

void loop()
{
 
 //init variabile
 val = 0;
 //eseguo un ciclo
 for(byte Ciclo = 0; Ciclo<100; Ciclo++)
 {
  //acquisisco il valore e lo sommo alla
  //variabile
  val += analogRead(0);
  float temp= val;
  //questo ritardo serve per dare il tempo
  //all' ADC di eseguire correttamente
  //la prossima acquisizione
  delay(10);
 }

 //eseguo la media dei 100 valori letti
 val /= 100;
 //calcolo la temperatura in °C
 temp = ((val * 0.003222) - 0.5) / 0.01;  // 0.003222 valore di precisione di conversione AD

  int pin=0 ; // per i primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G
// Serial.println("temperature in C =");
 //Serial.println(temp); // debug value

  int tempH;//high number
  tempH=int(temp/10);
 
  int tempL; //low number
  tempL=int(temp-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}
  delay(1000);
 
}

Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 09, 2020, 08:59 am
A parte il programma un po'  contorto
A parte almeno una variabile inutile

Secondo me quella formula è sbagliata

E non solo la formula, anche la acquisizione ha qualcosa che non va
Title: Re: Lettura Temperatura con Sensore TM36
Post by: gpb01 on Sep 09, 2020, 10:13 am
>LOLLO65: scusa, per chiarire, ma tu stai usando il TMP36 (https://www.analog.com/media/en/technical-documentation/data-sheets/TMP35_36_37.pdf)?  ... perché TM36 non mi dice nulla ... ::)

SE e solo SE, stai usando il TMP36, ricorda che il suo range va da -40 a +150 e che quindi, dal valore di temperatura calcolato occorre sempre sottrarre 50.

Questo il codice che io uso su ESP8266 collegando direttamente il sensore al pin analogico del ESP:

Code: [Select]
void getTemperature() {
   int   rawvoltage = analogRead(LM35_PIN);
   float celsius    = ( (float) rawvoltage * 0.3125 );
#ifdef USE_TMP36
   celsius -= 50.0;
#endif
}

... funziona sia con TMP35 (che non va sotto zero) che con TMP36 (che va sotto zero). Il pin analogico è definito come LM35_PIN indipendentemente dal tipo di sensore ed una #define (USE_TMP36) mi dice se sto usando o meno il TMP36.

Guglielmo
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 09, 2020, 10:42 pm
Ciao ragazzi,
cerco di procedere con domando che mi avete posto, la seriale la usata usate solo per vedere a quali valori covertiti corrispondeva la tesione fornita dal TMP36 e poi se i valori di temp sul serial monitor erano esatti ed ottenevo una corretta corrispondenza con la temp impostata sul sensore, che si Guglielmo hai ragione è il TMP36, con uno scarto di +- 0.2°.

Che il programma sia contorto lo capisco, date le mia scarse conoscenze di programmazione.
Ho ovviamente copiato ed incollato diversi programmi da differenti sketch e cercato di metterli insieme da questo deriva il caos del programma.
Igor a quale variabile in piu ti riferisci?
Per la formula è indicata su un link che da info su come usare il TMP36, cmq prima ho verificato e scritto il valore covertito in digitale da Arduino uno r3 dei valori di tensione fornita dal TMP36, es a 10° il TMP36 fornisce il valore di 0.6 volt che convertiti Arduino indica in 123, 20 ° =143, 30°=164 e cosi via 100°=307.
in definitiva ogni 10° ho uno step AD di 20 usando la tensione di alimentazione a 5V.
Applicati i valori digitali alla formule, usando il ext ref. ((123*0.03222) -0.5 )/0.01; dove 0.5 sono il voltaggio fornito dal TMP36 a 0°C e 0.01 sono i 10mV x ogni grado centigrado, mi restituisce.......
Ho capito dove è l'errore nella formula.
Devo verificare i valori AD convertiti con il Aref a 3.3v. Probabile anche nello schema elettrico abbia commesso l'errore di alimentare il sensore con 5 V anziche con 3.3V; mentre se applico il val di precisione ottenuto da 5/1024 la formula mi restituisce esattamnete 10.05° ed alimentando il sensore a 5V.
Ho apportato modifiche alla formula ora lo sketch funziona bene con una indecizione di -1° (accettabile), es a 70° impostati sul TMP36 di ad un valore di 69°
Con un piccolo aggiustamento al 0.01 messo a 0.00985 Arduino mi indica un val di 71 anziche 70, 

In Ogni Caso è grazie ai vostri suggerimenti, che mi danno la possibilità di riflettere sugli errori, che si sistema tutto.
Guglielmo mi cimenterò ad utilizzare la tua soluzzione.

Grazie ancora.
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 07:28 am
Allora vediamo un po'

Ipotizziamo 60 gradi, per semplicità
Fa 1.1 volt di uscita del sensore

Diviso 3,3 del riferimento e moltiplicato 1023 di fondo scala del convertitore fa 341 di uscita dallo adc

Tu fai cento letture e le sommi tutte
Questo da una somma di (circa, i valori sono solo stimati) di 34100

Non noti nulla?

Inoltre durante la somma, nel ciclo for, scrivi
Code: [Select]

float temp=val;

Variabile locale che muore alla fine del for

Inoltre ti consiglio di ripensare anche a 'come' fai i calcoli, non solo a che calcoli fai
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 12:40 pm
Questo il codice che io uso su ESP8266 collegando direttamente il sensore al pin analogico del ESP:

Guglielmo
Pausa pranzo grande noia

Riprendo il filo della discussione e noto una cosa

Ma ti funziona il codice che hai postato?

Perché è una funzione void, infatti manca il return, ma usa solo variabili locali...

Mi rimane dubbio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 10, 2020, 01:00 pm
...
Ma ti funziona il codice che hai postato?
...
Credo abbia messo una funzione con gli elementi minimi indispensabili a capire il concetto più che una funzione veramente funzionante.

...
SE e solo SE, stai usando il TMP36, ricorda che il suo range va da -40 a +150 e che quindi, dal valore di temperatura calcolato occorre sempre sottrarre 50.
...
So che Guglielmo con 2000 datasheet in testa è sicuramente andato a memoria, ma:
dal datasheet linkato, leggo " The TMP36 is specified from −40°C to +125°C, provides a 750 mV output at 25°C"
Quindi occhio che il range è da -40 a +125, quindi va sottratto 40 e non 50.

Aspe', fermi tutti, anche tu avevi indicato il -40 come min, quindi perchè sottraevi 50? Il max è ininfluente al fine della discussione, quindi chissene...
L'uscita non parte da zero in corrispondenza del -40?
Ora rileggo bene il datasheet per scoprire l'arcano.

EDIT: eliminato tutto perchè ho sbagliato io a leggere il datasheet. Guglielmo è stato redento perchè l'errore sul max è un peccato veniale  ;D

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 01:07 pm
Credo anch'io

Pero siccome sembrava una citazione...

C'è gente che copia e poi è capace di risponderti:
"tu hai torto e io ho ragione, perché io ho copiato da uno più bravo di te"

E non sto scherzando, mi è successo sul serio...

Quindi non vorrei un giorno sentirmi dire che io sbaglio a usare il return perché Gugliemo non lo fa....

Per la seconda parte: temo che si debba proprio togliere 50

Perche non sono gradi, ma corrispondono allo 'zoccolo' do 500 mV
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 10, 2020, 01:09 pm
Si, ho visto, si capisce bene da questa immagine del datasheet.

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=381255)

La curva B parte da 0 a -50 e sale in modo lineare, quindi è giusto sottrarre 50.
Che poi il cip a -50 non funzioni più correttamente perchè fuori range è un'altro problema.

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: gpb01 on Sep 10, 2020, 01:21 pm
Ma ti funziona il codice che hai postato?
... :D ... in realtà la funzone continua con altre cose che, per semplifcare e mostrare SOLO la parte calcoli ho eliminato.

In pratica, alla fine, converte in una string (globale) il valore letto, string che poi viene usata nella trasmissione HTTP :D

Guglielmo
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 10, 2020, 09:10 pm
Salve Ragazi, non pensavo di scatenare tanti commenti cmq benvengano.
Io lo ho detto che sono alle prime armi con la programmazione e il mio applicarmi a cio è saltuario e ho anche detto di aver copiato ed incollato vari pezzi di sketch.
Mi scuso se ho dato l'impressione di esprimere concetti e di saperne molto di più di voi, non è mia intenzione,  se  ero così esperto non chiedevo il vostro aiuto; che è sempre gradito.
E' gradito il vostro aiuto al fine di mettere un po di ordine allo sketch.

Mi scuso con Standaroil se non ho seguito il suo primo commento. per la formula funziona bene se anziche inserire il 0.003222 utilizzando il external ref,  vi inserisco il 0.0048828 del gardo di percisione.,
lo ho scritto che avevo capito dove era l'errore commesso nell'utilizzare la formula di coversione.

Per rispondere a IGOR, per i serial begin e println li ho disattivati al momento di utilizzare i 7seg, mi servivano nella prima fase per vedere il val ADC e il valore di temp fornito dal simulatote.

Poi che il misurare temperatura con arduino è più che ampiamente argomentato e con vari metodi.

Se mi aiutate a mettere ordine allo sketch vi clicco 1000 Karma :)  :)  :)  :)
Vi posto l'ultimo sketch con il quale ottengo, a mio parere e per ora solo sul simulatore, buoni risultati con indicazione di +-0.5 gradi.

Code: [Select]

int val_Adc = A0;     // sensore TMp36 applicato al analog pin A0
float temp =0;         


byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };
 
    void setup()
{
 /* Serial.begin(9600);          //  setup serial
  pinMode(0, OUTPUT);  //unita a primo led
  pinMode(1, OUTPUT);  //unita b
  pinMode(2, OUTPUT);  //unita c
  pinMode(3, OUTPUT);  //unita d
  pinMode(4, OUTPUT);  //unita e
  pinMode(5, OUTPUT);  //unita f
  pinMode(6, OUTPUT);  //unita g
  pinMode(7, OUTPUT);  //decine A 2ndo led
  pinMode(8, OUTPUT);  //decine B
  pinMode(9, OUTPUT);  //decine C
  pinMode(10, OUTPUT); //decine D
  pinMode(11, OUTPUT); //decine E
  pinMode(12, OUTPUT); //decine F
  pinMode(13, OUTPUT); //decine G
 */ 
  DDRD=0b11111111;
  DDRB=0b00111111;

}

void loop()
{
 delay(300);
 //init variabile
 val_Adc = analogRead(A0);
 //eseguo un ciclo
 for(byte Ciclo = 0; Ciclo<100; Ciclo++)
 {
  //acquisisco il valore e lo sommo alla variabile val_Adc
  val_Adc += analogRead(A0);
  float temp = val_Adc;
  //questo ritardo serve per dare il tempo
  //all' ADC di eseguire correttamente
  //la prossima acquisizione
  delay(10);
 
 }

 //eseguo la media dei 100 valori letti
 val_Adc /= 100;
// calcolo la temperatura in °C
 temp = ((val_Adc * 0.0048828125) - 0.5) / 0.00998;

// Serial.println("temperature in C =");
 //Serial.println(temp); // debug value

  int pin=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G

  int tempH;//high number
  tempH=int(temp/10);
 
  int tempL; //low number
  tempL=int(temp-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}
  delay(500);
 
}


Grazie in ogni caso a tutti.
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 09:20 pm
ma con che temperature hai provato?
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 10:30 pm
Se mi aiutate a mettere ordine allo sketch vi clicco 1000 Karma :)  :)  :)  :)
Ci conto, comincia ad aggiungere Karma........

Code: [Select]

int val_Adc = A0;     // sensore TMP36 applicato al analog pin A0
float temp =0;         


byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };
 
    void setup()
{
 // Serial.begin(9600);          //  setup serial
 // mai tenere codice inutile commentato
  DDRD=0b11111111;
  DDRB=0b00111111;

}
 
void loop()
{
 delay(300);
 //init variabile
 val_Adc = analogRead(A0); // e questa è una lettura
 //eseguo un ciclo
 for(byte Ciclo = 0; Ciclo<100; Ciclo++)
 {
  //acquisisco il valore e lo sommo alla variabile val_Adc
  val_Adc += analogRead(A0);
  float temp = val_Adc;
// questa variabile non la usi mai ( e te lo avevo già detto)

  //questo ritardo serve per dare il tempo
  //all' ADC di eseguire correttamente
  //la prossima acquisizione
// sicuro che serva? magari rileggere il reference ti chiarisce le idee....
  delay(10);
 
 }
// e adesso alla fine del ciclo ne hai fatte altre cento, di letture


 //eseguo la media dei 100 valori letti

// 100? sicuro?
// quante letture hai fatto?
 val_Adc /= 100;

// calcolo la temperatura in °C
 temp = ((val_Adc * 0.0048828125) - 0.5) / 0.00998;
// ecco forse perchè devi dividere per un nnumero così strano

/*
e poi scusa: moltiplicho per 0.004882815, sicuro che ci siano così tante cifre significative?
che poi dividi per 0.00998

forse scrivere 0.48828125 e 0.998 dà lo stesso risultato con meno casini di calcolo
moltiplicare e dividere per uno stesso numero non cambia il risultato, aritmetica da 4 elementare
te lo avevo detto di guardare "come" fai i calcoli, non solo "che" calcoli fai
*/

  int pin=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G

  int tempH;//high number
  tempH=int(temp/10);
 
  int tempL; //low number
  tempL=int(temp-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}
  delay(500);
 
}


Leggi i commenti che ti ho scritto nel programma

che mi sono meritato una buona fetta dei 1000 karma promessi

quando vedrò moneta ti mostrerò il resto del cammello
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 10, 2020, 10:47 pm
Con il simulatore (proteus8.1) le letture da 0° a 98° con indicazione di quest ultima a 99°.
Il mio campo di misura arriva fino 90°.
Poi ho dato una pulita allo sketch eliminando il cilo for e media, funziona lo stesso.
il valore 0.048828125 è cio che risulta dal calcolo 5/1024. So di per certo che non è necessario mettere un valore così lungo ed era solo una mia curiosita.
Mettere 0.00998 mi è servito solo per far leggermente sovrastimare la temperatura che con 0.01 invece me la sottostimava di 1° (es a 98 ° serduino indicava 97°), sicuramente dovuto ad approssimazioni della conversione.

PS  spero che il cammello non si chiami Serafino.  :D.

Standardoil, posso chiederti l'origina del tuo nick name?
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 10:52 pm
Tu facevi 101 letture e dividevi per 100, ecco l'origine delle varie imprecisioni

cambia simulatore, quello che usi è fallato

sommare 100 (e una) letture su una variabile int ti fa superare 32mila e fischia per temperature oltre i 60 gradi

questo è il significato del mio post di stamattina

se il tuo simulatore non va in overflow cambialo, non è adatto a fare prove che abbiano un minimo di affidabilità

per il resto domani, adesso è tarduccio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 10, 2020, 11:03 pm
Capisco ke da te è tarduccio , qui dove sono io negli USA sono le 5pm.
ok grazie in ogni caso.

A domani. Buona notte :smiley-sleep:

Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 10, 2020, 11:11 pm
ah, scusa, prima di nanna


il mio nick?

il mio papà mi ha chiamato Nelson......

e i miei compagni di scuola hanno "equivocato" con un noto membro di una famiglia di petrolieri

in particolare quando all'ITIS ci hanno fatto vedere una serie di filmati di fisica sponsorizzati dalla casa petrolifera in questione

e il soprannome mi è piaciuto e mi è rimasto
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 11, 2020, 06:51 pm
Ho avuto l'impressione che lavorassi per una qualche compagnia petrolifera o di indagini petrolifere dato l'inconsueto nick name che solitamente è usato da persone che lavorano nel settore.
Settore per il quasle ho lavorato, ora invece effettuo indagini geologia marina finalizzate all'installazione di generatori elettrici eolici. 
Tra qualche ora è in arrivo un uragano, il mare si sta inc......do e noi stiamo rientrando in porto ma si balla che non ti dico.
Infatti Gli US dopo qualche decenni rispetto all'europa sta investendo molto sul settore energetico green "diciamolo".
Infatti la Stardardoil è una compagnia Americana https://www.britannica.com/topic/Standard-Oil, il cui magnate era il famoso John D. Rockefeller. Nel link la storia di ST.oil.

finisco di sistemare lo sketch e poi lo riposto, vediamo se ho aggiustato tutto come si deve.
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 11, 2020, 07:58 pm
Allora spero di aver fatto abbastanza ordine:
1) aggiunta una variabile sensroPIN,
2) corretto nr acquisizioni a 99 per ottenere le 100 acquisizioni.
3)eliminata variabile float temp,
4) reimpostati valori formula conversione °C

Code: [Select]

//lettura temperatura con sensore TMP36

int sensorPIN = A0;
int val_Adc = 0;     // sensore TMp36 applicato al analog pin A0
float temp =0;         

byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };
 
    void setup()
{
 /* Serial.begin(9600);          //  setup serial
  pinMode(0, OUTPUT);  //unita a primo led
  pinMode(1, OUTPUT);  //unita b
  pinMode(2, OUTPUT);  //unita c
  pinMode(3, OUTPUT);  //unita d
  pinMode(4, OUTPUT);  //unita e
  pinMode(5, OUTPUT);  //unita f
  pinMode(6, OUTPUT);  //unita g
  pinMode(7, OUTPUT);  //decine A 2ndo led
  pinMode(8, OUTPUT);  //decine B
  pinMode(9, OUTPUT);  //decine C
  pinMode(10, OUTPUT); //decine D
  pinMode(11, OUTPUT); //decine E
  pinMode(12, OUTPUT); //decine F
  pinMode(13, OUTPUT); //decine G
 */ 
  DDRD=0b11111111;
  DDRB=0b00111111;

}

void loop()
{
 delay(300);
 //init variabile
 sensorPin = analogRead(A0);
 //eseguo un ciclo
 for(byte Ciclo = 0; Ciclo<99; Ciclo++) // 0-99 =100 acquisizioni
 
  //acquisisco il valore sensorPin e lo sommo alla variabile val_Adc
  val_Adc += analogRead(sensorPin);

 //eseguo la media dei 100 valori letti
val_Adc /= 100;  //controllare il reference /=
// calcolo la temperatura in °C
 temp = ((val_Adc * 0.0048828125) - 0.5) / 0.01; //  (valore da usare senza applicato il Vref 0.0048828125
// Serial.println("temperature in C =");
 //Serial.println(temp); // debug value

  int pin=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G


  int tempH;//high number
  tempH=int(temp/10);
 
  int tempL; //low number
  tempL=int(temp-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}
  delay(500);
 
}


Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 12, 2020, 05:08 am
Avevo dimenticato di aggiustare sensorPIN, fatto anche questo.  :smiley-confuse:
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 12, 2020, 11:00 am
Ho come l'impressione che tu non abbia un IDE davanti su cui testare il codice, è corretto?
Stai scrivendo tutto "a secco", vero?
Giusto per capirsi, così evitiamo incomprensioni e sappiamo che più che di codice funzionante si tratta di pseudocodice concettuale da rivedere nei dettagli una volta disponibile un IDE e un Arduino.

Detto questo, la mia domanda è:
Perchè continui a fare una lettura fuori ciclo?
Io per maggior chiarezza farei un reset fuori ciclo e poi le 100 letture tutte nel ciclo, così non rischi più di incasinarti con la media da 100 o 101, della serie: boh, vediamo se ho fatto altre letture sparse...
Tenere il codice semplice e lineare aiuta a mantenerne il controllo nel tempo.

Nel codice, poi, la lettura fuori ciclo l'hai fatta mettendo le variabili un po' a caso e scritte un po' a caso (da cui la premessa di cui sopra)

A parte il case sui nomi, che salterà all'occhio in fase di compilazioni, per cui al momento chissene...
La lettura fuori ciclo la fai scrivendo su sensorPin (che all'anagrafe sarebbe invece sensorPIN) invece che su val_Adc.

Poi, mi sa, che non hai colto il suggerimento sulle cifre significative.
Il concetto non era tanto sulla quantità di cifre, ma sul fatto che moltiplichi e dividi per numeri molto più piccoli di 1, quindi ti porti dietro tanti zeri.
Il suggerimento era di moltiplicare sia dividendo che divisore per lo stesso multiplo di 10 ottenendo valori più gestibili per le variabili utilizzate.
Ad es. se la variabile riesce a gestire 8 cifre significative, al dilà dell'esponente, e tu parti da 0,000... te ne sei già giocate 4 perdendo quelle oltre l'ottava.
Era questo il concetto che si voleva esprimere.

Ultimissimo suggerimento, per aiutare chi cerca di aiutarti, quando lo posti il codice, elimina tutti i pezzi di codice commentati perchè non servono alla discussione e creano solo confusione, tienili pure nel tuo sketch per il tuo debug, ma se qui li elimini non rischi incomprensioni.

Per il resto: in bocca al lupo per l'uragano, spero nulla di catastrofico.

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 12, 2020, 11:21 pm
Esatto per il momento non ho un IDE su cui testare il tutto, perche sono imbarcato su una nave oceanografica per idagini geologiche finalizzate alla costruzione di impianti Eolici, per cui mi limito a verificare il funzionamento del solo sketch, è quello che posso fare, Poi quando tornero a casa affronterò il problema con assemblaggio IDE.
Per ora ragiono sui tuoi suggerimenti.
Per l'uragano niente problemi siamo rientrati in porto. 

Grazie in ogni caso. aggiungo karma
Title: Re: Lettura Temperatura con Sensore TM36
Post by: zoomx on Sep 13, 2020, 07:34 pm
Domanda: perché un sensore analogico TMP36?
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 13, 2020, 08:40 pm
Perche mi serve di capire come arduino funziona dato che sono ancora alle prime esperienze.
Poi dalle caratteristiche sembra migliore del LM35,
poi perche volevo utilizzarlo sulla mia moto, che ha l'indicatore della temperatura a lancetta e a me piace vedere l'effettivo nr in °C di temperatura.
L'indicatore a lancetta è alimentato ovviamente in tensione e pensavo di applicarla ad arduino togliendo il sensore, apportando le necessarie modifiche per rispettare il valori di tensione da applicare ad arduino.
Il TMP36 così come LM35 possono essere facilmete messi a contatto con il motore della moto o inseriti in un tools che viene inserito sul circuito di raffreddamento della MOTO.
Potrei anche utilizzare direttamente un sensore digitale utilizzando altri schemi elettrici e sketch.
Per ora faccio un pò di esperienza con questo.

Se hai qualche suggerimento su altri sensori sono ben accetti.
Grazie della Domanda.

Saluti Lorenzo
Title: Re: Lettura Temperatura con Sensore TM36
Post by: zoomx on Sep 14, 2020, 10:03 am
I sensori analogici con uscita in tensione hanno il problema che possono prendere disturbi lungo il fili che lo collegano all'Arduino.
Se vuoi mantenere l'analogico dovresti usare quelli con uscita in corrente, cosa che però complica l'acquisizione perché devi aggiungere un circuito adattatore.
Il digitale dovrebbe risolvere. Se usi i DS18B20 ne puoi usare parecchi collegati tutti con solo 3 fili, sono indirizzabili. Il lato negativo è che sono un po' lenti, hanno bisogno di circa 700 millisecondi per effettuare una misura (alla massima precisione altrimenti il tempo scende) anche se puoi comandare la misura per tutti e dopo 700 millisecondi leggerli tutti alla massima velocità.
Se però vuoi misurare la temperatura sul motore devi tenere conto che se il sensore va oltre i 100 gradi il cavetto magari no.
Oltre i 150 ci sono praticamente solo gli analogici, termocoppie, Pt100 e NTC, per le prime 2 esistono delle schedine con il convertitore apposta per utilizzarli con Arduino.
Quindi il sensore va scelto in funzione dell'uso, dipende dall'intervallo di temperature, dalla precisione e accuratezza richiesta, dalla frequenza di acquisizione, dal tempo di equilibrio, dalle dimensioni e così via. Anche dal costo.
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 15, 2020, 06:17 am
Ciao ZoomX,
Ti ringrazio dei suggerimenti sui Sensori,
L'ideale sarebbe utilizzare una termocoppia appliucata ad un Amp operazionale opportunatamente calibrato.
Avrei anche lo schema elettrico dell'operazionale oppure usare lo schedino convertitore predisposto per Arduino, Vedrò come si comporta il circuito e poi studirò gli step successivi.
 

Ora rispondo alla domanda di Maubarzi(Perchè continui a fare una lettura fuori ciclo?),
L'IDE su cui testo gli sketch è 1.8.12 lo avevo frainteso con la disponibilità di una board arduino che non ho, 
In effetti il caos dello skect deriva da il copia ed incolla di alcuni sketch.
Mi sono messo quindi a riflettere su dove era l'errore e ripensando anche a come acquisivo le misure e ho riscritto lo sketch confrontandolo con altri esempi e ho notato le differenze.
Ora sono giunto a questo sketch mi funziona bene ma quando arrivo a misurare 95 mi indica 94 sul 7seg, a 97 indica 96.97 sul virtual monitor e 96sul 7seg, quando misuro 99 sul sensore mi indica 98 sul 7seg,
Tutto questo avviene sempre sul simulatore. 

Segue solo la prima parte dello sketch fino al coalcolo temperatura.
Code: [Select]

int misure[20];
int somma;
int media;
                     
 
void setup()
{
//DDRD=0b11111111;
//DDRB=0b00111111;
Serial.begin(9600);
}
 
void loop(){ 
 analogRead(A0); 
 int i;
  for (i=0;i<20;i++){
    misure[i]=analogRead(A0);
    Serial.println(misure[i]);
 
 }
  somma=0;
  for (int i=0;i<20;i++) {
  somma=somma+misure[i];
 // media=somma/20;
 
  }
 media=somma/20;
  Serial.print("la media e' ");
 Serial.println(media);
 
 
 float voltage = media * 5.0;
 voltage /= 1024.0;

 
 float temperatureC = (voltage - 0.5) * 100 ; 
                                               


 
Spero sia corretto questa volta.

Quello che noto sul serial monitor è che le letture avvengono rapidamente e ogni xtempo dato dal delay viene stampata la temperatura.
Cè un modo per fare le letture 1 al secondo? Sicuramente mi direte di si usalndo il millis.  :(  ::)

Grazie ancora,
PS ogni gg continuo a darvi Karma.



 
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 15, 2020, 09:14 am
Le letture analogiche, hanno si 1024 valori, ma vanno da 0 a 1023, quindi il tuo fondoscala è 1023 e non 1024.
Poi

Code: [Select]

 float voltage = media * 5.0;
 voltage /= 1024.0;


lo puoi fare usando la funzione map() (https://www.arduino.cc/reference/en/language/functions/math/map/) che fa proprio questo tipo di conversioni.

Poi, mi sa che hai problemi di arrotondamento sulle varie variabili.

Un consiglio che mi sentirei di darti è di evitare i float e di usare operazioni su interi, messe nell'opportuno ordine e stando attenti agli overflow.
Come fare con i decimali? Moltiplichi tutto per un multiplo di 10 tale da rendere interi i decimali che ti servono.
Ad es. i 100°C verrebbero rappresentati con 10000.
In questo modo si evitano arrotondamenti strani dei float e piloti tu il risultato che vuoi ottenere.
Non sempre gli arrotondamenti fatti sono quelli consueti, a volte si va solo per troncamento.

Da 10000 per ottenere i gradi basta dividere per 100 (che sugli interi produce già una divisione intera) e per i decimali basta che usi l'operatore % che ti restituisce il resto della divisione intera.

Per la temporizzazione, si, il consiglio e il modo giusto per farle è di usare millis().
E' una brutta bestia? Ti ci sei già imbattuto con scarsi risultati? Alla fine è solo una questione di adattarsi al modo di ragionare dei micro, fatto questo passo ti diventa tutto più naturale. All'inizio può essere antiintuitivo, ma solo perchè non siamo abituati a pensare formalmente a come parallelizziamo le varie operazioni che facciamo tutti i giorni, ma se ci pensi bene, l'approccio umano è molto più vicino all'uso di millis che di delay.

Se vuoi tenere sotto controllo il codice, potresti fare una funzione che fa una singola lettura completa e poi nel loop richiamarla con la logica di utilizzo di millis.

Code: [Select]

#define INTERVAL 1000

void setup() {
  unsigned long prev = millis();
}

void loop() {
  unsigned long curr = millis();
  if (curr - prev >= INTERVAL) { // Scritto così si evita il problema di overflow.
    letturaCompleta();
    prev = curr; // Fatto così cadenza in modo esatto anche se ci sono ritardi nell'esecuzione. Se fai prev = millis(), invece, la cadenza sarà INTERVAL + delta
  }
}


Con questo approccio, ogni compito è isolato in una singola funzione che diventa più leggibile perchè fa meno cose.
Come noti il loop è semplicissimo e si capisce subito cosa fa.
Ogni funzione che vuoi schedulare la puoi richiamare in questo modo con la sua variabile prevXXX dedicata e il suo INTERVALXXX relativo.
Ne metti 2+ in fila e hai un esempio di multi tasking elementare.  ;D

Se ti permangono problemi con decimali o differenze varie, il consiglio è di mettere dei Serial.print nei vari valori per capire da dove derivano e poi agisci di conseguenza cambiando strategia sugli arrotondamenti.

Grazie ancora,
PS ogni gg continuo a darvi Karma.
Dalli quando sono veramente meritati, altrimenti il meccanismo non diventa più meritocratico e perde di significato, oltre a stimolare a tirarla in lungo per guadagnarne di più  :P  :D

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 15, 2020, 07:59 pm
Ciao Maubarzi e grazie dei suggerimenti, quanta carne al fuoco, almeno per me,  molto interessanti e mi ci dedicherò.
Comincio a comprendere meglio il millis con gli esempi che hai fatto. andro anche a leggermi tutto sulla funzione map().
Grazie

Ve ne avevo promessi mille di K.
Consentimi, però, di dartene ancora uno credo ke te lo meriti.






 
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 15, 2020, 08:21 pm
Si nel millis mi ci sono già imbattuto e poi sono riuscito ad attenere cio che volevof acendo lampeggiare 3 led raggiunto un determinato valore.

Stavo provando ad inserirlo nello sketch ed cio ottenevo era solo la lettura di analogRead, x la somma e media ottenevo dati errati.

Ciao grazie ancora   
Title: Re: Lettura Temperatura con Sensore TM36
Post by: zoomx on Sep 15, 2020, 09:18 pm
Per le termocoppie ci sono degli integrati apposta che poi tu interroghi, Maxim se non sbaglio, li fa anche per le Pt100. Li quello che costa poi è il singolo sensore se lo vuoi di qualità.

I valori vanno da 0 a 1023 e le tensioni vanno da 0 a 4.99 non 5V. O meglio fino alla tensione di riferimento meno la tensione di riferimento diviso 1024 (c'è scritto nel datasheet). Se usi la USB già la tensione di riferimento può essere 4.97 volt o anche meno, ecco perché preferisco i sensori digitali. I chip tipo il Maxim poi ci pensano più o meno loro.

Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 15, 2020, 11:08 pm
Io per aumentare la precisione delle letture uso dei voltage reference, ad es. il LM336 a 2,5V fisso oppure uno variabile, es. il TL431 che in base ai valori delle resistenze del circuito tipico ti permette di "scegliere" la tensione di riferimento desiderata.
Uso due pin analogici (che spreco  ;D ) con uno leggo il voltage reference conoscendo la tensione esatta e con l'altro la tensione di interesse.
Con il primo ho una taratura esatta, da cui si riesce anche a calcolare la tensione di alimentazione.
Basta fare le dovute proporzioni avendo come prima equazione, un'equazione con tutte le variabili conosciute.
Mi ci trovo bene perchè così sono sicuro della bontà delle letture, ovviamente fatte più ravvicinate possibile o anche con la media di N letture consecutive, giusto per non beccare dei picchi strani.

Per la temperatura, in genere anche io uso sensori digitali, ma in altri casi, dove l'uscita è analogica, adotto la tecnica dei voltage reference.
Cippettini che trovo super economici e molto interessanti per i miei scopi.
Ne ho presi a decine per poco più di 1 euro, spedizione inclusa, su AliExpress tempo fa e ora sono a posto per un bel po'.  8)

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 17, 2020, 02:57 am
Ciao Maurizio,
Grazie ancora dei tuoi suggerimenti, teorici e pratici.
infatti quello che non mi spiegavo era perche ottene vo dei valori di temperatura leggermente sottostimati.
Poi mi sono riletto il tuo post del 15 sept. ed ho apportato la correzione alla formula adesso il tutto mi funziona bene, infatti adesso alla temp di 99° corrisponde l'indicazione di 99 sul display,
Ogni valore letto sul display corrispoinde a quello impostato sul sensore.
Per me l'indicazione +- 1° è piu che soddisfacente.
Quello che mi lascia più sconcertato è che su alcune esempi nel web riportano la formula x il calcolo temperatuta con il dividendo 1024 anziche 1023.
Colpa mia di non conoscere bene tutte le caratteristiche della scheda Arduino.

Ho provato anche ad usare la funzione map() leggendo alcuni post in merito e prendendo spunto da uno sketch per un anemometro, ed ho scritto questo:

Code: [Select]

int misure[20];
int somma;
int sensore;
float media;
float TEMP=0;
float inMin=102;
float inMax=305;
float tensMin=0.5;
float tensMax=1.5;

byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };


void setup() {
 DDRD=0b11111111;
 DDRB=0b00111111;
// Serial.begin(9600);
}

float fmap (float TEMP, float inMin, float inMax, float tensMin, float tensMax)
 {
   return (TEMP- inMin) * (tensMax - tensMin) / (inMax - inMin) + tensMin;
 }

void loop(){
 // sensore=analogRead(A0);
 
 Serial.println(sensore);
 int i;
   for (i=0;i<20;i++){
    misure[i]=analogRead(A0);
  Serial.println(misure[i]);
 }
  somma=0;
  for (int i=0;i<20;i++) {
  somma=somma+misure[i];
 Serial.print("la somma e' ");
  Serial.println(somma);
 
  }

  media=somma/20;
Serial.print("la media e' ");
Serial.println(media);
 float voltage = (media * 500);
 voltage /= 1023.0;
float temperatureC = (voltage - 50);
TEMP = fmap(TEMP,inMin,inMax,tensMin,tensMax);
 Serial.print(" TEMP ");
 Serial.println(temperatureC);
 
 // usara il calcolo seguente per convertire in Fahrenheit
// float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
// Serial.print(temperatureF); Serial.println(" degrees F");
 int pin=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
 int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G


  int tempH;//high number
  tempH=int(temperatureC/10);
 
  int tempL; //low number
  tempL=int(temperatureC-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}

  delay(500);
}




Sicuramente non la ho impostata nel modo giusto.  Non ho trovato grandi benefici e ho deciso di eliminarla dallo sketch che adesso è questo:
Code: [Select]

int misure[20];
int somma;
int sensore;
float media;
float TEMP=0;
float inMin=102;
float inMax=305;
float tensMin=0.5;
float tensMax=1.5;

byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };


void setup() {
 DDRD=0b11111111;
 DDRB=0b00111111;
// Serial.begin(9600);
}


void loop(){
 // sensore=analogRead(A0);
 
 Serial.println(sensore);
 int i;
   for (i=0;i<20;i++){
    misure[i]=analogRead(A0);
  Serial.println(misure[i]);
 }
  somma=0;
  for (int i=0;i<20;i++) {
  somma=somma+misure[i];
 Serial.print("la somma e' ");
  Serial.println(somma);
 
  }

  media=somma/20;
Serial.print("la media e' ");
Serial.println(media);
 float voltage = (media * 500);
 voltage /= 1023.0;
float temperatureC = (voltage - 50);

 Serial.print(" TEMP ");
 Serial.println(temperatureC);
 
 // usara il calcolo seguente per convertire in Fahrenheit
// float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
// Serial.print(temperatureF); Serial.println(" degrees F");

 int pin=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
 int pin1=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G


  int tempH;//high number
  tempH=int(temperatureC/10);
 
  int tempL; //low number
  tempL=int(temperatureC-tempH*10);

  for(int j=0;j<7;j++)
  {
    digitalWrite(pin,seven_seg_digits[tempL][j]);
  pin++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(pin1,seven_seg_digits[tempH][i]);
 pin1++;}

  delay(500);
}

 
Sono più che contento, provero a far lampeggiare i display raggiunta una certa temperatura es 95°

Ciao Grazie ancora
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 17, 2020, 09:10 am
Ottimo, son contento che sei contento  ;D

Per il 1024, è una brutta bestia, perchè l'umano tende sempre a ragionare uno based, cioè iniziando a contare i valori da 1, invece in informatica è molto più comune iniziare da zero. Ci si incasinano in molti.

Per map(), no problem, tanto fa solo la proporzione che avevi fatto anche tu. semplicemente poteva rendere più compatto e leggibile il codice, ma se uno non ci è abituato, o non ci si trova, fa l'effetto contrario di peggiorare la leggibilità, quindi hai fatto bene a tralasciarla.

Ciao e buon proseguimento.
Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: gpb01 on Sep 17, 2020, 09:25 am
Quello che mi lascia più sconcertato è che su alcune esempi nel web riportano la formula x il calcolo temperatuta con il dividendo 1024 anziche 1023.
Ed infatti è sbagliato dividere per 1023, bisogna dividere per 1024  dato che gli step sono proprio 1024  :smiley-evil:  ...
... se ne è discusso molto tempo fa (... ed è sufficiente leggere con attenzione il datasheet per capire come funziona), comunque trovi tutto QUI (https://forum.arduino.cc/index.php?topic=225043.msg1629335#msg1629335) :)

Guglielmo

P.S.: Per uleriori spiegazioni .. ci si ritrova nel tardo pomeriggio :D
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 18, 2020, 03:03 am
Ciao ragazzi,
oggi sono contentissimo xkè ho implementato lo sketch con la brutta bestia del millis, come dice Maurizio.
Mi ero già inbattuto nel millis combattendoci per svariati giorni con un altro mio proggettino (indicatore di livello carburante), postato un po di tempo, da cui ho preso spunto.

Questa volta ci ho impiegato solo 1gg e quel che è bello, con mia somma sorpresa, è che i display lampeggiano alla temperatura impostata 95°, e continuano a lampeggiare anche quando la temp supera il limite impostato a 95 indicando 96,97,98,99. :D   
Per rispondere a Guglielmo, il 1024 credo sia solo una questione di conteggio matematico umano,
infatti come tu affermi e anche come afferma Maurizio nella discussione linkata rispondendo a Paolo; i numeri sono 1024 ed il 1024mo corrisponde al 1023 dell' ADC di Ardu.
Usando il 1023 mi ritornano le diciamo giuste conversioni.   

Ce un a cosa che non riesco a capire nel parte del calcolo della media come si vede dall'allegato
la lettura inizia con il 205 ( temp impostata 50°) ma la media restituita da un valore negativo perché la prima lettura, così come le successive, viengono subito divise x 20 (valore dell'array);
 poi proseguendo con le letture e la loro somma e media si stabilizzano; quando l'array vien riempito dalle 20 letture il ritorno della media è 205 e la temp indicata è 50°.

Domanda, la media non dovrebbe essere calcolata solo dopo che l'array è stato riempito con le 20 letture?


 Qui di seguito lo sketch che sottopongo al vostro parere.
Code: [Select]



int sensore = A0;

float TEMP=0;
int const fsize = [20]; 
int fil[fsize]; 
int i=0;
int j=0;
float avg=0;
const int ledPin0 = 0;
const int ledPin1 = 1; 
const int ledPin2 = 2;
const int ledPin3 = 3;
const int ledPin4 = 4;
const int ledPin5 = 5;
const int ledPin6 = 6;
const int ledPin7 = 7;
const int ledPin8 = 8;
const int ledPin9 = 9;
const int ledPin10 = 10;
const int ledPin11 = 11;
const int ledPin12 = 12;
const int ledPin13 = 13;
int ledState = LOW;


unsigned long previousMillis = 0;       
const long interval = 500;     

byte seven_seg_digits[10][7] =                                                           
  { //seg. a,b,c,d,e,f,g          nr
         { 1,1,1,1,1,1,0 },  // = 0 
         { 0,1,1,0,0,0,0 },  // = 1
         { 1,1,0,1,1,0,1 },  // = 2
         { 1,1,1,1,0,0,1 },  // = 3
         { 0,1,1,0,0,1,1 },  // = 4
         { 1,0,1,1,0,1,1 },  // = 5
         { 1,0,1,1,1,1,1 },  // = 6
         { 1,1,1,0,0,0,0 },  // = 7
         { 1,1,1,1,1,1,1 },  // = 8
         { 1,1,1,1,0,1,1 },  // = 9
   };


void setup() {
 DDRD=0b11111111;
 DDRB=0b00111111;

}

void loop(){
  sensore=analogRead(A0);
 
  fil[i]= sensore;
   if (i < (fsize-1)) i++;
  else i = 0;
  avg=0;
  for (int j=0; j< fsize; j++) {
    avg +=(float)fil[j];
  }
  avg = avg / (float)(fsize);   // questa la linea incriminata
 

 float voltage = (avg * 500);
 voltage /= 1023.0;
float temperatureC = (voltage - 50);


int DSP1=0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
 int DSP2=7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G

  int tempH;//high number
  tempH=int(temperatureC/10);
 
  int tempL; //low number
  tempL=int(temperatureC-tempH*10);

  for(int j=0;j<7;j++)
  {
   digitalWrite(DSP1,seven_seg_digits[tempL][j]);
  DSP1++;}
  for(int i=0;i<7;i++)
  {
   digitalWrite(DSP2,seven_seg_digits[tempH][i]);
 DSP2++;}

 
 unsigned long currentMillis = millis();
  if ( temperatureC >= 95 ){
 if (currentMillis - previousMillis >= interval) {
    // save the last time you blinked the LED
    previousMillis = currentMillis;
  if (ledState == LOW) {
      ledState  == HIGH;
 } else {
     ledState  = LOW;
     
    }
    digitalWrite(ledPin0, ledState);
    digitalWrite(ledPin1, ledState);
    digitalWrite(ledPin2, ledState);
    digitalWrite(ledPin3, ledState);
    digitalWrite(ledPin4, ledState);
    digitalWrite(ledPin5, ledState);
    digitalWrite(ledPin6, ledState);
    digitalWrite(ledPin7, ledState);
    digitalWrite(ledPin8, ledState);
    digitalWrite(ledPin9, ledState);
    digitalWrite(ledPin10, ledState);
    digitalWrite(ledPin11, ledState);
    digitalWrite(ledPin12, ledState);
    digitalWrite(ledPin13, ledState);
   
  }
  }
  delay(300);
}

 


Grazie per i vostri suggerimenti.

   

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=382159)
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 18, 2020, 03:10 am
correggo non è lan mesia in negativo ma la temperatura.

 
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 18, 2020, 07:20 am
Programma complicato, semplificati

Inoltre non vedo le stampe che dici di fare, in effetti anche se ci fossero non farebbero il problema che dici tu


E comunque devi dividere per 1024, questo è certo

Se hai misure errate usando 10234 stai sbagliando da qualche parte

Metti sempre il programma che fa le stampe che mostri, altrimenti fai come si dice : una scarpa e una ciabatta
Title: Re: Lettura Temperatura con Sensore TM36
Post by: gpb01 on Sep 18, 2020, 08:51 am
... Per rispondere a Guglielmo, il 1024 credo sia solo una questione di conteggio matematico umano,
infatti come tu affermi e anche come afferma Maurizio nella discussione linkata rispondendo a Paolo; i numeri sono 1024 ed il 1024mo corrisponde al 1023 dell' ADC di Ardu.
Usando il 1023 mi ritornano le diciamo giuste conversioni ...
Perdona la brutalità, ma ... stai scrivendo delle "sciocchezze" ... si DEVE dividere per 1024 e lo dice il "datasheet", non "una questione di conteggio umano" ... evidentemente, NON hai letto neanche con attenzione il thread che ti ho linkato, altrimenti avresti capito "quanto valgono" i vari "step" del ADC e per "quale motivo" ... ::)

Detto questo ... per me fai come ti pare ... t'è stato detto che è sbagliato, se a te va bene così ... nessun problema!  :smiley-mr-green:

Guglielmo
Title: Re: Lettura Temperatura con Sensore TM36
Post by: maubarzi on Sep 18, 2020, 11:51 am
Per il 1024, è una brutta bestia .... Ci si incasinano in molti.
A volte pure io  ;D

Quello che dicono il Sommo (Guglielmo) e il socio (Standardoil) è corretto.
E come hai visto ci casco pure io a volte.
Ora mi manca il tempo per capire esattamente dov'è l'inghippo e per fornire una spiegazione dettagliata della questione.
Però è molto probabile che ci sia un secondo errore che fa produrre il risultato attuale andando contro quanto scritto sul datasheet.
Magari è proprio il simulatore, che facendo lo stesso errore sul 1023/1024, produce questi risultati.

Maurizio
Title: Re: Lettura Temperatura con Sensore TM36
Post by: gpb01 on Sep 18, 2020, 12:36 pm
Quello che dicono il Sommo (Guglielmo) e il socio (Standardoil) è corretto.
... è che nessuno tiene in considerazione il fatto che stiamo parlando di "gradini" ... quando il ADC da 0 sono 0V e basta, poi ... quando da 1 sono da > 0 fino a <= 1*(Vref/1024), quando da 2 sono > 1*(Vref/1024) fino a <= 2*(Vref/1024) e così via sino all'ultimo gradino, 1023 che NON è il massimo (Vref) ma è da > 1023*(Vref/1024) sino a Vref e oltre ... ovvero ... l'incertezza è sempre nell'ampiezza del singolo gradino e l'ultimo (il 1023esimo) parte da Vref -1 gradino in su.

La cosa è ben spiegata nel datasheet che, appunto, puntualizza: "0x000 represents analog ground, and 0x3FF represents the selected reference voltage minus one LSB."

Guglielmo

P.S.: Che poi, anche quanto sopra riportato, non è completamente esatto dato che, comunque, c'è da tenere conto di possibile un errore di "quatizzazione" di 0.5 LSB ;)
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 18, 2020, 12:56 pm
Faccio un esempio semplice

Invece che fondo scala 5v su adc a 10 bit

Faccio fondoscala 2 v su adc a 1 bit

Se leggo 0 è 0 volt ( più o meno l'errore dello adc)

Se leggo 1 è 1volt più o meno l'errore

2 non lo leggerò mai 
Lo adc da 1 bit ha 2 gradini, ma a scrivere 2 va in overflow

Altro esempio

Fondo scala 10 volt con display decimale a 1 cifra
Posso leggere 0 1 4 ...9 ma 10 mai
Serve un display a 2 cifre

L'ultimo gradino è una divisione sotto il fondo scala, sempre
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 19, 2020, 03:32 am
Ciao ragazzi,
Guglielmo grazie per la romanza, a volte mi serve anche quella per far svegliare quel mezzo neurone che mi è rimasto :D  :D  :D  :D,
hai perfettamente ragione, mi sono riletto i vari post, scaricato il datasheet pag 252 a 256 e si è giusto dividere x 1024.
Ripensando ai valori sottostimati che ottenevo con l'orribile primo sketch postato, ho effettuato delle letture usando il 1023 e poi il 1024 sull'ultimo sketch postato, ottenendo le letture che trovate allegate.
In sostanza con il divisore 1023 ed impostata una temp di 50° la temp indicata è 50.2 e di 50.1 con il divisore 1024.
Ciò su cui vorrei avere chiarimenti è sulla fase di immagazzinamento delle letture nell'array.
Alla 1ma acquisizione il valADC del sensore è di 205 con temp di 50° e questo è corretto, il val medio avg invece è di 10.25 che viene restituito dalla divisione "avg/(float)(fsize)" dove il divisore ha valore 20, infatti 205/20=10.25.
Poi man mano che le acquisizioni aumentano il val ADC del sensore rimane sempre a 205 mentre il avg e temp aumentano fino ad arrivare alla corretta indicazione. Infatti alla 20ma acquisizione il ADC è 205 il avg è restituito a 205 e la temp a 50.1, con il divisore 1024, e così rimangono anche per le successive acquisizioni.
Quello che mi aspettavo è che il divisore per il calcolo della media segua lo stesso valore dell'array, se ho immagazzinato 2 letture (205+205) il loro divisore dovrebbe essere 2 e non 20. Sembra che ardu, con l'impostazione che ho dato, prenda il valore int const fsize come divisore.

Riposto lo sketch fino al calcolo temperatura eliminando altre parti non necesarie.

Code: [Select]


int sensore = A0;

float TEMP=0;
int const fsize = 20;
int fil[fsize];
int i=0;
int j=0;
float avg=0;


void setup() {
 //DDRD=0b11111111;
 //DDRB=0b00111111;
Serial.begin(9600);
}

void loop(){
  sensore=analogRead(A0);
 Serial.print("val ADC sensore = ");
 Serial.println(sensore);
  fil[i]= sensore;
   if (i < (fsize-1)) i++;
  else i = 0;
  avg=0;
  for (int j=0; j< fsize; j++) {
    avg +=(float)fil[j];
  }
  avg = avg / (float)(fsize);   // questa la linea incriminata
 Serial.print("val medio = ");
 Serial.println(avg);

 float voltage = (avg * 500);
 voltage /= 1024.0;
float temperatureC = (voltage - 50);
Serial.print("TEMP = ");
 Serial.println(temperatureC);




1 karma x Gulielmo per la romanza.
Grazie ancora e grazie della pazienza che dimostrate.
Ciao
Lorenzo

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=382263)

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=382265)

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=382267)

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=382269)
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 19, 2020, 07:47 am
Alla 1ma acquisizione il valADC del sensore è di 205 con temp di 50° e questo è corretto, il val medio avg invece è di 10.25 che viene restituito dalla divisione "avg/(float)(fsize)" dove il divisore ha valore 20, infatti 205/20=10.25.
e già qui il primo problema:
visto che hai una temperatura impostata (dove? nel simulatore?) di 50 gradi dovresti avere una lettura di 204 (204.8 per l'esatttezza, ma dato che gli ADC danno uscite intere...)
se cominci con lettura di 205 significa che il riferimento di tensione non è corretto,
questo non è una novità, il riferimento di 5 volt di arduino è notoriamente inaffidabile
il vero problema è che tu stai simulando tutto questo: significa, ma te lo ho già detto, che il simulatore che usi non è preciso, ricordi quando NON andava in overflow con una lettura intera che superava 32000?


Quote
Poi man mano che le acquisizioni aumentano il val ADC del sensore rimane sempre a 205 mentre il avg e temp aumentano fino ad arrivare alla corretta indicazione.
beh, visto che gli fai fare una media mobile questo è esattamente il comportmento che ti saresti dovuto aspettare, ovvero quello che hai programmato
Quote
Infatti alla 20ma acquisizione il ADC è 205 il avg è restituito a 205 e la temp a 50.1, con il divisore 1024, e così rimangono anche per le successive acquisizioni.
....appunto
Quote
Quello che mi aspettavo è che il divisore per il calcolo della media segua lo stesso valore dell'array, se ho immagazzinato 2 letture (205+205) il loro divisore dovrebbe essere 2 e non 20. Sembra che ardu, con l'impostazione che ho dato, prenda il valore int const fsize come divisore.
ma non lo hai scritto tu questo?
Code: [Select]

  }
  avg = avg / (float)(fsize);   // questa la linea incriminata
 Serial.print("val medio = ");

pezzo di programma che fa esattamente quello che dici, che ti stupisce, ma che fa esattamente quello che hai programmato a fare, perché ti stupisci se un programma che hai scritto tu fa quello che hai scritto tu?


inoltre quel programma è troppo "rimaneggiato", ci sono troppi cast, peraltro tutti inutili
quel
Code: [Select]

  avg = avg / (float)(fsize);


è inutilmente complicato
Code: [Select]

avg=avg/fsize;

è meno contorto e fa esattamente lo stesso lavoro (sospetto inoltre che il compilatore lo traduca esattamente nella stessa maniera)

te lo ho già detto: semplificati

e ti aggiungo: ogni (ogni) singola "parola" del programma ha un preciso significato
dove per parola intendo keyword, statement, variabili, funzioni; ogni cosa scritta insomma
da questo discende che quando le scrivi tu intendi fare qualcosa, per l'esattezza la cosa ch quella "parola" significa

nell'ultima riga che ho citato ci sono 4 parentesi di troppo e un casting inutile, quindi sembra che tu le abbia messe a caso: non è così?
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 19, 2020, 09:24 pm
Ciao Nelson, 
grazia ancora per le spiegazioni, quella parte di programma in realta la ho presa da un esempio sul web di Paolo Aliverti, che da spiegazion i si come utilizzare gli array in una media mobile utilizzando un sensore di pressione, https://www.youtube.com/watch?v=cnQSCPUgiA4, quella parte la ho poi utilizzata per un altro proggettino indicatore di livello carburante.
il video lo ho trovato interessante perchè permetteva di aggiornare un array in modo semplice.
Probabile, anzi senza il probabile, sono io che mi fisso a pensare diversamente da quello che è programmato e continuo a cercare di penasre come io vorrei e non come la mecchiana Ardu lavora.
Per il Simulatore è probabile che ci sia qualcosa di erroneo ma questo non sono in grado di verificarlo, cerchero info in merito.
Leggero  info sui reference riguardo i cast di cui parli. 
Per la media ho gia approtato la semplificazione che hai indicato ma i risultati non cambiano, sono gli stessi,
Leffetto grafico sui display delle prime 20 letture tutto sommato non così brutto da vedersi poiché sembra che Ardu faccia un check funzionale e poi dupo 3-4 secondi indica la temperatura.
Ancora due settimane è poi tornerò in italia.

Grazie ancora delle risposte, ti sei meritato un altro Karma.
Title: Re: Lettura Temperatura con Sensore TM36
Post by: Standardoil on Sep 20, 2020, 11:51 am
Grazie
Title: Re: Lettura Temperatura con Sensore TM36
Post by: LOLLO65 on Sep 28, 2020, 06:37 am
Salve Ragazzi,
 rieccomi a voi per chiedervi ancora un consiglio su come visualizzare le lettura sui display dopo l'uso del millis.

Prima pero volevo dirvi che lo sketch precedente postato nelle precedenti pagine lo ho implementato con un blink dei display raggiunta una certa TEMP, usando l'esempio del blink led, un piccolo passetto avanti x me e questo è lo sketch con il blink
Code: [Select]



int sensore = A0;
int const fsize = 20;
int fil[fsize];  //imposta filtro buffer
int i = 0;
int j = 0;
float avg = 0;
const int ledPin0 = 0;
const int ledPin1 = 1;
const int ledPin2 = 2;
const int ledPin3 = 3;
const int ledPin4 = 4;
const int ledPin5 = 5;
const int ledPin6 = 6;
const int ledPin7 = 7;
const int ledPin8 = 8;
const int ledPin9 = 9;
const int ledPin10 = 10;
const int ledPin11 = 11;
const int ledPin12 = 12;
const int ledPin13 = 13;
int ledState = LOW;


unsigned long previousMillis = 0;       
const long interval = 500;

byte seven_seg_digits[10][7] =
{ //seg. a,b,c,d,e,f,g          nr
  { 1, 1, 1, 1, 1, 1, 0 }, // = 0
  { 0, 1, 1, 0, 0, 0, 0 }, // = 1
  { 1, 1, 0, 1, 1, 0, 1 }, // = 2
  { 1, 1, 1, 1, 0, 0, 1 }, // = 3
  { 0, 1, 1, 0, 0, 1, 1 }, // = 4
  { 1, 0, 1, 1, 0, 1, 1 }, // = 5
  { 1, 0, 1, 1, 1, 1, 1 }, // = 6
  { 1, 1, 1, 0, 0, 0, 0 }, // = 7
  { 1, 1, 1, 1, 1, 1, 1 }, // = 8
  { 1, 1, 1, 1, 0, 1, 1 }, // = 9
};


void setup() {
  DDRD = 0b11111111;
  DDRB = 0b00111111;
  //Serial.begin(9600);
}

void loop() {
  sensore = analogRead(A0);
  // Serial.println(sensore);
  fil[i] = sensore;
  if (i < (fsize - 1)) i++;
  else i = 0;
  avg = 0;
  for (int j = 0; j < fsize; j++) {
    avg += (float)fil[j];
  }
  avg = avg / float(fsize);

  Serial.print(" valore medio: ");
  Serial.println(avg);

  float voltage = (avg * 500);
  voltage /= 1024.0;
  float temperatureC = (voltage - 50);
  //Serial.print("la TEMP e'");
  //Serial.println(temperatureC);

  int DSP1 = 0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int DSP2 = 7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G

  int tempH;//high number
  tempH = int(temperatureC / 10);

  int tempL; //low number
  tempL = int(temperatureC - tempH * 10);

  for (int j = 0; j < 7; j++)
  {
    digitalWrite(DSP1, seven_seg_digits[tempL][j]);
    DSP1++;
  }
  for (int i = 0; i < 7; i++)
  {
    digitalWrite(DSP2, seven_seg_digits[tempH][i]);
    DSP2++;
  }

  // usare il calcolo seguente per convertire in Fahrenheit
  // float temperatureF = (temperatureC * 9.0 / 5.0) + 32.0;
  // Serial.print(temperatureF); Serial.println(" degrees F");

  unsigned long currentMillis = millis();
  if ( temperatureC >= 95 ) {
    if (currentMillis - previousMillis >= interval) {
      // save the last time you blinked the LED
      previousMillis = currentMillis;
      if (ledState == LOW) {
        ledState  == HIGH;
      } else {
        ledState  = LOW;

      }
      digitalWrite(ledPin0, ledState);
      digitalWrite(ledPin1, ledState);
      digitalWrite(ledPin2, ledState);
      digitalWrite(ledPin3, ledState);
      digitalWrite(ledPin4, ledState);
      digitalWrite(ledPin5, ledState);
      digitalWrite(ledPin6, ledState);
      digitalWrite(ledPin7, ledState);
      digitalWrite(ledPin8, ledState);
      digitalWrite(ledPin9, ledState);
      digitalWrite(ledPin10, ledState);
      digitalWrite(ledPin11, ledState);
      digitalWrite(ledPin12, ledState);
      digitalWrite(ledPin13, ledState);

    }
  }
  delay(300);
}





Volendo esercitarmi ancora mi sono detto: adesso devi far in modo che il tuo Arduino legga la temperatura e il Voltaggio della batteria moto e che li mostri alternativamante sui display.

Mi sono, poi, esercitato sull'uso del map e del millis inserendoli nello scketch, che suegue, prendendo spunto da una discussione sul forum"https://forum.arduino.cc/index.php?topic=643226.15"  ed ora riesco a visualizzare, sul virtual monitor, l'alternarsi delle due misure al tempo stabilito con il valore interval

Però non riesco a visualizzare TEMP e Volt Batteria sui display, e mi sono arrenato.
questo è il codice che mostra alternativamente il valori TEM e VOLT
Code: [Select]


int i = 0;
int j = 0;


const int analogTEMP = A0; 
const int analogBattVolt = A1;
//Variabile dopo conversione in temp e Volt
int val_TEMP;
int val_BattVolt;
float scala = 100; //100 per volt, 0.1 per millivolt

/*byte seven_seg_digits[10][7] =
  { //seg. a,b,c,d,e,f,g          nr
  { 1, 1, 1, 1, 1, 1, 0 }, // = 0
  { 0, 1, 1, 0, 0, 0, 0 }, // = 1
  { 1, 1, 0, 1, 1, 0, 1 }, // = 2
  { 1, 1, 1, 1, 0, 0, 1 }, // = 3
  { 0, 1, 1, 0, 0, 1, 1 }, // = 4
  { 1, 0, 1, 1, 0, 1, 1 }, // = 5
  { 1, 0, 1, 1, 1, 1, 1 }, // = 6
  { 1, 1, 1, 0, 0, 0, 0 }, // = 7
  { 1, 1, 1, 1, 1, 1, 1 }, // = 8
  { 1, 1, 1, 1, 0, 1, 1 }, // = 9
  };
*/
//Variabile stato PIN analogico
bool statoTemp = false;
bool statoBatt = false; 

unsigned long previousMillis = 0;
unsigned long interval = 500;
bool stato = false; //assegno alle variabili bool valore falso

void setup() {
  //DDRD=0b11111111;
  //DDRB=0b00111111;
  Serial.begin(9600);

}

void loop() {
  unsigned long currentMillis = millis();
  if (currentMillis - previousMillis >= interval) {
    previousMillis = currentMillis;
    if (stato == false) {
      val_TEMP = analogRead(analogTEMP);
      //  Serial.println(val_TEMP);
      float temp = map(val_TEMP, 102, 305, 50, 149);
      //Serial.println(temp);
      float TEMPC = (temp - 50);
      Serial.print("TEMP = ");
      Serial.println(TEMPC);
      stato = true;

    }    else {
      val_BattVolt = analogRead(analogBattVolt);
      //Serial.println(val_BattVolt);
      float misura = map(val_BattVolt, 0, 1023, 0, 2000);   //  il valore della tensione
      // Serial.println(misura);
      float volt = misura / scala; // inserire il valore del fondo scala che si desidera
      Serial.print("VOLT BATT = ");
      Serial.println(volt);
      stato = false;

    }
  }




Ho pensato di poter utilizzare questa parte di codice, che ho usato nel precedente sketch con il blink postato all'inizio, inserendola dopo il millis ma l'IDE mi da un errore,  perche mi dice che TEMPC non è dichiarato per questo scopo, ovviamente, sono conscio che è la parete di visualizzazione non è impostata correttamente.

Code: [Select]


int DSP1 = 0 ; // per il primo 7-seg pins 0,1,2,3,4,5,6 collegati ai pin led posiz. a,b,c,d,e,f,g
  int DSP2 = 7; // per 2ndo 7-seg pins 7,8,9,10,11,12,13 collegati ai pin led A,B,C,D,E,F,G

  int tempH;//high number
  tempH = int(TEMPC / 10);

  int tempL; //low number
  tempL = int(TEMP - tempH * 10);

  for (int j = 0; j < 7; j++)
  {
    digitalWrite(DSP1, seven_seg_digits[tempL][j]);
    DSP1++;
  }
  for (int i = 0; i < 7; i++)
  {
    digitalWrite(DSP2, seven_seg_digits[tempH][i]);
    DSP2++;
  }



quindin la domanda è il metodo usato per visualizzare in modo alternato TEMP e Volt è errato?
Ce un metodo che mi permette di richiamare le due variabili e visualizzarle sul display?
spero di essere stato il più chiro possibile nelle descrizione.
allegata screenshoot delle letture.


Grazie in anticipo
Lorenzo

(https://forum.arduino.cc/index.php?action=dlattach;topic=704278.0;attach=383418)