Dans cet article nous allons faire varier la puissance électrique d’une via le Raspberry. Le principe de fonctionnement peut permettre de contrôler par exemple l’intensité d’une lampe ou la vitesse d’un moteur.

Normalement pour effectuer cette tache nous devrions faire varier le courant ou l’intensité dans sur la charge. Seulement voila, avec un Rpi capable uniquement d’envoyer un signale en tout ou rien comment on fait? La réponse la voici : utiliser les deux états de façon alterné et répété. Cette technique se nomme le PWM pour Pulse Width Modulation, ce qui donne modulation de largeur d’impulsion en frenchy.

Sommaire

Principe de fonctionnement

Name: Tremplin Numérique
Price range: $$$

La modulation de largeur d’impulsions est une technique couramment utilisée pour synthétiser des signaux continus à l’aide de circuits à fonctionnement tout ou rien. Le principe général est qu’en appliquant une succession d’impulsion (passage de l’état 0 à 1) pendant des durées bien choisies, on peut obtenir en moyenne sur une certaine durée n’importe quelle valeur intermédiaire.

Ce principe repose sur deux paramètres:

La fréquence (période)
Le rapport cyclique

PWM_parametres

La fréquence (ou période) est le nombre de fois par seconde ou l’impulsion est générée. Cela se compte entre le moment du début d’une impulsion et le début de la suivante. L’unité de la fréquence est le Hertz (Hz). Le hertz est une pulsation par seconde. Par exemple 50 Hz correspond à 50 impulsions en une secondes, se qui donne une impulsion toute les 0.02 secondes.

Le rapport cyclique est le pourcentage de temps ou le signal est en position 1 pendant le cycle.

Par exemple une fréquence de 50 Hz et un rapport cyclique de 50% signifie que toutes les 0.02 secondes le signal sera à 1 (high) pendant la moitié du temps et à 0 (LOW) pendant l’autre moitié.

fivty_percent

50 Hertz et cycle de 50%

Pour une fréquence de 50 Hz et un rapport cyclique de 80% le signal sera à 1(HIGH) pendant 80% du temps du cycle de 0.02 secondes.

eighty_percent

50 Hertz et cycle de 80%

Test avec une LED

Bon la théorie c’est cool mais le plus fun c’est bien la pratique ! Pour un premier test vous aurez besoin d’une LED et d’une résistance de 10 Ohm pour protéger cette dernière. Le courant max d’une broche GPIO d’un Raspberry ne dépasse pas 16 mA. Sur la grande majorité des LED le courant supporté est de 20 mA. La résistance ne devrais donc pas être nécessaire mais ça protège quand même. A vous de voir. La formule de calcul est la suivante (si vous avez la documentation de votre LED).

Résistance = (Tension d’alimentation – Tension de LED) / Courant max LED

Le circuit est le suivant:

schema_test_rpi_del

Pour la suite je suppose que vous avez installé la librairie python permettant le contrôle des ports GPIO. Si ce n’est pas le cas je vous renvoie vers cet article.

Clignotement d’une LED

On va commencer par un simple clignotement de la LED. Le code suivant permet de faire clignoter la LED pendant 50% du temps de chaque période. Les périodes durent 0.5 Hz soit une période toutes les 2 secondes. Les commentaires devraient suffire à la compréhension du code.

<br /><br />
#!/usr/bin/env python</p><br />
<p>import RPi.GPIO as GPIO<br /><br />
GPIO.setmode(GPIO.BCM)<br /><br />
GPIO.setup(4, GPIO.OUT)</p><br />
<p>#0.5 Hz = 1 fois toutes les deux secondes<br /><br />
p = GPIO.PWM(4, 0.5)<br /><br />
# cycle = 50%<br /><br />
p.start(50)<br /><br />
# une touche pour quitter le programme.<br /><br />
input(‘Appuyez sur une touche pour stopper’)<br /><br />
# La fonction input est bloquante. Si on arrive ici alors on peut fermer le programme<br /><br />
p.stop()<br /><br />
GPIO.cleanup()

#!/usr/bin/env python

import RPi.GPIO as GPIO

GPIO.setmode(GPIO.BCM)

GPIO.setup(4, GPIO.OUT)

#0.5 Hz = 1 fois toutes les deux secondes

p = GPIO.PWM(4, 0.5)

# cycle = 50%

p.start(50)

# une touche pour quitter le programme.

input(‘Appuyez sur une touche pour stopper’)

# La fonction input est bloquante. Si on arrive ici alors on peut fermer le programme

p.stop()

GPIO.cleanup()

Clignotement d’une LED avec variation d’intensité

Dans l’exemple suivant nous allons faire clignoter la LED mais cette fois en contrôlant son niveau d’intensité grâce au rapport de cycle.

<br /><br />
#!/usr/bin/env python</p><br />
<p>import RPi.GPIO as GPIO<br /><br />
import time</p><br />
<p>GPIO.setmode(GPIO.BCM)<br /><br />
GPIO.setup(4, GPIO.OUT)</p><br />
<p># creation d’un objet PWM. canal=4 frequence=50Hz<br /><br />
LED = GPIO.PWM(4, 50)</p><br />
<p># demarrage du PWM avec un cycle a 0 (LED off)<br /><br />
LED.start(0)</p><br />
<p># On fait varier le rapport cyclique de 0 a 100 puis de 100 a 0<br /><br />
try:<br /><br />
    while 1:<br /><br />
        for dc in range(0, 101, 1):<br /><br />
            LED.ChangeDutyCycle(dc)<br /><br />
            time.sleep(0.01)<br /><br />
        for dc in range(100, -1, -1):<br /><br />
            LED.ChangeDutyCycle(dc)<br /><br />
            time.sleep(0.01)<br /><br />
except KeyboardInterrupt:<br /><br />
    pass<br /><br />
p.stop()<br /><br />
GPIO.cleanup()

#!/usr/bin/env python

import RPi.GPIO as GPIO

import time

GPIO.setmode(GPIO.BCM)

GPIO.setup(4, GPIO.OUT)

# creation d’un objet PWM. canal=4 frequence=50Hz

LED = GPIO.PWM(4, 50)

# demarrage du PWM avec un cycle a 0 (LED off)

LED.start(0)

# On fait varier le rapport cyclique de 0 a 100 puis de 100 a 0

try:

while 1:

for dc in range(0, 101, 1):

LED.ChangeDutyCycle(dc)

time.sleep(0.01)

for dc in range(100, –1, –1):

LED.ChangeDutyCycle(dc)

time.sleep(0.01)

except KeyboardInterrupt:

pass

p.stop()

GPIO.cleanup()

Variation de vitesse d’un moteur via Raspberry

Les ports GPIO du Rapsberry n’envoient qu’un signal de 3,3 V. Alors comment faire varier la puissance d’une charge nécessitant bien plus que ces 3,3V comme par exemple un moteur ? Pour cela nous allons utiliser un composant qui fonctionne comme un interupteur que l’on appel MOSFET. Un MOSFET est un composant électronique permettant de faire de la commande en puissance. Le principe du fonctionnement de ce type de transistor est que lorsque la tension de la Gate atteint une valeur suffisante, le courant passe entre le Drain et la Source. Certains transistors sont commandés en courant, le Mosfet est commandé en tension.

schema_MOSFET

1 = G = GATE : broche de commande. La commande ici sera le port GPIO.
2 = D = DRAIN : broche qui draine le courant (la charge quoi… c’est ici que l’on va raccorder notre moteur)
3 = S = SOURCE : broche source de courant (ou le courant est collecté pour être envoyé vers la charge… dans notre cas, il s’agit de la masse)

Donc le MOSFET permet de séparer le circuit ou ce trouve nôtre charge du circuit de commande, en l’occurrence le Rpi.

Voila le schéma avec un moteur éclectique et une alimentation sur batterie de 12V.

moteur_raspberry

Le code à utiliser est exactement le même que pour le clignotement de la LED avec avec variation d’intensité.

Vous n’avez pas de moteur ou d’alimentation sous la main? Vous pouvez essayer le circuit avec le Rpi. Pour cela il vous faut une LED et une résistance cette fois de 100 Ohm car nous allons utiliser la source Vcc 5v dur Rpi pour le circuit de test.

Matériel nécessaire pour tester:

LED
Résitance de 100 Ohm
MOSFET

Sur le circuit ci dessous, la source Vcc 5v du Rpi passe dans la résistance de 100 Ohm de façon à limiter le courant, puis dans la LED et enfin se branche au drain du MOSFET. Le port GPIO 4 permet, comme pour le circuit précédent de commander le MOSFET sur la gate.

raspberry_pwm

La encore, le code à utiliser est exactement le même que pour le clignotement de la LED avec variation d’intensité.