Dernières nouvelles

Z-UNO – Système pour chauffage au bois

Me chauffant au bois, j’ai décidé de me monter un système me permettant de gérer correctement mon chauffage au bois ce qui n’est pas évident vu les contraintes.

Aujourd’hui je vous présente donc ce projet.

Suite à mes tests, je me suis rendu compte que la chaudière bois n’est facile à gérer.
Plusieurs raisons à cela :

  • La chaudière bois ne doit pas descendre en dessous du certaine température pour qu’elle soit efficace
  • Sans ce système, je ne savais pas quand exactement remettre du bois dans ma chaudière et cela devenait problématique pour moi afin de ne pas bruler du bois pour rien. Quand on coupe du bois on y fait très attention.
  • En pleine hiver quand il fait des températures négatives, il faut impérativement garder la chaudière à bonne température, sinon, la température mettra trop de temps à remonter dans la maison.

Pré-requis

Matériel

  • un thermo-couple max6675
  • un buzzer
  • une z-uno
  • 3 TIP120
  • 4 résistance 1.5 kΩ
  • 12 V power supply unit for the RGB strip
  • du cable
  • un écran
  • des connecteurs
  • une sonde DS18B20

Logiciel

  • la librairie Max6675 arduino modifiée par mes soins
  • le logiciel de programmation pour la Z-Uno

Branchement

Programmation de la Z-Uno

Afin de ne pas surcharger inutilement la box domotique, j’ai décidé de programmer mes scénarios sur la carte Z-UNO. Je ferrai bien sûr un mode programmation Off afin de quand même pouvoir programmer mon projet à partir de la box domotique.

Cahier des charges que je me suis imposé pour arriver à contrôler correctement la gestion du bois :

  • prendre la température de la pièce
  • prendre la température de la fonte
  • changer de couleur pour savoir quand remettre du bois facilement et avoir une idée de la température de la fonte en un coup d’oeil sur le boitier
  • plusieurs modes (OFF, Eté, Hiver, Hiver avec gestion température pièce)
  • Buzzer si température fonte trop élevée + couleur rouge du boitier

Code :

// #----------------------------------------------------------------#
// # Librairies #
// #----------------------------------------------------------------#

// Ajout de la librairie DS18B20.h
#include "ZUNO_DS18B20.h"

// Ajout de la librairie modifiée pour Z-UNO du thermocouple
#include <max6675.h>

// Ajout de la librairie écran
#include "Print.h"
#include "Wire.h"

// #----------------------------------------------------------------#
// # Déclaration des pins #
// #----------------------------------------------------------------#

// Pin de connexion de la sonde de température ds18b20
#define PIN_DS18B20 11

// Pin de conenxion RGB
#define BLUEPIN PWM1 // pin connection Bleu
#define REDPIN PWM2 // pin connection Rouge
#define GREENPIN PWM3 // pin connection Vert

// Pin de connexion Thermocouple
#define thermoDO 22 //DO
#define thermoCS 21 //CS
#define thermoCLK 20 //CLK

//Pin de connexion BUZZER
#define buzzer PWM4

//Pin de connexion écran
#define LC_I2CADDR 0x27

// Commandes
#define LCD_CLEARDISPLAY 0x01
#define LCD_RETURNHOME 0x02
#define LCD_ENTRYMODESET 0x04
#define LCD_DISPLAYCONTROL 0x08
#define LCD_CURSORSHIFT 0x10
#define LCD_FUNCTIONSET 0x20
#define LCD_SETCGRAMADDR 0x40
#define LCD_SETDDRAMADDR 0x80

// Flags pour mode entrée
#define LCD_ENTRYRIGHT 0x00
#define LCD_ENTRYLEFT 0x02
#define LCD_ENTRYSHIFTINCREMENT 0x01
#define LCD_ENTRYSHIFTDECREMENT 0x00

// Flags pour controle ON/OFF
#define LCD_DISPLAYON 0x04
#define LCD_DISPLAYOFF 0x00
#define LCD_CURSORON 0x02
#define LCD_CURSOROFF 0x00
#define LCD_BLINKON 0x01
#define LCD_BLINKOFF 0x00

// Flags pour curseur
#define LCD_DISPLAYMOVE 0x08
#define LCD_CURSORMOVE 0x00
#define LCD_MOVERIGHT 0x04
#define LCD_MOVELEFT 0x00

// flags pour fonction set
#define LCD_8BITMODE 0x10
#define LCD_4BITMODE 0x00
#define LCD_2LINE 0x08
#define LCD_1LINE 0x00
#define LCD_5x10DOTS 0x04
#define LCD_5x8DOTS 0x00

// flags le controle backlight
#define LCD_BACKLIGHT 0x08
#define LCD_NOBACKLIGHT 0x00

//PINS écran
#define En 0x4 // Enable bit
#define Rw 0x2 // Read/Write bit
#define Rs 0x1 // Register select bit

// Déclarer les pins utilisées pour le thermocouple
MAX6675 thermocouple(thermoCLK, thermoCS, thermoDO);
OneWire ow(PIN_DS18B20);

// Connexion au capteur de température
DS18B20Sensor ds1820_1(&ow);

// #----------------------------------------------------------------#
// # Déclaration des variable #
// #----------------------------------------------------------------#

// Sonde DS18B20
byte addr1[8];
int temp; // here we will store the temperature

// RGB LED
int levelRed; // here wi will store for R
int levelGreen; // here wi will store for G
int levelBlue; // here wi will store for B

//Scénario
int levelScenario; // variable pour sénario
int iLoop; // variable pour loop

// Thermocouple
double Thermo=0; // Température
double ThermoZwave=0; // Témpérature Zwave

// Pour buzzer
int VBuzzer;

// Pour écran
int cols;
int rows;
int numlines;
int backlightval;
int displayfunction;
int displaycontrol;
int displaymode;

// #----------------------------------------------------------------#
// # Set up channel #
// #----------------------------------------------------------------#

// Configuration des capteurs
ZUNO_SETUP_CHANNELS(
 // déclaration du thermocouple
 ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE, SENSOR_MULTILEVEL_SCALE_CELSIUS, SENSOR_MULTILEVEL_SIZE_TWO_BYTES, SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS, getterThermo),
 // déclaration de la ds18b20
 ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE, SENSOR_MULTILEVEL_SCALE_CELSIUS, SENSOR_MULTILEVEL_SIZE_TWO_BYTES,SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS, getterTemp),
 // déclaration d'un switch pour sélection de la couleur Rouge
 ZUNO_SWITCH_MULTILEVEL(getRed, setRed),
 // déclaration d'un switch pour sélection de la couleur Verte
 ZUNO_SWITCH_MULTILEVEL(getGreen, setGreen),
 // déclaration d'un switch pour sélection de la couleur Bleu
 ZUNO_SWITCH_MULTILEVEL(getBlue, setBlue),
 // déclaration d'un switch pour sélection de scénario
 ZUNO_SWITCH_MULTILEVEL(getScenario, setScenario)
 // ZUNO_SENSOR_BINARY(ZUNO_SENSOR_BINARY_TYPE_HEAT, getterBuzzer)
);

// #----------------------------------------------------------------#
// # Void SETUP #
// #----------------------------------------------------------------#

void setup() {
 // RGB
 pinMode(REDPIN, OUTPUT); //PIN mode
 pinMode(GREENPIN, OUTPUT);// PIN mode
 pinMode(BLUEPIN, OUTPUT);//Pin Mode
 // taille écran
 lcdbegin(16,2);
 Serial.begin(9600);
 Serial.println("start");
 Serial.println("MAX6675 OK");
 Serial.println("DS18B20 OK");
 Serial.println("RGB LED OK");
 // Attendre que le circuit MAX se stabilise.
 delay(500);
 // déclaration de la pin buzzer en sortie:
 pinMode(buzzer, OUTPUT);
 beep(50);
 // écriture des PINS RGB
 analogWrite(REDPIN,0); // R switch off
 analogWrite(GREENPIN,0); // G switch off
 analogWrite(BLUEPIN,0); // B switch off
 levelScenario = 1; // Lancement du mode à 0
}

// #----------------------------------------------------------------#
// # Void LOOP #
// #----------------------------------------------------------------#

void loop() {
//for (int i = 0; i < 30; i++) {
 // Lecture de la valeur analogique pour scenario
 switch (levelScenario)
 {
 case 0:
 ProgrammationOFF();
 break;
 case 1:
 Hiver();
 break;
 case 2:
 HiverGC();
 break;
 case 3:
 HiverSSLED;
 break;
 case 4:
 Ete();
 break;
 }
 //Lecture des sondes
// if (i = 30) {

ReadDS18B20_1(); //Lecture de la Sonde N°1 DS18B20
 // température sur écran
 printTempds18b20(Thermo);
 printTempds18b20(temp);
 // Envoie des données
 zunoSendReport(1);
 // }
 // Délay
 delay(1000);
 // }
}

// #----------------------------------------------------------------#
// # Fonctions #
// #----------------------------------------------------------------#
//Fonction pour la lecture du thermocouple
void ReadThermo() {
 // Lecture en degrés Celcius
 Thermo = thermocouple.readCelsius();

// Conversion pour la lecture Zwave de la température
 ThermoZwave = Thermo * 100 ;

//Affichage sur l'écran
 Serial.print("C = ");
 Serial.println(Thermo);
 Serial.println("°C : Thermo");
 Serial.println(ThermoZwave);
 Serial.println("°C : zwave Thermo");

// Décommenter les lignes suivante pour afficher la température
 // en degrés Farenheit (unité qui à cours au USA)
 //Serial.print("F = ");
 //Serial.println(thermocouple.readFarenheit());
 zunoSendReport(1);
 // Attendre une seconde
 delay(1000);
}
/******** Fonction pour lecture de la sonde DS18B20 **********/

void ReadDS18B20_1() {
 ds1820_1.scanAloneSensor(addr1);
 float temerature_1 = ds1820_1.getTemperature(addr1);
 temp = int(temerature_1 * 100);
 Serial.print("Your sensor address is: ");
 for (int i = 0; i < 8; i++) {
 // print OneWire code
 Serial.print(addr1[i], HEX);
 Serial.print(" ");
 }
 Serial.println();

Serial.print("Temperature_1: ");

Serial.println(temerature_1);
}

/******** Fonction pour scénario **********/

void setScenario(byte value) {
 levelScenario = value;
 Serial.print("set scenario = ");
 Serial.println(value);
}

/************ Fonctions du bandeau de led *****************/

// Fonction pour couleur rouge
void setRed(byte value) {
 levelRed = value;
 analogWrite(REDPIN, levelRed * 255 / 99); // set R
 Serial.print("set red = ");
 Serial.println(value);
}

// Fonction pour couleur verte
void setGreen(byte value) {
 levelGreen = value;
 analogWrite(GREENPIN, levelGreen * 255 / 99); // set G
 Serial.print("set green = ");
 Serial.println(value);
}

// Fonction pour couleur blue
void setBlue(byte value) {
levelBlue = value;
 analogWrite(BLUEPIN, levelBlue * 255 / 99); // set B
 Serial.print("set blue = ");
 Serial.println(value);
}

/************ Fonctions des différents scénarios *****************/

// Fonction programmation OFF
void ProgrammationOFF() {
 Thermo = 0;
 ThermoZwave = 0;
 setRed(0); // R switch off
 setGreen(0); // G switch off
 setBlue(0); // B switch Off
}

// Fonction Hiver
void Hiver() {
 // Lecteur de la valeur du thermocouple
 ReadThermo();
 if (Thermo<100) {
 // Vert
 setRed(0); // Rouge
 setGreen(255); // Vert
 setBlue(0); // Bleu
 }
 else {
 if (Thermo>200){
 // Jaune
 setRed(255); // Rouge
 setGreen(255); // Vert
 setBlue(0); // Bleu
 }
 if (Thermo>300){
 // Orange
 setRed(255); // Rouge
 setGreen(153); // Vert
 setBlue(0); // Bleu
 }
 if (Thermo>400){
 // buzzer
 beep(2000);
 // Rouge
 setRed(255); // Rouge
 setGreen(0); // Vert
 setBlue(0); // Bleu
 }
 }
}

// Fonction Hiver avec gestion de la température
void HiverGC() {
 // Lecteur de la valeur du thermocouple
 ReadThermo();
 if (Thermo<100) {
 // Vert
 setRed(0); // Rouge
 setGreen(255); // Vert
 setBlue(0); // Bleu
 }
 else {
 if (Thermo>200){
 // Jaune
 setRed(255); // Rouge
 setGreen(255); // Vert
 setBlue(0); // Bleu
 }
 if (Thermo>300){
 // Orange
 setRed(255); // Rouge
 setGreen(153); // Vert
 setBlue(0); // Bleu
 }
 if (Thermo>400){
 // buzzer
 beep(2000);
 // Rouge
 setRed(255); // Rouge
 setGreen(0); // Vert
 setBlue(0); // Bleu
 }
 if (temp>24){
 // Rouge
 setRed(255); // Rouge
 setGreen(0); // Vert
 setBlue(0); // Bleu
 }
 else {
 if (Thermo<100){ // Vert setRed(0); // Rouge setGreen(255); // Vert setBlue(0); // Bleu } else { if (Thermo<200){ // Jaune setRed(255); // Rouge setGreen(255); // Vert setBlue(0); // Bleu } if (Thermo<300){ //buzzer beep(200); // Orange setRed(255); // Rouge setGreen(153); // Vert setBlue(0); // Bleu }
 }
 }
}

// Fonction été
void Ete() {
 // Valeur du thermocouple = 0 car pas de chauffage
 Thermo = 0;
 ThermoZwave = 0;
 setRed(0); // R switch off
 setGreen(0); // G switch off
 setBlue(0); // B switch Off
}
// Fonction Hiver sans LED() 
void HiverSSLED() { 
 // Valeur du thermocouple = 0 car pas de chauffage
 ReadThermo();
 setRed(0); // R switch off
 setGreen(0); // G switch off
 setBlue(0); // B switch Off 
}
/************ Fonctions buzzer *****************/

void beep(unsigned char delayms){
 analogWrite(buzzer, 20); // fréquence utiliser valeur entre 0 et 255
 delay(delayms); // délai
 analogWrite(buzzer, 0); // off buzzer
 delay(delayms); // délai
 VBuzzer = delayms;
}

/************ Fonctions écran *****************/

// Fonction impression température écran
void printTempds18b20(int temp) {
 clear();
 setCursor(0,0);
 write('T');
 write('=');
 if(temp<100) {
 write(32);
 } else {
 write(temp/100+48);
 }
 write((temp%100)/10+48);
 write(44);
 write((temp%100)%10+48);
 write(32);
 write('C');
 return;
}

void lcdbegin(int c,int r) {
 //
 cols=c;
 rows=r;
 backlightval = LCD_BACKLIGHT;
 //
 Wire.begin();
 displayfunction = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS;
 //
 if (rows > 1) {
 displayfunction |= LCD_2LINE;
 }
 numlines = rows;

// SEE PAGE 45/46 FOR INITIALIZATION SPECIFICATION!
 // according to datasheet, we need at least 40ms after power rises above 2.7V
 // before sending commands. Arduino can turn on way befer 4.5V so we'll wait 50
 delay(50);

// Now we pull both RS and R/W low to begin commands
 expanderWrite(backlightval); // reset expanderand turn backlight off (Bit 8 =1)
 delay(1000);

//put the LCD into 4 bit mode
 // this is according to the hitachi HD44780 datasheet
 // figure 24, pg 46

// we start in 8bit mode, try to set 4 bit mode
 write4bits(0x03 << 4);
 delayMicroseconds(4500); // wait min 4.1ms

// second try
 write4bits(0x03 << 4);
 delayMicroseconds(4500); // délai

// third go!
 write4bits(0x03 << 4);
 delayMicroseconds(150);

// configuratuion sur 4 bits
 write4bits(0x02 << 4);



// set # lines, font size, etc.
 command(LCD_FUNCTIONSET | displayfunction);

// turn the display on with no cursor or blinking default
 displaycontrol = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF;
 display();

// tous effacer
 clear();

// Initialisation de la direction d'écriture
 displaymode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT;

// appliquer mode entrée
 command(LCD_ENTRYMODESET | displaymode);

home();

}

/************ commandes High level *****************/
void clear(){
 command(LCD_CLEARDISPLAY);// clear display, set cursor position to zero
 delayMicroseconds(2000); // this command takes a long time!
}

void home(){
 command(LCD_RETURNHOME); // set cursor position to zero
 delayMicroseconds(2000); // this command takes a long time!
}

void setCursor(uint8_t col, uint8_t row){
 int row_offsets[] = { 0x00, 0x40, 0x14, 0x54 };
 if ( row > numlines ) {
 row = numlines-1; // we count rows starting w/0
 }
 command(LCD_SETDDRAMADDR | (col + row_offsets[row]));
}

// éteindre ou allumer écran rapidement
void noDisplay() {
 displaycontrol &= ~LCD_DISPLAYON;
 command(LCD_DISPLAYCONTROL | displaycontrol);
}
void display() {
 displaycontrol |= LCD_DISPLAYON;
 command(LCD_DISPLAYCONTROL | displaycontrol);
}





inline void command(uint8_t value) {
 send(value, 0);
}

inline size_t write(uint8_t value) {
 send(value, Rs);
 return 0;
}
/************ commandes Low level *****************/

void send(uint8_t value, uint8_t mode) {
 uint8_t highnib=value&0xf0;
 uint8_t lownib=(value<<4)&0xf0;
 write4bits((highnib)|mode);
 write4bits((lownib)|mode);
}

void write4bits(uint8_t value) {
 expanderWrite(value);
 pulseEnable(value);
}

void expanderWrite(uint8_t _data){
 Wire.beginTransmission(LC_I2CADDR);
 Wire.write((int)(_data) | backlightval);
 Wire.endTransmission();
}

void pulseEnable(uint8_t _data){
 expanderWrite(_data | En); // En high
 delayMicroseconds(1); // délai

expanderWrite(_data & ~En); // En low
 delayMicroseconds(50); // délai
}

// #----------------------------------------------------------------#
// # écriture des variables #
// #----------------------------------------------------------------#

// écriture du scenario
int getScenario() {
 return levelScenario;
}

// écriture couleur rouge
int getRed() {
 return levelRed;
}

// écriture couleur Verte
int getGreen() {
 return levelGreen;
}

// écriture couleur Bleue
int getBlue() {
 return levelBlue;
}

// écriture ds18b20
word getterTemp() {
 return temp;
}

// écriture thermocouple
int getterThermo() {
 return ThermoZwave;
}

// écriture thermocouple
word getterBuzzer() {
 return VBuzzer;
}

 

Mode

OFF : N’envoie aucune information et éteind les LEDS

Eté : Envoie seulement la température pièce le reste est OFF

Hiver : Envoie la température Thermocouple, la température de la pièce, gestion de la couleur en fonction de la température thermocouple, buzzer si fonte trop chaude

Hiver avec gestion température pièce : Envoie la température Thermocouple, la température de la pièce, gestion de la couleur en fonction de la température thermocouple, buzzer si fonte trop chaude, gestion de la température de la pièce

Photos du projet

Intégration à l’eedomus

Conclusion

Je peux maintenant maintenir ma fonte à bonne température et chauffer ma maison tranquillement grâce à la z-uno.
Ce système n’existait pas et j’en avait besoin d’où l’intérêt de cette carte domotique Zwave.
Je modifierai ce système pour intégrer physiquement l’écran et ferai une mise à jour un peu plus importante à l’arrivée du chauffage centrale avec chaudière bois.

A propos de Lilian

Passionné de nouvelles technologies et de modding PC, j'ai créé Gameinfotech.fr il y a 3 ans. Aujourd'hui j'ai rejoint la team Planète-domotique afin de découvrir encore plus de chose dans le domaine de l'habitat et des objets connectés !

2 commentaires

  1. Bravo Lilian pour ce travail

    • Merci le projet n’est pas encore complétement terminé, je ferrai un nouvel article dessus quand il le serra.

      La carte Z-Uno est vraiment une carte qui permet de faire ce genre de système et qui permet du coup de pousser les possibilités d’un module domotique encore plus loin. Voir même comme ici inventer un produit qui n’existe pas.

Répondre

Votre adresse email ne sera pas publiée. Les champs obligatoires sont marqués d'une étoile *

*

Revenir en haut de la page