<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/fr/blog/raspberry-pi/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Flux Atom</title>
    <id>https://funduinoshop.com/fr/blog/raspberry-pi/?sRss=1</id>
    <updated>2026-04-13T17:17:52+02:00</updated>
    
        <entry>
            <title type="text">Bouton-poussoir sur le Raspberry Pi</title>
            <id>https://funduinoshop.com/fr/bouton-poussoir-sur-le-raspberry-pi</id>
            <link href="https://funduinoshop.com/fr/bouton-poussoir-sur-le-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            Dans les premiers exemples, nous avons connu les broches GPIO comme des sorties que nous avons commutées sur HIGH pour faire briller une LED. Mais GPIO signifie General Purpose Input/Output. Tu peux donc aussi utiliser les broches comme entrée...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Dans les premiers exemples, nous avons connu les broches GPIO comme des sorties que nous avons commutées sur HIGH pour faire briller une LED. Mais GPIO signifie General Purpose Input/Output. Tu peux donc aussi programmer les broches comme entrée. On peut alors déterminer s&#039;il y a une tension à l&#039;entrée (HIGH) ou non (LOW). Le Raspberry Pi n&#039;a que des entrées numériques (nous verrons plus tard comment mesurer les tensions analogiques), mais la tension présente ne doit pas être exactement de 3,3V pour être reconnue comme HIGH, et pas de 0V pour être reconnue comme LOW. Jusqu&#039;à environ 1,4V, il est reconnu comme LOW, tout ce qui est supérieur à 1,9V est certainement reconnu comme HIGH. Seule la petite zone autour de ½ de 3,3V et une broche libre à laquelle rien n&#039;est connecté posent problème.  
  Nous allons découvrir plusieurs capteurs numériques qui doivent déclencher une alarme ou une action spécifique dans notre programme (par exemple, les détecteurs de mouvement). Le plus simple de ces capteurs est le bouton (angl. button), un interrupteur à ressort qui ferme un circuit lorsqu&#039;on appuie sur le bouton et l&#039;ouvre à nouveau lorsqu&#039;on le relâche.  
  Si nous connectons un contact du bouton à une broche GPIO et l&#039;autre à 3,3V, le signal HIGH est clairement détecté lorsque le bouton est appuyé. Le problème commence après le relâchement du bouton. Quel est alors l&#039;état du GPIO ? Un état indéfini ! On ne peut pas programmer avec ça. Dans l&#039;état éteint, le GPIO devrait donc être en permanence sur le potentiel GND. Mais cela provoquerait un court-circuit lorsque le bouton est appuyé. Pour y remédier, il faut une résistance suffisamment grande pour que seul un petit courant circule. Les résistances habituelles sont de 4,7 k&amp;nbsp;(=4700 ohms) ou de 10 kΩ&amp;nbsp;(=10 000 ohms). On appelle ces résistances des résistances pull-down.  
  Mais tu peux aussi programmer le GPIO de manière à ce qu&#039;il indique normalement HIGH et qu&#039;il reconnaisse la pression de la touche vers GND comme un changement vers LOW. La résistance est alors appelée résistance pull-up. Et pour rendre le tout encore plus confus pour les débutants, les GPIO Raspberry Pi ont une résistance interne Pull-up ou Pull-down qui peut être activée ou désactivée dans le programme. Heureusement, les premiers circuits deviennent ainsi très simples.  
  Le schéma de câblage : Bouton-poussoir sur le Raspberry Pi  
     
     
  Le code du programme : Bouton-poussoir sur le Raspberry Pi  
  from gpiozero import LED, bouton
from signal import pause
led = LED (12 )
 button  = bouton (16 )
 button  .when_pressed  = led .on 
 button  .when_released  = led .off 
  pause  ()    
   A partir du module gpiozero, les classes LED et bouton sont importées, séparées par une virgule, puis les objets led et button sont instanciés avec les numéros GPIO respectifs.     Au lieu de la    sleep()   -Fonction du module    time   &amp;nbsp;on utilise    pause   &amp;nbsp;du module    signal   &amp;nbsp;sleep() signifierait un arrêt complet, la pression sur la touche ne serait pas remarquée pendant ce temps. Sans pause(), le programme se terminerait et plus rien ne se passerait.     L&#039;instanciation de button a été très simple, car nous n&#039;avons indiqué que le numéro GPIO et avons utilisé les paramètres par défaut (voir la définition de la classe à la ligne suivante). Pour ceux qui souhaitent s&#039;en écarter, il faut ajouter des paramètres supplémentaires sous forme d&#039;arguments de mots-clés.   
   class  gpiozero .bouton  (pin , *,  pull_up=True ,  active_state=None ,  bounce_time=None ,
 hold_time=1 ,  hold_repeat=False ,  pin_factory=None )  
   Pour plus de détails sur gpiozero, voir      ici     .    
  Extension de la structure expérimentale : un cycle de feux de signalisation doit être lancé avec un Raspberry Pi lorsqu&#039;un bouton est actionné.  
  La construction expérimentale s&#039;inspire du premier exemple. Au lieu d&#039;une LED, on utilise un feu de signalisation LED. Celle-ci a des résistances intégrées. Nous instancions trois objets LED et définissions une fonction trafficLight qui est appelée lorsqu&#039;un bouton est appuyé.  
  Le code du programme : Cycle de feux de signalisation sur Raspberry Pi   
  from gpiozero  import  LED, bouton
from signal  import  pause
from time  import  sleep
redled = LED (16 )
yellowled = LED (20 )
greenled = LED (21 )
button = bouton (12 )
def trafficLight() :
       redled.on()
    sleep(1)
    yellowled.on()
    sleep(1)
    greenled.on()
    redled.off()
    yellowled.off()
    sleep(1)
    yellowled.on()
    greenled.off()
    sleep(1)
    redled.on()
    yellowled.off()
    sleep(1)
    redled.off()
button.when_pressed = trafficLight
pause()  
  Extension : jeu de réaction avec deux boutons sur Raspberry Pi  
   Tu as besoin de deux boutons, d&#039;un buzzer ainsi que d&#039;une LED rouge et d&#039;une jaune. Après le lancement du Reaction Game, c&#039;est d&#039;abord la LED jaune qui s&#039;allume. Avec    time = uniform(5, 10)   &amp;nbsp;après un temps aléatoire entre cinq et dix secondes, la LED rouge s&#039;allume. Ensuite, deux joueurs peuvent chacun appuyer sur leur bouton le plus rapidement possible. Celui qui appuie trop tôt est pris en flagrant délit de triche, le buzzer retentit pendant une demi-seconde.   
  Le code du programme : Cible de réaction avec deux boutons sur Raspberry Pi   
   # ! /usr/bin/python3 
 # Jeu de réaction - push button, quand la LED rouge s&#039;allume 
 # based on gpiozero documentation, Basic Recipes 
 # amélioré pour reconnaître les tricheries par Bernd Albrecht 
 # Red LED lights-up 5 - 10 sec after the yellow LED 
 from  gpiozero  import  bouton, LED, buzzer
 from  time  import  sleep
 from  random  import  uniform
 from  sys  import  exit
led_red = LED (16 )
led_yellow = LED (20 )
buzzer = buzzer (12 )
player_1 = bouton (23 )
player_2 = bouton (18 )

led_yellow .on ()
time = uniform (5 ,  10 )
sleep(temps)
 if  player_1.is_pressed :
    print ( &quot;Player 1 is cheating !&quot; )
    buzzer .on ()
    sleep (0.5 )
    buzzer .off ()
    led_yellow .off ()
    exit()
 if  player_2.is_pressed :
    print ( &quot;Player 2 is cheating !&quot; )
    buzzer .on ()
    sleep (0.5 )
    buzzer .off ()
    led_yellow .off ()
    exit()
led_red .on ()
led_yellow .off ()
 while  True :
    if  player_1.is_pressed :
        print ( &quot;Player 1 wins !&quot; )
        break 
    if  player_2.is_pressed :
        print ( &quot;Player 2 wins !&quot; )
        break 
led_red .off ()  
                ]]>
            </content>

                            <updated>2022-07-27T14:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED RGB sur Raspberry Pi</title>
            <id>https://funduinoshop.com/fr/led-rgb-sur-raspberry-pi</id>
            <link href="https://funduinoshop.com/fr/led-rgb-sur-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                             Une LED RGB est la réunion de trois LED de couleurs différentes dans un seul boîtier. Derrière le terme RGB se cachent les couleurs &quot;rouge&quot;, &quot;vert&quot; et &quot;bleu&quot;. Les LED respectives peuvent être activées par modulation de largeur d&#039;impulsion (PWM)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Piloter une LED RGB avec un microcontrôleur Raspberry Pi 
 Qu&#039;est-ce qu&#039;une LED RGB au juste ? 
 Une LED RGB est la réunion de trois LED de couleurs différentes dans un même boîtier. Derrière le terme RGB se cachent les couleurs &quot;rouge&quot;, &quot;vert&quot; et &quot;bleu&quot;. Les LED respectives peuvent être activées par modulation de largeur d&#039;impulsion (PWM). Ainsi, une multitude de combinaisons de couleurs est possible. 
 Une LED RGB a quatre pattes, une pour chaque couleur et une commune pour les trois couleurs. La plus longue des quatre pattes est, selon la version, l&#039;anode (+) ou la cathode (-) commune. La petite jambe à côté de la plus longue est la connexion pour la partie rouge. Les parties vertes et bleues sont commandées par les pattes situées de l&#039;autre côté.    
 Le type de LED RGB que tu as, anode commune ou cathode commune, n&#039;est pas reconnaissable à l&#039;œil nu. Heureusement, tu ne peux rien endommager en essayant. La LED RGB ne s&#039;allume pas dans le sens du blocage. Important : les trois LED implémentées ont également besoin de résistances. Si tu veux faire une étude académique, tu peux calculer différentes résistances à partir des tensions de flux respectives. Pour plus de simplicité, tu peux aussi prendre des résistances identiques entre 100 et 330 Ω (ohms). 
 Version a : &quot;Common cathode&quot; - la patte la plus longue de la LED est &quot;-&quot; et les trois pattes les plus courtes sont commandées sur les GPIO avec &amp;nbsp;&quot;+&quot; (tension). 
 Version b) &quot;Anode commune&quot; - La plus longue patte de la LED est &quot;+&quot; et les trois pattes les plus courtes sont commandées par &quot;-&quot; (GND) sur les GPIO. 
 En mélangeant les couleurs, il est possible de créer de nombreuses autres couleurs. Par exemple, en activant les couleurs &quot;bleu&quot; et &quot;vert&quot;, on obtient la couleur &quot;turquoise&quot;, le rouge et le vert donnent le jaune, le rouge et le bleu donnent le magenta, et les trois couleurs avec la même proportion donnent le blanc. 
       Le schéma de câblage : LED RGB sur Raspberry Pi   
 Le code du programme : LED RGB sur Raspberry Pi 
 Exemple de programme pour une LED RGB avec une cathode commune : 
 from gpiozero  import  RGBLED
from time  import  sleep
 led  = RGBLED (red=14,   green=15,   blue=18) 
 durée  =  2 

 # augmenter lentement l&#039;intensité de toutes les couleurs (5sec) 
for n  in  range (100 ) :
    led .blue  =  n/100 
    led .red  =  n/100 
    led .green  =  n/100    
    sleep (0.05 )
led .color  = (0 ,  0 ,  0 )  # off 
sleep(durée)
led .red  =  1   # full red 
sleep(durée)
led .red  =  0.5   # moitié du rouge 
sleep(durée)
led .color  = (1 ,  1 ,  0 )  # jaune 
sleep(duration)
led .color  = (0 ,  1 ,  0 )  # full green 
sleep(durée)
led .color  = (0 ,  1 ,  1 )  # cyan 
sleep(durée)
led .color  = (0 ,  0 ,  1 )  # full blue 
sleep(durée)
led .color  = (1 ,  0 ,  1 )  # magenta 
sleep(durée)
led .color  = (1 ,  1 ,  1 )  # blanc 
sleep(durée)
led .color  = (0 ,  0 ,  0 )  # off 
sleep(duration) 
 Plus tard, nous verrons comment définir les parts de couleur à l&#039;aide de trois potentiomètres. Mais pour cela, nous avons besoin d&#039;un convertisseur analogique-numérique externe, car le Raspberry Pi ne connaît que les signaux numériques - HIGH ou LOW. 
    
                ]]>
            </content>

                            <updated>2022-07-19T09:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED pulsée sur Raspberry Pi (modulation de largeur d&#039;impulsion)</title>
            <id>https://funduinoshop.com/fr/led-pulsee-sur-raspberry-pi-modulation-de-largeur-d-impulsion</id>
            <link href="https://funduinoshop.com/fr/led-pulsee-sur-raspberry-pi-modulation-de-largeur-d-impulsion"/>
            <summary type="html">
                <![CDATA[
                
                                            Une LED doit s&#039;éclaircir et s&#039;assombrir par pulsations. (On parle aussi de &quot;fading&quot;, d&#039;après le verbe anglais to fade= diminuer, s&#039;atténuer). Nous voulons réaliser cela avec ce que l&#039;on appelle la modulation de largeur d&#039;impulsion...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Une LED doit s&#039;éclaircir et s&#039;assombrir par pulsations. (On parle aussi de &quot; fading &quot;, d&#039;après le verbe anglais  to fade  = s&#039;estomper, diminuer). Nous voulons réaliser cela avec ce que l&#039;on appelle la modulation de largeur d&#039;impulsion. Tu trouveras plus d&#039;informations sur la modulation de largeur d&#039;impulsion sur Raspberry Pi un peu plus loin.  Dans un premier temps, nous allons regarder le schéma électrique. 
 Le schéma de câblage : LED à impulsions sur Raspberry Pi (PWM) 
   
  Pour faire varier la luminosité d&#039;une LED, il ne suffit pas de faire varier la tension. En raison de sa conception (diode !), une certaine tension minimale est nécessaire ; cette tension dite de flux (en anglais forward voltage) se situe entre environ 1,6 et environ 3 V, en fonction de la couleur de la LED. Au-dessus de cette tension de flux, la LED devient conductrice, le courant est limité par une résistance en série. Donc, contrairement aux lampes à incandescence, la luminosité n&#039;est pas régulée par la hauteur de la tension. D&#039;ailleurs, les broches GPIO ne fournissent de toute façon que 3,3V. 
 La modulation de largeur d&#039;impulsion (PWM) permet d&#039;y remédier. Pour cela, la tension continue est activée et désactivée à haute fréquence. L&#039;énergie totale transmise est déterminée par le rapport entre la durée d&#039;activation et la durée totale d&#039;un cycle. Ce cycle d&#039;utilisation (duty cycle en anglais) peut être compris entre 0 et 100%. 
 Sur le Raspberry Pi, tu peux utiliser le logiciel PWM sur toutes les broches GPIO. Mais il existe aussi deux broches PWM matérielles spéciales. C&#039;est parti ! 
 Le premier code de programme : LED pulsée sur Raspberry Pi avec modulation de largeur d&#039;impulsion 
  # Nous commençons par importer les modules du programme 
import RPi.GPIO as GPIO  # attention : respecter l&#039;orthographe : petit i 
import  time 
GPIO.setmode(GPIO.BCM)  # Nous réglons le mode sur BCM 
 LED=23   # Le mot &quot;LED&quot; représente maintenant le nombre &quot; 23 &quot;. 
GPIO.setup(LED,GPIO.OUT) # &quot;  LED&quot; (broche  23 ) est une sortie. 
Dimmer = GPIO.PWM(LED ,100 )  # Nous définissons la LED comme PWM avec une fréquence de  100  
Dimmer.start (0 )  # Le variateur est lancé 
 # C&#039;est ici que la boucle commence 
 try :
    while   True :  #boucle while pour que le programme fonctionne en continu 
        for  dc  in  range (0  ,101  ,5 ) :          # Boucle du cycle de service par  incréments de 5 . 
             Dimmer.ChangeDutyCycle(dc)  # Modifier le niveau d&#039;utilisation du variateur. 
            time  .sleep  (0.1 )  # Attends  0.1  seconde. 
        for  dc  in  range (100 , -1 , -5 ) :      # Boucle du cycle de service par incréments de  -5 . 
            Dimmer.ChangeDutyCycle(dc)  # Modifier le cycle de service du variateur. 
            time  .sleep  (0.1 )  # Attendre  0.1  seconde. 
except KeyboardInterrupt :  # Avec CTRL+C, nous interrompons le programme 
    print (&quot;Terminé&quot;)  # Ecris &quot;Terminé&quot; dans la fenêtre du shell 
    Dimmer .stop ()  # Arrêt du variateur. 
    GPIO.cleanup()  # Terminer le programme.  
 Dans cet exemple, nous apprenons à connaître une autre forme de boucle : tu peux faire une boucle for. Cette ligne de commande se termine également par un deux-points suivi d&#039;une indentation (en anglais) des lignes à répéter. 
 La variable dc (pour duty cycle) est augmentée dans la plage de 0 à l&#039;exclusion de 101 par incréments de cinq :  for dc in range(0,101,5) :  
 Dans la deuxième boucle for, on compte à rebours de -5 de 100 à -1 exclusivement :  for dc in range(100,-1,-5) :  
 Le deuxième code de programme : LED pulsée sur Raspberry Pi avec modulation de largeur d&#039;impulsion avec la commande gpiozero    
 # Nous commençons par importer les modules du programme
from gpiozero import PWMLED
import time
pwmled = PWMLED (23 ) #  paramètre  optionnel frequency=xxx  (default 100) 

# C&#039;est ici  que la boucle commence 
try :
    while  True : # boucle while pour que le programme  fonctionne   en continu 
        for  dc in range(0,101,5) :   # Incrémenter  le niveau de la tâche par incréments de 5. 
            pwmled.value  = (  dc/100 ) # Modifier le niveau d&#039;utilisation (entre  0  et  1 ) du variateur.
            time .sleep  (0.1 ) # Attends  0.1  seconde.
        for  dc in range (100  ,-1  ,-5 ) : # Décompte de la vitesse de détection par incréments   de -5 .
            pwmled.value = (dc/100 ) #  Modifier le niveau d&#039;utilisation (entre 0 et 1) du variateur. 
            time.sleep(0.1) # Attends  0.1 seconde. 

except  KeyboardInterrupt : # Avec CTRL+C, nous interrompons le programme 
    print  (  &quot;Terminé&quot;  ) # Ecris  &quot; Terminé &quot;  dans la fenêtre du shell 
# pwmled.value  = 0 # 1ère méthode pour effacer  la LED à la fin du programme 
    pwmled.close()  # 2ème méthode d&#039;effacement  de la LED à la fin du programme  
 Dans l&#039;ensemble, le code du programme est plus léger avec gpiozero. 
 Attention à ne pas oublier : Le degré de marche est compris entre 0 et 100%. Alors que l&#039;argument pour le taux d&#039;utilisation dans RPi.GPIO est la valeur en %, gpiozero attend la valeur comme un nombre à virgule flottante (en anglais floating  point &amp;nbsp;number) entre 0.0 et 1. 0, donc au lieu de 50 [%] 0.5. 
                ]]>
            </content>

                            <updated>2022-06-17T10:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Connecter le buzzer et la LED au Raspberry Pi</title>
            <id>https://funduinoshop.com/fr/connecter-le-buzzer-et-la-led-au-raspberry-pi</id>
            <link href="https://funduinoshop.com/fr/connecter-le-buzzer-et-la-led-au-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            Dans cet article, nous voulons faire s&#039;allumer un buzzer et une LED à l&#039;aide d&#039;un microcontrôleur Raspberry Pi. Ce programme est souvent utilisé dans les écoles pour montrer...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Remarque : pour ce programme, un buzzer actif est nécessaire (explication plus tard), il faut faire attention à la polarité. Aucune résistance en série n&#039;est nécessaire pour le buzzer (haut-parleur). 
 Dans ce blog, nous voulons faire s&#039;allumer ou sonner un buzzer et une LED à l&#039;aide d&#039;un microcontrôleur Raspberry Pi. Ce programme est souvent utilisé dans les écoles pour montrer comment des signaux de sortie simples peuvent être exploités avec des composants simples en utilisant un Raspberry Pi.  Avant d&#039;aborder la question de la différence entre un haut-parleur actif et un haut-parleur passif, nous allons d&#039;abord regarder le schéma et le code du programme. 
 Le schéma de câblage : Connecter le buzzer et la LED au Raspberry Pi 
   
 Le code source : Connecter le buzzer et la LED au Raspberry Pi 
  # Cette fois-ci, nous utilisons aussi la première section du programme. C&#039;est ici que les variables sont inscrites. Cela signifie que derrière une lettre ou un mot se cache un chiffre. Dans notre cas, la LED est connectée à la broche 23 et le haut-parleur piézo à la broche 4. Pour ne pas confondre les deux broches par la suite, nous renommerons simplement la broche 23 et la broche 24. 
 # Nous commençons par importer les modules du programme 
 import  RPI.GPIO  as  GPIO
 import  time
GPIO.setmode(GPIO.BCM)  # Nous réglons le mode sur BCM 
 LED=23 ;  # Le mot &quot;LED&quot; représente maintenant le nombre &quot;23&quot;. 
 Pieps=24   # Le mot &quot;Pieps&quot; représente maintenant le nombre &quot;24&quot;. 
GPIO.setup(LED,GPIO.OUT)  # La broche &quot;LED&quot; (broche 23) est une sortie. 
GPIO.setup(Pieps,GPIO.OUT)  # La broche &quot;Pieps&quot; (broche 24) est une sortie 
 # Ici commence la boucle 
 try :
 while   True :  # Boucle While pour que le programme fonctionne en continu 
GPIO.output(LED,GPIO.HIGH)  # Allume la LED. 
GPIO.output(Pieps,GPIO.HIGH)  # Allume le haut-parleur piézo .
time.sleep (1 )  # Attendre 1 seconde 
GPIO.output(LED,GPIO.LOW)  # Eteint la LED .
GPIO.output(Pieps,GPIO.LOW)  # Eteint le haut-parleur piézo .
time.sleep (1 )
 # Ici, à la fin, le programme saute au début de la boucle while. Il va donc bientôt recommencer à biper et à briller. Si tu réduis ou augmentes la pause (time.sleep),il bipe et s&#039;allume plus rapidement ou plus lentement. 
 except  KeyboardInterrupt :  # Avec CTRL+C, nous interrompons le programme 
 print  (&quot;Terminé&quot;)  # Ecris &quot;Terminé&quot; dans la fenêtre du shell 
GPIO.cleanup()  # Terminer le programme  
 Différence entre buzzers actifs et passifs 
 Le buzzer actif a un circuit électronique oscillant intégré (oscillateur) qui produit un son de buzz (en anglais  to buzz, bour donnement) lorsqu&#039;il est soumis à une tension de 3,3V ou 5V. De par sa conception, il faut donc faire attention à la polarité du buzzer. A la livraison, ces buzzers ont généralement un petit autocollant avec le signe plus et l&#039;autocollant &quot;REMOVE SEAL AFTER WASHING&quot;. Sur le boîtier du composant lui-même, on trouve également un plus + à nouveau. Pour voir la jambe la plus longue, il faut y regarder à deux fois. Ou alors, tu peux utiliser un petit panneau de montage, les contacts sont marqués S (pour signal) et - (moins, terre).&amp;nbsp; 
 Tu peux essayer le buzzer avec un programme simple comme pour la LED clignotante, en commutant la broche (presque) quelconque une seconde sur HIGH et une seconde sur LOW. 
 Le buzzer passif n&#039;a pas d&#039;oscillateur intégré, c&#039;est pourquoi le Raspberry Pi doit prendre en charge cette fonction. Si l&#039;on essaie le programme ci-dessus sur un buzzer passif, on entend un léger &quot;clic&quot; toutes les secondes. Mais si l&#039;on réduit extrêmement le temps de pause (sleep(0.001) ou sleep(0.002)) et que l&#039;on répète l&#039;allumage et l&#039;extinction pendant une certaine durée, on peut entendre un son dont nous pouvons facilement calculer la fréquence : chaque milliseconde HIGH ou LOW signifie (en négligeant le temps d&#039;exécution des autres commandes) environ 500 cycles on/off par seconde, soit environ 500Hz. 
 Si l&#039;on souhaite émettre un court son d&#039;avertissement, il faut utiliser un buzzer actif qui s&#039;allume et s&#039;éteint comme une LED. Il faut faire attention à la polarité. 
 Si tu veux programmer une sirène à deux tons (que l&#039;on entend plus clairement) ou une courte mélodie de reconnaissance (jingle), tu devrais utiliser un buzzer passif ou un petit haut-parleur. 
    
 &amp;nbsp; 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2022-06-15T15:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Alternance de LEDs clignotantes sur le microcontrôleur Raspberry Pi</title>
            <id>https://funduinoshop.com/fr/alternance-de-leds-clignotantes-sur-le-microcontroleur-raspberry-pi</id>
            <link href="https://funduinoshop.com/fr/alternance-de-leds-clignotantes-sur-le-microcontroleur-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            Tu peux aussi connecter les composants électroniques sur la breadboard sans T-cobbler. Mais dans ce cas, tu as besoin de câbles enfichables (en anglais jumper wire) de type femelle - mâle pour la connexion à la barrette de connexion J6 du Raspberry Pi...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Comment faire clignoter deux LED en alternance sur le Raspberry Pi ? 
 Il est possible de connecter les composants électroniques sur la breadboard sans T-cobbler. Dans ce cas, tu as besoin d&#039;un câble jumper de type femelle - mâle pour la connexion au connecteur J6 du Raspberry Pi, c&#039;est-à-dire une prise pour le Raspberry Pi et une prise pour le breadboard. 
   
  Le code du programme (LED clignotant en alternance sur le Raspberry Pi)   
  # A partir d&#039;ici, le code peut être copié directement dans le logiciel Python. 
 # En noir, en couleur = code et en gris = explications 
 #Nous commençons par importer les modules du programme 
import RPI.GPIO  as  GPIO
import  time 
GPIO.setmode(GPIO.BCM)  # Nous réglons le mode sur BCM 
GPIO.setup (23 ,GPIO.OUT)  #La broche 23 est une sortie. 
GPIO.setup (24 ,GPIO.OUT)  #Pin 24 est une sortie. 
 # Ici commence la boucle 
 try :
    while  True :  #Boucle While pour que le programme fonctionne sans interruption 
        GPIO.output (23 ,GPIO.HIGH)  # Allume la LED sur la broche 23. 
        GPIO.output (24 ,GPIO.LOW)  # Eteint la LED sur la broche 24. 
        time .sleep (1 )  # Attendre 1 seconde 
        GPIO.output (23 ,GPIO.LOW)  # Eteint la LED sur la broche 23. 
        GPIO.output (24 ,GPIO.HIGH)  # Allume la LED sur la broche 24. 
        time .sleep (1 )
 # Ici à la fin, le programme saute au début de la partie de la boucle. Alors.. 
 # ...allume la LED sur la broche 23. 
 # ... etc... etc... etc.. 
except KeyboardInterrupt :  # Avec CTRL+C, nous interrompons le programme 
    print ( &quot;Terminé &quot; ) # Ecris &quot;Terminé&quot; dans la fenêtre du shell
    GPIO.cleanup() # Terminer le programme
  
 Dans l&#039;exemple n° 01 LED clignotante, nous avions réalisé la boucle infinie avec while True et l&#039;indentation des lignes de code suivantes. Celui qui a interrompu cette boucle infinie avec la combinaison de touches Ctrl-C aura remarqué que, premièrement, il reçoit un message d&#039;erreur et que, deuxièmement, la LED continue éventuellement de briller. Pour éviter ces deux effets indésirables, quelques lignes de code ont été ajoutées dans cet exemple. Avant la boucle while True, la ligne  try :  est insérée. Les deux points entraînent l&#039;indentation de toute la boucle. Si une erreur se produit dans cette boucle lors de l&#039;exécution du programme, il n&#039;y a pas de message d&#039;erreur, mais le programme se poursuit à  except KeyboardInterrupt : . La commande print permet d&#039;afficher la fin du programme dans le shell Python (fenêtre inférieure chez Thonny), GPIO.cleanup() permet d&#039;éteindre les GPIO (donc nos LED) et de les libérer pour d&#039;autres utilisations. 
 Exemple : cycle de feux de signalisation sur Raspberry Pi 
 Voici une proposition de solution pour un cycle de feux de signalisation en utilisant le module gpiozero : 
   
   
   
                ]]>
            </content>

                            <updated>2022-06-06T08:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED clignotante sur le microcontrôleur Raspberry Pi</title>
            <id>https://funduinoshop.com/fr/led-clignotante-sur-le-microcontroleur-raspberry-pi</id>
            <link href="https://funduinoshop.com/fr/led-clignotante-sur-le-microcontroleur-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            Contrairement à l&#039;Arduino, le Raspberry Pi n&#039;a pas accès aux LED intégrées. Celles-ci indiquent uniquement l&#039;alimentation électrique et l&#039;accès à la carte µSD. Pour faire clignoter une LED, il faut donc utiliser une LED externe avec un...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Comment faire clignoter une LED sur le Raspberry Pi ? 
  Contrairement à Arduino, le Raspberry Pi n&#039;a pas accès aux LED intégrées. Celles-ci indiquent uniquement l&#039;alimentation électrique et l&#039;accès à la carte µSD.  
 Pour faire clignoter une LED, il faut donc une LED externe avec une résistance appropriée et des câbles de saut. Le plus judicieux est de construire le circuit sur une carte mère avec un T-Cobbler. Ce type de disposition facilite également les essais ultérieurs avec plusieurs LED, boutons et capteurs. La programmation se fait dans le langage de programmation Python. 
 Le schéma de câblage (LED clignotante sur Raspberry Pi) 
   
 Qu&#039;est-ce qu&#039;une LED ? 
 LED signifie Light Emitting Diode (diode électroluminescente). Ce dernier mot suggère les propriétés électroniques. Une diode est un semi-conducteur qui ne laisse passer le courant que dans un sens et le bloque dans l&#039;autre. Les deux &quot;pattes&quot; s&#039;appellent anode et cathode. Si tu regardes attentivement, tu peux voir que les pattes ont des longueurs différentes. La tension positive est appliquée à la jambe la plus longue, l&#039;anode, et la plus courte, la cathode, est reliée à la terre par une résistance. La résistance est nécessaire en raison d&#039;une autre caractéristique des diodes. Tout d&#039;abord, il faut une tension minimale pour qu&#039;un courant puisse circuler : C&#039;est ce qu&#039;on appelle la tension de flux (en anglais forward voltage). A des tensions plus élevées, la diode devient entièrement conductrice. C&#039;est pourquoi tu as besoin d&#039;une résistance de série pour limiter l&#039;intensité du courant, car les broches des microcontrôleurs et du Raspberry Pi doivent être alimentées au maximum par 15 à 20 mA. Nous utilisons des résistances en série de 100 à 330 Ω (ohms). 
 Le langage de programmation Python peut être étendu par des modules de programme, comme pour C/C++ avec les bibliothèques. Pour notre LED clignotante, nous avons besoin de deux de ces modules : premièrement, &quot;time&quot; pour définir la durée du clignotement. Et deuxièmement, un module pour accéder aux GPIO (General Purpose Input/Output). 
 Comment piloter un LED avec un Raspberry Pi ? 
 L&#039;importation des modules se fait au début du programme Python ; pour cela, tu as plusieurs possibilités. Exemples : 
 La ligne suivante permet d&#039;importer le module  time : 
  import   time  
 Lors de l&#039;appel de la méthode  sleep  , le nom du module  time  doit être précédé d&#039;un point : 
  time  .sleep  (1 ) 
 Contrairement à delay(), où l&#039;intervalle de temps est indiqué comme argument en millisecondes,  time.sleep()  indique les valeurs en secondes, éventuellement avec un point décimal. 
  import  RPi.GPIO  as  GPIO 
 Cela simplifie les appels aux méthodes dans le programme, par ex. 
  GPIO  .setmode  (GPIO  .BCM ) 
 Troisième exemple d&#039;un autre module pour l&#039;accès GPIO : 
 from gpiozero  import  LED 
 Seule la classe LED est importée à partir du module  gpiozero . Avec cette méthode d&#039;importation, le nom du module n&#039;est plus préfixé lors de l&#039;appel de la méthode/fonction. 
 Exemples de programmes pour piloter une LED avec un microcontrôleur Raspberry Pi 
 Premier exemple avec le module RPi.GPIO : 
 import RPi.GPIO as GPIO
import  time 
GPIO.setmode(GPIO.BCM) # Désignation des broches pour le processeur Broadcomm 
GPIO.setup (26 ,GPIO.OUT) # GPIO26 (= broche physique 37) devient sortie 

 while  True : # boucle infinie, arrêter avec Ctrl-C 
    GPIO .output  (26  ,1 ) # GPIO 26 devient HIGH 
    time  .sleep  (1 )
    GPIO .output  (26  ,0 ) # Le GPIO 26 est commuté en mode BAS 
    time  .sleep  (1 )
 
 Deuxième exemple avec le module gpiozero. Seules  les LED  et  sleep  sont importées. 
  from  gpiozero import LED
 from   time  import  sleep 
redLED = LED (26 ) # redLED est instanciée sur le GPIO  26  

 while   True :
    redLED.on() # la redLED est allumée 
    sleep  (1 )
    redLED.off() # la redLED est éteinte 
    sleep  (1 )
 
 Challenge : Elargir le circuit et le programme pour un cycle de feux de signalisation, par exemple rouge(3s), rouge/jaune(1s), vert(3s), jaune(1s), recommencer avec le rouge. 
 Proposition de solution voir n° 02 Le clignotant alterné 
                ]]>
            </content>

                            <updated>2022-06-01T00:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Débuter avec le Raspberry Pi - Partie 3 : Programmer</title>
            <id>https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-3-programmer</id>
            <link href="https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-3-programmer"/>
            <summary type="html">
                <![CDATA[
                
                                            En principe, tu peux aussi installer l&#039;IDE Arduino sur ton Raspberry Pi ou utiliser le programme préinstallé Geany, un éditeur très fonctionnel, dans différents langages de programmation...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 En principe, tu peux aussi installer l&#039;IDE Arduino sur le Raspberry Pi ou programmer dans différents langages de programmation avec le programme préinstallé Geany, un éditeur très fonctionnel, mais le Raspberry Pi tire son nom du langage de programmation Python ; à l&#039;origine, il n&#039;était prévu que comme  interprète   de Python . Donc, qui dit programmation du Raspberry Pi, dit généralement le langage Python, très répandu et facile à apprendre. 
 Ces dernières années, le programme Thonny s&#039;est établi comme environnement de développement intégré (IDE=Integrated Development Environment) pour les programmes  Python . 
 &amp;nbsp;  
 On distingue principalement l&#039;éditeur dans la partie supérieure de la fenêtre, où les programmes sont écrits, et le shell dans la partie inférieure, où les programmes s&#039;exécutent avec les entrées et sorties possibles. Mais tu peux aussi saisir des commandes courtes directement dans le shell. 
 Les programmeurs avancés devraient cliquer sur &quot;Switch to regular mode&quot; en haut à droite de l&#039;image afin d&#039;afficher également la barre de menu. 
 &amp;nbsp;  
 Ceux qui souhaitent apprendre le langage de programmation de manière autodidacte peuvent le faire à l&#039;aide de nombreux livres. Nous recommandons ici la méthode &quot;Learning by doing&quot;, c&#039;est-à-dire qu&#039;il suffit de suivre les exemples de programmes. La plupart du temps, le code de programmation est auto-explicatif. C&#039;est la beauté de Python. 
 Pour éviter toute frustration inutile, il convient de mentionner ici quelques règles qui s&#039;adressent principalement aux personnes qui passent d&#039;Arduino C/C++ : 
 Contrairement à C/C++, il n&#039;est pas nécessaire de déclarer le type de variable. Python reconnaît le type lors de la première utilisation. Par exemple, si tu saisis  type(&quot;abc&quot;)  dans le shell, tu obtiens en sortie &amp;lt;class &#039;str&#039;&amp;gt; ; le type String est donc reconnu à cause des apostrophes. 
 La ligne de commande ne se termine pas par un point-virgule. Au lieu de cela, en Python, il faut faire attention aux indentations. Ainsi, chaque commande commence toujours à la première place du paragraphe. 
 Les indentations (généralement tab=quatre espaces) se font (généralement automatiquement) pour les ramifications, les boucles ou les fonctions auto-définies, éventuellement plusieurs fois. 
 Les noms de programmes et de variables commencent toujours par une lettre ou le trait de soulignement _. Ensuite, des chiffres peuvent également être utilisés. Le trait de soulignement est le seul caractère spécial autorisé et est généralement utilisé à des fins particulières. 
 Comme déjà dit : plus d&#039;explications sur Python avec les exemples de programmes. 
                ]]>
            </content>

                            <updated>2022-05-24T11:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Débuter avec le Raspberry Pi - Partie 2 : matériel et logiciel</title>
            <id>https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-2-materiel-et-logiciel</id>
            <link href="https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-2-materiel-et-logiciel"/>
            <summary type="html">
                <![CDATA[
                
                                            Une brève introduction aux composants les plus importants pour le Raspberry Pi. Qu&#039;il s&#039;agisse d&#039;un câble enfichable, d&#039;une résistance ou d&#039;une LED, nous te montrons les composants dont tu as besoin pour démarrer. Nous abordons également l&#039;installation du logiciel pour le Rasp...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Matériel et logiciel pour le Raspberry Pi 
 Matériel pour le Raspberry Pi 
     
 Accessoires de base pour le Raspberry Pi 
 En plus des capteurs et des actionneurs, tu as besoin, comme base pour des constructions expérimentales rapides et flexibles, de&amp;nbsp; câbles enfichables &amp;nbsp;en combinaison avec une breadboard &amp;nbsp;. Cela permet d&#039;éviter les travaux de soudure qui prennent beaucoup de temps. En outre, les diodes lumineuses &amp;nbsp;&amp;nbsp; sont idéales pour vérifier la sortie du signal de la carte. 
 Le breadboard 
 Une breadboard ou une &quot;planche de connexion&quot; est un bon outil pour construire des circuits sans les souder. Dans un breadboard, plusieurs contacts sont toujours connectés en série. Il est donc possible de connecter de nombreux câbles à ces endroits sans avoir à les souder ou à les visser. 
 L&#039;image suivante montre en couleur les contacts qui sont reliés entre eux. 
 &amp;nbsp;  
 Planche de connexion standard pour Raspberry Pi et microcontrôleur.   Les lignes vertes sur l&#039;image indiquent le parcours des circuits. 
 Pour une bonne connexion du Raspberry Pi avec la breadboard, il existe ce que l&#039;on appelle des T-cobbler avec un câble plat qui sort toutes les 40 broches. 
   
 Diodes électroluminescentes, LED (light emitting diode) pour le Raspberry Pi 
 Avec les LED, tu peux tester très rapidement les résultats d&#039;un projet. Elles sont donc utiles pour presque tous les projets Arduino. Tu peux lire beaucoup de choses sur les LED sur le net. Voici juste les informations les plus importantes. 
   
 
 Le courant ne peut circuler que dans un sens à travers la LED. C&#039;est pourquoi elle doit être connectée correctement. Une LED a un contact plus long et un contact plus court. Le contact le plus long est + et le plus court est -. 
 Une LED est conçue pour une certaine tension. Si cette tension n&#039;est pas atteinte, la LED brille moins ou reste éteinte. Mais si la tension est dépassée, la LED brûle très rapidement et devient très chaude au niveau des contacts (ATTENTION !). 
 Valeurs de tension typiques selon les couleurs de LED : Bleu:3,1V, blanc:3,3V, vert:3,7V, jaune:2,2V, rouge:2,1V La tension sur les ports numériques de la carte est de 5V. En cas de connexion directe à ces ports, chaque LED rend rapidement l&#039;âme. Il faut donc ajouter une résistance dans le circuit électrique. Tu trouveras de très bons conseils sur Internet sous le terme de recherche &quot;calculateur de résistance LED&quot;. 
 Recommandation non contraignante pour les résistances des LED suivantes (en cas de connexion aux broches 5V de la carte microcontrôleur.   
 
 
 
 
 LED 
 Blanc 
 Rouge 
 Jaune 
 Vert 
 Bleu 
 Infrarouge (IR) 
 
 
 Résistance 
 100 ohms 
 200 ohms 
 200 ohms 
 100 ohms 
 100 ohms 
 100 ohms 
 
 
 
 &amp;nbsp; 
 Câbles enfichables ou Jumper Wire pour le Raspberry Pi 
 Les câbles enfichables sont disponibles en différents modèles, généralement en 10cm ou 20cm de long, avec des fiches ou des prises. Mm=male-male=fiche des deux côtés, mf=male-female=fiche d&#039;un côté, prise de l&#039;autre côté, et ff=female-female= avec prises des deux côtés. 
   
 Boutons et interrupteurs pour le Raspberry Pi 
 Le premier et le plus simple des capteurs est le bouton (&quot;button&quot; en anglais), un interrupteur à ressort qui rouvre le contact électrique lorsqu&#039;il est relâché. 
   
 Logiciel pour le Raspberry Pi 
 Le système d&#039;exploitation Raspberry Pi OS peut être téléchargé gratuitement sur le  site de la Raspberry Pi Foundation . La version 32 bits est actuellement encore identique pour tous les modèles. Pour écrire sur la carte µSD (8 à 32 Go) sur le PC, il est recommandé d&#039;utiliser le programme Imager, qui peut également être téléchargé sur le site de la fondation. 
 Installation du logiciel 
   
 Mise en service du Raspberry Pi 
 Au premier démarrage, le système d&#039;exploitation est mis en place. On y saisit entre autres les données d&#039;accès au WLAN de la maison. Depuis le printemps, le nom d&#039;utilisateur pi n&#039;est plus utilisé automatiquement, mais il est demandé d&#039;entrer un nom d&#039;utilisateur et un mot de passe. Après un redémarrage à la fin de l&#039;initialisation, une interface utilisateur graphique démarre. Ce processus dure un peu plus d&#039;une minute. 
 En cliquant sur l&#039;icône, on te demande si tu veux seulement que les mises à jour possibles soient affichées ou si tu veux les lancer directement. 
 La capture d&#039;écran suivante a été prise avec le programme préinstallé &quot;scrot&quot; (pour  screen  shot ). 
 &amp;nbsp;  
                ]]>
            </content>

                            <updated>2022-05-22T12:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Débuter avec le Raspberry Pi - Partie 1 : La préface</title>
            <id>https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-1-la-preface</id>
            <link href="https://funduinoshop.com/fr/debuter-avec-le-raspberry-pi-partie-1-la-preface"/>
            <summary type="html">
                <![CDATA[
                
                                            Ce guide doit servir de base pour apprendre le système d&#039;exploitation Raspberry Pi OS en mettant l&#039;accent sur le langage de programmation Python. Il vise à offrir aux débutants une introduction simple, intéressante et...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Qu&#039;est-ce que &quot;Raspberry Pi&quot; en réalité ?  
 Ce guide doit servir de base pour apprendre le système d&#039;exploitation Raspberry Pi OS en mettant l&#039;accent sur le langage de programmation Python. Il vise à donner aux débutants une introduction simple, intéressante et étroitement guidée aux thèmes de la pensée informatique et de l&#039;informatique physique. Le guide s&#039;oriente principalement vers des tâches pratiques avec une introduction théorique au préalable. Il est important de les lire au préalable afin de ne pas échouer sur des détails lors des tâches pratiques ultérieures. 
 Ce guide a été créé dans le cadre d&#039;une activité d&#039;enseignement. Il peut être utilisé gratuitement pour apprendre les bases des ordinateurs Raspberry Pi, mais ne peut pas être copié ou utilisé d&#039;une autre manière sans autorisation. Le guide a été rédigé avec soin et est continuellement mis à jour, mais aucune garantie n&#039;est donnée quant à son exactitude et son exhaustivité. 
 Pour les tâches pratiques, il faut être équipé de quelques composants électroniques. Sur le site Internet funduinoshop.fr, ils peuvent commander des kits de capteurs adaptés, spécialement conçus pour ces instructions. 
 Le Raspberry Pi, avec désormais une multitude de modèles différents, est, contrairement au microcontrôleur (par exemple Funduino Uno ou Nano), un véritable ordinateur avec un système d&#039;exploitation basé sur Linux (Raspberry Pi OS, anciennement Raspbian). Le système d&#039;exploitation ainsi que les programmes d&#039;application et les données se trouvent sur une carte µSD (8 à 32 Go), qui est chargée au démarrage. Les interfaces les plus importantes sont d&#039;abord les prises USB pour le clavier et la souris ainsi que la ou les interfaces HDMI vers l&#039;écran.    
 Raspberry Pi B (2012) 
 Le grand succès du Raspberry Pi repose à la fois sur la programmation avec le langage de programmation Python, très répandu, et sur la possibilité de connecter des composants électroniques à l&#039;en-tête J6 à 40 broches (souvent appelé barre GPIO). Celui-ci est identique pour tous les modèles depuis 2014. Dans la nomenclature, il faut faire attention à savoir s&#039;il s&#039;agit de la broche physique (dans l&#039;image, à gauche les numéros impairs de 1 à 39, à droite les numéros pairs de 2 à 40) ou de la désignation GPIO. Par exemple, la broche physique 11 correspond au GPIO17 (General Purpose Input Output Connector 17 du processeur). Les GPIO sont donc, comme pour le microcontrôleur, des entrées ou des sorties numériques. 
   
 Image J6-Header : 40 broches, dont 2x3,3V, 2x5V, 8xGround, 26xGPIOs, 2 réservés 
  Certaines des broches ont une deuxième affectation en tant qu&#039;interface électronique (angl. Interface), par exemple One Wire sur la broche 7, I2C(= Inter-Integrated Circuit) sur les broches 3 et 5, UART (= Universal Asynchronous Receiver and Transmitter) sur les broches 8 et 10 et SPI (=Serial Peripheral Interface) sur les broches 19, 21, 23 et 24 ou 26. Cette deuxième affectation est définie dans le système d&#039;exploitation dans la configuration Raspberry Pi. Plus de détails dans les exemples respectifs. 
                ]]>
            </content>

                            <updated>2022-05-19T13:30:00+02:00</updated>
                    </entry>

    
</feed>
