MicroPython-Hack-fading

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.

Contrôler la luminosité

En plus de pouvoir allumer et éteindre une LED, il est également possible d'en contrôler la luminosité en utilisant un signal PWM (voir ci-dessous). L'utilisation d'un signal PWM est une technique très répandue pour obtenir une sortie variable sur une broche digital. Cela permet d'estomper la luminosité d'une LED:

MicroPython-Hack-fading.jpg

C'est quoi PWM?

PWM est l'acronyme anglais de "pulse width modulation" que l'on traduit par "modulation par largeur d'impulsions".

PWM est un terme fort répandu sur le net, Arduino et en hacking électronique... raison de laquelle nous allons le préserver tel quel.

La modulation par largeur d'impulsion (MLI en français) est une technique utilisée pour contrôler la puissance envoyée à un périphérique. Nous l'utiliserons dans ce tutoriel pour contrôler la quantité d'énergie alimentant le moteur et par conséquent sa vitesse de rotation.

Le graphique ci-dessous montre le signal PWM tel qu'il est envoyé par la broche PWM du Raspberry Pi

Rasp-Hack-L293-PWM-01.jpg
Crédit: AdaFruit Industries www.adafruit.com

Chaque 1/500 ième de seconde, la sortie PWM produit une impulsion. La longueur de cette impulsion (dans le temps) contrôle la quantité d'énergie qui alimente le moteur. Comme vous pouvez le constater sur le graphique la longueur de l'impulsion peut varier de 0 à 100%.

Sans impulsion, le moteur ne fonctionne pas, une courte impulsion le fera tourner lentement. Si l'impulsion est active pendant cinquante pour cent du cycle, le moteur recevra la moitié de la puissance qu'il recevrait avec des impulsions maximales (constante dans le temps).

Montage

Le matériel nécessaire

PYBX-FILS.png
PYBX-R100.png

Résistance de 100 Ohms (brun-noir-brun)
x1

PYBX-LED-verte.png

LED (DEL) verte
x1

 

Branchement

Dans ce tutoriel, nous allons utiliser la broche X1. Connectez un côté de la résistance de 100 Ohms sur X1 et l'autre bout sur l'anode de la LED (la broche + de la LED... la PLUS longue).

Connectez ensuite la cathode de la LED (la broche "-" de la LED... la MOINS longue broche) sur la masse/GND/ground.

{{{2}}}
Crédit: MicroPython micropython.org

Selection du Timer et Channel

Dans l'exemple ci-dessous, nous allons travailler avec la broche X1.

Il nous faut donc sélectionner le Timer et Channel permettant de générer le signal.

En examinant le graphique de référence de la carte PyBoard (ci-dessous), nous pouvons constater que la broche X1 est est connectée sur le canal 1 ( dit channel 1) du Timer 5. Regarder le graphique, vous noterez la terminologie TIM5 CH1 pour X1.

Pybv10-pinout.jpg
Crédit: MicroPython micropython.org

Par conséquent, nous allons d'abord créer un objet Timer pour le timer 5 PUIS nous allons créer un objet TimerChannel pour le canal 1:

from pyb import Timer
from time import sleep

# Le timer 5 sera créer à une fréquence de 100 Hz
tim = pyb.Timer(5, freq=100)
tchannel = tim.channel(1, Timer.PWM, pin=pyb.Pin.board.X1, pulse_width=0)

Code - En largeur d'impulsion

La luminosité de la LED est contrôlée par la largeur d'impulsion du signal PWM, cela correspond à la quantité de temps durant laquelle la LED est allumée durant chaque cycle PWM.

Avec le timer à une fréquence de 100 Hz, chaque cycle est prends 0.01 seconde (ou 10 millisecondes).

Pour réaliser l'effet d'allumage progressif, nous avons besoin d'initialiser la largeur d'impulsion à une petite valeur, puis doucement accroitre la largeur d'impulsion pour augmenter la luminosité. Ensuite, nous recommençons le cycle lorsque nous aurons atteint un maximum de luminosité:

# maximum et minimum de largeur d'impulsion, qui correspond
# au maximum et minimum de luminosité
max_width = 200000
min_width = 20000

# De combien faut il augmenter la largeur d'impulsion
# à chaque étape
wstep = 1500


cur_width = min_width
while True:
  # Appliquer la largeur d'implusion sur le Canal PWM
  tchannel.pulse_width(cur_width)

  # Faire une pause de 0.01 seconde.
  # Ceci détermine le fréquence de modification de la largeur d'impulsion.
  # C'est assez analogue à la notion d'images-par-seconde (frames-per-second)
  sleep(0.01)

  # Augmenter la largeur d'impulsion
  cur_width += wstep

  if cur_width > max_width:
    cur_width = min_width

Effet de battement

Nous allons nous pencher sur l'effet de battement. Effet où la LED s'éclaire progressivement jusqu'à son maximum de luminosité puis diminue progressivement jusqu'a son minimum et recommence le cycle.

Pour atteindre cet effet, nous avons besoin d'inverser le signe de wstep lorsque la luminosité atteint son maximum, et ré-inverser une nouvelle fois au minimum de luminosité. Il suffit alors de modifier la boucle while pour qu'elle ressemble à ceci:

while True:
  tchannel.pulse_width(cur_width)

  sleep(0.01)

  cur_width += wstep

  if cur_width > max_width:
    cur_width = max_width
    # Si on atteint le maximum, on passe en pas
    # négatif.
    wstep *= -1
  elif cur_width < min_width:
    cur_width = min_width
    # Si on atteint le minimum, on repasse en pas
    # positif.
    wstep *= -1

Code - PWM en pourcent

La luminosité de la LED est contrôlée par la largeur d'impulsion du signal PWM, cela correspond à la quantité de temps durant laquelle la LED est allumée durant chaque cycle PWM.

Avec le timer à une fréquence de 100 Hz, chaque cycle est prends 0.01 seconde (ou 10 millisecondes).

Pour réaliser l'effet d'allumage progressif, nous avons besoin d'initialiser la largeur d'impulsion à une petite valeur, puis doucement accroitre la largeur d'impulsion pour augmenter la luminosité. Ensuite, nous recommençons le cycle lorsque nous aurons atteint un maximum de luminosité:

from pyb import Timer,delay

# Le timer 5 sera créer à une fréquence de 100 Hz
tim = pyb.Timer(5, freq=100)
tchannel = tim.channel(1, Timer.PWM, pin=pyb.Pin.board.X1, pulse_width_percent=100 )

for i in range( 0, 100 ):
    tchannel.pulse_width_percent( i )
    delay( 250 ) # attendre 250 ms

Exercice avancé

Vous avez peut-être remarqué que la luminosité de la LED semble décroître lentement, mais qu'elle augmente rapidement. C'est parce que nos yeux évalue la luminosité de façon logarithmique (la loi de Weber-Fechner impliquée dans le seuil de discrimination). Tandis que la luminosité change linéairement, de la même quantité à chaque fois.

Comment résoudre ce problème (truc: c'est quoi l'opposé d'une fonction logarithmique?)

Addendum

Nous pouvons également utiliser un convertisseur DAC (digital-to-analog converter, convertisseur digital vers analogique) pour atteindre le même effet avec d'autres périphériques. La méthode PWM à l'avantage de piloter la LED avec le même courant à chaque fois mais avec une longueur de temps différente. Cela permet un meilleur contrôle de la luminosité, parce que les LEDs ne dispose pas nécessairement d'une relation linéaire entre le courant de fonctionnement et la luminosité.



Source: Fading leds écrit par/written by Damien P.George

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

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

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.