Riscaldatore e termostato

International Italiano Generale
1

Ho scritto un minuscolissimo codice per un termostato:

// Termostato
#define SSR 13 //pin SSR
int tSSRMin; // temperatura per accensione relé
int tSSRMax; // temperatura per spegnimento relé

void setup() {
  pinMode(SSR, OUTPUT); // SSR
  digitalWrite(SSR, LOW);  // SSR OFF 
  tSSRMin = 25;
  tSSRMax = 27;

void loop () {
 //termostato
  int statusSSR; // stato del pin SSR - HIGHT/LOW - 1/0
  statusSSR = digitalRead(SSR);

  if (T1 < tSSRMin) {   
    digitalWrite(SSR, HIGH);  
  }  // set the SSR ON
  if (T1 > tSSRMax) {   
    digitalWrite(SSR, LOW);  
  }  // set the SSR OFF

  // Status Pin - SSR riscaldatore 
  if (statusSSR == 1) {
    Serial.println("Riscaldatore Acceso");
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat ON ");
  }

  else {
    Serial.println("Riscaldatore Spento"); 
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat OFF"); 
  }

Funziona tutto. Bello lavorare non in ram overflow, le cose funzionano :smiley:
Al posto del pin led metterò poi un SSR.
Mi chiedevo, ha senso fare qualcosa di più complicato o vado bene così?
Nello specifico ero molto attratta dalla libreria PID. Ho un controller PID nel fornetto per la ceramica ed è grosso tre volte l'arduino... il pensiero che l'arduino mi potesse fare anche da controller pid era quindi assai succulento.

Ma non credo abbia senso, datemi conferma :slight_smile:
Le info per la valutazione sono queste:
L'SSR controllerà dei riscaldatori tubolari a filo, delle cose così per intenderci.
Questi affari hanno quella che credo si chiami alta impedenza termica, ci mettono una buona mezzoretta a scaldarsi ed un altra mezzoretta a raffreddarsi.
In pratica un controllo pwm, pur lento quanto ci pare, è inutile no?
Ora come ora sono controllati da un semplice termostato a spina che, suppongo, faccia la stessa cosa del codice che ho scritto.

Discorso secondario:
tmax e tmin le ho messe fisse. Nella realtà saranno 21 e 18.
E' un intervallo ben specifico che non ho necessità reale di cambiare... MA.
Ma ponderavo che sarebbe interessante mettere due pulsantini (momentary che ho già) per variare quei valori.

Qualche suggerimento? Nel frattempo frugo il web ma ovviamente chiedo anche a voi.
Se fosse una cosa complicata da metter su, lascio perdere in partenza, perché nella realtà non è che mi serva davvero.
Se fosse una cosa semplice semplice mi piacerebbe impararla e implementarla.

2

uhmmm... dov'è che dichiari assegni un valore a T1?

SSR lo usi come output, non credo che tu possa farci una digitalWrite sopra. Io ho sempre usato una bollean per ricordarmi il valore, ma sinceramente non mi sono mai posto il problema.

tSSRMin e tSSRMax usale con la define, così non occupano spazio in ram

spero che il povero pin arduino non alimenti direttamente quei tubazzi lì, se no vedo una triste fine del micro :slight_smile:

il pid... beh, diciamo che non ti serve, il pid NON è un algoritmo che da un risultato ottimale, ma permette di avere una soluzione a problemi multivariabile e/o complessi.

Nei fornetti si usa perchè scaldano molto e in frettta, quindi per evitare di superare la temperatura massima (anche se spegni il forno, la temperatura continua a salire per qualche attimo), oppure per seguire delle "curve" di riscaldamento per evitare che la temperatura salga troppo in fretta, etc etc..
ma non credo che questo sia il tuo caso. E poi hai problemi di RAM, evitiamo di incasinare troppo le cose :slight_smile:

3

lesto:
uhmmm... dov'è che dichiari assegni un valore a T1?

T1 è una float che ha dentro il valore di un sensore dallas... è un pezzo di codice nel loop, non volevo allungare il post :slight_smile:

SSR lo usi come output, non credo che tu possa farci una digitalWrite sopra. Io ho sempre usato una bollean per ricordarmi il valore, ma sinceramente non mi sono mai posto il problema.

Questa non l'ho capita :
Negli esempi di codice che ho trovato, per i relé o per accendere un led, si inizializza un pin come output e per mandarlo high si usa digitalWrite
http://www.arduino.cc/en/Reference/digitalWrite
Ma più probabilmente non ho capito cosa intendi :slight_smile:

spero che il povero pin arduino non alimenti direttamente quei tubazzi lì, se no vedo una triste fine del micro :slight_smile:

Ma nooo :slight_smile:
Il pin comanderà un relé allo stato solido, per la precisione questo
Accetta in ingresso dai 4.5 ai 32vdc, quindi dovrebbe essere perfetto per l'arduino (la scheda da un Input Voltage di 3, ma sul pack c'è scritto 4.5 in ogni caso con i 5v dell'arduino sono a posto)

E poi hai problemi di RAM, evitiamo di incasinare troppo le cose :slight_smile:

Non ho più problemi di RAM :stuck_out_tongue:
Sto già lavorando al codice diviso per l'architettura multiprocessore, ora sono a 13k per lo sketch ed al 30% di ram, avr size said.

Cmq niente PID, mi hai confermato l'inutilità.
Rimane la questione dei bottoncini... :stuck_out_tongue_winking_eye:

4

DanielaES:

SSR lo usi come output, non credo che tu possa farci una digitalWrite sopra. Io ho sempre usato una bollean per ricordarmi il valore, ma sinceramente non mi sono mai posto il problema.

Questa non l'ho capita :
Negli esempi di codice che ho trovato, per i relé o per accendere un led, si inizializza un pin come output e per mandarlo high si usa digitalWrite
http://www.arduino.cc/en/Reference/digitalWrite
Ma più probabilmente non ho capito cosa intendi :slight_smile:

Neanch'io. :sweat_smile:
E' giusto, infatti. Pin su output e poi High o Low a seconda dei casi..

5

SCUSATEEEEEE intendevo che sopra ci fa anche una digitalRead :grin:
[...]
statusSSR = digitalRead(SSR);
[...]

scsate ma ieri sera ero stanco :sleeping:

6

lesto:
[...]
statusSSR = digitalRead(SSR);
[...]

Uhm, perché c'è qualcosa che non va in ciò? (chiedo eh)
Io necessito di archiviare lo stato del relé in una variabile, che poi invierò per il datalogging al secondo arduino.
Ora come ora mi sembra che funzioni senza problemi, facendo il print a seriale, quando sono HIGH lo statusSSR vale 1 e quando sono LOW vale 0... c'è qualche problema nel fare ciò?

7

non lo so, io ho sempre evitato di farlo come la peste, dovrei vedere il codice delle digitalRead prima di poter dire qualcosa.

8

lesto:
non lo so, io ho sempre evitato di farlo come la peste, dovrei vedere il codice delle digitalRead prima di poter dire qualcosa.

Se ho capito cosa intendi, è già nel post iniziale

// Status Pin - SSR riscaldatore 
  if (statusSSR == 1) {
    Serial.println("Riscaldatore Acceso");
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat ON ");
  }

  else {
    Serial.println("Riscaldatore Spento"); 
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat OFF"); 
  }

Oltre a questo, quando implementerò la comunicazione seriale tra i due arduino... invierò la variabile statusSSR come una qualsiasi altra variabile

9

Non avevo notato questa cosa (bravo lesto).
Perché dichiarare un pin come OUTPUT se poi lo devi usare come INPUT?
Nonostante il datasheet non condanni questa cosa:

Reading the Pin Value
Independent of the setting of Data Direction bit DDxn, the port pin can be read through the PINxn Register bit. (...)

(quindi si può leggere da un pin settato come output), la logica invece lo fa :stuck_out_tongue:
Se il tutto è in vista della comunicazione seriale, puoi evitare dato che la comunicazione è gestita in HW (almeno sui pin D0/D1) per cui non dove preoccuparti del loro stato.

10

leo72:
Non avevo notato questa cosa (bravo lesto).
Perché dichiarare un pin come OUTPUT se poi lo devi usare come INPUT?

Inizio a capire. In pratica per comandare il relé setto il pin in OUTPUT ma per leggerne lo stato ed archiviarne il valore nella variabile lo "tratto" come INPUT.
Ed a logica risulta strano anche se cmq è consentito e funziona.

Se il tutto è in vista della comunicazione seriale, puoi evitare dato che la comunicazione è gestita in HW (almeno sui pin D0/D1) per cui non dove preoccuparti del loro stato.

Oggi sarò stordita ma non capisco ciò che hai scritto :slight_smile:
Molto semplicemente:
Arduino MASTER_SEN / sensori lcd e termostato /
Arduino SLAVE_WEB / datalogging e web server /
Scambio dati Easysoftserial (basata su softserial).
A me serve sapere quando il relé è HIGH o LOW perché:
MASTER_SEN deve scriverlo sullo schermo LCD ed inviare il valore 0/1 tramite softserial (quindi pin d2 d3 nel mio caso).
SLAVE_WEB riceve lo stato del pin SSR e lo logga su sd ( 0/1)

EasySoftSerial gestisce da sola la ricostruzione dei dati seriali, a patto che si dichiari prima che tipo di variabile è inviata (int, long ecc).
Per questo ho creato una variabile che contenga lo stato del relé... usando quindi digitalRead.
Non capisco perché non dovrei preoccuparmi dello stato ecc.
In alternativa, se ciò che sto facendo è contronatura è meglio qualcosa di questo tipo?.
Cosi elimino il digitalRead

fuori dal loop: int statusSSR; // stato del pin SSR - HIGHT/LOW - 1/0

Nel loop:

  if (T1 < tSSRMin) {   
    digitalWrite(SSR, HIGH);  
    statusSSR = 1;
  }  // set the SSR ON
  if (T1 > tSSRMax) {   
    digitalWrite(SSR, LOW);  
    statusSSR = 0;
  }  // set the SSR OFF

 // Status Pin - SSR riscaldatore 
  if (statusSSR == 1) {
    Serial.println("Riscaldatore Acceso");
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat ON ");
  }

  else {
    Serial.println("Riscaldatore Spento"); 
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat OFF"); 
  }
11

se il reference dice che non ci sono problemi usalo tranquillamente, così eviti eventiali problemi di sincornizzazione pin-variabile, anzi è più leggibile il codice.
L'unico problema che mi ponevo è che la read andasse di nascosto a settarti il pin come input o qualche roba del genere e creasse un bel macello

12

DanielaES:
In alternativa, se ciò che sto facendo è contronatura è meglio qualcosa di questo tipo?.
Cosi elimino il digitalRead

fuori dal loop: int statusSSR; // stato del pin SSR - HIGHT/LOW - 1/0

Nel loop:

if (T1 < tSSRMin) {   
    digitalWrite(SSR, HIGH); 
    statusSSR = 1;
  }  // set the SSR ON
  if (T1 > tSSRMax) {   
    digitalWrite(SSR, LOW); 
    statusSSR = 0;
  }  // set the SSR OFF

// Status Pin - SSR riscaldatore
  if (statusSSR == 1) {
    Serial.println("Riscaldatore Acceso");
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat ON ");
  }

else {
    Serial.println("Riscaldatore Spento");
    Serial.println(statusSSR);
    srlcd.setCursor(12, 2);
    srlcd.print("Heat OFF");
  }

Mi rispondo da sola :slight_smile:
Si, questo codice sembra decisamente meglio del digitalRead().
con digitalRead avevo un minuscolissimo, ma percettibile, lag nell'aggiornamento dei dati sul display.
Cambiando il codice e togliendo il read sul pin in OUTPUT il lag è sparito e l'aggiornamento dei dati è istantaneo.
Suppongo che, anche se si può fare un digitalRead su un pin in OUTPUT, probabilmente c'è qualcosa che fa a pugni :slight_smile:
Grazie lesto e leo! :slight_smile:
E se avete altri suggerimenti sul codice, ben vengano!

EDIT:

L'unico problema che mi ponevo è che la read andasse di nascosto a settarti il pin come input o qualche roba del genere e creasse un bel macello

Sono estremamente convinta che facesse esattamente qualcosa di simile e creasse così quel piccolo lag nel leggere lo status del pin in OUTPUT.