Pilotage d’une rampe de led

Ce tutoriel va être le 1er d’une série à propos de la manipulation de bandeau led.

1. Pré requis

a. Librairies utilisées :

button.h : librairie maison de gestion de boutons poussoirs

b. Connaissance utile :

Voir le tutoriel sur la librairie de boutons

2. Objectif

L’objectif final est d’équiper mon escalier de sous sol d’une rampe de led. Cet installation possédera deux capteurs PIR afin de détecter la présence des personnes, l’installation communiquera avec une centrale domotique pour communiquer les passages et notamment si les personnes montent ou descendent.

Evidemment, avant d’en arriver là, nous allons passer par une série de tutoriaux. 1er d’entre eux, nous allons piloter l’allumage et l’extinction de la rampe de led à l’aide d’un bouton.

Nous en profiterons pour réaliser un petit effet d’allumage et d’extinction.

Allez hop, c’est parti.

a. L’effet d’allumage/extinction

Vous verrez un peu plus bas, qu’il est possible de moduler la luminosité des Leds. Plutôt que de passer d’une extinction à un allumage à 100% (ce qui est assez violent car les leds éclair très bien), nous allons réaliser un allumage avec une monté en luminosité assez rapide. Pour l’extinction, nous réaliserons l’effet inverse ; une descente de luminosité progressive, mais cette fois ci, plus lente (Au cas ou une personne resterai immobile, elle pourra se rendre compte que l’extinction est en cours).

1. Processus de gestion des allumages et extinctions

Il va s’agir ici d’un automate très simple. Si le bandeau est éteint et que je réalise un clic sur le bouton, je lance la procédure l’allumage. Si le bandeau est allumé, et que je réalise un clic, je lance la procédure l’extinction.

Néanmoins, si pendant la procédure d’extinction, je réalise la moindre action sur le bouton (Onpress : Voir le tutoriel sur la librairie gestion des boutons), je rallume immédiatement le bandeau led.

3. Un peu d’algorithmie

Nous voyons que la gestion des procédures d’allumage et d’extinction ne vont pas être similaire. En effet, la procédure d’extinction doit prendre en compte la gestion des boutons pour pouvoir intervenir et interrompre le processus d’extinction.

Donc soit, on gère de nouveau la gestion des boutons dans la procédure d’extinction, soit on essai de rester asynchrone. Nous avons déjà abordé cette logique de programmation dans le Tuto n°3. Je ne vais donc pas revenir sur ce point mais pour la procédure d’extinction, nous ne réaliserons pas une boucle qui change l’intensité puis un delay. Nous miserons sur la boucle loop pour réaliser les itérations.

Cela complexifie la programmation, mais cela apporte une grande souplesse à vos programmes.

4. Matériel utilisé

a. A propos du Tip 120

La rampe de led est alimenté en 12v (on en profitera pour alimenter l’arduino dans l’installation définitive). L’arduino ne peut délivrer que 5V sur une pin, il nous faut donc utiliser l’alimentation du transformateur mais contrôler son interruption. De base, on pense à un relais. Le relais est une action mécanique (tel un interrupteur manuel) qui laisse ou non passer le courant. L’inconvénient, c’est qu’il a une durée de vie (en nombre de commutation). Il est indispensable lorsqu’on manipule le courant alternatif de nos foyers. Mais ici, nous sommes en courant continu et qui plus est de 12v. Hors il existe un dispositif permettant de commander un courant beaucoup plus important, le transistor. Il s’agit ici d’un transistor NPN.

Non seulement ce transistor remplira son office d’interrupteur, mais en plus, nous pourrons réaliser de la modulation de fréquence. Des effets de lumière seront alors possible.

 

b. La modulation de fréquence PWN

Les Arduinos possèdent des ports PWN qui permettent la modulation de fréquence. Sur le Nano, les broches 3, 5, 6, 9, 10 et 11. Il suffit alors d’y réaliser un AnalogWrite avec une intensité allant de 0 à 255. Le courant émis alors par la broche aura cette allure :

La résultante sur le bandeau led est simple, si vous envoyez par exemple 127, les Leds auront 50% de l’intensité de luminosité. Il sera donc possible de réaliser des effets d’allumage progressif et d’extinction progressive, ce que nous allons réaliser :). Pour plus d’info sur le PWN voir ici.

5. Schéma

sur le schéma, le bandeau Led sera matérialisé par une led simple et l’alimentation est en faite le Led Driver branché sur le 220v alternatif.

schéma de montage

6. Programme

Voyons maintenant les différents éléments du programme.

On retrouve en define les pin des différents éléments : Le bouton et le TIP120.

L’objet de gestion des boutons et un ensemble de variables.

Partie déclarative
#include <Button.h>			// Inclusion de la librairie de gestion des boutons.

#define BTN 2				// Pin du bouton
#define TIP120 5			// Pin du Tip120 que l'on va gérer en PWM
#define LIGHTON 2000		// Durée d'allumage de la rampe à 100% en millisecondes.
#define LIGHTOFF 3500		// Durée d'extinction de la rampe en millisecondes.

ManageButton m_btns(BTN);	// Déclaration du gestionnaire de bouton

bool m_isAlight;			// Est ce que le bandeau est allumé ou non.
long m_diffTimeFade;		// Mesure du temps pour le fadeOut
int m_delayToLessIntesity;	// Temps d'attente pour descendre l'intensitéd du bandeau
int m_delayToUpIntesity;	// Temps d'attente pour monter l'intensité du bandeau
byte m_fadeOutIntensity;	// Valeur d'intensité pour le fadeout

Le choix du nom de la méthode parle à des informaticiens le fade in fade out est un procédé qui veut dire faire apparaître en fondu et faire disparaître en fondu.

La méthode fadeIn permet de gérer tous les allumages, en effet, il y en a deux. L’allumage complet depuis zéro et l’interruption d’extinction (En effet, lorsque l’on appuie sur le bouton au cours de l’extinction, la rampe se rallume aussitôt. Avec le détecteur de présence, on sera bien heureux que la rampe n’oublie pas de se rallumer si elle nous détecte de nouveau).

Cette procédure possède une boucle, elle ne rend pas la main au loop. Ici, on ne souhaite justement pas que la procédure puisse être interrompu.

FadeIn
void FadeInLed()
{
	byte v_intensity;				// L'intensité envoyé en PWM
	if (!m_isAlight)
	{
		Serial.println("On allume la rampe de led.");		
		for (v_intensity = 0; v_intensity < 255; v_intensity++)
		{
			analogWrite(TIP120, v_intensity);
			delay(m_delayToUpIntesity);
		}
		Serial.println("la rampe est allumée.");
		m_isAlight = true;
	}
	else
	{
		if (m_fadeOutIntensity != 0)	// La rampe était en cours d'extinction, on rallume.
		{		
			Serial.println("On interrompe l'extinction de la rampe de led.");
			for (v_intensity = m_fadeOutIntensity; v_intensity < 255; v_intensity++)
			{
				analogWrite(TIP120, v_intensity);
				delay(m_delayToUpIntesity);
			}
			Serial.println("la rampe est allumée.");
			m_isAlight = true;
			m_fadeOutIntensity = 0;		// Important pour ne pas rentrer en conflit avec le fadeOut.
		}
		else
			Serial.println("Elle est déjà allumée.");
	}
	m_btns.Release();					// Je force la remise à zero du statut ici.
}

La procédure fadeOut quand à elle ne possède pas de boucle pour rendre la main au loop et pouvoir gérer d’autres action au cours du processus. Si celui ci n’est pas interrompu, la procédure se déroulement comme si nous avions une boucle.

FadeOut
void FadeOut()
{
	int v_pourcentage;
	if (m_isAlight && m_fadeOutIntensity > 1)
	{
		Serial.print("Rampe à ");
		v_pourcentage = (m_fadeOutIntensity * 100) / 255;
		Serial.print(v_pourcentage); Serial.println("%");
		analogWrite(TIP120, m_fadeOutIntensity);
		m_fadeOutIntensity--;
	}
	else
	{
		m_fadeOutIntensity--;
		analogWrite(TIP120, m_fadeOutIntensity);
		m_isAlight = false;
		m_delayToLessIntesity = 0;
		Serial.println("Extinction totale de la rampe de led.");
	}
	m_diffTimeFade = millis();
}

Je vous passe la méthode setup qui est enfantine.

Intéressons nous plutôt à la boucle loop. Vous verez tout d’abord, l’écoute de l’état du bouton ainsi que le fadeIn.

Puis vient le bloc de gestion du fadeout avec trois cas :

  1. La détection du lancement de la procédure, il faut que l’on soit allumé (complet) et que l’on ai un clic.
  2. Le déroulement lui même. Si le délai de chaque étape est atteint, on lance la procédure pour descendre l’intensité.
  3. La détection d’une pression sur le bouton pour interrompre la procédure. Il faudra vieiller dans le fadeIn à réintialiser les variables de telle sorte que le fadeOut ne désire pas continuer son action. On voit tout de suite que le levier se situe sur la valeur de m_fadeOutIntensity.
loop
void loop()
{
	m_btns.listen();					 // Permet de gérer et d'obtenir le status des boutons.
	if (m_btns.OnClick() && !m_isAlight) // Procédure d'allumage synchrone
		FadeInLed();
	/* 
	Ci dessous Bloc de code qui permet la gestion asynchone de l'extinction de la rampe.
	Cela nous permet de pouvoir gérer simultanément l'extinction et la détection d'un
	événement sur le bouton. Celui çi interrompant le processus d'arrêt pour rallumer la rampe.
	*/
	if (m_btns.OnClick() && m_isAlight)  // Procédure pour éteindre la rampe lancement
	{		
		Serial.println("On éteind la rampe de led.");
		m_fadeOutIntensity = 255;
		FadeOut();
		m_btns.Release();				 // Je force la remise à zero du statut ici.
	}
	// Déroulement de la procédure d'extinction.
	if (m_fadeOutIntensity != 0 && (millis() - m_diffTimeFade > m_delayToLessIntesity))
	{
		FadeOut();
	}
	// Détection de l'événement sur le bouton.
	if (m_btns.OnPress())
	{
		FadeInLed();
	}
}

a. Source à télécharger

BandeauLedBouton.ino

7. Résultat

en image

Démo vidéo

8. Conclusion

En conclusion, voilà une bonne petite étape de franchi. Il va falloir maintenant incorporer les capteurs PIR pour le prochain tutoriel et remplacer le bouton.

D’un point de vue algo, c’était intéressant aussi puisque nous avons pu voir dans ce programme les deux cas de gestion synchrone et asynchrone d’une tâche dans le temps. Evidemment la version synchrone avec une boucle est connu de tous, mais la version asynchrone, bien que plus complexe, nous ouvre un champs de possibilité. N’oubliez jamais cette possibilité pour éviter des temps de latence dans vos programmes lorsque ceci gère plusieurs capteurs, paramètres, …

2 thoughts on “Pilotage d’une rampe de led

  1. Bonjour Sébastien,
    Avant toute chose, je vous félicite pour votre Site traitant des possibilités d’Arduino.
    Je suis à la recherche d’un petit programme me permettant de démarrer progressivement le moteur A.C de mon portail coulissant (avec interface, moc et triac), ensuite un palier de pleine vitesse, et pour finir un arrêt progressif ( Ces 3 étapes s’exécutantes, pour chacune d’entre elle dans des délais de 0 à 6 secondes environ )
    Donc à ce sujet, j’ai lu votre article très intéressant ( ci-dessus) traitant de l’allumage et de l’extinction progressifs d’une rampe de Leds.
    Pourriez-vous me dire si ce programme conviendrait à ma recherche ?
    D’ avance, je vous remercie.

    Très cordialement,
    Jean-Clément

    Pour info:
    – Je suis un ancien électricien (en télécom et EnR ) à la retraite, mais novice en programmation Arduino.
    – Je possède une carte Nano et je me connecte ( pour l’instant ! ) juste à l’interface Arduino 1.8.9,  c’est tout ….. Lol

  2. Bonsoir Jean Clément, tout d’abord, je vous remercie et je me suis permis d’éditer votre post pour retirer vos coordonnées.

    En effet, je pense que dans le programme, vous pourriez reprendre la partie fadein fadeout, qui permet cette progressivité dans une durée données.

    Evidemment l’ensemble du programme serait à adapter à votre problématique. Vous pouvez si vous voulez le réaliser et me l’envoyer avec votre cahier des charges afin que je le vérifie d’un point de vue algorithmie.

    Cordialement,
    Sébastien.

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.