Conta giri a led per auto e temperatura

ho dai il comado clear e cancelli tutto lo schermo oppure prima di inviare il numero lo controlli con un if e se è il caso aggiungi uno spazio dopo le cifre in modo da cancellare eventuali numeri precedenti.

no ho capito molto bene comunque io ho fatto così e pare che funzioni per adesso sto facendo uno per la temperatura che è più semplice

lcd.setCursor(0,0);
    lcd.print("Temp:");
     if (valore_sensore_analg< 10)
   lcd.setCursor(6,0);
    lcd.print(" ");
   
    if (valore_sensore_analg< 100)
    lcd.setCursor(7,0);
    lcd.print(" ");
    if (valore_sensore_analg< 1000){
    lcd.setCursor(8,0);
    lcd.print(" ");
    }
    lcd.setCursor(5,0);
    lcd.print(valore_sensore_analg);
  
    delay(1);
  lcd.setCursor(10,0);
  lcd.print("C");
  lcd.setCursor(0,1);
  lcd.print("Rpm:");

ragazzi ho un problema io devo capionare un segnale analogico allora arduino va da 0 a 1020 bit se io volessi fare una tabbella in coi dico ad arduino che a 10 bit corrispondono 25 gradi a 20 bit corrispondo 32 gradi ecc. però io non voglio che arduino mi dia solo 25 gradi 32 gradi ecc. ma voglio che in base alla tabbella mi dia i gradi diciamo da 0 a 120 gradi non so se mi sono spiegato. :frowning: aiutatemi sto uscendo pazzo

Pensa un po, quello che hai scritto fa impazzire pure me. Io non ho capito per intero tutto ma intuisco che non ha ben chiaro il concetto di campione digitale, risoluzione ecc.

Ora veniamo al dunque.
Il microcontroller di arduino ha un solo ADC e uno switch interno che permette di aquisire da un numero x di porte, nel caso del ATmega328 dip il numero di porte adc è 5. L'ADC ha una risoluzione di conversione di 1024, per cui una tensione massima di 5 volts viene divisa per 1024, quindi ottieni 1024 valori diversi incluso lo zero, per cui il valore massimo restituito dal'ADC sarà di 1023 equivalenti a 5/1024*ADCvalue.

Questo ammesso che l'alimentazione del micro sia a 5 volts.

Non ho capito che sensore di temperatura usi, se usi quello dell'auto si tratta di un NTC di cui però non hai la curva caratteristica R/t.

Non uscire pazzo per così poco, ok. :stuck_out_tongue:

Ciao.

allora adesso ti spiego tutto: un amico di mi padre a programmato un display lcd esattamente questo SmartGLCD 240x128 - PIC Development Board with GLCD Touch Screen con contagiri e temperatura motore per un auto da corsa di mio fratello adesso io vorrei fare la stessa cosa da quello che so il sensore della temperatura che abbiamo usato che e di serie sulla auto che utilizza anche la ecu tira fuori un segnale analogico credo 0 - 12 volt(non l ho ancora misurato ) adesso io quello che ho intensione di fare e con un partitore e abbassare i volt a 5 in modo da farli mangiare ad arduino, io ricordo che abbiamo preso il sensore lo abbiamo immerso in una ciotola con un fornello sotto e abbiamo campionato il segnale in base ai bit che tirava fuori e alla temperatura a cui era l acqua si e fatto una sorta di tabella e quindi credo si è ricavato la curva caratteristica R/t io vorrei fare la stessa cosa ma non so che funzione usare per mettere questa tabella ad arduino, allora io avevo pensato di fare così mettiamo che alla minima temperatura di 10° il sensore tira fuori 0 e alla massima temperatura di 120 tira fuori 5 volt cioè 1024 se uso la finzione temp1 = map(valore_segnale, 0, 1024, 10, 120); secondo voi i valori di temperatura da 10 a 120 sono giusti ?? è giusto il ragionamento che ho fatto ?? che soluzioni mi date

Non conosco la mcro map, ma credo sia giusto quello che dici, e funziona se la curva r/t è una linea retta, ma se è una curva ci sarà un errore. Comunque in questo caso la curva (o retta) sarà v/t in quanto mette in relazione la tensione e la temperatura.

Da 0 a 5vdc un range di 110 (120 - 10) ottieni una retta dove v/t è uguale a 5/110 = 0,045454545, e questo valore lo otterrai a tutte le temperature, mentre se il sensore di temperatura non è così lineare a 50 °C v/t dovrebbe essere 0,045ecc e invece risulta 0,056. Se le differenze di v/t sono minime avrai un errore accettabile.

Puoi anche fare un'array di interi senza segno da riempire con le temperature, ma ti servirebbe un array grande 1024 elementi questo esaurirebbe la ram di 2Kb.

Per i valori di temperatura a 120 l'acqua diventa vapore e già la guarnizione di testata la puoi buttare o quasi, per la temperatura minima mi sembra inutile scendere sotto i 10 gradi, anche in caso di gara nelle Madonie, nel radiatore c'è l'antigelo e sapere che l'acqua e a 3 °C non è una informazione utile. Quindi mi sembra un range ragionevole.

Simpatico l'LCD intelligente smartglcd, comodo per quelle applicazioni tipo cruscotto digitale.

Ciao.

oggi finalmente ho trovato il tempo per misurare il sensore allora il sensore tira fuori 5 - 0 volt :smiley: con l aumentare la temperatura ho modificato la funzione così : temp1 = map(valore_segnale, 1024, 0, 10, 120); ma sembra dare de valori sbagliati rispetto al cruscotto digitale. ho notato pure una cosa di strano che qundo attacco arduino al sensore, il cruscotto digitale sballi che cosa può causare questo interferenza fra i due ??io ho pensato di mettere un diodo all entrata di arduino

up!

Io trovo sbagliato il modo di procedere che hai intrapreso. Mi sta bene il fatto che sperimenti sperando di ottenere dei risultati, non si sa mai quando arriva un colpo di fortuna.

Comunque, fammi una foto del sensore di temperatura, descrivendomi anche dove viene montato sulla vettura, quanti fili ha il sensore ecc.

Le auto moderne hanno sensori di temperatura un po ovunque, quelle vecchie ti po 205, uno ecc, ne hanno al massimo 2, uno non è facilmente accessibile, l'altro è montato sul radiatore. Nel caso fosse quello montato sul radiatore si tratta di un NTC (documentati su cosa è).

Nel caso di un NTC, c'è una formula che permette di ricavare la temperatura in base ai dati del NTC, dati che si trovano nel datasheet, in questo caso però il datasheet non c'è è bisogna procedere a tentativi, ma la formula rimane sempre valida.

Quindi per prima cosa devi appurare circa il tipo di sensore, NTC, PTC ecc, e poi si possono fare le altre considerazioni. Questo è il modo giusto di procedere, e il fatto che tu legga una tensione non vuole dire che il sensore fornisce una tensione. Altri errori di interpretazioni devono essere evitati e per questo devi sapere nel dettaglio con quali componenti stai lavorando.

Prova a metterti nei miei panni o in genere nei panni di chi deve risponderti e quindi fornisci più dati possibili per risponderti in modo risolutivo, cioè foto, sigle, marca, modello ecc.

Io ad esempio non ho idea di che sensore di temperatura sia montata nella tua vettura di cui non conosco la marca il modello e se per caso mi dici che è una fiat uno, mi hai detto meno che niente perchè di versioni della uno ne sono state prodotte tante e sono in genere riconoscibili anche dalla data di produzione.

Ciao.

ecco le foto ImageShack - Best place for all of your image hosting and image sharing needs anche i ldatasheet http://home.kpn.nl/duran103/pics/wts05%20v4.pdf il sensore qui dice che è un NTC appartiene ad una fiat 600 , misurato col tester collegato all'auto col quadro girato il sensore a temperatura minima tira fuori 5v e se scaldato la tensione si abbassa, ecco anche un link Servizio parcheggio dominio il sensore e istallato sul'collettore di aspirazione dell'auto il sensore de è collegato alla centralina di gestione motore(ecu).Io l entrata analogica dell aurduino l ho collegata al filo viola (dalle foto di vede) e il gnd alla massa dell auto ripeto se scaldo il sensore la temperatura si alza ma mi da dei valori sbagliati.Grazie a MauroTec per l' aiuto che mi stai dando sei proprio gentilissimo grazie ancora :blush:

Sapevo che potevi fare di meglio e infatti ora sai.
Sai che si tratta di un resistore il cui valore muta in funzione della temperatura, purtroppo non sono molto lineari e serve la formula per migliorare la linearità. Ora come puoi immaginare il resistore NTC non "tira fuori 5 volts" perchè si tratta di un componente passivo.

Per lavorare correttamente un NTC richiede un resistore posto in serie così da formare un partitore resistivo, dove un resistore è fisso mentre l'altro (il NTC) muta in funzione della temperatura.

L'NTC lo puoi simulare grazie ad un potenziometro e a un resistore serie e il collegamento è questo:

5Volts---- R -----O-----NTC------GND
|
|
vout to analog pin

Segui questo tutorial di ladyada, mettilo in pratica senza saltare una virgola e se hai domande dubbi posta pure.

Quando arrivi al codice sorgente da provare devi modificare alcuni valori, es Resistenza a 25 °C e questa la prendi dal datasheet che dice 3 k, ma ti serve il valore in ohm per cui 3 * 1000 = 3000 ohm
Ti serve anche RESISTORSERIE che nello sketch di ladyada è da 10Kohm (10000 ohm) se ne hai uno uguale va bene altrimenti può usare uno da 3300, 3900, 4700, 5600, ecc. e non dimenticare a specificare il valore al posto di 10000.

Un parametro non c'è e si chiama BCostant, ma non importa al momento tu dagli il valore di 3500 che poi ti calcolo il valore esatto teorico.

Non mi pare di essermi scordato nulla, ah si il valore della temperatura letta dal cruscotto sballa perchè ponendoti in paralello al NTC ne cambi il valore di resistenza che dovrebbe dimuire e quindi leggi una t maggiore.

Ciao.

scusa ma io ho un problema il sensore in questione è gia alimentato dalla centralina elettronica quindi io quindi io non lo posso alimentare con l arduino e non posso nemmeno mettere la resistenza in serie perchè mi sballerebbe la lettura della centralina elettronica in questo caso come posso modificare il programma ??

Non si tratta di modificare il programma, il problema da te evidenziato è di carattere elettronico. Per risolvere hai due strade, aggiungere un sensore NTC economico (tipo quello di ladyada) e lasciare il sensore bulbo connesso alla centralina. Oppure se vuoi sfruttare lo stesso sensore, ti serve un circuito che offra una impedenza di carico molto alta e che di fatto disaccoppi il sensore dal convertitore AD di arduino. Il circuito in questione può essere un amplificatore operazionale collegato come amplificatore DC a guadagno unitario, cioè un buffer.

Vedi se riesci a trovare qualcosa in rete, appena ho tempo cerco qualcosa di adatta a lavorare come buffer. Utile sarebbe anche aprire un altro post nella sezione hardware per chiedere lumi su possibili buffer da acquistare già pronti.

Io fossi in te acuisterei dei sensori NTC come questi:

Ne prendi più di uno così puoi rilevare anche la temperatura esterna e interna alla vettura, ti servono anche i resistori da 10 kohm 1/4W.

Però dovrai ingegnerti per fissare il sensore al collettore o testata o altra parte meccanica preoccupandoti anche del fatto che il sensore non venga influenzato da correnti di aria, l'ideale è propio forare un perno, inserire il sensore nel foro e chiude il tutto con resina epossidica.

Ciao.

allora io ho sentito anche un mio amico che è ingegnere elettrico è lui mi ha detto che il valore nel cruscotto digitale si sballava prechè quando collegavo l aurduino io facevo una misura differenziale perchè l arduino era alimentato dal pc mentre il sensore era alimentato dalla centralina invece se io l arduino lo alimento con l automobile secondo lui il problema non si pone devo provare a fare questa prova molto probabilmente lo farò dopo natale perchè non ho molto tempo da dedicarci quindi per adesso non farò molte prove.

quando l'amico di mio padre ha programmato il glcd di cui parlavo qualche post precedente lui ha preso il segnale dallo stesso mio sensore come sto facendo io poi abbiamo preso il sensore lo abbiamo scaldato e si è fatto una tabella e dove da una parte c'erano i bit che segnava il display e da un altra c'era i vari capioni di temperatura che abbiamo fatto se io volessi fare la stessa cosa poi che funzione dovrei usare per dire ad aurduino che a tot temperatura corrisponde a tot bit ecc?? secondo me questa sarebbe la strada più semplice e pare che il valore è a a bastanza preciso...grazie ancora

Il tuo amico ingegnere ha ragione. Io non sapevo che come avevi fatto i collegamenti.

Una tensione di 5 Volts ha quel potenziale rispetto ad un altro punto del circuito che in questo caso è il negativo di batteria, se vuoi alimentare arduino da usb devi condividere il polo negativo della batteria dell'auto. Quindi devi solo collegare il negativo della batteria al negativo di Arduino.

Però insisti nell'errore, il tuo obbiettivo è raggiungere il risultato, invece dovrebbe essere quello di imparare le basi.
Per cui io ti suggerisco di seguire il tutorial di ladyada, arrivare a leggere la temperatura nel display e poi tentare di risolvere il problema della lettura NTC montato in auto, però sono sicuro che farai di testa tua.

Che funzione vuoi usare?

Non c'è una funzione pronta per fare quello che vuoi, mentre il codice del tutorial di ladyada è già pronto e funzionante, devi solo adattarlo secondo necessità.

Io non capisco cosa vuoi dire con: fatto una tabella e dove da una parte c'erano i bit che segnava il display e da un altra c'era i vari capioni di temperatura.

L'adc di arduino ritorna la lettura di un pin analogico in formato decimale, se hai una corrispondenza tra il valore decimale letto e la temperatura misurata, puoi mettere questi in relazione tabellare, dovresti accontentarti di un valore di temperatura privo di decimali, cioè 80 °C anche se la temperatura effettiva sarà di 79,60 °C. Io non sono in grado di aiutarti in tal senso, perchè non vedo il motivo di complicarsi la vita, quando hai già uno sketch pronto e funzionante. Insomma, ti sconsiglio di usare gli array per mettere in relazione temperatura e lettura analogica.

Ricordati che io non sono li con te e quindi non so come hai fatto i collegamenti, non so come te la cavi con il linguaggio di arduino e con il C/C++ in generale, ecc.

Ciao.

ok ti ripeto grazie ancora per le risposte molto accurate, adesso se sento anche l amico del glcd e ti faccio sapere e magari mi aiuti ancora con l impresa che sto facendo se voi magari mi mandi un messaggio privato con la tua email così se ci sentiamo anche al di fuori del forum...

No niente email privata, anche se la mia email è conosciuta, il motivo di ciò è legato al fatto che rispondo con piacere sul forum, perchè così molti possono seguire il tutto e magari intervenire, privatamente questa per me diventerebbe una consulenza.

Quindi scrivi qui sul forum che se non ti leggo oggi ti leggo domani e magari altri rispondo e seguono il post.

Ciao.

ok per me va benissimo così...parliamo qui sul forum

ciao MauroTec ho sentito come promesso il programmatore del Glcd e lui mi ha risposto cosi:

  • Temperatura:

Senza farla tanto lunga, devi vedere la temperatura come un segnale di
tensione analogico che devi convertire in digitale utilizzando L 'ADC del
microcontrollore e visualizzarla sul display.
Per quanto riguarda il lavoro che ho fatto sul display della 600, ho
"caratterizzato il sensore" annotandomi delle coppie di valore (tensione,
temperatura) costruendo così una tabella di 20-30 coppie.
A questo punto ho usato una semplice funzione per linearizzare la tabella
stessa così da produrre, avendo in ingresso un conteggio relativo alla
conversione di una tensione, un valore di temperatura in uscita (approssimato
ma quanto più aderente alla realtà quanto più ampia è la tabella). Questo è
tutto. Comunque ti allego la tebella di conversione del sensore temperatura
della 600 con la funzione di conversione che prende come paramentro di ingresso
i conteggi (derivanti dalla conversione Analogico Digitale della tensione del
sensore temperatura) e ritorna un intero che è il valore della temperatura
corrispondente alla tensione di ingresso.Per avere una misura meno "nervosa",
prima di chiamare la funzione di temperatura, ti consiglio di fare una media
matematica di 10-15 valori di conteggi.

e ecco il codice che ha usato:

#define LIMITE_CONTEGGI_AI_TEMP 1010
#define ERR_MISURA              0xCFFE
#define MAX_PT_T 26



// Tabella conteggi  / temperatura acqua

const int TABT[MAX_PT_T][2]=
{
        160,  121,
        211  , 111,
        251  , 104,
        263  , 101,
        274  , 99,
        286  , 96,
        299  , 94,
        314  , 91,
        328  , 89,
        351  , 85,
        361  , 83,
        383  , 80,
        406  , 76,
        437  , 71,
        468  , 67,
        498  , 63,
        555  , 56,
        613  , 48,
        665  , 42,
        726  , 35,
        795  , 28,
        858  , 23,
        916  , 18,
        960  , 16,
        974  , 14,
        995  , 13
};




int ConvTAcqua(int Conteggi)
// Converte una misura di temperatura acqua
{
//*******************************************************/
//
//       Conversione  TEMPERATURA Conteggi/Gradi
//
//                    T(i+1)-T(i)
//      T  = T(i) + -------------  *  ( Conteggi - C(i) )
//                    C(i+1)-C(i)
//
//*******************************************************/
        unsigned char        i;
        int                 locCont;
        int                C1;
        int                C2;
        int                T1;
        int                T2;
        int             DeltaT;
        int             DeltaC;
        int             DeltaCont;
        int             Temp;



        if (Conteggi > LIMITE_CONTEGGI_AI_TEMP || Conteggi==0)  return (ERR_MISURA); // DownScale e Conteggi allo Start
        locCont = Conteggi;

        // Sotto il minimo valore in tabella
        if (Conteggi <= TABT[0][0]) return (TABT[0][1]);

        // Valore nel range
        for (i=1; i<MAX_PT_T; i++)
        {
                C2 = TABT[i][0];
                if (Conteggi < C2)
                {
                 C1  = TABT[i-1][0];
                 T1  = TABT[i-1][1];
                 T2  = TABT[i][1];
                 break;
                }
        }
        DeltaT    = (T2 - T1);
        DeltaC    = (C2 - C1);
        DeltaCont = (locCont - C1);
        Temp          =        T1+(DeltaT*DeltaCont)/DeltaC;

        return(Temp);
}

secondo te e possibile fare tutto questo con arduino ?? e mi aiuteresti a modificare il codice per farlo capire ad arduino ??

Certo che puoi fare quel lavoro, anzi è già fatto.

Il codice usato dal programmatore Glcd è standard C e arduino usa un compilatore C/C++, quindi il codice è compatibile.

Allora leggi il valore della conversione AD con analogRead(pin) e chiama la funzione ConvTAcqua(int Conteggi) più o meno così:

unsigned int adc_value;                          // variabile dove conservare la conversione AD
byte n_samples = 6;                               // variabile contenente il numero di letture consecutive su cui calcolare la media 
int temp_centigradi;

// legge n_samples volte il valore di AD e lo somma a se stesso
for (byte i=0; i< n_samples; i++) {
        adc_value += analogRead(A0);
        delay(10);
}
// calcola la media
adc_value /= n_samples;

temp_centigradi =  ConvTAcqua( adc_value );  // temp_centigradi contiene il valore di temperatura

Devi solo modificare la funzione ConvTAcqua per prendere un valore intero sensa segno (unsigned int).

Originale:
int ConvTAcqua(int Conteggi)
Modificata:
int ConvTAcqua(unsigned int Conteggi)

Ciao.