Le sapin de Noël domotique en Z-Wave ou 433 MHz

16 décembre 2016

Aujourd’hui nous vous présentons un article pour créer votre sapin de Noël domotique grâce à une Z-UNO. Plus exactement, c’est le coloris de la guirlande qui va être commandé par la domotique.

Après une soirée de rigolade, de travail et de tests sur la carte Z-uno avec Mickael (fondateur de Planète Domotique), nous avons réussi à faire de ce sapin ordinaire un sapin domotique avec de jolis effets.

De plus avec mon collègue Pierre-Marie, nous nous sommes penchés sur la partie 433 MHz de ce projet.

Pour parfaire ce travail, nous avons décidé d’intégrer notre sapin domotique sur une eedomus.

Sapin domotisé avec bandeau de LED, Z-UNO, eedomus

Pré-requis / présentation

Materiel :

Logiciel :

le compilateur Arduino configuré pour Z-UNO

Préparation et réflexion

Au départ, nous avions 3 possibilités pour créer ce sapin domotique :
– Un module Fibaro RGBW comme dans ma vidéo du projet desk
– Un module RF pour bandeau de LED
– Une carte Z-UNO

Pour les deux premières solutions, l’inconvénient était que cela demanderai beaucoup de ressources à la box domotique en permanence (nous vous montrerons tout de même en fin de cet article comment faire fonctionner votre sapin de Noël en 433 MHz).

Nous nous sommes donc tournés naturellement vers la Z-UNO. L’avantage de cette solution c’est que les ressources seront concentrées exclusivement sur la carte Z-UNO. La box domotique servira exclusivement à sélectionner les scénarios programmés sur la carte Z-UNO.

Une fois la solution trouvée, il fallait maintenant se mettre au travail.

Création du circuit électronique

Voici le schéma :

Photo de la partie RGB :

Photo de la table complète :

Création de la programmation de la carte Z-UNO

Nous allons vous montrer, avec 3 scénarios exemples, comment créer un joli sapin domotique.

Petit point rapide sur le principe des LEDs RGB : il y a 3 canaux, rouge vert et bleu, qui en étant combinés permettent d’obtenir une grande diversité de couleurs.

Le mélange vert et bleu permet d’obtenir du cyan (bleu clair)
Le mélange rouge et bleu permet d’obtenir du rose/violet
Le mélange rouge et vert permet d’obtenir du jaune
Toutes les couleurs ensemble donnent du blanc

Coloris LEDs RVB sur sapin

Voici l’intégralité du code :

// #----------------------------------------------------------------#
// # Librairies #
// #----------------------------------------------------------------#
// #----------------------------------------------------------------#
// # Déclaration des pins #
// #----------------------------------------------------------------#
#define REDPIN PWM1 // pin connexion R
#define GREENPIN PWM2 // pin connexion G
#define BLUEPIN PWM3 // pin connexion B

// #----------------------------------------------------------------#

// # Déclaration des variable #
// #----------------------------------------------------------------#
int levelRed; // variable pour Rouge
int levelGreen; // variable pour Vert
int levelBlue; // variable pour Bleu
int levelScenario; // variable pour Bleu
int iLoop; // variable sapin

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

ZUNO_SETUP_CHANNELS(
// déclaration RGB
ZUNO_SWITCH_MULTILEVEL(getRed, SetRed),
ZUNO_SWITCH_MULTILEVEL(getGreen, SetGreen),
ZUNO_SWITCH_MULTILEVEL(getBlue, SetBlue),
// déclaration d'un switch pour sélection de scénario du sapin
ZUNO_SWITCH_MULTILEVEL(getScenario, setScenario)
);

// #----------------------------------------------------------------#
// # Void setup #
// #----------------------------------------------------------------#

void setup() {
    pinMode(REDPIN, OUTPUT);
    pinMode(GREENPIN, OUTPUT);
    pinMode(BLUEPIN, OUTPUT);
    Serial.begin();
    Serial.println("start");

    analogWrite(REDPIN,0); // R switch off
    analogWrite(GREENPIN,0); // G switch off
    analogWrite(BLUEPIN,0); // B switch off
    iLoop = 0;
    levelScenario = 9; // Lancement du mode démo pour 3 scénarios

}

// #----------------------------------------------------------------#
// # Void Loop #
// #----------------------------------------------------------------#

void loop() {

     

    // Lecture de la valeur analogique pour scenario sapin
    switch (levelScenario)
    {
    case 0:
        SapinNoelOff();
        break;
    case 1:
        SapinNoelScen1();
        break;
    case 2:
        SapinNoelScen2();
        break;
    case 3:
        SapinNoelScen3();
        break;
    case 4:
        SapinNoelScen4();
        break;
    case 5:
        SapinNoelScen5();
        break;
    case 6:
        SapinNoelScen6();
        break;
    case 7:
        SapinNoelScen7();
        break;
    case 8:
        SapinNoelScen8();
        break;
    case 9:
        SapinNoelScen9();
        break;
    }
    delay(1000);
}

// #----------------------------------------------------------------#
// # Fonctions #
// #----------------------------------------------------------------#

// Fonction sapin de noel
void SapinNoelOff() {
    SetRed(0); // R switch off
    SetGreen(0); // G switch off
    SetBlue(0);
}

//scénario sapin 1
void SapinNoelScen1() {
    for (int i = 0; i < 256; i++) {
        // Rouge
        SetRed(255); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // Vert
        SetRed(0); // Rouge
        SetGreen(255); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // Jaune
        SetRed(255); // Rouge
        SetGreen(255); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // Violet
        SetRed(80); // Rouge
        SetGreen(0); // Vert
        SetBlue(80); // Bleu
        delay(i*4);
        // Blanc
        SetRed(255); // Rouge
        SetGreen(255); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // Bleu
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // Rose
        SetRed(255); // Rouge
        SetGreen(0); // Vert
        SetBlue(50); // Bleu
        delay(i*4);
        // Eau
        SetRed(0); // Rouge
        SetGreen(255); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // Marron
        SetRed(88); // Rouge
        SetGreen(41); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
    }
}

//scénario sapin 2
void SapinNoelScen2() {
    for (int i = 0; i < 256; i++) {
        // Rouge
        SetRed(255); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Vert
        SetRed(0); // Rouge
        SetGreen(255); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Jaune
        SetRed(255); // Rouge
        SetGreen(255); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Violet
        SetRed(80); // Rouge
        SetGreen(0); // Vert
        SetBlue(80); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Blanc
        SetRed(255); // Rouge
        SetGreen(255); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Bleu
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Rose
        SetRed(255); // Rouge
        SetGreen(0); // Vert
        SetBlue(50); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Eau
        SetRed(0); // Rouge
        SetGreen(255); // Vert
        SetBlue(255); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
        // Marron
        SetRed(88); // Rouge
        SetGreen(41); // Vert
        SetBlue(0); // Bleu
        delay(i*4);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        if( i < 50) {
            delay(i*4);
        }
        else {
            delay(200);
        }
    }
}

void SapinNoelScen3() {
    for (int i = 0; i < 500; i++) {
        // Couleur
        SetRed(i); // R switch off
        SetGreen(255-i); // G switch off
        SetBlue(0);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(100);
        // Couleur
        SetRed(0); // R switch off
        SetGreen(i); // G switch off
        SetBlue(255-i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(100);
        // Couleur
        SetRed(i); // R switch off
        SetGreen(0); // G switch off
        SetBlue(255-i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(100);
        // Couleur
        SetRed(i); // R switch off
        SetGreen(255-i); // G switch off
        SetBlue(i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        delay(100);
        // Couleur
        SetRed(i); // R switch off
        SetGreen(i); // G switch off
        SetBlue(255-i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        // Couleur
        SetRed(0); // Rouge
        SetGreen(255-i); // Vert
        SetBlue(i); // Bleu
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        // Couleur
        SetRed(i); // R switch off
        SetGreen(0); // G switch off
        SetBlue(255-i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
        // Couleur
        SetRed(255-i); // R switch off
        SetGreen(255-i); // G switch off
        SetBlue(i);
        delay(100);
        // off
        SetRed(0); // Rouge
        SetGreen(0); // Vert
        SetBlue(0); // Bleu
    }
}

void SapinNoelScen4() {
    for (int i = 0; i < 256; i++) {
        SetRed(i); // R switch off
        SetGreen(i); // G switch off
        SetBlue(i);
        delay(100);
    }
}
void SapinNoelScen5() {
    SetRed(40); // R switch off
    SetGreen(40); // G switch off
    SetBlue(40);

    delay(1000);
    SapinNoelOff();
}

void SapinNoelScen6() {
    SetRed(200); // R switch off
    SetGreen(0); // G switch off
    SetBlue(0);

    delay(1000);
    SapinNoelOff();
}

void SapinNoelScen7() {
    SetRed(200); // R switch off
    SetGreen(0); // G switch off
    SetBlue(0);
    delay(1000);
    SetRed(200); // R switch off
    SetGreen(200); // G switch off
    SetBlue(0);
    delay(1000);
    SetRed(200); // R switch off
    SetGreen(200); // G switch off
    SetBlue(200);

    SapinNoelOff();
}
void SapinNoelScen8() {
    SetRed(200); // R switch off
    SetGreen(0); // G switch off
    SetBlue(0);
    delay(500);
    SetRed(0); // R switch off
    SetGreen(200); // G switch off
    SetBlue(0);
    delay(500);
    SetRed(0); // R switch off
    SetGreen(0); // G switch off
    SetBlue(200);

    SapinNoelOff();
}
// Enchainement
void SapinNoelScen9() {
    SapinNoelScen1();
    SapinNoelScen2();
    SapinNoelScen3();
    SapinNoelOff();
}

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

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

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

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

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

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

// écriture de la couleur rouge
int getRed() {
    return levelRed;
}
// écriture de la couleur verte
int getGreen() {
    return levelGreen;
}

// écriture de la couleur bleue
int getBlue() {
    return levelBlue;
}

Nous vous avons montré 3 scénarios très simples pour que vous puissiez comprendre le fonctionnement.

Au fur et à mesure de la rédaction, nous nous sommes pris au jeu et nous avons complété bien sûr tout le code avec un effet crossfader, une optimisation du code, etc.

Nous vous proposons de voir le résultat en vidéo plus bas dans cet article.

Intégration à l’eedomus

Nous avons ensuite intégré la Z-UNO à l’eedomus pour faire varier les scénarios du sapin de Noël

Nous avons ensuite créé une pièce Sapin afin d’avoir tous les channels de la ZUNO dans cette pièce.

Résultat en vidéo

Le sapin domotique en 433 MHz

Pour tous ceux qui ont un Transceiver USB de RFXCom et qui nous ont posé la question « est-il possible contrôler un bandeau de LED avec le RFXCom ? », nous voulions aussi leur montrer que cela était faisable.

Pour cela, nous utilisons une petite nouveauté de la boutique : le Mini Contrôleur Ruban LED RGB 12V contrôlé en 433 MHz. Il s’agit d’un ensemble comportant un contrôleur de LED RGB pilotable en 433 MHz ainsi qu’une télécommande pouvant le commander.

Contrôleur de LED RGB 433 MHz de Wizelec

Le contrôleur dispose de 7 couleurs pré-enregistrées et directement pilotable depuis la télécommande : blanc, rouge, vert, bleu, jaune, cyan et violet. Il dispose aussi d’une fonction « Demo » permettant d’utiliser plusieurs modes de clignotement prédéfinis (clignotement d’une couleur ou de plusieurs couleurs, alternance, ou crossfader).

Toutes les fonctions disponibles sur le contrôleur (et donc indiquées sur la télécommandes) peuvent directement être lancées depuis le RFXCom. Nous allons voir ci-dessous comment les données peuvent être récupérées et émises avec le RFXCom depuis l’utilitaire RFXMgr.

Dans l’utilitaire RFXMgr, nous sélectionnons le protocole « Lightning 4 ». Si vous avez d’autres protocoles en cours d’utilisation, vous pouvez également laisser ceux-ci sélectionnés. N’oubliez pas de cliquer sur « Set Mode » pour que la modification soit prise en compte.

Choix d'un protocole sur le RFXcom : Lightning 4

Après le bon enregistrement de ce protocole, à chaque appui sur un des bouton de la télécommande, vous verrez un code apparaître dans la fenêtre de RFXMgr. Par exemple, ci-dessous, la trame qui définit le passage à la couleur rouge et celui qui correspond au bouton on/off. Notez pour chaque bouton la ligne « S1-S24 » : elle correspond à une série de 24 bits propre à chaque bouton.

Codes Lightning 4 reçus sur le RFXCom

Il ne nous reste alors plus qu’à aller dans l’onglet « Lightning 4 » pour émettre une de ces commandes. Pour envoyer une des commandes que vous avez vu, il suffit de cocher les rangées correspondantes. Il vous faut une case cochée pour chaque « 1 » et une case non cochée pour chaque « 0 ». Par exemple ci-dessous nous reproduisons le code pour émettre l’ordre « Rouge » [000 1110 0001 1011 0001 0000].

Trames d'émission en Lightning 4 du RFXCom

Bien sûr, l’utilisation reste limitée, mais avec une couche logicielle au-dessus, capable de garder en mémoire les différents codes et les lancer avec un simple bouton ou selon un scénario, le bandeau RGB devient ainsi commandable à volonté, avec pour seules limites les programmes inclus dans le contrôleur (ce qui correspond aux boutons de la télécommande).

Le pilotage par un RFXCom est donc tout à fait possible, bien qu’il est nécessaire d’avoir un logiciel qui peut prendre en charge le type de trame utilisé par le contrôleur de LED RGB 433 MHz. Nous reviendrons sur cet aspect dans un prochain article dédié à la question.

Conclusion

Nous avons vu l’aspect RGB d’un bandeau de LED pour ce sapin de noël domotique, cependant dans de futurs articles, nous verrons d’autres bandeaux de LED, comme les bandeaux de LED RGBW ou encore les bandeaux de LED PIXEL.

L’avantage de la solution avec la Z-UNO reste la liberté de la solution permettant de programmer le scénario voulu et surtout de ne pas surcharger la box domotique.

Comme vous avez pu le remarquer sur la table de test Z-UNO, il y a les sondes de température DS18B20 car ce projet de LED RGB n’est pas fait au hasard, il fait suite à mon premier article sur cette carte. Le code a lui bien sûr été amélioré et optimisé par rapport à celui donné dans cet article mais nous le verrons dans un futur article

Lilian

Passionné de nouvelles technologies et de modding PC, j'ai rejoint la team Planète-domotique pour découvrir le monde des objets connectés et de la maison intelligente. Mes compétences me permettent de vous guider dans vos projets, de vous aider à installer vos appareils domotiques, mais aussi de développer de nouveaux produits connectés pour notre boutique. Mon objectif premier est de rédiger des articles clairs et précis pour aider au mieux la communauté.

Voir tous les articles de Lilian

Laisser un commentaire

Vous devez vous connecter pour publier un commentaire.

L	M	M	J	V	S	D
			1	2	3	4
5	6	7	8	9	10	11
12	13	14	15	16	17	18
19	20	21	22	23	24	25
26	27	28	29	30	31

Le sapin de Noël domotique en Z-Wave ou 433 MHz

Pré-requis / présentation

Préparation et réflexion

Création du circuit électronique

Création de la programmation de la carte Z-UNO

Intégration à l’eedomus

Résultat en vidéo

Le sapin domotique en 433 MHz

Conclusion

Lilian

Laisser un commentaire

Derniers Articles

Catégories

Étiquettes

Le sapin de Noël domotique en Z-Wave ou 433 MHz

Pré-requis / présentation

Préparation et réflexion

Création du circuit électronique

Création de la programmation de la carte Z-UNO

Intégration à l’eedomus

Résultat en vidéo

Le sapin domotique en 433 MHz

Conclusion

Lilian

Articles Similaires

La domotique, c’est facile ! #2 : Gérez le chauffage de votre maison 🌡️

Top 10 : Avantages et raisons de passer au protocole Z-Wave

Fibaro Smart Implant : Créer un capteur de niveau Z-Wave pour piscine

Guide de mise à jour OTA d’un module Zwave sur un PC

Comment configurer un module EnOcean sur Eedomus

Résoudre le « problème » d’inclusion des modules Z-Wave

Laisser un commentaire