Circuito da termistore a led

[stefanopc]

... prendere + e - direttamente dalla batteria riduce i problemi, prenderemmo due piccioni con una fava...... Per me è molto più semplice

Si è più semplice ma se l'attacchi alla batteria rimane sempre acceso.
O metti un interruttore sulla scatolina,altrimenti ti devi prendere da una alimentazione che arriva dal sotto chiave.
Se vicino alla batteria ci fosse il rele comandato dalla chiave potresti attaccarti li.
Altrimenti anche se lentamente scarica la batteria se è sempre attivo.
Ciao

[drGremi]

Infatti sono un dilettante da più di 30 anni, diciamo dilettante con esperienza.

Non sei un dilettante

Ho una propensione per i flag di assembly e non sono abituato ad alzarmi troppo di livello in cose che non conosco.

Ed anche per usare direttamente i registri del micro Potresti usare analogRead e risparmi molte righe

Un po' la politica del meno cose ci sono meno si rompono.

Quello è vero ed è la mia politica, ma sono anche della politica che se le cose non le tocca l'uomo si diminuisce l'errore umano. Tra l'altro quelle direttive sono del preprocessore, quindi disattivando il flag è un po' come disattivare completamente il codice. Quella parte non viene proprio vista dal compilatore perché il precompilatore la zappa via.

Il case mi piaceva usarlo perché non lo avevo mai usato e poi è più ordinato degli if else if.

È vero! Hai fatto bene!

Se ho tempo gli do una modificata a mio gusto (poi mi dici se ti piace). Ah (e quanto rompe le palle 'sto drGremi), ti conviene usare un altro editor per il codice (tipo Atom con il plugin per arduino, oppure c'è un bellissimo plugin per eclipse). Sono molto meglio di quello di default di arduino e supportano l'indentazione automatica (e la correzione di spazi se non ne metti o ne metti troppi nelle funzioni, etc), tipo su atom c'è un plugin che si chiama beautify, mentre su eclipse è incorporato. Non serve a niente, ma rende il codice molto più leggibile.

Per me è molto più semplice

Di che moto stiamo parlando? Forse lo hai detto e mi è sfuggito. Perché magari la conosco o si trova su internet qualche info sull'impianto elettrico

[stefanopc]

Se ho tempo gli do una modificata a mio gusto (poi mi dici se ti piace). Ah (e quanto rompe le palle 'sto drGremi), ti conviene usare un altro editor per il codice (tipo Atom con il plugin per arduino, oppure c'è un bellissimo plugin per eclipse).
Sono molto meglio di quello di default di arduino e supportano l'indentazione automatica (e la correzione di spazi se non ne metti o ne metti troppi nelle funzioni, etc), tipo su atom c'è un plugin che si chiama beautify, mentre su eclipse è incorporato. Non serve a niente, ma rende il codice molto più leggibile.

Non rompi assolutamente.
Anzi grazie dei suggerimenti se riesco li provo volentieri.
Si impara sempre qualcosa di interessante .

Quello che non sopporto dell'editor di Ardu' è che non puoi tenere due parti di listato aperte nella stessa finestra.
In Mplab mi sembra si potesse fare ed era stracomodo.
In una parte tieni per esempio le righe da 20 a 30.
Nella seconda le righe da 151 a 180.
E ti eviti due " bip" a scorrere su e giù per controllare copiare e verificare.
L'indentazione automatica spero di riuscire ad utilizzarla correttamente.
Per il resto me la cavo o meglio, ci provo.
Poi il tempo è piuttosto tiranno.
Cominci una cosa oggi e dopo una settimana la riprendi, non è il modo migliore...
Adesso poi c'è orto prato fotografia e altre duemila cose che si vorrebbero fare.

Avrei una libreria e/o subroutine da sottoporti se ti va di darci una occhiata.

Ci ho impiegato diversi mesi a sistemarla e ora funziona ma non sono troppo sicuro riguardo l'uso corretto delle variabili globali e non.
Purtroppo linear non l'ha rilasciata per tutte le versioni di chip che ha prodotto.
Ovviamente mancava quella che ho utilizzato io Ltc6811/2( tra l'altro quella migliore a mio parere ).
Strane le politiche di certe aziende e le scelte dei progettisti.
Ciao

[Aldebaran78]

Giusto.... Non si può fare.

[Aldebaran78]

.

Di che moto stiamo parlando? Forse lo hai detto e mi è sfuggito. Perché magari la conosco o si trova su internet qualche info sull'impianto elettrico

Una Honda VF 400 del 83.
Io lo schema elettrico ce l'avrei, ma l'ho un po' modificato per tutti i lavori fatti finora.
Non so se può essere utile lo stesso.

[drGremi]

Io lo schema elettrico ce l'avrei, ma l'ho un po' modificato per tutti i lavori fatti finora.

No, niente di fondamentale, era per capire più o meno se potessero esserci particolari criticità. Ma non credo.

Purtroppo per i picchi di tensione e varie menate, come già ha detto da IsidoroKZ, servirebbe la strumentazione adeguata (oscilloscopio).
Bisognerebbe individuare la causa della morte di arduino (se è morto per colpa di un corto, per via di una sovralimentazione o per via "naturale"). Hai provato ad alimentarlo a 5V dai pin 5V (o a 3.3V, non mi ricordo la tensione di quello specifico atmega, anzi credo proprio esista in entrambe le versioni)? Così capiamo (forse, mica è detto, è una prova del menga) se è morto il regolatore di tensione interno o il processore?

Non è da escludere neanche che il "cinesone" fosse fallato anche se devo dire che con i cinesoni mi sono sempre trovato molto bene.

Comunque io mi procurerei un nuovo cinesone e un regolatore di tensione esterno aggiuntivo per protezione (se il regolatore interno è ciofegoso, almeno si protegge), va bene o un L7812CV, ma anche il classico LM317 con un paio di resistori e capacità.

Quello che non sopporto dell'editor di Ardu' è che non puoi tenere due parti di listato aperte nella stessa finestra.

Io quello che non sopporto dell'editor di arduino è l'editor di arduino
No scherzo, la cosa che più mi manda ai pazzi di arduno è l'assenza di un debugger come si deve (limiti anche del processore) e non poter ispezionare variabili e fissare checkpoint.

Adesso poi c'è orto prato fotografia e altre duemila cose che si vorrebbero fare.

Vedo che ci sono molti tarli che ci accomunano

Avrei una libreria e/o subroutine da sottoporti se ti va di darci una occhiata.

Volentieri (ma non avere grandi aspettative da me, c'è un sacco di gente molto più brava di me). La cosa che non ho capito (anche guardando il codice che hai scritto) è se c'è un motivo per cui non usi arduino puro o forse sono stato troppo frettoloso io. Cioè perché per esempio lavori con i registri e MisuraAna invece di usare la libreria arduno e un più semplice analogRead? Anche perché così poi quando la chiami devi configurare il multiplexer tramite registro e non gli passi l'ingresso A0, cosa che analogRead fa in automatico.

Poi se uno volesse essere "chiccoso" per far lampeggiare i led ci si potrebbe "divertire" con timer e interrupt. Ma oggettivamente è nosense in una applicazione come questa dove il microcontrollore non fa altro e non deve fare altro. Così come fai bene a lavorare con i float, ti semplifichi un botto la vita (i pursiti direbbero che è sbagliato perché il processore non supporta il float nativamente e quindi dovresti lavorare con gli interi e gestire tu la precisione, sinceramente non sono d'accordo, è sempre importante valutare costi benefici: in questo caso si riduce l'errore e si accelera lo sviluppo del codice).

[stefanopc]

Si è vero Ardu' ha un sacco di limiti ma rispetto ai PIC sembra di essere in paradiso.
Certo si può fare meglio ma ci si può anche accontentare.
Purtroppo non c'è assolutamente niente di sviluppo virtuale.
Si va di print delle variabili e di tutto quello che ti serve.
Un sistema un po' basico.
Ma funziona.
C'è chi va in bicicletta e chi va con l'Hummer H1.
A velocità diversa e con soddisfazioni diverse forse arriveranno alla loro meta.

Riguardo gli interrupt se proprio li devo utilizzare e non c'è modo di evitarlo uno unico magari lo utilizzo.
Altrimenti si va di loop libero e infinito.
Piuttosto si utilizzano i numerosi counter e poi si va ogni tanto a vedere cosa è successo.
Non amo avere sorprese del tipo "va benissimo ma ogni tanto mi tocca spegnere e accendere" .
Poi ci sono le scuole di pensiero ma il mio orientamento ad ora è quello.

Il vantaggio che vedo in arduino è che rende facile il riutilizzo se implementato bene.
Senza saldare lo smonti dal progetto x lo programmi e lo riutilizzi per il progetto z
In due minuti.
Anche perché spesso sono effettivamente tutti prototipi a esemplare unico.

Anche sui float le scuole di pensiero si sprecano.
Da dilettante miro al funzionamento piu che altro.

Mi ricordo bene con i PIC 16F8x la gestione dei numeri a 16bit con due byte e poi ricavare i codice del carattere da visualizzare su display Lcd il tutto in assembly.
Per fortuna una buon' anima aveva messo in rete come fare con esempio e spiegazione in inglese che non so.
Insomma a lacune siamo mesi bene.
Sul resto ci stiamo lavorando.
Ciao

[drGremi]

Si è vero Ardu' ha un sacco di limiti ma rispetto ai PIC sembra di essere in paradiso.

Guarda che si è in paradiso anche rispetto ad NXP anche se ha un sacco di funzioni in più. Poi le librerie buone si costruiscono e fai velocemente, ma facilità di ingresso, costo di acquisto non ha euguali (e altrimenti non avrebbe avuto successo, l'umanità non è mica scema, un po' sì, ma non troppo.
Io odio lavorare con i registri, è il giusto modo per aggiungere errori qui o lì.

C'è chi va in bicicletta e chi va con l'Hummer H1

De gustibus (il cassone da morto da 300k€), ma ad ognuno il suo, vacci in ZTL in città con l'hummer . Arduino è una grande cosa ed ha anche molto per crescere ulteriormente, anche in ambito professionale.

Poi ci sono le scuole di pensiero ma il mio orientamento ad ora è quello.

Secondo me proprio il concetto di scuola di pensiero è errata. Alla fine bisogna fare quello che serve quando serve.

Da dilettante miro al funzionamento piu che altro.

Forse solo gli accademici possono permettersi di puntare più sulla teoria che sul funzionamento, e poi nemmeno ne sono troppo convinto.

Comunque il codice lo ho tagliuzzato, ma non lo ho ancora mai fatto girare quindi onde evitare figure di ***** prima lo provo. Non ho fatto niente di che, semplicemente rimosso cose che secondo me si potevano non fare.

Il codice mai verificato è questo. Devo verificare che l'analogRead fornisca lo stesso risultato del registro ADCW, ma credo di si.

Codice: Seleziona tutto

/**********
   Termometro a Due Led
   (c) 2021 stefanopc
   (c) 2021 drGremi
************/

/****************
* CODE OPTIONS *
****************/
// Enable debug (aka serial print)
#define DEBBYUG 0
#define SERIAL_BAUD 9600

// Set pins
#define NTC_PIN A0
#define LED_ROSSO 2
#define LED_VERDE 3

// Set resistor and termistor
#define R1 3300.0
#define A 1.137375596e-03
#define B 2.324292814e-04
#define C 0.9712841963e-07

/****************
* DEBUG MACROS *
****************/
#if DEBBYUG == 1
#define NDEBUGPRINT(x) Serial.print(millis()); \
        Serial.print(": "); \
        Serial.print(__PRETTY_FUNCTION__); \
        Serial.print(' '); \
        Serial.print(__FILE__); \
        Serial.print(':'); \
        Serial.print(__LINE__); \
        Serial.print(' '); \
        Serial.println(x)
#define DEBUGPRINT(x) Serial.println(x)
#define DEBUGPRINTNN(x) Serial.print(x)
#else
#define NDEBUGPRINT(x)
#define DEBUGPRINT(x)
#define DEBUGPRINTNN(x)
#endif

/*****************
*   LIBRARIES   *
*****************/
#include "Arduino.h"

/*******************
*   FUNCTIONS     *
*******************/
/**
* Testa i led all'avvio se sono correttamente funzionanti
* @return void
*/
void testPins(){
        // test verde
        digitalWrite(LED_VERDE, HIGH); //Led test accensione
        digitalWrite(LED_ROSSO, LOW);
        delay (500);
        // test rosso
        digitalWrite(LED_ROSSO, HIGH);
        delay (50);
        digitalWrite(LED_VERDE, LOW);
        delay (500);

        // test entrambi
        digitalWrite(LED_VERDE, HIGH);
        delay (1000);
}

/**
* Esegue 10 letture dall'ADC e ritorna il valore medio
* @param uint8_t pin di lettura
* @return uint16_t
*/
uint16_t adcRead(uint8_t pin){
        uint32_t total = 0;
        for (uint8_t i = 0; i<=9; i++) {
                total += analogRead(pin);
                delayMicroseconds(10);
                DEBUGPRINT("lettura"); //stampa  righe di prova demo
        }

        return(total/10);
}

/**
* Calcola la temperatura per 10
* @param uint16_t valore ritornato dall'ADC
* @return uint16_t
*/
int16_t calcolaT(uint16_t rawread){
        static float R2;
        static float logR2;
        static float T;

        R2 = (R1 * ( 1023.0 / float (rawread) )) - R1;
        logR2 = log(R2);
        // Steinhart and Hart Equation. T  = 1 / {A + B[ln(R)] + C[ln(R)]^3}
        T = (1.0 / (A + B * logR2 + C * logR2 * logR2 * logR2));
        T =  (T - 273.15);// T - 273.15;

        DEBUGPRINTNN(" TEMPMedia = ");
        DEBUGPRINTNN(rawread);
        DEBUGPRINTNN(" T ");
        DEBUGPRINT(T);

        return(int16_t(T*10));
}

/*******************
*     SETUP       *
*******************/
void setup() {
#if DEBBYUG == 1
        Serial.begin(SERIAL_BAUD);
#endif
        // Set pins
        // declare the EnablePin, PulsePin as an OUTPUT:
        pinMode(LED_VERDE, OUTPUT);
        pinMode(LED_ROSSO, OUTPUT);
        pinMode(NTC_PIN,INPUT );

        // Test accensione led
        testPins();
}

/*******************
*      LOOP       *
*******************/
void loop() {
        int temp = calcolaT(adcRead(NTC_PIN));

        if (temp > 1200) {// temp > 120°C // rosso lampeggiante
                digitalWrite(LED_VERDE, HIGH);
                digitalWrite(LED_ROSSO, LOW);
                delay(500);
                digitalWrite(LED_ROSSO, HIGH);
                delay(500);
        }
        else if (temp > 1100) {// 110°C < temp <= 120°C // rosso
                digitalWrite(LED_VERDE, HIGH);
                digitalWrite(LED_ROSSO, LOW);
                delay(1000);
        }
        else if (temp > 900) {// 90°C < temp <= 110°C // giallo
                digitalWrite(LED_ROSSO, LOW);
                digitalWrite(LED_VERDE, LOW);
                delay(1000);
        }
        else if (temp > 650) {// 65°C < temp <= 90°C // verde fisso
                digitalWrite(LED_ROSSO, HIGH);
                digitalWrite(LED_VERDE, LOW);
                delay(1000);
        }
        else{// <=65°C // Rosso fisso, verde lampeggia
                digitalWrite(LED_ROSSO, HIGH);
                digitalWrite(LED_VERDE, LOW);
                delay(500);
                digitalWrite(LED_VERDE, HIGH);
                delay(500);
        }
}

[drGremi]

Aggiungo, in realtà se non vado errando la somma di 10 valori ci sta in un uint16 e non un uint32, infatti l'adc è a 12 bit quindi 10 letture sono log2(2^12*10)=15.3 bit quindi non dovremo andare in overflow. Se vuoi rimuovere eventuali outsider (cosa che ho levato) dalle letture perché credo sia superflua puoi usare un qsort invece del bubble sort che ti permette di effettuare le operazioni con una complessità O(NlogN) invece di O(N^2).
Per implementarla ti serve una funzione di sorting (che spiega alla funzione qsort come ordinare i dati) e gliela passi, cioè

Codice: Seleziona tutto

int values[10];// valori da ordinare
// codice
int compMet(const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}

qsort(values, 10, sizeof(int), compMet);

a 10 ancora non ci fai caso ma appena la lista si allunga di un pochino di più la complessità quadratica si fa sentire.

Fammi sapere che ne pensi (magari non sei d'accordo con quanto suggerisco e ci può stare ).

Edit: tra l'altro fai la prova con la modalità debug on e off e vedi quanto non caricare per niente la seriale alleggerisca il tutto. E questo lo ottieni cambiando uno 0 in un 1 senza dover stare a commentare codice

[stefanopc]

È molto interessante come hai reso più lineare il codice.
Sicuramente sono d'accordo, come non esserlo.
Già solo il fatto di dichiarare " static " una variabile è una cosa che non ho mai fatto.
Venendo dal basso come dicevo sono più portato a lavorare a basso livello magari sui registri direttamente ma mi manca molta parte del conoscenze dei livelli superiori.
Ignoro quali siano le scelte corrette per limitare la complessità del codice.
Come già detto un rimango un dilettante che ama pasticciare coi registri.
Cercherò di approfondire quanto hai scritto per elevare la mia condizione.
Per ora grazie mille.