Dernières nouvelles

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

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 :

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

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 !

Un commentaire

  1. Sympa le sapin !
    On ne peut plus geek … j’ai été beaucoup plus flemmard que vous pour ma part il est branché sur une multiprise greenwave powernode 6 … qui permet de l’allumer automatiquement et l’éteindre … effet garantie pour les enfants quand cela s’allume tout seul 😉
    Mais derrière ce beau sapin on comprend bien comment piloter les bandeaux leds ! merci

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