[box type= »shadow » align= »aligncenter »]
Planète Domotique a lancé en septembre dernier un concours autour de la carte de développement Z-UNO. Suite à un appel de candidatures, trois projets ont été retenus et les lauréats ont gagné leur propre carte de développement. Il est désormais temps de découvrir chaque jour sur ce blog un des projets concrétisés avec le Z-UNO. À la fin de la semaine, vous pourrez voter pour le projet qui vous aura le plus plu, et permettre ainsi au gagnant de remporter un bon d’achat de 100 € !
Aujourd’hui nous vous proposons de découvrir le projet de Lilian.
N.B. : Lilian, membre de l’équipe Planète Domotique, propose ce projet en « hors concours ». Si son projet remporte le maximum de votes, les gains seront partagés entre les deux autres participants.[/box]
Premier projet domotique : Desk by Gameinfotech
Mon premier projet domotique fut le projet Desk by Gameinfotech, un bureau informatique complètement domotisé intégrant aussi un système audio ainsi que beaucoup d’autres choses que je vous laisse découvrir grâce au lien ci dessous :
Liens de présentation du projet :
https://www.facebook.com/GameInfoTech.Info/posts/1126066794106572
https://www.bitfenix.com/mod/product/desk-by-gameinfotech/
Vidéo :
Workblog :
Articles sur la partie domotique :
SMS Desk :
Allumage à distance d’un ordinateur :
Allumage de l’un ordinateur grâce à un digicode :
Contrôle des lumières de l’ordinateur à distance :
Le projet : Gestion complète du refroidissement d’un ordinateur avec Z-UNO
Dans mon nouveau projet, j’ai voulu arriver à domotiser le refroidissement d’un ordinateur et voir l’impact réel que cela avait pour voir si une gestion précise et complète pouvait apporter un réel impact sur les températures et donc sur les performances d’overcloking des composants.
Le but de l’orvercloking étant de pousser les composants au maximum pour avoir des performances beaucoup plus importantes avec les mêmes composants.
Présentation du système de refroidissement
Pour ce système de refroidissement, il me faudra respecter plusieurs points importants :
- avoir un contrôle de la vitesse des ventilateurs de l’ordinateur
- avoir le contrôle de la pompe et du débit de la pompe
- avoir un contrôle des bandes de LEDS pour pouvoir les allumer de la bonne couleur et prévenir l’utilisateur sur l’état de son ordinateur
- avoir le contrôle des portes de l’ordinateur pour pouvoir les ouvrir ou les fermer automatiquement en fonction de la température de l’ordinateur
- contrôle de 3 sondes de température
- ajouter un écran pour avoir les informations importes en un coup d’œil
Pourquoi le projet sur Z-Uno
En tout premier lieu, pour la suite de mes projets, j’ai voulu encore domotiser l’informatique.
Je me suis donc lancer dans un nouveau projet que vous pouvez suivre sur le Facebook de Gameinfotech, ainsi que sur le blog de Planète domotique.
La seule différence avec le premier projet le Desk, j’ai voulu créer mon système et me concentrer cette fois ci sur la partie refroidissement de l’ordinateur de façon autonome.
Même si je rajouterai un module indépendant de consommation et prise à distance de l’extension et de l’allumage de l’ordinateur comme sur l’exemple évoqué dans l’article vu plus haut.
Pour plusieurs raisons :
– Me lancer un défi personnel comme sur tous mes projets Gameinfotech
– Créer enfin un système de refroidissement autonome mais aussi contrôlable de n’importe où et à partir de n’importe quel périphérique ayant un navigateur web
– Le concours Z-Uno était le bien venu pour pouvoir réaliser ce projet
– Les possibilités multiples de la carte Z-UNO
Présentation de la carte Z-Uno
La carte de développement Z-Uno est un mélange entre la puissance du protocole de communication sans fil Z-Wave pour la domotique, et la simplicité d’un Arduino. Inspiré des projets Arduino, le Z-Uno hérite de toutes les caractéristiques des solutions matérielles et logicielles simples à utiliser, gardant ainsi un maximum de flexibilité.
Z-Uno est un produit entièrement DIY (Do It Yourself / à faire soi-même). Il est pensé pour tous ceux qui se sentent limités par le choix existant de produits Z-Wave et veulent augmenter les possibilités de leur maison connectée avec plus de sondes et d’actionneurs. Connectez des LEDs, des boutons, des interrupteurs, des moteurs, ou tout autre capteur basse tension y compris la plupart des capteurs compatibles Arduino.
Les sondes de température
Je me suis directement tourné vers les sondes DS18B20 1-wire, inspiré de l’exemple sur le site de la Z-UNO.
Il me fallait donc 3 sondes de températures :
– Une vers le processeur
– Une vers la carte graphique
– Une pour la température ambiante de l’ordinateur
En fonction de la température de chaque sonde cela activera le système de refroidissement approprié.
Sonde numéro 1 et 2 seront lié ensemble pour contrôler le watercooling de l’ordinateur.
Sonde numéro 3 pour le contrôle des ventilateurs et le contrôle des portes de l’ordinateur.
J’ai donc commencé avec une seule sonde de température pour commencer mon développement.
Je l’ai câblé et programmé comme dans l’exemple fourni par le site Z-Uno.
// demo sketch for connecting OneWire temperature sensor DS18B20 to Z-Uno
// add library ds18b20
#include "ZUNO_DS18B20.h"
// pin connection ds18b20
#define PIN_DS18B20 11
OneWire ow(PIN_DS18B20);
// onewire connection temperature sensors
DS18B20Sensor ds1820(&ow);
byte addr1[8];
int temp; // here we will store the temperature
// set up channel
ZUNO_SETUP_CHANNELS(
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE,
SENSOR_MULTILEVEL_SCALE_CELSIUS,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterTemp)
);
void setup() {
Serial.begin();
Serial.println("start");
}
void loop() {
ds1820.scanAloneSensor(addr1);
// obtaining readings from the sensor ds18b20
float temerature = ds1820.getTemperature(addr1);
// make scaled word value for report
temp=int(temerature*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: ");
Serial.println(temerature);
// send data to channel
zunoSendReport(1);
// send every 30 second
delay(30000);
}
word getterTemp() {
return temp;
}
J’ai bien évidement repris tous le code ainsi que les commentaires pour avoir un codage vraiment propre.
J’ai créé des fonctions pour alléger le codage. Ainsi j’aurais juste à appeler les fonctions dans la boucle « void loop ».
Pour le moment le code n’était pas bien long mais au fur et à mesure pour s’y retrouver cela me paressait indispensable.
Vidéo
J’ai ensuite modifié ce code exemple ainsi que le schéma électrique pour avoir la lecture de 3 sondes de température.
Une fois la programmation effectuée et la câblage fini pour ces 3 sondes, il m’a fallut tester le projet en réel et pour vérifier que je n’étais pas « rouillé » en programmation.
J’ai donc pris Domoticz pour tester en premier lieu ces trois sondes de température, en les disposant dans un ordinateur à l’endroit où je voulais prendre les différentes températures.
Ce n’est pas l’ordinateur définitif, j’ai juste pris celui-là car le montage de l’autre n’est pas encore. Un ordinateur haut de gamme moddé demande énormément de temps et d’investissement.
J’ai donc mis une sonde vers le processeur, une sonde vers la carte graphique et une sonde dans le boitier.
Voici le résultat des tests de ces trois sondes.
J’ai ensuite lancé un jeu pour voir si les sondes réagissaient bien et voici le résultat :
Carte graphique :
La sonde processeur qui sera à la fin intégrée au waterblock car là la température n’est pas bien représentative de la valeur réelle mais au moins la sonde fonctionne.
Là aussi le test, ayant été fait boitier ouvert, n’est pas représentatif de la valeur réelle, mais la sonde fonctionne également :
Voici d’ailleurs pour ceux qui sont intéressés, le code propre pour 3 sondes de température. Il vous suffira de modifier les PINs en fonction de votre branchement.
Vous pourrez de plus facilement ajouter ou enlever dans la programmation des sondes de températures.
De plus, il faudra modifier le délai dans la Void Loop car la pour mes tests, j’avais mis le rafraichissement à 30 secondes.
delay(30000);
Voici donc le code complet pour 3 sondes DS18B20. Il sera encore amélioré à la fin du projet mais il est déjà très propre.
// #----------------------------------------------------------------#
// # Librairies #
// #----------------------------------------------------------------#
// ajouter la librairie ds18b20
#include <ZUNO_DS18B20.h>
// #----------------------------------------------------------------#
// # Déclaration des pins #
// #----------------------------------------------------------------#
#define PIN_DS18B20_1 11 //Sonde numéro 1
#define PIN_DS18B20_2 12 //Sonde numéro 2
#define PIN_DS18B20_3 10 //Sonde numéro 3
// #----------------------------------------------------------------#
// # Connexion aux sondes #
// #----------------------------------------------------------------#
OneWire ow(PIN_DS18B20_1);
OneWire ol(PIN_DS18B20_2);
OneWire om(PIN_DS18B20_3);
// Connexion aux sondes OneWire DS18B20
DS18B20Sensor ds1820_1(&ow); //Sonde Numéro 1
DS18B20Sensor ds1820_2(&ol); //Sonde Numéro 2
DS18B20Sensor ds1820_3(&om); //Sonde Numéro 3
// Définition des adresses des sondes
byte addr1[8]; //Sonde Numéro 1
byte addr2[9]; //Sonde Numéro 2
byte addr3[10]; //Sonde Numéro 3
// #----------------------------------------------------------------#
// # Déclaration des variable #
// #----------------------------------------------------------------#
int temp; // variable température 1
int temp2; // variable température 2
int temp3; // variable température 3
// #----------------------------------------------------------------#
// # Set up channel #
// #----------------------------------------------------------------#
ZUNO_SETUP_CHANNELS(
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE,
SENSOR_MULTILEVEL_SCALE_CELSIUS,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterTemp),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE,
SENSOR_MULTILEVEL_SCALE_CELSIUS,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterTemp2),
ZUNO_SENSOR_MULTILEVEL(ZUNO_SENSOR_MULTILEVEL_TYPE_TEMPERATURE,
SENSOR_MULTILEVEL_SCALE_CELSIUS,
SENSOR_MULTILEVEL_SIZE_TWO_BYTES,
SENSOR_MULTILEVEL_PRECISION_TWO_DECIMALS,
getterTemp3)
);
// #----------------------------------------------------------------#
// # Void setup #
// #----------------------------------------------------------------#
void setup() {
Serial.begin();
Serial.println("start");
delay(2000); // Délai pour éviter le -327° sur la sonde
}
// #----------------------------------------------------------------#
// # Void Loop #
// #----------------------------------------------------------------#
void loop() {
//Lecture des sondes
ReadDS18B20_1(); //Lecture de la Sonde N°1 DS18B20
ReadDS18B20_2(); //Lecture de la Sonde N°2 DS18B20
ReadDS18B20_3(); //Lecture de la Sonde N°3 DS18B20
// Envoyer les données à la Z-Uno
zunoSendReport(1); // Envoi la température Sonde 1 DS18B20
zunoSendReport(2); // Envoi la température Sonde 2 DS18B20
zunoSendReport(3); // Envoi la température Sonde 3 DS18B20
// L'envoyer toutes les 30 secondes
delay(30000);
}
// #----------------------------------------------------------------#
// # Fonctions #
// #----------------------------------------------------------------#
// Fonction pour lecture Sonde 1 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 lecture Sonde 2 DS18B20
void ReadDS18B20_2() {
ds1820_2.scanAloneSensor(addr2);
float temerature_2 = ds1820_2.getTemperature(addr2);
temp2 = int(temerature_2 * 100);
Serial.print("Your sensor address is: ");
for (int i = 0; i < 9; i++) {
// print OneWire code
Serial.print(addr2[i], HEX);
Serial.print(" ");
}
Serial.println();
Serial.print("Temperature_2: ");
Serial.println(temerature_2);
}
// Fonction pour lecture Sonde 3 DS18B20
void ReadDS18B20_3() {
ds1820_3.scanAloneSensor(addr3);
float temerature_3 = ds1820_3.getTemperature(addr3);
temp3 = int(temerature_3 * 100);
Serial.print("Your sensor address is: ");
for (int i = 0; i < 10; i++) {
// print OneWire code
Serial.print(addr3[i], HEX);
Serial.print(" ");
}
Serial.println();
Serial.print("Temperature_3: ");
Serial.println(temerature_3);
}
// #----------------------------------------------------------------#
// # écriture des variables #
// #----------------------------------------------------------------#
// ecriture de la variable sonde 1
word getterTemp() {
return temp;
}
// ecriture de la variable sonde 2
word getterTemp2() {
return temp2;
}
// ecriture de la variable sonde 3
word getterTemp3() {
return temp3;
}
La Z-Uno enfin sous Eedomus
J’avais à cœur de faire ce projet sous une box domotique que j’aime tout particulièrement : la Box Eedomus.
J’ai donc contacté Eedomus, et en particulier Baptiste du support technique de Eedomus, pour lui demander l’intégration de la carte Z-UNO sur la Eedomus.
Il m’a tout de suite répondu positivement à cette demande et nous avons d’ailleurs travaillé ensemble à l’intégration de la carte Z-UNO sur la box Eedomus.
Je tiens d’ailleurs à remercier l’équipe du support technique de Eedomus pour leur fiabilité, leur rapidité, ainsi que leur sérieux.
Mon projet avançant pendant l’intégration sur la Eedomus, vous verrez sur la copie d’écran suivante la partie suivante du projet, la gestion des LEDs RGB.
J’ai donc démarré l’ordinateur et inclus la carte Z-UNO sur la Eedomus.
Voici les résultats obtenus avec la box Eedomus. J’ai mis dans la capture le moment où j’ai intégré la nouvelle version de mon sketch avec la modification du fichier .cpp. Vous verrez pourquoi un peu plus bas (passage de -327° à une température normale).
Astuce sur Eedomus voir sur d’autre box domotiques :
Pour ne pas avoir vos sondes de température qui affichent une valeur de – 327°, il faut :
- rajouter cette ligne de code dans la « Void setup » :
delay(2000); // Délai pour éviter le -327° sur la sonde
- il faut modifier un fichier du Firmware 2.0.6 de la Z-UNO.
Chemin du fichier sous linux ou mac :/"NomUtilisateur"/Library/Arduino15/packages/Z-UNO/hardware/zw8051/2.0.6/librairies/ZUNO_OneWire/ZUNO_OneWire.cpp
Sous Windows :
Ligne 155 il faut modifier le délai :
delayMicroseconds(480);
et mettre à la place :
delayMicroseconds(1500);
Suite et fin du projet
Pour la suite et fin du projet, afin de ne pas tout dévoiler tout de suite (ce projet étant lié aussi à un projet plus important de modding informatique), je vous dévoilerai la suite dans un futur article. Une fois que l’ordinateur haut de gamme sera modifié par mes soins, avec l’intégration de la Eedomus moddée (modification hardware + modification design), ainsi que l’intégration du projet Z-UNO, je pourrais écrire ce fameux article complet sur mon projet. Voici un petit aperçu de l’ordinateur pour ce projet :
Le code du projet ainsi que le schéma électrique du projet est complet et fini.
Je suis sur la conception de la carte électronique sur ordinateur pour sa réalisation, car je la ferai réaliser intégralement pour avoir un résultat vraiment professionnel et pas une carte bidouillée.
Une fois le circuit imprimé réalisé, je viendrais souder mes composants dessus afin d’obtenir la carte finie et fonctionnelle.
En ce qui concerne le boitier, je le réaliserai à l’imprimante 3d pour avoir un résultat vraiment propre.
Conclusion sur la carte Z-UNO
À l’heure actuelle car cela pourrait évoluer avec mon projet et avec des futurs mise à jour de la carte, mais je trouve déjà un produit très plaisant à manipuler et l’aide sur les forums et sur le site Z-UNO permet déjà de combler beaucoup de personnes néophytes mais aussi expert en programmation arduino.
Les possibilités multiples ainsi que la programmation tout de même assez simple sont des atouts énormes pour cette carte Z-Wave.
La carte Z-Uno montre quelques limites, cependant je pense qu’elle a tout de même un bel avenir devant elle.
Ce que j’ai vraiment adoré dans ce projet c’est pouvoir lier l’informatique, la domotique ainsi que la programmation et pouvoir me dire que j’allais ensuite pouvoir laisser cours à mon imagination.
Il y a encore des fonctions que je garde secrètes et dont je n’ai pas parlé sur cet article pour garder un peu de surprise 😉 .
Donc à très vite sur le blog Planète Domotique ainsi que sur le site Gameinfotech !
Lucas
