Come aggiungere il controllo wireless ad una valvola termostatica TM3030 - Progetto Walvola - HW

In questo post descrivo come ho realizzato una valvola per termosifoni controllabile via Internet denominata Wireless Valvola (Walvola). Qui descrivo la versione 4 in quanto le versioni precedenti sono obsolete causa problemi legati al layout del PCB ed ai consumi della batteria.

Il post e' strettamente collegato ad un mio progetto precedente (post originali Controllo Remoto per Caldaia - HW e Controllo Remoto per Caldaia - Raspberry e Client SW)

Background

Come spiegato nei post menzionati sopra, fino ad ora ho avuto la possibilita' di accendere/spegnere la caldaia per riscaldamento tramite un paio di app web (una solo accendi e spegni e la seconda un calendario per programmazione giornaliera/settimanale).

Questo e' molto funzionale con il mio stile di vita e con la mia presenza/assenza in casa.

Tuttavia un problema che ho riscontrato e' la necessita' disincronizzare esattamente le valvole con l'accensione della caldaia onde evitare che la caldaia vada in blocco. (se tutte le valvole sono chiuse ed il bruciatore parte l'acqua va in ebollizione in pochissimi istanti e la caldaia va in blocco - almeno nel mio impianto).

Anche dopo un'accurata pianificazione e sincronizzazione il sistema, benche' funzionante, e' poco flessibile generando degli sprechi di energia o comunque riscaldando la casa quando non necessario.

Per esempio se programmo la valvola camera letto e la caldaia per accendersi alle 21 ma sono in pizzeria e tardo e rientro alle 23 con il sistema attuale non posso fare nulla in quanto la valvola si apre automaticamente alle 21. Questo perche' non ho controllo sulla valvola da remoto.

Questo progetto ha come obiettivo l'eliminazione del problema descritto sopra rendendo cosi' il mio sistema di riscaldamento casalingo completamente controllabile da remoto e quindi altamente flessibile.

Valvola Termostatica

Ho applicato su ogni termosifoni di casa una valvola termostatica elettronica della Technoline modello TM3030 

Questa valvola e' un oggettino molto interessante.
Si puo' aprire e chiudere come una qualsiasi valvola termostatica in base alla temperatura. Inoltre puo' essere programmata fino a 5 chiusure/aperture giornaliere in base ad un calendario settimanale.

Quest'ultima funzionalita' e' stato il motivo principale della mia scelta.

Come spiegato sopra nonostante siano ottime funzionalita', non sono abbastanza flessibili per il mio scopo.

In questo articolo spiego come rendere qusta valvola wireless e controllabile da remoto con pochissimi euro (circa 3/4 euro per valvola).

Lista Materiali

Per questo progetto ho utilizzato i seguenti componenti

Basetta ramata

Basetta ramata singola faccia dalle dimensioni di 45mm x 48mm

Transistor PNP

Due (2) transistor PNP tipo 2N3906 o simile

Transistor NPN

Quattro (4) transistor NPN tipo BC547 2N3904 o simile

Resistenze

8 resistenze da 10K ohm e 1 resistenza da 470 ohm

Condensatori

1 Condensatore elettrolitico da 100uF e 1 Condensatore da 470 pF o simile

Modulo ESP8266-12

Modulo wireless ESP8266-12 per connessione remota

Fili

1 piccolo pezzo di filo (circa 0,5 centimetri)  da usare come ponticello per il PCB

4 spezzoni di filo per connettere la nuova scheda di controllo alla valvola.

Schema Circuito v4

La valvola TM3030 e' composta essenzialmente da un motore elettrico DC alimentato da due pile AA (3V), da un meccanismo di riduzione della velocita' e di sollevamento/abbassamento pistoncino e da una piccola scheda di controllo.

In questo progetto la scheda di controllo viene completamente rimossa e sostituita da una progettata appositamente.

Il circuito implementa un Half Bridge  a 6 transistor, in modo da poter pilotare il motore e farlo girare in entrambe le direzioni per sollevare/abbassare il pistoncino della valvola e quindi chiudere/aprire il termosifone.

Il funzionamento e' semplicissimo e viene controllato dai piedini 4 e 5 del modulo EPS8266-12 in base al seguente schema

• pin4 = ON e pin 5= OFF -> motore gira in una direzione
• pin4 = OFF e pin 5= ON -> motore gira in nella direzione opposta
• pin4 = OFF e pin 5= OFF -> motore fermo
• pin4 = ON e pin 5= ON -> non ammesso

In questo modo posso azionare e fermare il motore via wireless e quindi da remoto (Internet).

Schema PCB v4

Ho realizzato il seguente PCB posizionando i componenti in modo da lasciare quanto piu' spazio possibile per il motore della valvola. sul lato componenti della basetta.

Qui potete vedere tutti i passi su come realizzare il PCB a casa in maniera autonoma.

Il progetto fritzing completo e' disponibile sul mio github.

Come si vede sul lato destro ho posizionato le piazzole per la saldatura del modulo ESP8266-12. Pertanto il modulo viene saldato lato rame, lasciando ampio spazo sul latocomponenti per poter alloggiare il motore della valvola.

Il PCB e' stato intenzionalmente realizzato senza piano di massa per semplificare il PCB e la realizzazione casalinga. Chi vuole puo' aggiungerlo da se. In ogni caso non e' strettamente necessario per quetso tipo di circuito in quanto non ci sono segnali critici da veicolare.

Circuito e PCB v5

Su github e' presente la versione 5 della scheda che aumenta la stabilita' al risveglio del deep sleep.

Scheda di controllo

Qui la scheda che implementa il circuito visto prima (v4)

Qui il PCB completamente montato con tutti i componenti

Come si vede ho docuto sagomare la basetta per poterla alloggiare nello spazio ridotto presente nel'involucro della valvola TM3030.

Sul lato componenti e' rimasto lo spazio necessario per alloggiare il motore della valvola.

Modifica valvola

Una volta realizzato il PCB e saldato i componenti e' necessario aprire la valvola e sostituire la scheda di controllo per rendere la valvola Wireless.

L'obiettivo e' rimpiazzare la scheda di controllo originale con quella descritta in questo progetto in modo reversibile e quindi lasciando la valvola in uno stato che mi permetta di tornare alla configurazione originale in caso sia necessario (obiettivo non comprarne una nuova se necessario :) ).

Ecco i passi che ho seguito io:

Inizio

Rimozione del coperchio e manopola di programmazione laterale

Rimozione delle 4 viti per poter aprire la valvola

Le viti sono di tipo Torx  e quindi serve un cacciavite adattto, tipo questo

Rimozione delle 4 viti che fissano la scheda di controllo al corpo della valvola

Dissaldatura e Taglio Fili

Dissaldatura di questi 3 fili (sono collegati ad un encoder per misurare la posizione della ghiera dentata e quindi del pistoncino). La valvola implemeta una funzione di autocalibrazione e quindi ha bisogno dell'encoder.

Nella mia versione non ho bisogno di questa funzionalita', inq uanto coem si vedra' nella parte software la valvola si apre e si chiude con un tempo prestabilito.

E' importante ricordarsi l'ordine di saldatura dei fili per poter ripristinare correttamente la valvola in caso sia necessario.

A questo punto la scheda di controllo e' collegata all'alimentazione (vano batterie) ed al motore, quindi dobbiamo rimuovere questi collegamenti.

Mi sono segnato con un pennarello il polo positivo e negativo dei morsetti di alimentazione. (Passo non obbligatorio)

Con pazienza ho dissaldato i fili evitando di rimuovere troppo stagno dai morsetti.

Come si vede il modulo di controllo originale non e' piu' collegato all'alimentazione

mentre e' ancora collegato al motore.

Per evitare di rovinare il modulo di controllo non ho dissaldato i fili del motore ma ho deciso di tagliarli a meta'. Se dovessi ripristinare la valvola non sara' troppo difficile ricongiungere i fili rispettando i colori.

Nota: In alcune versioni che ho implementato anziche' tagliare i fili li ho dissaldati dalla baseta originale. Entrambi i metodo portano allo stesso risultato

Prolunga fili motore

Ho spellato  i fili che fuoriescono dal motore

Ora ho spellato due fili della lunghezza di circa 3 centimetri

e li ho saldati a quelli che fuoriescono dal motore rendendoli cosi' piu' lunghi

A questo punto ho isolato la giunzione dei fili (l'applicazione del nastro isolante non e' il massimo ma non sono un buon elettricista :) )

Ho anche saldato i fili dal motore (la prolunga) alla nuova scheda di controllo creata nei passi precedenti.

I fili vanno saldati in base al seguente schema:

dove

• M+ corrisponde al filo rosso del motore
• M-  corrisponde al filo nero del motore

Prolunga fili alimentazione

Adesso ho preparato altri due fili di circa 3 centimetri e li ho saldati ai morsetti di alimentazione.

Se avessi avuti fili di colore diverso li avrei usati, ma ho usato cio' che avevo in casa :)

Adesso ho saldato i fili di alimentazione negli appositi fori nella nuova scheda di controllo

A questo punto la scheda di controllo originale e' stata completamente rimpiazzata dalla nuova scheda di controllo.

Ho inserito la scheda nel vano batteria e l'ho fissata con una vite (la seconda in basso a sinistra non sono riuscito siccome ho sagomato male la scheda :) )

Ora posso finalomente richiudere la valvola.

Riposiziono il motore con le ghiere nell'apposito spazio usando le guide originali.

Come si vede la nuova scheda con il modulo wireless (lato rame) si adatta perfettamente alla valvola occupando solo lo spazio disponibile permettendo un corretto posizionamentio del motore della valvola.

Adesso richiudo il corpo principale con le 4 viti rimosse all'inizio ed inserisco nuovamente la manopola laterale.

Adesso la valvola termostatica e' pronta ed e' ora una Wireless Valvola (Walvola) :)

Non mi resta che installarla sul termosifone ed iniziare ad usarla :)

Qui un breve video che mostra che la valvola funziona. Si vede solo che il pistoncino va su (gira a destra) e va giu' (gira a sinistra). Il pistoncino si muove solo di pochi millimetri e quindi non si vede benissimo nel video.

Conclusioni

Come descritto nel post ho trasformato con successo una valvola termostatica gia' molto buona in qualcosa di altamente flessibile.
Il processo descritto si puo' applicare enza troppi problemi ad altre valvole. Il circuito rimane lo stesso. E' possibile che altre valvole abbiano PCB di dimensioni diverse, ma l'adattamento dovrebbe non essere complesso.

Se sperimentate altre valvole sarei molto curioso di ricevere il vostro feedback

Arduino e motore DC

In questo post spiego brevemente come pilotare un motore in corrente continua con Arduino.

Il controllo e' molto piu' semplice rispetto ad un motore passo-passo (Arduino e Motore Passo Passo)

Nel caso del motore DC non ci sono fasi da alimentare in sequenza.
Basta applicare una tensione ai morsetti ed il motore gira. Se si inverte la tensione il motore gira in senso contrario.

Questa minor complessita' nel far ruotare il motore rispetto ad un passo-passo ha pero' lo svantaggio che con un motore DC non si ottiene una rotazione precisa e controllata come con il passo-passo.

Mentre nel motore passo-passo si puo' far ruotare il motore di un numero di step o gradi ben determinato con un motore DC si possono solo specificare la tensione da applicare e la durata dell'impulso di alimentazione.

Quindi normalmente i motori DC e passo-passo vengono utilizzati in applicazioni diverse.

Come nel caso del motore passo-passo, Arduino non puo' alimentare il motore direttamente. Si rischia seriamente di bruciare la scheda Arduino.

Anche in questo caso ci vuole un driver per il motore.
Normalmente si usa un transistor di potenza in configurazione Darlington, per esempio TIP 120.

Siccome io non ho un TIP 120 o simile o pensato di utilizzare il ULN2003  che e' un chip che racchiude 7 transistor Darlington.

Quindi funzionalmente il ULN2003 equivale a 7 TIP 120, percio' perfetto per qusto uso

Il ULN2003 l'ho riciclato dalla scheda di controllo per motore passo-passo che ho usato in un mio precedente post

In aggiunta al ULN2003 ho anche usato un piccolo condensatore applicato ai poli del motore a spazzole in corrente continua.

Anche in questo caso ho utilizzato un semplice 7805 per ricavare i 5V necessari a questo circuito partendo da una batteria a 9V. (Nel post relativo ai motori passo-passo spiego meglio come realizzarlo).

A questo punto ho tutti gli elementi necessari a realizzare il semplice circuito.

Ecco come ho cablato il tutto su una breadboard.

Adesso che il circuito e' pronto vediamo il software.

Sketch di controllo

Ho creato un semplice sketch per Arduino (basato sullo sketch usato per il post relativo al controllo bluetooth)

#include <string.h>

//struttura del comando
struct CMD {
  int  speed;  //speed of the motor
  int  time; //timeof the impulse
};

int i = 0;
int readByte = 0;
char buff[255]; //contiene i dati ricevuti
struct CMD parsed_cmd; //comando ricevuto

void setup()
{
  Serial.begin(9600); 
  bt_println("Init!!!!");
}

//pulisce il buffer dopo che e' stato utilizzato
void clear_buff()
{
  for (i=0; i < 255; i++)
    buff[i] = 0;
}

//println verso bluetooth
void bt_println(String str)
{
  Serial.println(str);
  delay(10);
}

//print verso bluetooth
void bt_print(String str)
{
  Serial.print(str);
  delay(10);
}

//parsing della stringa ricevuta in un comando da eseguire
//comando ha il seguente formato:  PIN--COMANDO. esempio: 13--OFF; 13--ON
struct CMD read_command(char *command)
{
  struct CMD cmd;
  const char s[3] = "--";
  char *token;
 
  token = strtok(command, s);
  cmd.speed = atoi(token);
  
  token = strtok(NULL, s);
  cmd.time = atoi(token);  

  return cmd;
}

int validate_cmd(struct CMD cmd)
{
  return ((cmd.speed > 0) && (cmd.speed < 256) && (cmd.time > 0));
}

void execute_cmd(struct CMD cmd)
{
  int speed = cmd.speed;
  int time = cmd.time;
  
  analogWrite(3, speed);
  delay(time);
  analogWrite(3, 0);
}

void loop()
{
  clear_buff();  
  delay(100);
  
  if ((readByte = Serial.available()) > 0) {
    bt_println("-------------------------");
    
    Serial.readBytes(buff, readByte);
    
    bt_println(String("Parsing commnand: ") + buff);
        
    parsed_cmd = read_command(buff);
    
    if (validate_cmd(parsed_cmd)) {   
      bt_println(String("SPEED = ") + String(parsed_cmd.speed));
      bt_println(String("TIME = ") + String(parsed_cmd.time));
      execute_cmd(parsed_cmd);
    }
    else
      bt_println("ERROR: COMMAND NOT VALID!");
  }
}

Per utilizzare lo sketch basta inserire un semplice comando nel monitor seriale seguendo questo formato:

V--T

dove

• V = velocita' di rotazione (1 -- 255)
• T =  durata dell'inpuslo in millisecondi

Quindi per esempio il comando 128--500 fara' ruotare il motore a meta' della sua velocita' massima per 500 ms.

Allo stesso modo 255-1000 lo fara' ruotare alla massima velocita' per 1 secondo

Verifica Funzionamento

Come sempre verifichiamo che il tutto funzioni come previsto

Arduino e Motore Passo Passo

In questo post spiego brevemente come pilotare un motore passo-passo con Arduino.

Ci sono vari modi per pilotare un motore passo-passo. Nel mio caso ho un motore 28BYJ-48

e una scheda di controllo ULN2003

In questo modo e' facilissimo pilotare il motore passo-passo.

Come si vede la scheda di controllo richiede:

• +5V
• GND
• 4 GPIO di Arduino (per controllare i 4 avvoglimenti del motore in questione)

E' imporante notare che l'alimentazione della scheda e quindi del motore non deve essere prelevata da Arduino, altrimenti quasi certamente lo friggiamo.

L'alimentazione deve essere esterna ad Arduino


Nel mio caso siccome ho una batteria a 9V ho creato un semplice regolatore DC-DC di tensione in modo da ottenere i 5V richiesti per l'alimentazione del motore.

Regolatore DC-DC

Lo schema del circuito di un semplice regolatore DC-DC e' semplicissimo

Come si vede dalla figura ho usato un 7805 e due condensatori. Nel mio caso il condensatore Ci all'ingresso ha una capacita' di 100 uF e Co all'uscita una capacita' di 10 uF.

Qui sotto un semplice schema di come ho montato il regolatore su una breadboard:

Ecco come ho realizzato velocemente il regolatore sulla basetta:

Ok a questo punto sulle due piste in basso (filo giallo e bianco) ho i +5V e GND con cui alimentero' il motore passo passo e la scheda di controllo.

Collegamento motore ad Arduino

Adesso ho collegato il motore alla scheda di controllo e questa ad Arduino come spiegato qui sotto.

Il motore ha un connettore con 5 fili. Lo collego alla scheda (entra in una sola direzione).

Dopo di cio' ho inserito i fili dell'alimentazione in questo modo:

• filo rosso -> GND
• filo marrone -> +5V

Adesso collego questi due fili alla breadboard all'uscita del regolatore DC-DC

Il filo rosso in corrispondenza del filo giallo sulla breadboard (GND)

Il filo marrone in corrispondenza del filo bianco sulla breadboard (+5V)

A questo punto ho collegato la scheda di controllo del motore ad Arduino come spiegato qui sotto.

• filo nero         --> pin IN1 della scheda motore
• filo marrone   --> pin IN2 della scheda motore
• filo rosso        --> pin IN3 della scheda motore
• filo arancione --> pin IN4 della scheda motore

Dal lato Arduino:

• filo nero         --> pin 8
• filo rosso        --> pin 9
• filo marrone   --> pin 10
• filo arancione --> pin 11

Nota
Come notate i pin 9 e 10 sono invertiti per far si che il motore possa giare in senso orario e antiorario.
Immagino che queso sia un problema della schedina da 2$.
Quindi tutto sommato solo invertendo i fili abbiamo risolto il problema.

A questo punto ho collegato la batteria alla breadboard rispettando la polarita'.

Arduino Sketch

Ho creato questo semplice sketch (basato su stepper_oneRevolution) che rimane in attesa di input dal monitor seriale di arduino

#include <Stepper.h>

const int stepsPerRevolution = 4;  

int readByte = 0;
char buff[255]; //contiene i dati ricevuti
int steps = 0;

// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8,9,10,11);            

void setup() {
  // set the speed
  myStepper.setSpeed(4096);
  // initialize the serial port:
  Serial.begin(9600);
}

void clear_buff()
{
  int i = 0;
  for (i=0; i < 255; i++)
    buff[i] = 0;
}

void loop() {
  clear_buff();  
  delay(100);
  
  if ((readByte = Serial.available()) > 0) {
    // insert the number of step (+ or -) manually trhough serial monitor  
    Serial.readBytes(buff, readByte);
    steps = atoi(buff);  
    Serial.println(steps);
    myStepper.step(steps);
  }
}

Inserisci il numero di step e il verso in cui si vuole che il motore giri:

• 2048 : il motore compie un giro completo in senso orario
• -2048: il motore compie un giro completo in senso antiorario
• 1024: il motore compie mezzo giro in senso orario

Dopo varie prove ho verificato che i valori 4 per stepsPerRevolution e 4096 per la velocita' di rotazione sono i migliori. In questo modo il motore compie un giro completo in circa 6 secondi.

Potete variare questi due valori ma fate in modo che il prodotto dei due valori sia sempre 16384.

Verifica Funzionamento

Come sempre verifichiamo che il tutto funzione come previsto!!!

Come sempre chiunque abbia idee e migliorie e' il benvenuto.