KY-009 Module led RGB

int Led_Rouge = 10;
int Led_Verte = 11;
int Led_Bleue = 12;
  
void setup ()
{
  // Initialisation des broches de sortie pour les LEDS
  pinMode (Led_Rouge, OUTPUT); 
  pinMode (Led_Verte, OUTPUT);
  pinMode (Led_Bleue, OUTPUT); 
}
  
void loop () //Boucle de programme principale
{
  digitalWrite (Led_Rouge, HIGH); // la Led s'allume
  digitalWrite (Led_Verte, LOW); // la LED commute
  digitalWrite (Led_Bleue, LOW); // la LED commute
  delay (3000); // Délai de 3 secondes
  
  digitalWrite (Led_Rouge, LOW); // la LED commute
  digitalWrite (Led_Verte, HIGH); // la LED s'allume
  digitalWrite (Led_Bleue, LOW); //la LED commute
  delay (3000); // Délai de 3 secondes supplémentaires pendant lequel les LEDS sont commutées
   
  digitalWrite (Led_Rouge, LOW); // la LED commute
  digitalWrite (Led_Verte, LOW); // la LED commute
  digitalWrite (Led_Bleue, HIGH); // la LED s'allume
  delay (3000); // Délai de 3 secondes supplémentaires pendant lequel les LEDS sont commutées
}

int Led_Rouge = 10;
int Led_Verte = 11;
int Led_Bleue = 12;
 
int val;
 
void setup () {
  // Initialisation des broches de sortie pour les LEDS
  pinMode (Led_Rouge, OUTPUT); 
  pinMode (Led_Verte, OUTPUT); 
  pinMode (Led_Bleue, OUTPUT); 
}
void loop () {
   // Dans une boucle For, différentes valeurs PWM sont envoyées aux 3 LEDS
   for (val = 255; val> 0; val--)
      {
       analogWrite (Led_Bleue, val);
       analogWrite (Led_Verte, 255-val);
       analogWrite (Led_Rouge, 128-val);
       delay (1);
   }
   // Les signaux sont ensuite inversés
   for (val = 0; val <255; val++)
      {
      analogWrite (Led_Bleue, val);
      analogWrite (Led_Verte, 255-val);
      analogWrite (Led_Rouge, 128-val);
      delay (1);
   }
}

Ce module LED contient trois LED différentes de couleur rouge, bleue et verte. Ces trois LED sont reliées entre elles par une cathode commune, ce qui signifie qu'elles partagent toutes la même connexion négative. La LED rouge a besoin d'une tension de 1,8 V pour s'allumer, tandis que les LED verte et bleue ont besoin d'une tension de 2,8 V chacune. Toutes les LED fonctionnent avec un courant de 20 mA.

Ce module permet de créer de multiples combinaisons de couleurs en adaptant la luminosité de chaque LED. En mélangeant le rouge, le vert et le bleu, il est possible de créer presque toutes les couleurs du spectre visible. Ce module est idéal pour les projets nécessitant des signaux visuels, des affichages ou des effets lumineux décoratifs.

Sa conception compacte permet de l'intégrer facilement dans différents circuits et projets. Que vous soyez un débutant ou un développeur expérimenté, ce module LED offre une solution flexible et polyvalente à vos besoins d'éclairage. Grâce à la clarté de la sortie couleur et à la simplicité du contrôle, vous pouvez réaliser des installations d'éclairage créatives et impressionnantes.

Données techniques
Tension directe [rouge]	1,8 V
Tension directe [vert, bleu]	2,8 V
Courant de passage	20 mA

Les désignations (Vf et If) font référence à la tension directe et au courant direct de la diode électroluminescente.

Résistances en série :

En fonction de la tension d'entrée, des résistances en série sont nécessaires..

La désignation (Rf) désigne ici la résistance en série nécessaire devant la diode électroluminescente en fonction de la tension appliquée.

Tension d'entrée	Résistance en série
3,3 V [Rouge]	180 Ω
3,3 V [Vert]	100 Ω
3,3 V [Bleu]	100 Ω
5 V [Rouge]	180 Ω
5 V [Vert]	100 Ω
5V [Bleu]	100 Ω

Affectation des broches

Raspberry Pi	Capteur
GPIO 25 [Pin 22]	LED ROUGE
GPIO 24 [Pin 18]	LED VERT
GPIO 23 [Pin 16]	LED BLEU
GND [Pin 6]	GND

Exemple de code (ON/OFF)

Cet exemple de code montre comment les DEL intégrées peuvent être changées alternativement dans un cycle de 3 secondes au moyen d'une broche de sortie définissable.

from gpiozero import LED
import time

# Déclaration des LEDs sur leurs broches GPIO correspondantes
led_rouge = LED(25)
led_vert = LED(24)
led_bleue = LED(23)

print("Test de la LED [appuyez sur CTRL+C pour terminer le test]")

# Boucle du programme principal
try:
    while True:
        print("LED ROUGE allumée pendant 3 secondes")
        led_rouge.on()
        led_vert.off()
        led_bleue.off()
        time.sleep(3)  # Mode d'attente pendant 3 secondes

        print("LED VERT allumée pendant 3 secondes")
        led_rouge.off()
        led_vert.on()
        led_bleue.off()
        time.sleep(3)  # Mode d'attente pendant 3 secondes

        print("LED BLEUE allumée pendant 3 secondes")
        led_rouge.off()
        led_vert.off()
        led_bleue.on()
        time.sleep(3)  # Mode d'attente pendant 3 secondes

# Retravailler après la fin du programme
except KeyboardInterrupt:
    print("Programme terminé par l'utilisateur")
    # gpiozero s'occupe automatiquement du nettoyage à la fin du programme

Exemple de programme ON/OFF Télécharger

KY009-RPi-ON-OFF.zip

Pour commencer avec la commande :

sudo python3 KY009-RPi.py

Exemple de code (PWM)

La modulation de largeur d'impulsion [PWM] permet de réguler la luminosité d'une LED - la LED est allumée et éteinte dans certains intervalles de temps, le rapport entre le temps d'allumage et le temps d'extinction correspondant à une luminosité relative - en raison de l'inertie de la vision humaine, les yeux humains interprètent ce comportement d'allumage/extinction comme un changement de luminosité. Pour plus d'informations sur ce sujet, consultez cet article de mikrokontroller.net.

Plusieurs LED sont intégrées dans ce module. En superposant différents niveaux de luminosité, il est donc possible de créer différentes couleurs. Ceci est illustré dans l'exemple de code suivant. Dans le Raspberry Pi, seul un canal PWM matériel n'est pas limité aux broches GPIO, c'est pourquoi cet exemple utilise un PWM logiciel.

from gpiozero import PWMLED
import time
import random

# Définition des PWMLED pour chaque couleur
led_rouge = PWMLED(25)
led_vert = PWMLED(24)
led_bleue = PWMLED(23)

# Cette fonction génère la couleur proprement dite
# L'intensité de la couleur peut être modifiée à l'aide de la variable de couleur correspondante.
# Après avoir défini la couleur, "time.sleep" définit la durée d'affichage de la couleur en question.
def led_farbe(rouge, vert, bleue, pause):
    led_rouge.value = rouge
    led_vert.value = vert
    led_bleue.value = bleue
    time.sleep(pause)

    # Remise à zéro après le passage
    led_rouge.value = 0
    led_vert.value = 0
    led_bleue.value = 0

print("Test de la LED [appuyez sur CTRL+C pour terminer le test]")

# Boucle du programme principal :
# Elle a pour tâche de créer une variable pour chaque couleur individuelle et de parcourir, au moyen d'une boucle For, l'intensité de chaque couleur individuelle de 0 à 100%.
# Le mélange des différents niveaux de luminosité de chaque couleur crée ainsi un dégradé de couleurs.
try:
    while True:
        for x in range(0, 2):
            for y in range(0, 2):
                for z in range(0, 2):
                    print(x, y, z)
                    for i in range(0, 101):
                        # Réglage de la couleur de la LED en fonction du passage actuel de la boucle
                        led_farbe(x * i / 100, y * i / 100, z * i / 100, 0.02)

# Nettoyage après la fin du programme
except KeyboardInterrupt:
    print("Programme terminé par l'utilisateur")

Programme d'exemple PWM Télécharger

KY009-RPi-PWM.zip

Pour commencer avec la commande :

sudo python3 KY009-PWM.py

	
		input.onButtonPressed(Button.A, function () {
		    pins.digitalWritePin(DigitalPin.P2, 1)
		    pins.digitalWritePin(DigitalPin.P0, 0)
		    pins.digitalWritePin(DigitalPin.P1, 0)
		})
		input.onButtonPressed(Button.AB, function () {
		    pins.digitalWritePin(DigitalPin.P1, 1)
		    pins.digitalWritePin(DigitalPin.P2, 0)
		    pins.digitalWritePin(DigitalPin.P0, 0)
		})
		input.onButtonPressed(Button.B, function () {
		    pins.digitalWritePin(DigitalPin.P0, 1)
		    pins.digitalWritePin(DigitalPin.P2, 0)
		    pins.digitalWritePin(DigitalPin.P1, 0)
		})
	

# Charger les bibliothèques
from machine import Pin, PWM
from time import sleep

# Initialisation de GPIO26, GPIO27 et GPIO28 comme sortie.
Green = Pin(28, Pin.OUT)
Red = Pin(27, Pin.OUT)
Blue = Pin(26, Pin.OUT)

# Fonction : Les différentes couleurs disponibles de la LED sont allumées et éteintes l'une après l'autre.
def solo():
    Green.value(1)
    Red.value(0)
    Blue.value(0)
    sleep(3)
    Green.value(0)
    Red.value(1)
    Blue.value(0)
    sleep(3)
    Green.value(0)
    Red.value(0)
    Blue.value(1)
    sleep(3)
    Green.value(0)
    Red.value(0)
    Blue.value(0)

# Fonction : Les différentes couleurs disponibles de la LED sont commutées simultanément l'une après l'autre pour créer des couleurs mélangées.
def mix():
    Green.value(1)
    Red.value(1)
    Blue.value(0)
    sleep(3)
    Green.value(1)
    Red.value(0)
    Blue.value(1)
    sleep(3)
    Green.value(0)
    Red.value(1)
    Blue.value(1)
    sleep(3)
    Green.value(0)
    Red.value(0)
    Blue.value(0)
    
while True:
    solo()
    sleep(3)
    mix()

# Charger les bibliothèques
import machine
import math

# Initialisation de GPIO26, GPIO27 et GPIO28 comme broche PWM
ledRed = machine.PWM(machine.Pin(27))
ledRed.freq(1000)
ledBlue = machine.PWM(machine.Pin(26))
ledBlue.freq(1000)
ledGreen = machine.PWM(machine.Pin(28))
ledGreen.freq(1000)

# Définition d'une liste de 3 chiffres
RBG = [0,0,0]

# Fonction : Calcul de l'espace couleur pour le rouge, le vert et le bleu | Le vert est décalé de 120° par rapport au rouge | Le bleu est décalé de 240° par rapport au rouge
def sinColour(number):
    a = (math.sin(math.radians(number))+1)*32768
    b = (math.sin(math.radians(number+120))+1)*32768
    c = (math.sin(math.radians(number+240))+1)*32768
    RBG = (int(a),int(b),int(c))
    return RBG

# Boucle sans fin où la valeur de la couleur pour les 3 couleurs est décalée encore et encore de 0,01.
a = 0
while True:
    RBG = sinColour(a)
    a += 0.01
    if a == 360:
        a = 0
    ledRed.duty_u16(RBG[0])
    ledBlue.duty_u16(RBG[1])
    ledGreen.duty_u16(RBG[2])