MicroPython-Hack-led-RGB

De MCHobby - Wiki
Aller à : navigation, rechercher

MCHobby investit du temps et de l'argent dans la réalisation de traduction et/ou documentation. C'est un travail long et fastidieux réalisé dans l'esprit Open-Source... donc gratuit et librement accessible.
SI vous aimez nos traductions et documentations ALORS aidez nous à en produire plus en achetant vos produits chez MCHobby.

Ce que nous faisons

.: Lumière colorée :.

.: LED RGB :.

Nous avons fait clignoter une LED et aussi contrôlé une séquence de huit LEDs. Maintenant, il est temps d'en contrôler la couleur.

En utilisant une LED RGB (Red Green Blue ou RVB pour Rouge Vert Bleu) qui est en fait 3 LEDs dans un seul boîtier, nous pouvons générer n'importe laquelle des couleurs que vous souhaitez. Nous y arrivons en faisant un mélange de couleur.

Ce qui nécessite de faire un petit retour en arrière sur nos premiers cours d'éducation artistique, ces jours durant lesquels nous expérimentions les mélanges de couleurs à partir de feuilles de cellophane colorées.

Pas de panique si vous ne vous en souvenez pas, vous trouverez ci-joint une roue des couleurs pour vous aider.

ARDX-Montages-CIRC12-table-couleur.png

ARDX-Montages-CIRC12-roue-couleur.png

Le montage

Le matériel nécessaire

ARDX-fils.png
PYBX-R330.png

Résistance de 330 Ohms (orange-orange-brun)
x3

PYBX-LED-RGB.png
 

Tous ces éléments sont disponibles sur shop.mchobby.be.

Schéma

Bien la la LED RGB soit habituellement utilisée sur Arduino (5V), nous pouvons fort bien l'utiliser avec une tension d'alimentation de 3.3v.

Nous allons brancher:

  • La LED rouge sur Y10
  • La LED verte sur Y11
  • La LED bleu sur Y12

MicroPython-Hack-led-RGB-schema.png

Montage

MicroPython-Hack-led-RGB-montage.jpg
Made with - réalisé avec - Fritzing fritzing.org

Le code

Attention, logique inversée:

Pour allumer la LED rouge, il faut que le courant puisse passer du +3.3V vers la masse.

Comme la LED est déjà branchée sur le +3.3v, la seule marge de manoeuvre se trouve sur l'autre broche qu'il fait soit placer à la masse (niveau bas, low), soit à +3.3v (niveau haut, high).

Lorsque la broche du pyboard est au niveau bas, le courant peut circuler de +3.3v vers la masse (au travers de la LED et de la résistance) --ET-- la LED s'illuminera.

Cela signifie que pour avoir du rouge, il faut placer la broche de la LED rouge au niveau bas (à la masse, low) mais surtout il faut que les LEDs verte et bleue soient éteintes et leur broche respective à +3.3v (niveau haut, high, ce qui empêche un courant de circuler dans ces LEDs).

RED_PIN = pyb.Pin.board.Y10    # Led rouge
GREEN_PIN = pyb.Pin.board.Y11  # Led verte
BLUE_PIN = pyb.Pin.board.Y12   # Led bleue

# Déclaration des broches
pRed = pyb.Pin( RED_PIN, pyb.Pin.OUT_PP )
pGreen = pyb.Pin( GREEN_PIN, pyb.Pin.OUT_PP )
pBlue = pyb.Pin( BLUE_PIN, pyb.Pin.OUT_PP )

# Eteindre la LED
pRed.high()
pGreen.high()
pBlue.high()

# Allumer la led ROUGE
pRed.low()
pGreen.high()
pBlue.high()

# Attendre 1 secondes
pyb.delay( 1000 )
	
# Allumer la led BLEUE
pRed.high()
pGreen.high()
pBlue.low()

# Attendre 1 secondes
pyb.delay( 1000 )    

# Allumer la led VERTE
pRed.high()
pGreen.low()
pBlue.high()

# Attendre 1 secondes
pyb.delay( 1000 )    

# Allumer en BLANC (toutes les LEDs allumées)
pRed.low()
pGreen.low()
pBlue.low()

# Attendre 1 secondes
pyb.delay( 1000 )    

# Tout en noir (toutes les LEDs éteintes)
pRed.high()
pGreen.high()
pBlue.high()

Cela ne fonctionne pas?

Voici 3 choses à essayer.

La LED reste noire ou affiche une couleur incorrecte?

Il est facile de faire une erreur avec les quatre broches de la LED si proches les unes des autres.

Essayez de vérifier si chacune des broches est bien à sa place.

Attention, logique inversée: Pour allumer la LED rouge, il faut que le courant puisse passer du +3.3V vers la masse. Vous devez donc placer la broche de la LED rouge à l'état BAS pour qu'elle s'allume. Cela signifie aussi que les broches des LEDs bleue et verte doivent être au niveau haut (+3.3V, et donc pas courant dans ces LEDs là, donc elles sont éteintes).

c'est trop "rouge"!

La diode rouge de la LED RGB pourrait être plus brillante que les deux autres.

Pour ajuster la balance des couleurs, essayez d'utiliser une résistance plus grande (ou deux résistances montées en série).

En effet, la LED rouge de la LED RGB consomme un courant de 4.30mA là où les LEDs Verte et Bleue consomme environ 1.90mA.

Faire encore mieux

Plus de couleurs

J'imagine que vous êtes moins qu'impressionné par l'affichage des trois couleurs de base. Nous allons donc rendre le jouet un peu plus intéressant en élaborant d'autres couleurs (en les mélangeant), en définissant une séquence de couleur et en automatisant l'affichage de celles-ci.

RED_PIN = pyb.Pin.board.Y10    # Led rouge
GREEN_PIN = pyb.Pin.board.Y11  # Led verte
BLUE_PIN = pyb.Pin.board.Y12   # Led bleue

# Déclaration des broches
pRed = pyb.Pin( RED_PIN, pyb.Pin.OUT_PP )
pGreen = pyb.Pin( GREEN_PIN, pyb.Pin.OUT_PP )
pBlue = pyb.Pin( BLUE_PIN, pyb.Pin.OUT_PP )

# Déclaration des 3 broches la LED RGB 
pRGB = (pRed,pGreen,pBlue)

# Assigne l'etat des broches rouge,vert,bleu à partir d'un tuple de 
# 3 éléments tels que  (True,True,True)
def set_led( p_rgb, state_tuple ):
	for i in range(0,3):
		# Note: Une led est activée si l'on met la broche correspondante
		#       a GND.
	    p_rgb[i].value( not( state_tuple[i] ) ) 

# Faire un mix de deux états RGB pour en composer un troisième.
# Rouge (True,False,False) + Bleu (False,False,True) = Magenta (True,False,True)
def mix_color( color1, color2 ):
    return (color1[0] | color2[0], color1[1] | color2[1], color1[2] | color2[2] ) 

# Désactivation des LEDs
set_led( pRGB, (False, False, False) )

# Sequences d'allumage des LEDs R,G,B
noir  = (False,False,False)
rouge = (True,False,False)
vert  = (False,True,False)
bleu  = (False,False,True)  
jaune = mix_color( rouge, vert )
cyan  = mix_color( vert, bleu )
magenta = mix_color( bleu, rouge )
 
sequences = [ 
    rouge, vert, bleu, noir, # Couleurs de base
    rouge, jaune, vert, cyan, bleu, magenta # Suivre la rouge des couleurs
    ]
    
# Initialiser la LED à toutes les séquences
for seq in sequences:
	set_led( pRGB, seq )
	# Attendre 2 secondes
	pyb.delay( 2000 )
	
set_led( pRGB, noir )

Afficher les couleurs aléatoirement

Nous allons modifier le programme pour qu'il sélectionne aléatoirement un couleur parmi celles que nous avons définie et active la LED en fonction de cette couleur aléatoire.

Le programme ainsi modifier répétera l'opération une centaine de fois avec un délai de 1/4 seconde entre chaque changement.

Quelques explications:

Nous allons commencer par créer une liste des couleurs disponibles que nous allons stocker dans la variable COLORS.

COLORS = [ rouge, vert, bleu, jaune, cyan, magenta ]

Nous avons donc un tableau dont d'une taille de len(COLORS), soit 6 éléments.

Nous allons ensuite générer un nombre aléatoire avec pyb.rng() qui génère une valeur entière sur 30 bits.

Nous allons prendre le reste de la division entière par 6 (la longueur du tableau) pour obtenir une valeur bornée entre 0 et 5... soit l'index d'une couleur dans le tableau COLORS.

La sélection d'une couleur aléatoire peut se résumer dans les deux lignes suivantes:

couleur_index = pyb.rng() % len( COLORS )
couleur = COLORS[couleur_index]

Le programme modifié

RED_PIN = pyb.Pin.board.Y10    # Led rouge
GREEN_PIN = pyb.Pin.board.Y11  # Led verte
BLUE_PIN = pyb.Pin.board.Y12   # Led bleue

# Déclaration des broches
pRed = pyb.Pin( RED_PIN, pyb.Pin.OUT_PP )
pGreen = pyb.Pin( GREEN_PIN, pyb.Pin.OUT_PP )
pBlue = pyb.Pin( BLUE_PIN, pyb.Pin.OUT_PP )

# Déclaration des 3 broches la LED RGB 
pRGB = (pRed,pGreen,pBlue)

# Assigne l'etat des broches rouge,vert,bleu à partir d'un tuple de 
# 3 éléments tels que  (True,True,True)
def set_led( p_rgb, state_tuple ):
	for i in range(0,3):
		# Note: Une led est activée si l'on met la broche correspondante
		#       a GND.
	    p_rgb[i].value( not( state_tuple[i] ) ) 

# Faire un mix de deux états RGB pour en composer un troisième.
# Rouge (True,False,False) + Bleu (False,False,True) = Magenta (True,False,True)
def mix_color( color1, color2 ):
    return (color1[0] | color2[0], color1[1] | color2[1], color1[2] | color2[2] ) 

# Désactivation des LEDs
set_led( pRGB, (False, False, False) )

# Sequences d'allumage des LEDs R,G,B
noir  = (False,False,False)
rouge = (True,False,False)
vert  = (False,True,False)
bleu  = (False,False,True)  
jaune = mix_color( rouge, vert )
cyan  = mix_color( vert, bleu )
magenta = mix_color( bleu, rouge )
 
COLORS = [ rouge, vert, bleu, jaune, cyan, magenta ]
    
# Afficher 100 couleurs aléatoirement
for i in range( 100 ):
	# Choisir un index aléatoirement pour COLORS
	rnd = pyb.rng() % len( COLORS )
	couleur = COLORS[rnd]
	set_led( pRGB, couleur )
	
	# Attendre 1/4 secondes
	pyb.delay( 250 )
	
# Tout éteindre
set_led( pRGB, noir )

Contrôle analogique des couleurs

Passer d'une couleur à l'autre est amusant. Mais les LEDs RGBs ne montrent tout leur potentiel que lorsque l'on fait des mélanges de couleurs à l'aide du contrôle analogique.

En utilisant la modulation de largeur d'impulsion (PWM) il est possible de produire presque n'importe quelle couleur et de faire des fondus d'une couleur à l'autre.

Nous avons appris dans le tutoriel "Led et luminosité" comment identifier les Timer et le Channel associé à la sortie.

Nous allons également réutiliser la fonction arduino_map découvert dans le tutoriel dédié à la "lecture analogique".

Par contre, nous avons besoin de sorties PWM pour commander les LEDs rouge, vert, bleu de notre LED RGB. Nous allons devoir modifier notre montage pour utiliser les broches X8, Y9 et Y10.

MicroPython-Hack-led-RGB-PWM.jpg
Made with - réalisé avec - Fritzing fritzing.org

Voici un programme qui permet de fixer une couleur arbitraire.

En prime, il y a quelques autres fonctions intéressante (que nous aborderons dans la section. "Plus Plus et encore plus".

from pyb import Timer
from time import sleep

# Definir des couleurs (valeur RGB (red, green, blue) 
ROUGE  = (255, 0, 0) 
ORANGE = (83, 4, 0) 
JAUNE  = (255, 255, 0) 
VERT   = (0, 255, 0)
BLEU   = (0, 0, 255) 
INDIGO = (4, 0, 19) 
VIOLET = (23, 0, 22) 
CYAN   = (0, 255, 255) 
MAGENTA= (255, 0, 255) 
BLANC  = (255, 255, 255) 
NOIR   = (0, 0, 0)
ROSE   = (158, 4, 79) 
	
class PWM_RGB:
    """ Permet de controler une LED RGB en PWM. """
    PWM_FREQ = 100 # Frequence 100 Hz
    
    def __init__(self, pwn_red, pwm_green, pwm_blue ):
        """ Initialise l objet avec les informations de controle PWM.
            :param pwm_red: pour led rouge. dictionnaire avec pin, timer, channel à utiliser
            :param pwm_green: pour led verte. idem 
            :param pwm_blue: pour led bleue. idem"""
        self.__red = pwn_red
        self.__green = pwm_green
        self.__blue = pwm_blue
         
        for pwm_for in [self.__red, self.__green, self.__blue]:
            # Cree le timer et le channel et stocke les references dans le 
            # dictionnaire PWM_FOR_x
            pwm_for['tim'] = pyb.Timer( pwm_for['timer'], freq=self.PWM_FREQ )
            pwm_for['pchannel'] = pwm_for['tim'].channel( pwm_for['channel'], Timer.PWM, pin=pwm_for['pin'], pulse_width_percent=100 )

    def arduino_map(self, x, in_min, in_max, out_min, out_max):
        """ fonction qui permet de passer d'un range de valeur (in_) à une autre
            (out_) en appliquant une règle de trois. """
        return int( (x - in_min) * (out_max - out_min) // (in_max - in_min) + out_min )
    
    def set_color(self, color ):
        """ Assign une couleur (r,g,b) pour la LED RGB. 
            :param pwm_rgb: la definition des canaux PWM de la LED RGB 
            :param color: un tuple pour les valeurs ( R, G, B ). Valeurs de 0 à 255 """
        
        # Attention couleur pleine = 0% cycle utile
        #           pas de couleur = 100% cycle utile -> logique inversée
        percent_width = self.arduino_map( color[0], 0, 255, 100, 0 ) 
        self.__red['pchannel'].pulse_width_percent( percent_width )
        percent_width = self.arduino_map( color[1], 0, 255, 100, 0 ) 
        self.__green['pchannel'].pulse_width_percent( percent_width )
        percent_width = self.arduino_map( color[2], 0, 255, 100, 0 ) 
        self.__blue['pchannel'].pulse_width_percent( percent_width )

    def fade_to_color( self, from_color, to_color, delay_ms ):
        """ Passe d'une couleur à l'autre. insère un delay de x ms entre
            chaque modification de couleur (donc influence la vitesse
            de changement

            :param from_color: Couleur de depart. Tuple (r,g,b). Valeur de 0 à 255
            :param to_color: Couleur de fin.
            :param delay_ms: Temps entre deux étape (en milliseconde)
        """
        changedRed   = to_color[0] - from_color[0]
        changedGreen = to_color[1] - from_color[1]
        changedBlue  = to_color[2] - from_color[2]
        steps = max( abs(changedRed), abs(changedGreen), abs(changedBlue) )
        
        for i in range( steps ):
            newRed   = from_color[0] + (i * changedRed / steps)
            newGreen = from_color[1] + (i * changedGreen / steps)
            newBlue  = from_color[2] + (i * changedBlue / steps)
            self.set_color( (newRed, newGreen, newBlue) )
            pyb.delay( delay_ms )

# Déclaration des broches, timers et channels pour controler une LED
# RGB en PWM
PWM_FOR_RED   = { 'pin' : pyb.Pin.board.X8 , 'timer' :14, 'channel' : 1, 'tim': None, 'pchannel' : None }
PWM_FOR_GREEN = { 'pin' : pyb.Pin.board.Y9 , 'timer' : 2, 'channel' : 3, 'tim': None, 'pchannel' : None }
PWM_FOR_BLUE  = { 'pin' : pyb.Pin.board.Y10, 'timer' : 2, 'channel' : 4, 'tim': None, 'pchannel' : None }  

# Creation de l'objet LED
led = PWM_RGB( PWM_FOR_RED, PWM_FOR_GREEN, PWM_FOR_BLUE )
led.set_color( NOIR )

# Affichage d'une couleur prédéfinie 
led.set_color( ROSE )

# Affichage d'une couleur de votre choix
# led.set_color( (12,34,12) )

# Passer d'une couleur à l'autre avec un delay de 10ms par étapes
# Le délais determine la vitesse de chg de couleur.
# led.fade_to_color( ROUGE, VERT, 10 )

# Roue des couleurs
#COLORS = [ROUGE,JAUNE,VERT,CYAN,BLEU,MAGENTA,ROUGE]
#for current_color, next_color in zip( COLORS, COLORS[1:] ):
#    led.fade_to_color( current_color, next_color, 10 )
#
#led.set_color( NOIR )

Plus, plus et encore plus

Si vous regardez attentivement le script du contrôle analogique des couleurs (ci-dessus), vous noterez que la classe PWM_RGB dispose d'une méthode fade_to_color() permettant de passer d'une couleur à l'autre.

Passer d'une couleur à l'autre

Ainsi la ligne de code suivante:

# Passer d'une couleur à l'autre avec un delay de 10ms par étapes
# Le délais determine la vitesse de chg de couleur.
led.fade_to_color( ROUGE, VERT, 10 )

Permet de passer progressivement de la couleur ROUGE à la couleur VERTE.

Roue des couleurs

Il est aussi passer de passer d'une couleur à l'autre afin de créer un système de fading de couleur assez sympa.

# Roue des couleurs
COLORS = [ROUGE,JAUNE,VERT,CYAN,BLEU,MAGENTA,ROUGE]
for current_color, next_color in zip( COLORS, COLORS[1:] ):
    led.fade_to_color( current_color, next_color, 10 )

Comment ça marche:

La petite instruction magique est l'appel de la fonction zip qui permet d'assembler la liste COLORS (index 0 à N) avec cette même liste mais décalée (en commençant la l'indexe 1).

Si vous êtes curieux, vous pouvez essayer le petit script suivant (test de la fonction ZIP) et constater la successions de couleur de départ et d'arrivée utilisés lors des appels fade_to_color()

COLORS = ['ROUGE','JAUNE','VERT','CYAN','BLEU','MAGENTA','ROUGE']
for current_color, next_color in zip( COLORS,  COLORS[1:] ):
    print( current_color, next_color )

Ce qui produit la séquence suivante:

ROUGE JAUNE                                                       
JAUNE VERT
VERT CYAN
CYAN BLEU
BLEU MAGENTA
MAGENTA ROUGE


Source: Micro Python Intro écrit par/written by Damien P.George

Traduit par Meurisse D. pour MCHobby.be - Translated by Meurisse D. for MCHobby.be

Toute référence, mention ou extrait de cette traduction doit être explicitement accompagné du texte suivant : «  Traduction par MCHobby (www.MCHobby.be) - Vente de kit et composants » avec un lien vers la source (donc cette page) et ce quelque soit le média utilisé.

L'utilisation commercial de la traduction (texte) et/ou réalisation, même partielle, pourrait être soumis à redevance. Dans tous les cas de figures, vous devez également obtenir l'accord du(des) détenteur initial des droits. Celui de MC Hobby s'arrêtant au travail de traduction proprement dit.

Traduit avec l'autorisation de micropython.org - Translated with the authorisation of micropython.org