martedì 23 dicembre 2014

Arduino e motore DC con H-bridge L293D

Nel precedente post http://mancusoa74.blogspot.it/2014/12/arduino-e-motore-dc.html ho spiegato con pilotare un motore DC con Arduino.

Tuttavia in quel post il motore poteva girare in un solo verso siccome ho usato un ULN2003.

In questo post uso un L293D, cioe' un chip che implementa due circuiti Half-Bridge (per maggiori info: http://www.rakeshmondal.info/L293D-Motor-Driver




In questo modo e' possibile controllare il verso di rotazione del motore.

Circuito




Ho implementato il circuito riportato qui sopra









Sketch

Ho implemetato questo semplicissimop sketch che fa ruotare il motore in un versoper  1 secondo e poi nel verso opposto per 1 secondo

void setup() {
  Serial.begin(9600);
  Serial.println("Staring");

  pinMode(2, OUTPUT);
  pinMode(7, OUTPUT);
}



void loop() {

  digitalWrite(2, HIGH);
  digitalWrite(7, LOW);
  delay(1000);          

  digitalWrite(2, LOW);
  digitalWrite(7, LOW);
  delay(2000);
  
  digitalWrite(2, LOW);
  digitalWrite(7, HIGH);
  delay(1000);

  digitalWrite(2, LOW);
  digitalWrite(7, LOW);
  delay(2000);  
}


Come si vede dal codice il motore e' controllato dai pin 2 e 7:


  • Se i pin sono entrambi HIGH o LOW il motore e' fermo.
  • Se il pin 2 e' HIGH e il 7 e' LOW il motore gira in senso orario
  • Se il pin 2 e' LOWe il 7 e' HIGH il motore gira in senso antiorario


Verifica Funzionamento

Come sempre verifichiamo che il tutto funzioni come previsto





mercoledì 10 dicembre 2014

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




lunedì 8 dicembre 2014

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.


domenica 7 dicembre 2014

Controllo Arduino via Bluetooth

In questo post descrivo come ho collegato Arduino Uno (per altri tipi di Arduino i collegamenti sono simili) con un modulo JY-MCU Bluetooth che avevo comprato qualche tempo fa.









Questo modulo mi permette di collegarmi in Bluetooth attraverso il mio telefono o tablet o PC.
Il modulo viene visto da Arduino come una comunicazione seriale e quindi e' di facilissima gestione.

Ho gia' im mente un piccolo progettino per la mia casa con questo modulo, ma per il momento concentriamoci su come utilizzare il modulo.

Per utilizzare il modulo con Arduino ci sono sue passaggi da eseguire:


  1. Configurare il modulo
  2. Utilizzare il modulo







Configurazione del modulo JY-MCU

Questo articolo speiga molto bene come configurare il modulo JYMCU https://github.com/rwaldron/johnny-five/wiki/JY-MCU-Bluetooth-Serial-Port-Module-Notes

Effettuate i collegamenti del modulo bluettoth come in figura



Nel mio caso ho usato 4 fili di colo Nero, Marrone, Rosso ed Arancione.

I fili sono collegati in questo modo al modulo bluettoth:


  • nero -> VCC
  • marrone -> GND
  • rosso -> TX
  • arancio -> RX




Adesso ho collegato l'altra estremita' dei fili a Arduino in questo modo







  • nero -> pin +5V
  • marrone -> pin GND
  • rosso -> pin 10
  • arancio -> pin 11




E' importante collegare i fili in modo corretto siccome il software di configurazione del modulo assegna al pin 10 il ruolo RX e al pin 11 il ruolo di TX.

Quindi come si capisce dalle conenssione il collegamento e' ovviamente incrociato in modo che:

  • modulo TX --> Arduino RX (pin 10)
  • modulo RX -> Arduino TX (pin 11)






Una volta che il modulo bluetooth e' stato collegato ad Arduino come descritto sopra caricare il seguente sctach su Arduino:

 

#define ROBOT_NAME "YOUR ARDUINO NAME"

// If you haven't configured your device before use this
#define BLUETOOTH_SPEED 9600
// If you are modifying your existing configuration, use this:
// #define BLUETOOTH_SPEED 57600

#include 

// Swap RX/TX connections on bluetooth chip
//   Pin 10 --> Bluetooth TX
//   Pin 11 --> Bluetooth RX
SoftwareSerial mySerial(10, 11); // RX, TX


/*
  The posible baudrates are:
    AT+BAUD1-------1200
    AT+BAUD2-------2400
    AT+BAUD3-------4800
    AT+BAUD4-------9600 - Default for hc-06
    AT+BAUD5------19200
    AT+BAUD6------38400
    AT+BAUD7------57600 - Johnny-five speed
    AT+BAUD8-----115200
    AT+BAUD9-----230400
    AT+BAUDA-----460800
    AT+BAUDB-----921600
    AT+BAUDC----1382400
*/


void setup()
{
  Serial.begin(9600);
  while (!Serial) {
    ; // wait for serial port to connect. Needed for Leonardo only
  }
  Serial.println("Starting config");
  mySerial.begin(BLUETOOTH_SPEED);
  delay(1000);

  // Should respond with OK
  mySerial.print("AT");
  waitForResponse();

  // Should respond with its version
  mySerial.print("AT+VERSION");
  waitForResponse();

  // Set pin to 0000
  mySerial.print("AT+PIN0000");
  waitForResponse();

  // Set the name to ROBOT_NAME
  mySerial.print("AT+NAME");
  mySerial.print(ROBOT_NAME);
  waitForResponse();

  // Set baudrate to 57600
  mySerial.print("AT+BAUD7");
  waitForResponse();

  Serial.println("Done!");
}

void waitForResponse() {
    delay(1000);
    while (mySerial.available()) {
      Serial.write(mySerial.read());
    }
    Serial.write("\n");
}

void loop() {}




Se tutto ha funzionato correttamente dovreste vedere un output come questo:






A questo punto il modulo bluetooth e' correttamente configurato e pronto per essere utilizzato.

Il modulo bluetooth adersso puo' essere scollegato da Arduino in quanto per il suo utilizzo dobbiamo collegarlo in modo leggermente diverso.

Utilizzo del modulo JY-MCU

Per verificare il funzionamento del modulo ho creato un simplicissimo esempio.
Voglio poter accendere o spegnere due led dal mio cellulare inviando dei semplici comando a Arduino.

I comandi hanno il seguente formato

# PIN--COMANDO

dove 

  • PIN: numero di pin su arduino
  • COMANDO: ON o OFF

Quindi per esemprio il comando: 10-ON imposta il pin 10 di Arduino a HIGH
Mentre 10-OFF impostal il pin 10 di Arduino a LOW






Circuito di prova

Ho create il semplicissimo circuito rappresentato qui sotto su una breadboard.

Ho collegato il pin 8 e 10 rispettivamente a due led inserendo una resistena per limitare la corrente. Questo e' importantissimo altrimenti quasi certamente si brucia il pin di Arduino o si puo' addirittura danneggiare tutta la scheda Arduino (io ho usato resistenze da 220 Ohm in quanto ho solo queste)












Come si vede il modulo JY-MCU bluetooth e' collegato ad Arduino in modo diverso da prima. Piu' precisamente:

  • nero -> pin +5V
  • marrone -> pin GND
  • rosso -> pin 0 (RX)
  • arancio -> pin 1 (TX)





In questo modo il modulo bluetooth viene visto da Arduino come una comunicazione seriale.


Sketch di esempio

Ho creato un semplicissimo sketch che rimane in attesa ed esegue un comando ricevuto tramite bluetoot

Ovviamente lo sketch e' solo per verificare il funzionamento e' non e' solido abbastanza per un utilizzo piu' serio, ma dovrebbe essere d'aiuto a capire meglio come usare il modulo stesso.


 
#include 

//struttura del comando
struct CMD {
  int  pin;  //pin da controllare
  char *cmd; //comando da applicare al pin (ON|OFF)
};

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

void setup()
{
  Serial.begin(57600); 
  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.pin = atoi(token);
  
  token = strtok(NULL, s);
  cmd.cmd = token;  

  return cmd;
}

int validate_cmd(struct CMD cmd)
{
  return ((cmd.pin > 0) && ((String(cmd.cmd) == "ON") || (String(cmd.cmd) == "OFF")));
}

void execute_cmd(struct CMD cmd)
{
  int pin = cmd.pin;
  int status = (String(cmd.cmd) == "ON")?HIGH:LOW; 
 
  bt_println(String("Settin PIN: ") + String(pin) + String(" to ") + String(status));
  
  pinMode(pin, OUTPUT);
  digitalWrite(pin, status); 
}

void loop()
{
  clear_buff();  
  delay(1000);
  
  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("Serial PIN = ") + String(parsed_cmd.pin));
      bt_println(String("Serial STATUS = ") + parsed_cmd.cmd);
      execute_cmd(parsed_cmd);
    }
    else
      bt_println("ERROR: COMMAND NOT VALID!");
  }
}


Verifica del funzionamento

Adesso che abbiamo completato la configurazione del modulo bluetooth, il cablaggio del semplice circuito di prova non ci resta che caricare lo sketch su Arduino.

Per verificare che il tutto funzioni in modo corretto ho installato una semplice app sul mio cellulare Android (per iOS esistono app simili).

L'app che ho installato si chiama BluetoothTerminal.
Questa app mi permette di digitare dei caratteri (comandi) e di inviarli tramite bluetooth al mio Arduino

Nel video si vede che i led si accendono e si spengono quando invio il comando corretto ad Arduino.

Il modulo che ho usato io ha un pin uguale a 0000 per l'accoppiamento del bluetooth con il cellulare.





Come sempre se avete idee per migliorare questo progetto saro' lieto di leggere i vostri commenti e  di aggiornare il post.







domenica 30 novembre 2014

Remote heater - HW

This is an English translation of the original Italian post http://mancusoa74.blogspot.it/2014/11/controllo-remoto-per-caldaia-progetto.html.

I am doing that as some friends told me they would have been interested in the project but they cannot simply read Italian.


In this post I describe how I have built a simple remote control mechanism for my home heating system.

My objective here is to create a simple system which is capable to answer two simple questions:


  1. how do I switch on/off my heating system when I am out of home?
  2. how do I program my home heating system in a flexible way?

Currently the home heating system is controlled by a normal on the wall thermostat





That one doesn't give me the required flexibility necessary to satisfy above item #1 and #2.

One day I got in my hands a  raspberry pi model B  and then I have asked myself: why not replacing the on the wall thermostat with the raspberry?

This was the starting point of my small home project.

The first step has been to get the approval from my boss (wife??? ) :). She has immediately added a third requirement:

3. the on the wall thermostat should (must) always be working and should not be replaced by the raspberry one.

Well, now all the requirements are clear so I can start the implementation of the project.

Initial Circuit

The current circuit of the home heater is the following:





Final Circuit

In order to be compliant with requirement #3 I have modified the initial circuit in the following way:






This way I have realized a simple logical OR between the raspberry pi and the on the wall thermostat. This satisfies all the 3 requirements:

  1. through the raspebbry I can switch the relay and thus switching on/off the heating system from a remote location
  2. I can program the raspberry in a way that it switch on/off the heating system in a flexible way 
  3. in case the Rasperry will not be working (network down, hw failure, ...)  I can still operate the heating system from the legacy on the wall thermostat

Assembly of the project

In order to build and assemble this simple home project I have used the following components:


Step 1: Prepating the Junction Box
I have positioned the rapsberry in a corner of the junction box. Raspberry will be fixed in that position through a screw








As my junction box is not large enough to fully host the raspberry, I have signed with a pencil the place on the junction box in which to create a slot to allow the insertion of the power cable and the SD card.






As you can see the slots have been created with an electrical drill. I am not very proud of this part of the project :) . If you have better idea and better tools to create the slots let me know.

Step 2: Fixing the junction box to the wall

I have drilled a hole in the junction box so later I can apply a nut and bolt screw in order to fix and hold the raspberry pi.



Later I have applied some glue to the junction box and to the wall. This is how the junction box is hold on the wall. I have used glue to avoid drilling the wall.
Obviously this is my preference and you can select a different way to hold the box on the wall.

Step 3: Raspberry Wiring

The wiring is pretty straightforward. It is only needed:

  • VCC +5V
  • GND
  • 1x GPIO (#15) but you can use any other available GPIO on your board. I have used 15 just for wiring issues.




More in detail I have wired the raspberry in this way:




  • green wire    -> +5V  = Pin 2
  • white wire -> GND = Pin 6
  • yellow wire  ->  GPIO 15 = Pin 10


Those Pin numbers are valid for Raspberry model B revision 2. If you are using a different Raspberry model or revision make sure to select the correct GPIO layout in order to avoid issues.




Step 4: Wiring Relay module

As shown in the final circuit diagram above, I need to add a new relay which is controlled by a GPIO (#15) of the raspberry pi.

In the past I have bought a 5V relay module online from  http://www.dx.com/p/arduino-5v-relay-module-blue-black-121354#.VHJFwIvF98E


As I had this module in my workbench I have decided to use it for this project.  Obviously you can use any other module or relay you want. In any case I really suggest to be sure to add the protection diode in order to avoid "surprises" with your raspberry. With no protection diode you can burn the GPIO line of your raspberry.

I have made the wiring as follow:






white wire ->  pin - of the module
green wire   ->  pin + of the module
yellow wire   ->  pin S of the module

Merely for assembly issues into the junction box I have used 3 pairs of wires. This way I have a longer wiring and an easier routing inside the box.
This is essentially needed as with short wires the connection to GPIO of raspberry is quite unstable. On the contrary with longer cables the connection to GPIO pins is more solid and stable.

I have then wired the wires from raspberry with the wires from relay module using a small "mammut" as shown in the picture below





This is obviously optional. Everyone can decide whether do it or not in this way.

Step 5: Fitting everything in the box

At this stage the wiring process is over. The relay module is properly connected to the raspberry. Now we only need to assemble and fit all the component inside the junction box.

I have fixed the raspberry to the screw previously added to the box. Make sure the glue is solid (I have applied it twice :) )

Now I have connected the  Netgear WNCE2001  to an available USB port to get power and to the ethernet port of the raspberry.
This way I have a stable and fast connectivity to my wifi network.





The wifi dingle I had was not reliable enough for a stable wifi connection.

As always the reader is free to select a different mechanism to gain network connectivity (wifi, wires, ...). Important is to get access to the Internet.

Now is the time to set in place the relay module.
In order to continue I had used a small trick to gain additional space in my junction box.
I have added a thin plexiglass layer on top of the raspberry and I have fix it to the only available screw in this project.




This way I have created a new empty layer on which I can position the relay module which it is also fixed to the same screw as before.



Step 6: Wiring to the heater and box closing

We have now reached the final stage.

  • Insert the SD card with Raspbian OS and custom control software
  • Plug of power cable
  • Wiring to the existing heating system circuit according to final circuit diagram




Now I have applied the cover of the junction box and fixed the screws.




If needed or preferred you can apply some sealant material to the slots. I have not done this as I am lazy :) and especially as my heater room is completely dry.

Obviously in the future (never :) ) I will apply some insulating tape to the blue and brown wire. In the end I am not very interested in the electrical part of this portion. The fun is with the control software....


Improvements

Possible improvements that I have in mind for the future:

  • replacing the Netgear wifi module with a smaller USB wifi dongle which is properly working
  • replacing raspberry with model A+. smaller sizes and lower power consumption
  • replacing the junction box with a smaller one
  • replacing raspberry with arduino and RF receiver. This will reduce the cost of this project

Software

In this post Controllo remoto per caldaia e raspberry I have described the control software for the raspberry server and for the client of this project.

Conclusions

I have had a lot of fun with this small home project. With just few Euro I now have a system which allows me to remotely control my home heating system in a way which is much more flexible than the legacy on the wall thermostat.

Obviously I could have found existing solution on the market and paid an higher price for it. However I would have missed the fun and the learning experience

Anyone which has improvements or new ideas for this project is welcome to share them. I will be more than happy to add it to my project.