<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/fr/blog/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Flux Atom</title>
    <id>https://funduinoshop.com/fr/blog/?sRss=1</id>
    <updated>2026-04-11T12:20:46+02:00</updated>
    
        <entry>
            <title type="text">WRO Finale Allemagne 2025</title>
            <id>https://funduinoshop.com/fr/wro-finale-allemagne-2025</id>
            <link href="https://funduinoshop.com/fr/wro-finale-allemagne-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Cette année encore, nous avons pu participer en tant qu&#039;exposant à la finale allemande des World Robot Olympiad - cette fois-ci du 27 au 28 juin 2025 à la Westfalenhalle de Dortmund.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Cette année encore, nous avons eu le plaisir d&#039;exposer à la finale allemande du World Robot   Olympiade   cette fois-ci, nous serons présents   du 27 au 28 juin 2025   à   dans la Westfalenhalle   Dortmund. En 2024, nous étions déjà sur la ligne de départ à Passau, et ce fut pour nous une expérience inoubliable   super   C&#039;est la deuxième fois que je participe à cette fête spéciale   (et qui ne cesse de croître !)   Nous sommes ravis de participer à cet événement.   
 
 
       
   Nous avons recueilli une quantité incroyable d&#039;impressions et de souvenirs   de superbes   Nous avons eu des conversations, en particulier avec des enfants et des jeunes de tous âges. L&#039;enthousiasme et la curiosité avec lesquels ils abordent la technique et la robotique sont tout simplement contagieux et agréables. Pour nous, la finale était non seulement passionnante, mais aussi très enrichissante.   
 
 
   Nous tenons à féliciter Markus pour son travail   Fleige   et son équipe, qui ont une fois de plus organisé l&#039;événement de manière formidable. On sentait à chaque coin de rue à quel point l&#039;événement était passionné.   
 
 
   Sur   Funduino  -Stand, nous avons présenté quelques-uns de nos produits - entre autres le Starter Kit   et le Cube aussi   le   Unitree   Chien robot Go2. Le jeune public, en particulier, était ravi, a posé d&#039;innombrables questions et a admiré le chien avec des yeux brillants.   
 
 
   Dans l&#039;ensemble, ce fut pour nous un week-end réussi à tous les niveaux, plein d&#039;inspiration, d&#039;échanges et de belles rencontres. Nous sommes reconnaissants d&#039;avoir été là - et nous attendons déjà la prochaine fois avec impatience !   
    Votre équipe Funduino       
 &amp;nbsp; 
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Forum européen de la robotique 2025</title>
            <id>https://funduinoshop.com/fr/forum-europeen-de-la-robotique-2025</id>
            <link href="https://funduinoshop.com/fr/forum-europeen-de-la-robotique-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Du 25 au 27 mars 2025, nous étions présents au European Robotics Forum à Stuttgart - l&#039;un des principaux points de rencontre pour les experts en robotique de toute l&#039;Europe.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Du     25. jusqu&#039;au 27 mars 2025     nous étions présents au     European Robotics Forum à Stuttgart     l&#039;un des points de rencontre les plus importants pour les experts en robotique de toute l&#039;Europe.   
 
 
   Cette fois-ci   nous étions exclusivement présents avec les     Les bras robotisés de   Dobot     i  au centre culturel et de congrès de   Stuttgart   et nous avons pu les présenter à un public international de professionnels. Pour nous, c&#039;était une occasion passionnante de montrer les multiples possibilités d&#039;utilisation des robots   Dobot  -Et de discuter avec les visiteurs intéressés.   
 
 
       
   La réponse a été formidable : de nombreux professionnels de la recherche, de l&#039;industrie et de l&#039;éducation ont profité de l&#039;occasion pour voir les robots en action. Nous avons été particulièrement heureux de l&#039;étonnement et de l&#039;enthousiasme que nous avons pu ressentir sur notre stand, que ce soit lors de la première rencontre ou lors des discussions techniques intenses qui en ont découlé.   
 
 
   Nous repartons de Stuttgart avec de nombreuses nouvelles impressions. Ce qui a été particulièrement précieux pour nous, c&#039;est de faire partie de ce réseau international et de voir les   Dobots   pouvoir présenter à un public professionnel aussi large. Les discussions et les réactions nous encouragent à continuer à faire avancer activement la robotique dans l&#039;éducation et la pratique. Pour nous, la première apparition au salon     European Robotics Forum     une étape importante - et certainement pas la dernière.   
    Ton équipe Funduino   
       
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Didacta 2025 à Stuttgart</title>
            <id>https://funduinoshop.com/fr/didacta-2025-a-stuttgart</id>
            <link href="https://funduinoshop.com/fr/didacta-2025-a-stuttgart"/>
            <summary type="html">
                <![CDATA[
                
                                            Du 11 au 15 février 2025, nous étions à nouveau présents au salon Didacta à Stuttgart - et comme les années précédentes, le salon a une fois de plus tenu ses promesses.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Du     11. jusqu&#039;au 15 février 2025     nous étions à nouveau présents au salon     Didacta à Stuttgart     le salon a été un succès, comme les années précédentes   encore une fois   une fois de plus   tient ses promesses  .   
 
 
   Nous avons eu de nombreuses conversations passionnantes   nous sommes très heureux de l&#039;intérêt que tu portes à nos produits. Sur notre stand, nous avons présenté un mélange coloré : de   nos   classiques     Funduino  -Produits     en passant par les     Dobot  -Bras de robot     jusqu&#039;aux    Découpeuses laser Flux    . Il était particulièrement agréable de voir que des visiteurs de tous âges s&#039;enthousiasmaient pour notre technique - des élèves curieux aux enseignants expérimentés. C&#039;est justement cet échange avec tant de personnes différentes qui fait pour nous le charme particulier de Didacta.   
     
 
 
   Un vrai point fort cette année   w  a été   le site     Unitree   Go2    . L&#039;agile chien robot a immédiatement attiré tous les regards, a fait briller les yeux et est devenu une attraction pour le public. De nombreuses photos ont été prises et beaucoup ont profité de l&#039;occasion pour interagir un peu avec lui. L&#039;enthousiasme était à son comble   il n&#039;y avait pas de doute   c&#039;était très amusant pour nous aussi.   
 
 
     
   Nous avons vécu cinq jours de salon intenses, pleins d&#039;inspiration, d&#039;échanges et de nouvelles idées. En plus des nombreuses impressions, nous prenons aussi   EUER   des commentaires précieux et de nouvelles impulsions qui nous encouragent dans notre travail. Un grand merci à tous ceux qui nous ont rendu visite - vous avez fait de Didacta 2025 un moment inoubliable pour nous   tout à fait   une expérience particulière. Nous sommes déjà impatients de vous revoir l&#039;année prochaine !   
 &amp;nbsp; 
 
 
    Votre équipe   de   Funduino    
 
 
                ]]>
            </content>

                            <updated>2025-08-22T11:15:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">LED Halloween Kürbis</title>
            <id>https://funduinoshop.com/fr/led-halloween-kuerbis</id>
            <link href="https://funduinoshop.com/fr/led-halloween-kuerbis"/>
            <summary type="html">
                <![CDATA[
                
                                            Halloween steht kurz bevor und das Gruselfieber steigt. Daher ist es allerhöchste Zeit, uns in diesem Jahr einen echt gruseligen (oder niedlichen?) Kürbis zu basteln. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  LED&amp;nbsp;Halloween&amp;nbsp;Kürbis  
 Halloween steht kurz bevor und das Gruselfieber steigt. Daher ist es allerhöchste Zeit, uns in diesem Jahr einen echt gruseligen (oder niedlichen?) Kürbis zu basteln.&amp;nbsp; 
 Wie Ihr alle wisst, wird traditionell ein Gesicht in einen ausgehölten Kürbis geschnitzt und anschließend von Innen mit einer Kerze beleuchtet. Doch leider hält der Kürbis nur wenige Tage und die Kerze brennt häufig zu schnell aus.  Glück für uns Tüftler: Mit einem 3D-gedruckten Kürbis und einem LED-Ring können wir uns schnell Abhilfe schaffen. Dieser kann die ganze Nacht durchleuchten und länger.&amp;nbsp; 
   
  Bauanleitung  
  Materialien:  
 
  3D-Drucker  
  3D-Modell&amp;nbsp;des&amp;nbsp;Kürbisses  
 
 &amp;nbsp; 
  Schritt&amp;nbsp;1: Kürbis 3D-Modell&amp;nbsp;ausdrucken  
 Lade&amp;nbsp;dir&amp;nbsp;das&amp;nbsp; 3D-Modell&amp;nbsp;des&amp;nbsp;Kürbis &amp;nbsp;herunter&amp;nbsp;und&amp;nbsp;drucke&amp;nbsp;es&amp;nbsp;mit&amp;nbsp;deinem&amp;nbsp;3D-Drucker&amp;nbsp;aus. 
   Schritt&amp;nbsp;2:&amp;nbsp;Elektronik&amp;nbsp;zusammenbauen  
 Stecke&amp;nbsp;die&amp;nbsp;Kabel&amp;nbsp;des&amp;nbsp;LED-Rings&amp;nbsp;an&amp;nbsp;den&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp;Nano.&amp;nbsp;Verbinde&amp;nbsp;dann&amp;nbsp;den&amp;nbsp;Nano&amp;nbsp;mit&amp;nbsp;einem&amp;nbsp;USB-Kabel&amp;nbsp;mit&amp;nbsp;deinem&amp;nbsp;Computer.&amp;nbsp; 
   
  Schritt&amp;nbsp;3:&amp;nbsp;Code&amp;nbsp;übertragen  
 Öffne&amp;nbsp;die&amp;nbsp;Arduino&amp;nbsp;IDE&amp;nbsp;und&amp;nbsp;füge&amp;nbsp;den&amp;nbsp;folgenden&amp;nbsp;Code&amp;nbsp;ein: 
 # include &amp;nbsp;&amp;lt;Adafruit_NeoPixel.h&amp;gt;&amp;nbsp;//&amp;nbsp;Die&amp;nbsp;Adafruit&amp;nbsp;NeoPixel&amp;nbsp;Bibliothek&amp;nbsp;wird&amp;nbsp;verwendet&amp;nbsp;um&amp;nbsp;den&amp;nbsp;LED-Ring&amp;nbsp;anzusteuern 
 # ifdef &amp;nbsp;__AVR__ 
 # include &amp;nbsp;&amp;lt;avr/power.h&amp;gt; 
 # endif  
 # define &amp;nbsp;PIN&amp;nbsp;5&amp;nbsp;//&amp;nbsp;Datenleitung&amp;nbsp;an&amp;nbsp;Pin&amp;nbsp;5 
 Adafruit_NeoPixel&amp;nbsp;strip&amp;nbsp;=&amp;nbsp;Adafruit_NeoPixel(8,&amp;nbsp;PIN,&amp;nbsp;NEO_GRB&amp;nbsp;+&amp;nbsp;NEO_KHZ800);&amp;nbsp;//&amp;nbsp;In&amp;nbsp;diesem&amp;nbsp;Beispiel&amp;nbsp;sind&amp;nbsp;am&amp;nbsp;LED&amp;nbsp;Ring&amp;nbsp;8&amp;nbsp;Pixel. 
 void&amp;nbsp;setup()&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;strip.begin(); 
 &amp;nbsp;&amp;nbsp;strip.show();&amp;nbsp;//&amp;nbsp;Alle&amp;nbsp;Pixel&amp;nbsp;zu&amp;nbsp;Beginn&amp;nbsp;ausschalten 
 } 
 void&amp;nbsp;loop()&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;for&amp;nbsp;(int&amp;nbsp;i&amp;nbsp;=&amp;nbsp;0;&amp;nbsp;i&amp;nbsp;&amp;lt;&amp;nbsp;strip.numPixels();&amp;nbsp;i++)&amp;nbsp;{ 
 &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;strip.setPixelColor(i,&amp;nbsp;strip.Color(255,&amp;nbsp;random(100,183),&amp;nbsp;random(20)));&amp;nbsp;//&amp;nbsp;Die&amp;nbsp;Pixel&amp;nbsp;leuchten&amp;nbsp;jeweils&amp;nbsp;rot-orange&amp;nbsp;in&amp;nbsp;zufälligen&amp;nbsp;Farben 
 &amp;nbsp;&amp;nbsp;} 
 &amp;nbsp;&amp;nbsp;strip.show(); 
 &amp;nbsp;&amp;nbsp;delay(random(100)); 
 } 
 Klicke&amp;nbsp;dann&amp;nbsp;auf&amp;nbsp;die&amp;nbsp;Schaltfläche&amp;nbsp;&quot;Hochladen&quot;,&amp;nbsp;um&amp;nbsp;den&amp;nbsp;Code&amp;nbsp;auf&amp;nbsp;den&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp;Nano&amp;nbsp;zu&amp;nbsp;übertragen. 
 &amp;nbsp; 
  Schritt&amp;nbsp;4:&amp;nbsp;LED-Ring&amp;nbsp;in&amp;nbsp;den&amp;nbsp;Kürbis&amp;nbsp;einsetzen  
 Lege&amp;nbsp;den&amp;nbsp;LED-Ring&amp;nbsp;in&amp;nbsp;den&amp;nbsp;Kürbis&amp;nbsp;und&amp;nbsp;stecke&amp;nbsp;die&amp;nbsp;Kabel&amp;nbsp;durch&amp;nbsp;die&amp;nbsp;Öffnung&amp;nbsp;in&amp;nbsp;dem&amp;nbsp;Kürbis. 
 Fertig! 
 Jetzt&amp;nbsp;kannst&amp;nbsp;du&amp;nbsp;deinen&amp;nbsp;Halloween&amp;nbsp;Kürbis&amp;nbsp;mit&amp;nbsp;dem&amp;nbsp;LED-Ring&amp;nbsp;bewundern.    
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2025-08-21T22:15:00+02:00</updated>
                    </entry>

    
    
        <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">Construire une voiture RC pour Arduino : Véhicule autonome - partie 3</title>
            <id>https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-3</id>
            <link href="https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-3"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenue dans le troisième épisode de notre série de blogs sur les voitures robots. Dans la première partie, nous avons découvert les bases du véhicule de base. Dans la deuxième partie, nous avons développé un système de code universel qui nous permet de définir des étapes de...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprendre la mobilité du futur avec les voitures robots, partie 3  
 Bienvenue dans le troisième épisode de notre série de blogs sur les voitures robots. Dans le   première partie  &amp;nbsp;nous avons découvert les bases du véhicule de base. Dans   deuxième partie  &amp;nbsp;nous avons développé un système de code universel pour définir les étapes de conduite de la voiture robot et réalisé une commande à distance simple avec une télécommande infrarouge. En raison des limites physiques de cette télécommande, je souhaite montrer dans cet épisode la transmission des instructions de conduite avec Bluetooth, par exemple d&#039;un smartphone vers le récepteur BT HC-05. Bluetooth est un signal radio de 2,4 GHz à courte portée. Sûr jusqu&#039;à environ 10m et sans interférences à la lumière du soleil. 
 Le module Bluetooth HC-05 est en fait un  émetteur-récepteur=transmetteur +  récepteur . Mais nous ne l&#039;utilisons que comme récepteur, pour envoyer les instructions de conduite, nous utilisons une APP Bluetooth sur un smartphone Android (à cause de la voie spéciale d&#039;Apple pour le Bluetooth, cela ne fonctionne pas avec un iPhone). Il est en principe possible de construire aussi une télécommande Bluetooth avec le HC-05 ; mais pour cela, il faut un deuxième HC-05, d&#039;autres microcontrôleurs et un périphérique d&#039;entrée (contrôleur de joystick). 
 &amp;nbsp;  
  Sur les six broches du module HC-05, seules quatre sont nécessaires : VCC (5V) et GND pour l&#039;alimentation du module, ainsi que RXD et TXD pour la connexion à deux broches du microcontrôleur, sur lesquelles SoftwareSerial est configuré. Cependant, tu ne peux pas ignorer l&#039;inscription LEVEL : 3.3V pour ne pas endommager le module. Sur notre microcontrôleur avec logique 5V, nous avons besoin, au moins pour la broche RXD, d&#039;un diviseur de tension de 5V à 3,3V, donc par exemple des résistances de 1 kohm et 2,2 kohm. 
 Le schéma de câblage : Module HC-05 sur le microcontrôleur    
 Les commandes AT du module HC-05 pour les microcontrôleurs Arduino 
 A gauche du connecteur marqué Key se trouve un petit bouton (button) qui est important pour la configuration. En appuyant sur ce bouton lors de l&#039;allumage, nous entrons dans le mode de commande AT (la LED clignote lentement au rythme de 2s), dans lequel nous effectuons les réglages avec ce que l&#039;on appelle les commandes AT (pour Attention, Attention). Pour cela, nous utilisons un programme d&#039;exemple modifié, dans lequel l&#039;interface sérielle habituelle est connectée au moniteur sériel de l&#039;Arduino IDE et au HC-05 via SoftwareSerial. 
  /*
  Software serial multiple serial test
 Reçoit de la série matérielle, envoie à la série logicielle.
 Reçoit du software serial, envoie au hardware serial.
 Le circuit :
 * RX est la broche numérique 10 (se connecte à TX d&#039;un autre appareil)
 * TX est la broche numérique 11 (connexion à RX d&#039;un autre appareil) // diviseur de tension !
 créé en arrière dans le temps
 modifié le 25 mai 2012
 par Tom Igoe
 basé sur l&#039;exemple de Mikal Hart
 Cet exemple de code est dans le domaine public.
 */ 
  #include  &amp;lt;SoftwareSerial  .h&amp;gt;  
 SoftwareSerial  BTSerial (10 ,  11 ) ;  // RX, TX // mySerial changé en BTSerial 
 char  c= &#039; &#039; ;  // Déclaration de la variable pour la transmission 

 void   setup () {
   // Open serial communications and wait for port to open: 
   Serial . begin ( 9600 );                                                                                    // Baud rate changed to 9600 
   Serial . println ( &quot;Serial started!&quot; );

   // set the data rate for the SoftwareSerial port 
  BTSerial. begin ( 38400 );                                                                             // Baud rate for BT 38400 
   Serial . println ( &quot;BTSerial started!&quot; );
}

 void   loop () {  // run over and over 
  if  (BTSerial .available ()) {
    c=BTSerial. read ();
     Serial . write (c);
  }
  if  (Serial  .available ()) {
    c= Serial . read ();
    BTSerial. write (c);
     Serial . write (c);                                                                                        // re-transmission of input in Serial Monitor 
  }
} 
 Les commandes AT essentielles sont utilisées dans l&#039;image suivante. L&#039;interlocuteur, le HC-05, envoie une réponse le cas échéant et acquitte avec OK. 
 Nous sommes surtout intéressés par le nom et l&#039;adresse HEX afin d&#039;identifier clairement le module plus tard sur le smartphone. Les commandes AT sont saisies dans le moniteur série du microcontrôleur. Dans l&#039;image ci-dessous, tu peux voir le moniteur série de l&#039;IDE Arduino. 
 Si tu le souhaites, tu peux changer le mot de passe par défaut 1234 avec &quot;AT+PSWD=xxxx &quot;, où x représente un chiffre de 0 à 9. Vérifier ensuite avec &quot;AT+PSWD ? &quot; si la saisie a réussi.    Une fois les saisies terminées, le module est brièvement coupé du courant. Après la remise en marche sans appuyer sur le bouton, le module HC-05 se trouve en mode standard. La LED clignote rapidement (environ 5 fois/s). 
 Modifications de la voiture RC : autre Motorshield 
 Passons maintenant à la voiture robot. Après avoir utilisé la dernière fois le contrôleur de moteur V2, qui ne nécessite que les deux connecteurs I2C SDA=A4 et SCL=A5 pour les signaux de commande, je voudrais cette fois-ci présenter le contrôleur de moteur V1, plus ancien, qui bloque de nombreuses broches numériques mais que l&#039;on peut souvent acheter à un prix d&#039;aubaine.     J&#039;ai également modifié un peu ce motorhield pour avoir accès aux capteurs et aux récepteurs radio. Du côté des broches numériques, il n&#039;y a qu&#039;une seule broche qui est accessible à l&#039;aide d&#039;un connecteur coudé : La broche 2. C&#039;est bien pour ceux qui veulent y connecter le récepteur IR. Il y a plus de possibilités d&#039;extension de l&#039;autre côté, où l&#039;on peut accéder à toutes les entrées analogiques et à l&#039;alimentation électrique à l&#039;aide de connecteurs à ressort (également appelés connecteurs femelles). 
 Comme toutes les entrées analogiques peuvent également être utilisées comme entrées ou sorties numériques, nous avons ici la possibilité de connecter nos récepteurs radio. Cela fonctionne parfaitement avec l&#039;émetteur-récepteur 433 MHz HC-12 (voir l&#039;épisode suivant), mais avec des restrictions pour le récepteur BT HC-05. Premièrement, nous ne pouvons pas connecter directement la broche RXD, nous avons besoin du diviseur de tension, et deuxièmement, les broches ne fournissent pas assez de courant pour alimenter le module sur ces broches. 
 Sur l&#039;image suivante, tu peux voir un petit adaptateur fait maison qui alimente le HC-05 en 5V et en ground à partir des connecteurs correspondants, connecte TXD directement à RX de l&#039;interface SoftwareSerial A1 =D15 et RXD à A2 = D16 via le diviseur de tension.   
 Le schéma de câblage : Module HC-05 avec L293D Motorshield sur le microcontrôleur Arduino     
 Le circuit peut bien sûr aussi être réalisé sur une mini breadboard avec des câbles jumper. 
 Comme la dernière fois, le code pour les instructions de conduite est augmenté ou diminué en appuyant sur un bouton ; cette fois-ci seulement, pas avec la télécommande IR, mais avec la fonction tactile dans l&#039;APP du smartphone et l&#039;interrogation Bluetooth via SoftwareSerial. 
 Couplage du module Bluetooth HC-05 avec une application Android (APP) 
 Avant que l&#039;APP puisse se connecter à la voiture robot, nous devons effectuer l&#039;appairage avec le module Bluetooth dans les paramètres. Cela devrait être très simple, car nous avons auparavant demandé le nom et l&#039;adresse HEX du HC-05 avec les commandes AT. 
 Si l&#039;appairage a fonctionné et qu&#039;une application BT appropriée a été installée, celle-ci peut être lancée et configurée. En tapant sur la loupe dans l&#039;image de gauche, les appareils appropriés s&#039;affichent. On tape sur le HC-05 et on obtient le message &quot;connecté&quot;. L&#039;application que j&#039;utilise propose plusieurs interfaces pour l&#039;utilisation (image du milieu). J&#039;ai opté pour le contrôleur de jeu. Sur l&#039;image du milieu en haut à droite, il y a deux flèches qui forment un petit cercle. Touche ici si tu as perdu la connexion. 
 Sur l&#039;image de droite, les boutons d&#039;une manette de jeu sont représentés. Avant la première utilisation, il faut attribuer aux boutons les valeurs numériques qui seront transmises lorsque tu taperas. 
 Pour les boutons du curseur, j&#039;ai donné les valeurs numériques 1 à 4 dans le sens des aiguilles d&#039;une montre. J&#039;ai attribué la valeur numérique 5 aux autres boutons. Ces valeurs sont transmises dans le sketch à la variable  blueToothVal &amp;nbsp;et conduisent dans les instructions&amp;nbsp;if  de la fonction  loop()  à la détermination du code pour le niveau de conduite.    
 Les changements de l&#039;infrarouge au Bluetooth et du contrôleur de moteur V2 à V1 provoquent quelques modifications dans la partie principale du sketch. Par contre, presque rien ne change dans la fonction motor(). C&#039;est seulement au niveau de l&#039;écriture que les fonctions motor1-&amp;gt;setSpeed() deviennent motor1.setSpeed() en raison des différentes bibliothèques de programmes (libraries). 
 Le code du programme : Construire une voiture RC pour Arduino 
 * Sample Code  for  Robot Car with Motor Shield V1 and BT receiver   HC-05 , as of  20220515 
* based on Adafruit Motor shield V2 library, copyright Adafruit Industries LLC
*  ce  code est dans le domaine  public , enjoy !
* modifié  pour  Funduino
* Pins
* BT VCC vers Arduino  5V out.
* BT GND vers GND
* Arduino  A1=15  (SS RX) - BT TX pas besoin de diviseur de tension
* Arduino  A2=16  (SS TX) - BT RX par un diviseur de tension (5v à  3.3v )
*/

  #include  &amp;lt;AFMotor  .h&amp;gt;  
AF_DCMotor motor1 (2 ) ;
AF_DCMotor motor2 (3 ) ;

  #include  &amp;lt;SoftwareSerial  .h&amp;gt;  
 // initialize HC-05 
 SoftwareSerial  BTSerial (15 ,  16 ) ;  // RX, TX en croix sur TX, RX(voltage divider) 
 char  blueToothVal ;
 int  x =  0 ;
 int  y =  0 ;
 int  gauche =  0 ;
 int  droite =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correction pour speedLevel 255/100 * 6V/VBatt 

 void   setup () {
   Serial . begin ( 9600 );  // set up Serial Monitor at 9600 bps 
   Serial . println ( &quot;Motor test!&quot; );
  BTSerial. begin ( 9600 );  // set up transmission speed for HC-12 
   Serial . println ( &quot;SoftwareSerial initialized!&quot; );
}  // end setup 

 void   loop () {
  if (BTSerial .available ())  //si des données sont reçues.  .. 
 Serial.print(&quot;available&quot;) ;  
{
    blueToothVal=BTSerial. read (); //..sollen diese ausgelesen werden 
 Serial.println(blueToothVal); 
  }
    if  (blueToothVal== &#039;1&#039; )  //si le module Bluetooth reçoit un &quot;1&quot;.. .
   {
       if  (code&amp;lt; 9000 )   code = code +  1000 ;      
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal=&#039; 2&#039; )  //si le module Bluetooth reçoit un &quot;2&quot;. ..
   {
       if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal=&#039; 3&#039; )  //si le module Bluetooth reçoit un &quot;3&quot;. 
   {
       if  (code&amp;gt; 2000 )   code = code -  1000 ;        
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal=&#039; 4&#039; )  //si le module Bluetooth reçoit un &quot;4&quot;. 
    {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }  
    else   if  (blueToothVal=&#039; 5&#039; )  //si le module Bluetooth reçoit &quot;5&quot; ...
   {           
      code =  5555 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);    
    }
    delay  (200 ) ;  //petit délai pour une meilleure communication en série et pour éviter les rebonds 
    moteur() ;
}  // fin de la boucle 

 void  motor(){
  int  speedLevel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (code /  1000 ) ;
  x =  int ((code -  1000*y ) /  100 ) ;
  speedL = speedLevel[ y-1 ] ;
  Serial  .print ( &quot;code = &quot; ) ;
  Serial  .print (code) ;
  Serial  .print ( &quot; y = &quot; ) ;
  Serial  .print (y) ;
  Serial  .print ( &quot; x = &quot; ) ;
  Serial  .print (x) ;
  Serial  .print ( &quot; speedL = &quot; ) ;
  Serial  .println (speedL) ;

  //Correction des niveaux de vitesse pour les virages 
  if  ( x==1 ){
    right = speedL+ 20 ;
    left = speedL -20 ;
  }
  else   if  ( x==2 ){
    right = speedL+ 15 ;
    left = speedL -15 ;
  }
  else   if  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  else   if  ( x==4 ) {
    right = speedL+ 5 ;
    left = speedL -5 ;
  }
  else   if  ( x==6 ) {
    right = speedL  -5 ;
    left = speedL+ 5 ;
  }
  else   if  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  else   if  ( x==8 ) {
    right = speedL -15 ;
    left = speedL+ 15 ;
  }
  else   if  ( x==9 ) {
    right = speedL -20 ;
    left = speedL+ 20 ;
  }
  else  {
    right = speedL;
    left = speedL;
  }

  //Entrer les niveaux de déplacement pour &quot;left&quot; et &quot;right&quot; 
  Serial  .print ( &quot;left = &quot; ) ;
  Serial  .print (left) ;
  Serial  .print ( &quot; right = &quot; ) ;
  Serial  .println (right) ;

  if  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1. run (RELEASE);
  }
  if  (right &amp;lt;  40  &amp;amp; right &amp;gt;  -40 ) {
    motor2. run (RELEASE);
  }
  if  ( left&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1. run (FORWARD);
      motor1. setSpeed (left * factor);
  }
  if  ( right&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2. run (FORWARD);
      motor2. setSpeed (right * factor);
  }
  if  (left&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1. run (BACKWARD);
      left = -left;
      motor1. setSpeed (left * factor);
  }
  if  (right&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2. run (BACKWARD);
      right = -right;
      motor2. setSpeed (right * factor);
  }
}  // end motor  
 Voilà la deuxième solution la plus économique pour une voiture robot avec télécommande (à condition d&#039;avoir un smartphone Android). La prochaine fois, je veux montrer à quel point il est facile d&#039;intégrer un émetteur-récepteur HC-12 de 433 MHz. Cela permet même d&#039;obtenir une portée de plusieurs centaines de mètres. Cependant, les coûts augmentent, car il faut maintenant deux émetteurs-récepteurs et un autre microcontrôleur. A bientôt. 
                ]]>
            </content>

                            <updated>2022-06-20T08: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">Construire une voiture RC pour Arduino : Véhicule autonome - partie 2</title>
            <id>https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-2</id>
            <link href="https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-2"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenue dans le deuxième épisode de notre nouvelle série de blogs sur les voitures robotisées. Dans la première partie, nous avons découvert les bases du véhicule de base. Cette fois-ci, nous voulons aborder les possibilités de contrôle à distance, tout en développant un sys...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprendre la mobilité du futur avec les voitures robots, partie 2  
 Bienvenue dans le deuxième épisode de notre nouvelle série de blogs sur les voitures robotisées. Dans la  première partie , nous avons découvert les bases du véhicule de base. Cette fois-ci, nous voulons aborder les possibilités de commande à distance, en développant un système de code qui nous permet de déterminer les étapes de conduite de la voiture robot et, enfin, de réaliser une commande à distance simple avec une télécommande infrarouge. 
 Pourquoi ai-je besoin de niveaux de vitesse pour une voiture RC pour microcontrôleurs Arduino ? 
 1. Pour contrôler les vitesses du moteur à partir d&#039;un autre appareil, il existe en principe la possibilité de déterminer et de transmettre des valeurs en continu à l&#039;aide d&#039;un potentiomètre (poti), ou d&#039;augmenter ou de diminuer la valeur de l&#039;étape de conduite en appuyant sur un bouton. Sur les images suivantes, quelques exemples choisis, sur la première image des commandes par joystick : 
 &amp;nbsp;  
 &amp;nbsp; 
 Sur la deuxième image, nous voyons des commandes à distance infrarouges, une application pour smartphone avec récepteur Bluetooth ainsi que le panneau de commande LCD1602 qui peut être utilisé, entre autres, avec un émetteur-récepteur 433 MHz : 
 &amp;nbsp;  
 &amp;nbsp; 
 Pour obtenir un schéma uniforme, il est judicieux de réduire les valeurs analogiques du potentiomètre avec la fonction map() à des valeurs qui peuvent être transmises par radio. Le convertisseur analogique-numérique fournit des nombres de 10 bits, c&#039;est-à-dire des valeurs comprises entre 0 et 1023. La position centrale des mini-joysticks est d&#039;environ 511. En divisant cette valeur par 100, tu peux obtenir deux valeurs (direction x et y) avec un joystick, qui se situent entre 0 et 10 ou, en utilisant la fonction map(), entre 1 et 9. Cela suffit largement pour entrer la vitesse et pour les virages. Que nous déterminions 11 ou 9 valeurs, l&#039;immobilité signifie une valeur de 5 dans la direction y et une valeur de 5 pour aller en ligne droite. 
 En ce qui concerne le contrôleur avec les deux joysticks (partie du kit  4DOF Mini bras robotique avec joysticks et servocommande ), j&#039;opte pour un code facile à transmettre entre 1111 et 9999, avec le premier chiffre pour la direction y du joystick gauche, le deuxième chiffre pour la direction x du joystick gauche, le troisième et le quatrième chiffre pour un deuxième joystick optionnel ou certaines touches. Dans le premier exemple avec la télécommande IR, nous n&#039;avons besoin que des deux premiers chiffres du code à quatre chiffres. 
 Le contrôle de la vitesse de la voiture RC pour Arduino 
 La régulation de la vitesse des moteurs se fait par modulation de largeur d&#039;impulsion (PWM). La valeur de ce que l&#039;on appelle le duty cycle est un nombre de 8 bits, c&#039;est-à-dire une valeur comprise entre 0 et 255 (=2 puissance 8 -1). Si tu appliques des tensions entre 0 et 6V au moteur avec un bloc d&#039;alimentation réglable, tu constateras que jusqu&#039;à environ 1,5 V, tu ne remarqueras rien. Ensuite, le moteur commence à bourdonner, mais ne bouge pas. Si tu mesures en même temps l&#039;intensité du courant, tu constateras une valeur relativement élevée. L&#039;énergie est transformée en chaleur et en ronflement - pas vraiment bon. A partir de 2,4 - 3 volts, le moteur commence à tourner, l&#039;intensité du courant diminue un peu lorsque le moteur n&#039;est pas chargé. Ensuite, la vitesse augmente en fonction de la tension appliquée. En baissant la tension, le moteur tourne jusqu&#039;à moins de 2 volts, mais s&#039;il s&#039;arrête, par exemple à cause d&#039;une résistance de frottement accrue ou d&#039;un obstacle, il ne redémarre pas. Conclusion : les valeurs inférieures à environ 2,4 volts devraient être évitées, l&#039;entrée devrait être fixée à 0 (zéro) afin d&#039;éviter une usure et une consommation d&#039;énergie inutiles. En dehors de l&#039;arrêt (code=5), nous avons besoin de Duty Cycle entre environ 40% et 100% pour une tension d&#039;alimentation de 6V pour les moteurs. 
 L&#039;alimentation électrique de la voiture RC pour Arduino 
 Nous avons déjà abordé plusieurs possibilités d&#039;alimentation électrique dans la première partie. Quatre piles AA de 1,5V chacune donnent 6V, la tension maximale des petits moteurs jaunes. Quatre piles AA de 1,2 V chacune ne suffisent pas pour l&#039;alimentation. Il faut alors un support de piles pour 6 piles, ce qui donne 7,2 volts. Et deux batteries lithium-ion (tension nominale de 3,7V) fournissent plus de 8 volts lorsqu&#039;elles sont complètement chargées. Il est donc logique de définir dans le programme un facteur qui limite la tension du niveau de conduite le plus élevé à 6V. 
 Le contrôle de la RC Car pour Arduino 
 Si les instructions de conduite sont données avec des boutons, qui peuvent même se trouver dans une application pour smartphone, la valeur de sortie 55xx (arrêt) est augmentée ou diminuée de la valeur correspondante, sans que le maximum ne puisse être dépassé. 
 Lire le code correctement 
 L&#039;attribution du premier chiffre du code aux valeurs nécessaires des étapes de conduite se fait par l&#039;index d&#039;une liste avec les valeurs numériques correspondantes. 
 Conclusion : avec un code à quatre chiffres, nous pouvons contrôler la vitesse et les virages avec les deux premiers chiffres, les deux derniers chiffres servent à d&#039;autres fonctions (pas nécessaires au début). Donc, par exemple, code95xx pour aller le plus vite en ligne droite, 55xx pour s&#039;arrêter, 77xx pour avancer vers la droite.&amp;nbsp; 
 
 
 
 
 
 y ↓ 0&amp;nbsp; x→ 
 
 
 1 
 
 
 2 
 
 
 3 
 
 
 4 
 
 
 5 
 
 
 6 
 
 
 7 
 
 
 8 
 
 
 9 
 
 
 
 
 9 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 8 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 7 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 6 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 ↑ 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 5 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
  0  
 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 4 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 
 ↙ 
 
 
 &amp;nbsp; 
 
 
 ↓ 
 
 
 &amp;nbsp; 
 
 
 ↘ 
 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 3 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 2 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 1 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↙  
 
 
 &amp;nbsp; 
 
 
  ↓  
 
 
 &amp;nbsp; 
 
 
  ↘  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 
 &amp;nbsp; 
 Maintenant, nous voulons construire notre première Smart Robot Car avec le kit, un microcontrôleur de type ATmega328 (forme de construction de l&#039;UNO R3), un MotorShield V2 et des émetteurs et récepteurs IR. 
 Le Motor Shield V2 peut contrôler jusqu&#039;à quatre moteurs, en utilisant le bus I2C avec les connecteurs SDA (= données sérielles) sur l&#039;entrée analogique A4 et SCL (= horloge sérielle) sur A5 pour connecter les lignes de contrôle. Pour cela aussi, Adafruit a développé et mis à disposition une bibliothèque de programmes adaptée. Attention : les bibliothèques pour les Motor Shield V1 et V2 ne sont pas compatibles. 
 &amp;nbsp;  
 Image Motor Shield V2 avec modification :  Connecteurs femelles soudés (connecteurs à ressort) pour la connexion d&#039;équipements supplémentaires 
 Quel que soit le Motor Shield que tu souhaites utiliser - V1 ou V2 -,&amp;nbsp; il est judicieux de souder des connecteurs femelles supplémentaires sur les deux Motor Shield pour pouvoir y connecter plus tard des émetteurs/récepteurs Bluetooth ou 433 MHz (en anglais transceiver=émetteur + récepteur) ou des capteurs. Plus de détails dans les articles de blog suivants. Le récepteur IR n&#039;a besoin que de l&#039;alimentation électrique des broches 3 et 4 ainsi que de la broche 2 pour le récepteur IR. Le fer à souder peut encore rester froid. 
 Comme commande, nous utiliserons d&#039;abord la petite télécommande infrarouge de Funduino et un récepteur IR. Bien que le capteur IR &quot;nu&quot; suffise, je recommande la petite carte de breakout, car une LED scintille lorsque des signaux IR sont reçus ; une aide précieuse lorsqu&#039;une erreur est recherchée. 
 Le sketch est composé de deux parties qui ont fait leurs preuves : Le sketch d&#039;exemple d&#039;Armin Joachimsmeyer, qu&#039;il a ajouté à sa superbe bibliothèque de programmes IRremote, et un sketch de voiture robot de l&#039;auteur, basé sur la bibliothèque de programmes d&#039;Adafruit. 
 Le code de programme pour la RC Car pour Arduino 
  /* Sample Code for Robot Car with Motor Shield V2 and IR receiver, as of 20220515
* based on Adafruit Motor shield V2 library, copyright Adafruit Industries LLC, 2009
* et SimpleReceiver.cpp, partie de Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* MIT License Copyright (c) 2020-2022 Armin Joachimsmeyer
* modifié pour Funduino
* Motor Shield V2 utilise I2C avec SDA=A4 et SCL=A5
* IRreceiver utilise la broche 2
 ************************************************************************************
 * Permission est accordée par la présente, gratuitement, à toute personne obtenant une copie
 * de ce logiciel et des fichiers de documentation associés (le &quot;logiciel&quot;), à traiter
 * dans le logiciel sans restriction, y compris, sans limitation, les droits de
 * d&#039;utiliser, de copier, de modifier, de fusionner, de publier, de distribuer, de sous-licencier, et/ou de vendre
 * copies du logiciel, et à autoriser les personnes à qui le logiciel est fourni à le faire
 * à le faire, sous réserve des conditions suivantes :
 *
 * La notice de copyright ci-dessus et cette notice d&#039;autorisation doivent être incluses dans toutes les copies
 * copies ou parties substantielles du logiciel.
 *
 * LE LOGICIEL EST FOURNI &quot;EN L&#039;ÉTAT&quot;, SANS GARANTIE D&#039;AUCUNE SORTE, EXPRESSE OU IMPLICITE,
 * Y COMPRIS, MAIS SANS S&#039;Y LIMITER, LES GARANTIES DE QUALITÉ MARCHANDE, D&#039;APTITUDE À UN USAGE PARTICULIER
 * UN BUT PARTICULIER ET L&#039;ABSENCE D&#039;ERREURS. EN AUCUN CAS LES AUTEURS OU LES COPYRIGHTS NE PEUVENT ÊTRE TENUS POUR RESPONSABLES
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRAT, TORT OU AUTRE, DÉCOULANT DE, OU EN RELATION AVEC LE LOGICIEL
 * OU L&#039;UTILISATION OU D&#039;AUTRES TRANSACTIONS DANS LE LOGICIEL.
 *************************************************************************************/ 
 
  #include  &amp;lt;Adafruit_MotorShield  .h&amp;gt;  
 // Créer l&#039;objet motor shield avec l&#039;adresse I2C par défaut 0x60 
Adafruit_MotorShield AFMS = Adafruit_MotorShield() ;
 // Choisir quel &#039;port&#039; M1, M2, M3 ou M4.  
Adafruit_DCMotor *motor1 = AFMS.getMotor (2 ) ;
Adafruit_DCMotor *motor2 = AFMS.getMotor (3 ) ;

 // définir le protocole pour le contrôle à distance, pour en savoir plus see samples code SimpleReceiver.cpp 
  #define  DECODE_NEC  // Inclut Apple et Onkyo, aussi pour la petite télécommande Funduino  
 //#define INFO // Pour voir des informations précieuses du décodeur universel pour les protocoles de largeur d&#039;impulsion ou de distance d&#039;impulsion 
  #define  IR_RECEIVE_PIN 2  // à la place de #include &quot;PinDefinitionsAndMore.h&quot;  
  #include  &amp;lt;Arduino  .h&amp;gt;  
  #include  &amp;lt;IRremote  .hpp&amp;gt;  

 // Signal du récepteur IR connecté à Pin2, VCC à Pin3, GND à Pin4 
 int  IR_GND =  4 ; 
 int  IR_VCC =  3 ;

 int  x =  0 ;
 int  y =  0 ;
 int  gauche =  0 ;
 int  droite =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correction pour speedLevel 255/100 * 6V/VBatt 

 void   setup () {
  Serial  .begin  (9600 ) ;
  Serial  .println ( &quot;Test moteur !&quot; ) ;
  Serial  .println ( &quot;Motorshield v2 - test moteur DC !&quot; ) ;
  if  (!AFMS .begin ()) {          // create with the default frequency 1.6KHz 
     Serial . println ( &quot;Could not find Motor Shield. Check wiring.&quot; );
     while  ( 1 );
  }
  Serial  .println ( &quot;Bouclier moteur trouvé.&quot; ) ;
  // Juste pour savoir quel programme est en cours d&#039;exécution sur mon Arduino 
  Serial  .println (F( &quot;START &quot;  __FILE__  &quot; from &quot;  __DATE__  &quot;\r\nUsing library version &quot;  VERSION_IRREMOTE)) ;
  // Démarrer le récepteur 
  IrReceiver .begin (IR_RECEIVE_PIN) ;  //, ENABLE_LED_FEEDBACK) ; 
  Serial  .print (F( &quot;Prêt à recevoir les signaux IR des protocoles : &quot; )) ;
  printActiveIRProtocols( &amp;amp;Serial ) ;
  Serial  .print (F( &quot;à la broche &quot; )) ;
  Serial  .println (IR_RECEIVE_PIN) ; 
  // initialiser les broches numériques comme sortie pour l&#039;alimentation électrique 
  pinMode (IR_GND ,OUTPUT ) ;
  pinMode (IR_VCC ,OUTPUT ) ;
  digitalWrite (IR_GND ,LOW ) ;
  digitalWrite (IR_VCC ,HIGH ) ; 
}  // end setup 

 void   loop () {
  if  (IrReceiver.decode()) {
      // Imprime un bref résumé des données reçues 
      IrReceiver.printIRResultShort( &amp;amp;Serial ) ;
      if  (IrReceiver.decodedIRData.protocol == UNKNOWN) {
           // We have an unknown protocol here, print more info 
          IrReceiver.printIRResultRawFormatted(&amp;amp; Serial , true);
      }
      Serial  .println () ;
      /*
       * !!Important ! ! Activer la réception de la valeur suivante,
       * car la réception s&#039;est arrêtée après la fin du paquet de données actuellement reçu.
       */ 
      delay  (100 ) ;  // désensibilisation, pas de répétition rapide      
      IrReceiver.resume() ;  // Activer la réception de la valeur suivante 
      /*
       * Enfin, vérifier les données reçues et effectuer des actions en fonction de la commande reçue
       */ 
  if  (IrReceiver.decodedIRData.command ==  0x46 )  {
     if  (code&amp;lt; 9000 )   code = code +  1000 ;         
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x15 ) {
     if  (code&amp;gt; 2000 )   code = code -  1000 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    } 
  else   if  (IrReceiver.decodedIRData.command ==  0x43 )  {
     if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x44 )  {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else   if  (IrReceiver.decodedIRData.command ==  0x40 )  {
    code =  5555 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  else  {
     Serial . print ( &quot;invalid code&quot; );
    }
  motor() ;
  }
}  // fin de la boucle 

 void  motor(){
  int  speedLevel [9 ]={ -100 , -80 , -60 , -40 , 0 , 40 , 60 , 80 , 100 };
  y =  int (code /  1000 ) ;
  x =  int ((code -  1000*y ) /  100 ) ;
  speedL = speedLevel[ y-1 ] ;
  Serial  .print ( &quot;code = &quot; ) ;
  Serial  .print (code) ;
  Serial  .print ( &quot; y = &quot; ) ;
  Serial  .print (y) ;
  Serial  .print ( &quot; x = &quot; ) ;
  Serial  .print (x) ;
  Serial  .print ( &quot; speedL = &quot; ) ;
  Serial  .println (speedL) ;

  //Correction des niveaux de vitesse pour les virages 
  if  ( x==1 ){
    right = speedL+ 16 ;
    left = speedL -16 ;
  }
  else   if  ( x==2 ){
    right = speedL+ 13 ;
    left = speedL -13 ;
  }
  else   if  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  else   if  ( x==4 ) {
    right = speedL+ 7 ;
    left = speedL -7 ;
  }
  else   if  ( x==6 ) {
    right = speedL  -7 ;
    left = speedL+ 7 ;
  }
  else   if  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  else   if  ( x==8 ) {
    right = speedL -13 ;
    left = speedL+ 13 ;
  }
  else   if  ( x==9 ) {
    right = speedL -16 ;
    left = speedL+ 16 ;
  }
  else  {
    right = speedL;
    left = speedL;
  }

  //Entrer les niveaux de déplacement pour &quot;left&quot; et &quot;right&quot; 
  Serial  .print ( &quot;left = &quot; ) ;
  Serial  .print (left) ;
  Serial  .print ( &quot; right = &quot; ) ;
  Serial  .println (right) ;

  if  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1-&amp;gt; run (RELEASE);
  }
  if  (right &amp;lt;  40  &amp;amp; right &amp;gt;  -40 ) {
    motor2-&amp;gt; run (RELEASE);
  }
  if  ( left&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1-&amp;gt; run (FORWARD);
      motor1-&amp;gt; setSpeed (left * factor);
  }
  if  ( right&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2-&amp;gt; run (FORWARD);
      motor2-&amp;gt; setSpeed (right * factor);
  }
  if  (left&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1-&amp;gt; run (BACKWARD);
      motor1-&amp;gt; setSpeed (-left * factor);
  }
  if  (right&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2-&amp;gt; run (BACKWARD);
      motor2-&amp;gt; setSpeed (-right * factor);
  }
}  // end motor 
 
 Explications du code de programmation pour la voiture RC 
 Après avoir inclus les bibliothèques pour le Motor Shield V2 et IRremote, deux moteurs sont instanciés avec le numéro sur le bloc terminal du contrôleur et quelques variables globales sont déclarées (type de données) et initialisées (valeur initiale). 
 Dans la fonction  setup() , l&#039;interface série et le récepteur IR sont initialisés et les broches pour l&#039;alimentation du récepteur IR sont configurées comme sorties avec l&#039;état HIGH ou LOW. 
 Dans la fonction  loop() , le signal de la télécommande IR est d&#039;abord reçu, puis en fonction de la touche appuyée, le code pour la commande du moteur est modifié. Les touches de curseur up et down modifient le premier chiffre, left et right le deuxième chiffre du code dans la plage de valeurs 1 à 9. La touche X entraîne l&#039;arrêt avec le code 5555. Les troisième et quatrième chiffres du code n&#039;ont pas encore d&#039;importance pour le moment. A la fin, la fonction autodéfinie  motor()  est appelée sans arguments, car nous avions défini les variables globalement, c&#039;est-à-dire valables dans toutes les fonctions. 
 Dans la fonction autodéfinie  motor() , que nous utiliserons également dans d&#039;autres configurations avec d&#039;autres télécommandes, les niveaux de conduite pour les moteurs gauche et droit sont déterminés à partir du code. Le pourcentage du niveau de vitesse est finalement converti en valeur PWM pour  setSpeed  à l&#039;aide du facteur défini au début. 
 &amp;nbsp;  
 La voiture robot est alors prête à fonctionner. Cela fonctionne très bien tant que tu peux maintenir la connexion optique entre la télécommande et le récepteur IR. Cependant, en roulant sur la route, j&#039;ai constaté qu&#039;un fort rayonnement solaire entrave la réception. C&#039;est pourquoi je passe à la télécommande radio. A bientôt. 
                ]]>
            </content>

                            <updated>2022-06-09T07:30: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">Construire une voiture RC pour Arduino : Véhicule autonome - partie 1</title>
            <id>https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-1</id>
            <link href="https://funduinoshop.com/fr/construire-une-voiture-rc-pour-arduino-vehicule-autonome-partie-1"/>
            <summary type="html">
                <![CDATA[
                
                                            Bienvenue dans une nouvelle série de blogs sur les voitures robotisées. Dans la première partie, nous allons découvrir les bases pour cela, comme une aide à la décision d&#039;achat, quel châssis, quel microcontrôleur et quel type de télécommande...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comprendre la mobilité du futur avec les voitures robots  
 Bienvenue dans une nouvelle série de blogs sur les voitures robotisées. Dans la première partie, nous allons découvrir les bases pour cela, pour ainsi dire comme aide à la décision d&#039;achat, quel châssis, quel microcontrôleur et quel type de télécommande sont les plus appropriés. 
 Deux ou quatre roues - peser les avantages et les inconvénients pour la construction de voitures RC pour Arduino 
 Commençons par le châssis et examinons les avantages et les inconvénients des kits bon marché avec deux ou quatre roues motrices. Tous ont en commun les moteurs électriques, de sorte qu&#039;ils ne constituent pas à eux seuls un critère de sélection. Les voitures robotisées à deux roues sont d&#039;abord moins chères, car le coût de deux moteurs électriques et de deux roues supplémentaires n&#039;est pas nécessaire. Au lieu de cela, elles ont une ou deux roues d&#039;appui qui confèrent aux voitures RC une grande maniabilité. Ceux qui veulent &quot;tourner sur l&#039;assiette&quot; sont donc bien servis. Cependant, à ce niveau de prix des moteurs à courant continu, on ne peut pas s&#039;attendre à ce qu&#039;ils fonctionnent de manière régulière avec une grande précision. C&#039;est pourquoi la course en ligne droite n&#039;est pas aussi bonne que celle de la variante à quatre roues. Juste au moment du démarrage, les moteurs montrent une plus grande stabilité directionnelle, mais les virages ne sont possibles qu&#039;avec des rayons nettement plus importants. Un autre avantage des châssis à quatre roues est qu&#039;il y a plus de place pour les batteries, le microcontrôleur, le cas échéant le convertisseur DC/DC et les capteurs. 
   
 Le choix du microcontrôleur pour la construction d&#039;une voiture RC 
 La question suivante concerne le microcontrôleur et le type de programmation. La plus grande puissance de calcul sur un petit châssis est par exemple celle d&#039;un micro-ordinateur de type Raspberry Pi. En ce qui concerne la télécommande, les types avec WiFi et Bluetooth intégrés offrent des avantages et on peut même transmettre des images d&#039;une caméra Raspberry Pi. La programmation se fait dans le langage de programmation très répandu Python, mais le démarrage du système d&#039;exploitation basé sur Linux Raspberry Pi OS prend environ une minute. Un autre inconvénient des Raspi (abréviation de Raspberry Pi) est la nécessité d&#039;une bonne alimentation en 5V. Cela nécessite un bon convertisseur DC/DC. 
 En rapport avec le thème de la télécommande Bluetooth, un exemple avec Raspberry Pi et l&#039;APP Android BlueDot de Martin O&#039;Hanlon (collaborateur de la Raspberry Pi Foundation) sera présenté dans un épisode ultérieur. 
 Le démarrage du système est beaucoup plus rapide avec un micro contrôleur basé sur l&#039;ATmega 328, par exemple le  Funduino Uno  ou  le Funduino&amp;nbsp;  Nano. Environ une seconde après l&#039;allumage, on peut commencer à entrer les commandes, pas de démarrage à partir de la carte microSD, le programme une fois téléchargé n&#039;est pas oublié. La tension d&#039;entrée peut être comprise entre 5 et 9 volts. La programmation se fait dans l&#039; IDE Arduino , un environnement de développement inspiré de C/C++ (pour plus d&#039;explications, voir  https://funduino.de/hardware-software) . C&#039;est pourquoi nous allons d&#039;abord examiner des exemples avec le Funduino Uno R3, pour lesquels il existe des contrôleurs de moteur parfaits sous forme de ce que l&#039;on appelle des shields. Ceux-ci sont simplement enfichés sur l&#039;Uno et les bibliothèques (en anglais libraries) nous aident à les programmer. 
 Digression : qu&#039;est-ce qu&#039;un contrôleur de moteur / pilote de moteur ? 
 En raison de l&#039;intensité fortement limitée des sorties des microcontrôleurs, les gros consommateurs - et tous les types de moteurs électriques et de relais en font partie - nécessitent une alimentation externe et un circuit électronique qui convertit le signal de commande du microcontrôleur. Mais les exigences de ce circuit intégré (en anglais IC=Integrated Circuit) sont encore plus élevées : il doit d&#039;une part permettre une vitesse variable du moteur, et d&#039;autre part nous voulons aussi pouvoir changer le sens de rotation du moteur en inversant la polarité. 
 Le fonctionnement est expliqué à l&#039;aide de l&#039;exemple du CI L293D. En principe, ce module DIP avec seize &quot;pattes&quot;/connexions suffit comme contrôleur de moteur pour deux moteurs électriques.     
 L&#039;alimentation du CI se fait par les connecteurs VCC1 et Ground. On peut prélever cette tension sur le microcontrôleur. L&#039;alimentation des moteurs se fait par VCC2 et Ground. C&#039;est ici que nous connectons la ou les batteries (par exemple 6 ou 9 volts). Pour les grands moteurs, le CI doit être refroidi, pour les petits jaunes du kit non. 
 Nous connectons l&#039;un des moteurs à 1Y et 2Y, les lignes de commande correspondantes vers le MCU (Micro Controller Unit) sont 1A, 2A et 1,2EN. 
 L&#039;inversion de la polarité des moteurs pour le changement de direction se fait en principe avec ce que l&#039;on appelle un circuit en H. Nous réalisons cela avec notre microcontrôleur en mettant deux broches de sortie (celles-ci vont à 1A et 1B) soit sur HIGH soit sur LOW. 
 Le changement de vitesse se fait comme dans l&#039; exemple 04 - LED pulsante  avec la modulation de largeur d&#039;impulsion (PWM, en anglais pulse width modulation), c&#039;est-à-dire l&#039;allumage et l&#039;extinction très rapides de la tension. C&#039;est pourquoi nous avons besoin d&#039;une sortie compatible avec la PWM sur le MCU pour la connexion 1,2EN (&quot;Enable&quot;) (ce sont les broches avec le tilde ~). 
 Pour le deuxième moteur, les connexions 3A, 4A et 3,4EN sont connectées aux broches du MCU. 
 L&#039;image de droite (Logic Diagram) explique le fonctionnement du CI. Nous voyons les quatre amplificateurs qui donnent les signaux d&#039;entrée 1A à 4A respectivement avec la tension de la batterie aux sorties 1Y à 4Y. Mais cela ne se produit que si, en plus, les entrées PWM 1,2EN et 3,4EN sont également connectées HIGH. 
 Deux de ces CI L293D sont montés sur le Motor Shield V1, de sorte que jusqu&#039;à quatre moteurs peuvent être connectés ici. 
 Pour ne pas utiliser trop de broches, un registre à décalage (SN74HC595) se trouve au milieu du Motor Shield V1. Expliquer son fonctionnement dépasserait le cadre de cet article. Heureusement, les collègues de la société new-yorkaise Adafruit ont fait le plus gros du travail de programmation et ont mis à disposition une bibliothèque de programmes (angl. library) pour contrôler facilement les moteurs.    
 Image Motor Shield V1 avec modification :   Connecteurs femelles soudés (connecteurs à ressort) pour la connexion d&#039;équipements supplémentaires 
 &amp;nbsp; 
 Le Motor Shield V2 peut également contrôler jusqu&#039;à quatre moteurs et utilise un circuit intégré similaire, mais pour la connexion des lignes de commande, il utilise le bus I2C avec les connexions SDA (= données sérielles) à l&#039;entrée analogique A4 et SCL (= horloge sérielle) à A5. Pour cela aussi, Adafruit a développé et mis à disposition une bibliothèque de programmes appropriée. 
   
 Image Motor Shield V2 avec modification :  Connecteurs femelles soudés (connecteurs à ressort) pour la connexion d&#039;équipements supplémentaires 
 Sur les deux Motor Shield, des connecteurs supplémentaires sont soudés ici pour pouvoir connecter ultérieurement des émetteurs/récepteurs Bluetooth ou 433 MHz (en anglais transceiver=émetteur + récepteur) ou des capteurs. Plus d&#039;informations dans un prochain article de blog. 
 Alimentation et contrôle pour une voiture RC pour microcontrôleur Arduino 
 Si notre voiture robot doit se déplacer de manière autonome, nous devons la déconnecter du port USB du PC. Ainsi, l&#039;alimentation électrique est également perdue. A partir de maintenant, le centre de commande (MCU) et les moteurs électriques sont alimentés par des piles ou des batteries. Les moteurs sont de loin les plus gros consommateurs. Le support de piles fourni avec la plupart des kits est conçu pour quatre piles AA, soit 6 volts pour le MCU et les moteurs. Pour ceux qui souhaitent utiliser des piles rechargeables, il est conseillé d&#039;utiliser soit six piles AA, soit deux piles lithium-ion de type 18650, en raison de la tension plus faible. 
 Dans les prochains épisodes, nous découvrirons d&#039;abord les télécommandes avec télécommande infrarouge, les émetteurs-récepteurs Bluetooth avec APP pour smartphone ou un deuxième microcontrôleur également avec l&#039;émetteur-récepteur BT HC-05 ainsi que les télécommandes radio avec 433Mhz et 2,4 GHz. La série de blogs se terminera par les aspects de la conduite autonome, principalement la détection d&#039;obstacles. A très bientôt. 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2022-06-03T11: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>

    
    
        <entry>
            <title type="text">Convertisseur de niveau dans la microélectronique</title>
            <id>https://funduinoshop.com/fr/convertisseur-de-niveau-dans-la-microelectronique</id>
            <link href="https://funduinoshop.com/fr/convertisseur-de-niveau-dans-la-microelectronique"/>
            <summary type="html">
                <![CDATA[
                
                                            Souvent, dans les circuits électroniques, deux appareils ou modules doivent communiquer entre eux. Plus souvent encore, ces deux modules ont besoin d&#039;un niveau de tension différent. Dans la microélectronique...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Où sont utilisés les convertisseurs de niveau dans la microélectronique ? 
 Souvent, dans les circuits électroniques, deux appareils ou modules doivent communiquer entre eux. Plus souvent encore, ces deux modules ont besoin d&#039;un niveau de tension différent. Dans la microélectronique, par exemple dans un microcontrôleur Arduino, ce niveau de tension est généralement de 3,3V ou 5V. Si l&#039;on connecte directement un module fonctionnant à 3,3V et un module fonctionnant à 5V, le module avec une tension de fonctionnement maximale de 3,3V sera détruit avec un niveau de 5V.&amp;nbsp; 
 Pour éviter cela, on a recours à des convertisseurs de niveau. Les convertisseurs de niveau permettent donc la communication entre deux modules avec un niveau de tension différent. Ce qui est particulièrement intéressant, c&#039;est que les convertisseurs de niveau fonctionnent dans deux directions, sans qu&#039;il soit nécessaire de modifier quoi que ce soit au niveau de la connexion. Le signal peut donc être émis par un module, les convertisseurs de niveau sont donc également adaptés aux lignes I2C. Il est également possible d&#039;augmenter ou d&#039;abaisser le niveau de tension des entrées ou des sorties de commutation.&amp;nbsp; 
   
 Convertisseurs de niveau : comment fonctionnent-ils ? 
 L&#039;image ci-dessus montre clairement comment fonctionne la transmission du signal dans un convertisseur de niveau pour 3,3 et 5V. Sur le circuit imprimé, le niveau 5V (HV, &quot;High Voltage&quot;) et le niveau 3.3V (LV, &quot;Low Voltage&quot;) sont directement opposés. Il faut savoir que le module utilisé dans cet exemple (l&#039;article est lié ci-dessous) ne peut &quot;commuter&quot; que quelques milliampères. Le module ne convient pas, par exemple, pour commuter des moteurs ou des lampes. 
                ]]>
            </content>

                            <updated>2022-05-17T00:15:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Le module MPU-6050 : Gyroscope et accéléromètre</title>
            <id>https://funduinoshop.com/fr/le-module-mpu-6050-gyroscope-et-accelerometre</id>
            <link href="https://funduinoshop.com/fr/le-module-mpu-6050-gyroscope-et-accelerometre"/>
            <summary type="html">
                <![CDATA[
                
                                            Il y a peu de modules sur le marché qui ont suscité autant d&#039;engouement ces derniers mois que le module MPU-6050. Le circuit imprimé deux en un combine deux...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Il existe peu de modules sur le marché qui ont suscité autant d&#039;engouement ces derniers mois que le module MPU-6050. Le circuit imprimé deux en un combine deux caractéristiques de capteur très appréciées : Le module peut être utilisé à la fois comme gyroscope et comme accéléromètre.  Comment faire ? Le capteur comprend un gyroscope à 3 axes et un capteur d&#039;accélération à 3 axes sur une seule et même puce. Ainsi,&amp;nbsp;peut récupérer toutes ( !) les valeurs du capteur en même temps. Ainsi, le bricoleur est toujours bien informé de la position actuelle du capteur. Cette caractéristique est particulièrement intéressante pour le modélisme, surtout pour les châssis équilibrés ou les drones. De plus, il est possible d&#039;accéder à des magnétomètres externes ou à d&#039;autres capteurs via un autre bus I2C maître, de sorte que les données de ces capteurs peuvent également être entièrement collectées.&amp;nbsp; 
 Aperçu rapide des données de capteur du MPU-6050 (GY-521) : 
 
 Chipset : MPU-6050 (également connu sous le nom de GY-521) 
 Alimentation électrique : 3,3 - 5V DC 
 Droite de liberté : 6* 
 Interface : I2C 
 Espacement des broches : 2,54 mm   
 
 Passons maintenant à la partie la plus excitante : la pratique. Pour que tu puisses te faire une idée des fonctions utiles du module MPU-6050, nous avons développé pour toi un exemple de schéma électrique. Le module MPU-6050 est lu par un Funduino UNO R3 et les données recueillies sont analysées.  Nous nous intéressons principalement aux données des capteurs du gyroscope. Nous voulons lire les valeurs des axes X, Y et Z et déterminer si la position du capteur a été modifiée. Le changement de position doit être représenté par des LED de couleur. 
   
 Jusqu&#039;ici, tout va bien : mais comment mettre cela en œuvre ? 
 Le code de programmation du module MPU-6050 
 Maintenant, on entre dans le vif du sujet : enfin, à moitié. Tout d&#039;abord, nous devons télécharger la bibliothèque appropriée pour le module MPU6050 et l&#039;intégrer dans notre IDE Arduino. La bibliothèque s&#039;appelle &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; et peut être trouvée et installée directement via la gestion des bibliothèques de l&#039;IDE Arduino. 
 Après cette première étape, nous commençons le code proprement dit. Tout d&#039;abord, nous définissons les connexions pour nos LED, qui nous serviront d&#039;indicateurs de la position de l&#039;axe. Ensuite, nous définissons deux variables pour la position des trois axes.&amp;nbsp; 
 Tu te demandes certainement pourquoi nous avons besoin de deux variables par axe. Comme nous voulons savoir si la position de chaque axe a changé, nous devons d&#039;abord savoir quelle valeur le capteur a enregistrée pour la position actuelle. La valeur du capteur du MPU-6050 est sauvegardée dans la première variable pendant une courte période. La valeur de la position de l&#039;axe est à nouveau sauvegardée dans la deuxième variable peu après. Nous pouvons maintenant comparer les deux valeurs de mesure saisies. Si une déviation de la position d&#039;une valeur minimale définie au préalable a été enregistrée (dans notre exemple de code +-3), on peut supposer que le capteur a changé de position. Dans ce cas, nous allumons la LED correspondante.&amp;nbsp; 
 Particulièrement agréable : les données de mesure saisies s&#039;affichent bien sur le traceur sériel de l&#039;IDE Arduino.   
  // Ce sketch compare les angles des axes X/Y/Z avec les valeurs précédentes. 
 // S&#039;ils sont différents de +/-3°, le sketch allume des LED. (jew.1 pour POS ou pour NEG) 
 // Attention : ce ne sont pas des valeurs absolues mais des valeurs RELATIVES par rapport à la mesure précédente 


  #include  &amp;lt;MPU6050_tockn  .h&amp;gt;   // inclure les bibliothèques  
  #include  &amp;lt;Wire  .h&amp;gt;   // &amp;lt;-  

MPU6050 mpu6050 (Wire ,  0.1 ,  0.1 ) ;  // Amortissement des valeurs. Plus elles sont petites (direction &quot;0&quot;), plus les valeurs sont nerveuses
                                  // plus grande est la direction &quot;1&quot;, plus les valeurs sont lentes 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // * 
 const   int  ledYpos  =4 ;  // * Définir les connexions des LED 
 const   int  ledYneg  =5 ;  // * 
 const   int  ledZpos  =6 ;  // * 
 const   int  ledZneg  =7 ;  //*** 

 int  xMaintenantPos ;  // variable X-Pos ACTUELLE 
 int  yMaintenantPos ;  // variable Y-Pos ACTUELLE 
 int  zMaintenantPos ;  // variable Z-Pos ACTUELLE 

 int  xPourPos ;  // variable X-Pos PRÉCÉDENTES 
 int  yVorPos ;  // variable Y-Pos PRÉCÉDENTES 
 int  zVorPos ;  // variable Z-Pos PRÉCÉDENTES 

 int  différence =  3 ;

 void   setup () {                   // Beginn Setup-Funktion 
   Serial . begin ( 115200 );          // Öffne serielle Übertragung (115200Baud) !!! Am Monitor ebenfalls einstellen !!! 
  
   pinMode (ledXpos,  OUTPUT );      //*** 
   pinMode (ledXneg,  OUTPUT );      //  * 
   pinMode (ledYpos,  OUTPUT );      //  * Festlegen dass LED-Anschlüsse Ausgänge sind 
   pinMode (ledYneg,  OUTPUT );      //  * 
   pinMode (ledZpos,  OUTPUT );      //  * 
   pinMode (ledZneg,  OUTPUT );      //*** 
  
   Wire . begin ();                  // Beginn I2C Protokoll 
  mpu6050. begin ();               // Start des Gyros 
  mpu6050.calcGyroOffsets();     // Gyro kalkuliert seine Offsets !!! Währenddessen ruhig liegen lassen !!! 
                                 // Benutze mpu6050.calcGyroOffsets(true), um es im seriellen Monitor zu verfolgen. 
 delay ( 1000 );                     // Darauf warten wir... 
}

 void   loop () {  // Début de la boucle 

  mpu6050.update() ;  // créer un nouvel ensemble de données dans le gyroscope 

xMaintenantPos=(mpu6050.getGyroAngleX()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable X 
yMaintenantPos=(mpu6050.getGyroAngleY()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable Y 
zMaintenantPos=(mpu6050.getGyroAngleZ()) ;  // Demande un nouveau jeu de données au gyroscope, écris dans la variable Z 

 if  (xMaintenantPos &amp;lt; xVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Ensuite, commute les LED en conséquence 
 else   if  (xMaintenantPos &amp;gt; xVorPos+(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou alors, éteindre toutes les X LEDs ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Alors allume les LED en conséquence 

 if  (yMaintenantPos &amp;lt; yVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Ensuite, allume les LED en conséquence 
 else   if  (yMaintenantPos &amp;gt; yVorPos+(différence))  // Compare l&#039;ancien ensemble de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou bien toutes les Y LEDs sont éteintes ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Alors allume les LED en conséquence 

 if  (zJetztPos &amp;lt; zVorPos-(différence))  // Compare l&#039;ancien jeu de données avec le nouveau. Différence &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Ensuite, allume les LED en conséquence 
 else   if  (zMaintenantPos &amp;gt; zVorPos+(différence))  // Compare l&#039;ancien ensemble de données avec le nouveau. Différence &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Alors, allume les LED en conséquence 
 else   // Ou bien toutes les Z LEDs sont éteintes ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Alors allume les LED en conséquence 

xVorPos=xMaintenantPos ;  // Mettre à jour l&#039;ancien jeu de données (jusqu&#039;à présent) 
yVorPos=yMaintenantPos ;  // actualise l&#039;ancien jeu de données (jusqu&#039;à présent) 
zVorPos=zMaintenantPos ;  // Mettre à jour l&#039;ancien jeu de données (jusqu&#039;à présent) 
                                     // Ensuite, lors du prochain passage, on peut à nouveau comparer avec &quot;avant&quot; 

 Serial  .print (xMaintenantPos) ;  // &amp;gt;&amp;gt; traceur sériel&amp;lt;&amp;lt; écriture juste [donner X] 
 Serial  .print ( &quot; &quot; ) ;Serial  .print (yMaintenantPos) ;  // (&quot; &quot;) = (\t) = nouvelle couleur [donner Y] 
 Serial  .print ( &quot; &quot; ) ;Serial  .println (zMaintenantPos) ;  // (&quot; &quot;) = (\t) = Nouvelle couleur [donner Z] 
  delay  (15 ) ;  // (un délai minimal calme la sortie série) 
}  // Fin de la boucle 


 // Expérimente un peu avec l&#039;atténuation dans la troisième ligne de programme 
 //-&amp;gt; MPU6050 mpu6050(Wire, 0.3, 0.3) ; 
 // ou avec le delay() à la fin. Observe ensuite les valeurs dans &amp;gt;&amp;gt;le PLOTTER sériel &amp;lt;&amp;lt;.  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Régulateur de vitesse PWM en microélectronique</title>
            <id>https://funduinoshop.com/fr/regulateur-de-vitesse-pwm-en-microelectronique</id>
            <link href="https://funduinoshop.com/fr/regulateur-de-vitesse-pwm-en-microelectronique"/>
            <summary type="html">
                <![CDATA[
                
                                            Avant le développement de l&#039;électronique de puissance, le contrôle de la vitesse des moteurs à courant continu (à balais) était résolu avec des régulateurs linéaires ou des résistances en série. D&#039;une manière imagée,...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Origine des régulateurs de vitesse PWM 
 Avant le développement de l&#039;électronique de puissance, la régulation de la vitesse&amp;nbsp;des moteurs à courant continu (à balais) était résolue avec des régulateurs linéaires ou des résistances&amp;nbsp;. De manière imagée, on a réduit la tension&amp;nbsp;(et donc aussi le courant) pour modifier la vitesse de rotation. 
 Mais cela présente quelques inconvénients, qui se manifestent surtout en fonctionnement sur batterie&amp;nbsp;. La tension et le courant sont transformés en énergie thermique (inutilisée) (&quot;brûlés&quot;) au niveau de l&#039;unité de régulation (ou&amp;nbsp;la résistance). 
 La consommation totale reste très élevée, tandis que la puissance utilisable&amp;nbsp;diminue.&amp;nbsp;Comme le couple dépend du flux de courant, celui-ci s&#039;effondre également. 
 Comment fonctionnent les régulateurs de vitesse PWM ? 
 Avec le développement de l&#039;électronique de puissance, une idée&amp;nbsp;différente a été adoptée pour résoudre le problème.&amp;nbsp;En activant et désactivant (très) rapidement la tension d&#039;alimentation&amp;nbsp;, on &quot;pulse&quot; la tension (et donc le courant).&amp;nbsp;L&#039;interrupteur (électronique) ne perd pas de puissance pendant la période &quot;OFF&quot;.&amp;nbsp;Ainsi, il n&#039;y a (presque) plus de pertes au niveau de la régulation. 
 Pendant la période de &quot;marche&quot;, la tension du moteur est PLEINE. Par conséquent,&amp;nbsp;le courant - et donc le couple - est élevé en conséquence.&amp;nbsp;Malheureusement, un moteur avec ses bobines et son noyau de fer n&#039;est pas un&amp;nbsp;consommateur ohmique idéal, c&#039;est pourquoi cette affirmation n&#039;est pas totalement correcte du point de vue physique&amp;nbsp;.&amp;nbsp; 
 Cependant, la combinaison de l&#039;inductance de la bobine et de l&#039;inertie du moteur&amp;nbsp;aide à lisser la vitesse de rotation, de sorte que le moteur se comporte comme&amp;nbsp;, comme si&amp;nbsp;il fonctionnait avec une tension continue continue. 
 &amp;nbsp; 
   
 &amp;nbsp; 
 Cela nous amène aux inconvénients de la modulation de largeur d&#039;impulsion.&amp;nbsp;La modulation avec une tension carrée entraîne l&#039;émission&amp;nbsp;de multiples fréquences radio. Il en résulte des perturbations CEM qui peuvent conduire à des erreurs perfides, en particulier sur les commandes&amp;nbsp;. 
 Dans la plage de fréquences PWM basses (1-2kHz), le moteur émet des sifflements désagréables&amp;nbsp;&amp;nbsp; On pourrait maintenant simplement continuer à augmenter la fréquence de commutation.&amp;nbsp;Mais alors, le courant n&#039;a pas assez de temps pour atteindre son état maximal&amp;nbsp;dans la bobine/l&#039;enroulement.&amp;nbsp;Il oscille alors entre deux valeurs d&#039;état non stables, ce qui entraîne&amp;nbsp;une ondulation du courant. 
 Une ondulation de courant trop élevée augmente l&#039;échauffement dans le paquet d&#039;enroulement,&amp;nbsp;ce qui diminue la puissance du moteur et affecte la durée de vie du moteur&amp;nbsp;. 
 ... c&#039;est beaucoup de physique pour un petit composant. 
 Maintenant, la bonne nouvelle :&amp;nbsp;Pour les moteurs de cette classe de puissance, ces inconvénients sont tout à fait acceptables&amp;nbsp;. Réjouissons-nous des avantages décrits précédemment. 
                ]]>
            </content>

                            <updated>2022-05-12T09:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Module PN532 NFC RFID - communication en champ proche</title>
            <id>https://funduinoshop.com/fr/module-pn532-nfc-rfid-communication-en-champ-proche</id>
            <link href="https://funduinoshop.com/fr/module-pn532-nfc-rfid-communication-en-champ-proche"/>
            <summary type="html">
                <![CDATA[
                
                                            Dans cet article, nous souhaitons te faire découvrir la lecture des étiquettes d&#039;identification. L&#039;article se concentre sur le module PN532 NFC RFID. Le module est basé sur la puce NXP PN532. Ce jeu de puces est surtout utilisé dans le domaine de la NFC (angl. pour &quot;Near Field...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 LA RFID ? NFC ? Qu&#039;est-ce que c&#039;est ? 
 Dans cet article, nous souhaitons te faire découvrir la lecture des tags d&#039;identification. L&#039;article se concentre sur le module PN532 NFC RFID.&amp;nbsp; 
 Le module est basé sur la puce NXP PN532. Ce jeu de puces est surtout répandu dans le domaine de la NFC (anglais pour &quot;Near Field Communication&quot;). Pour cela, un objet compatible NFC, souvent une carte bancaire avec une puce NFC, est tenu devant un lecteur NFC. L&#039;échange d&#039;informations se fait ainsi en une fraction de seconde.&amp;nbsp; 
 Cela semble abstrait ? Si tu as une carte EC récente et que tu l&#039;utilises pour payer sans contact, tu connais même la NFC dans la vie quotidienne. Il suffit de poser la carte sur le terminal de paiement pour déclencher la transaction - c&#039;est rapide et facile. 
 Nous aimerions examiner de plus près les processus techniques sous-jacents. Le module PN532 est idéal pour cela, car il est compatible avec I2C et SPI. Le type de communication souhaité peut être sélectionné directement sur le circuit imprimé du PN532 en déplaçant les commutateurs qui s&#039;y trouvent. La position des commutateurs nécessaires pour chaque interface se trouve à droite du schéma de commutation, qui se trouve un peu plus bas sur la page. 
 &amp;nbsp; 
 Le schéma de câblage : 
   
 Conseil : tu trouveras une version haute résolution de cette image  ici . Tu peux y voir un peu mieux l&#039;affectation des broches.   
 Le code du programme (version I2C) 
  //******************************************************************************************************* 
 //** Exemple de chaîne pour la lecture des tags ID. Si l&#039;ID correspond, PIN 13 est activé pendant 2 secondes **
  //** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) ** 
 //** utiliser. Au lieu d&#039;une LED, il est également possible d&#039;activer une serrure de porte (via l&#039;amplificateur de commutation TIP120 **) 
 //******************************************************************************************************* 

  #include  &amp;lt;Wire  .h&amp;gt;   // bibliothèque pour le protocole I2C  
  #include  &amp;lt;Adafruit_PN532  .h&amp;gt;   // bibliothèque pour le module NFC/RFID !   A charger via Arduino IDE !  


  #define  PN532_IRQ (2)  // Définir le port IRQ  
  #define  PN532_RESET (3)  // Définir le port de réinitialisation  

 const   int  AlarmPin =  12 ;  // sortie Pin 12 pour le haut-parleur piézoélectrique 
 const   int  OutputPin =  13 ;  // Pin 13 sortie pour LED ou via TIP120 vers une serrure magnétique 
 unsigned   long  cardid ;  // variable pour le TAG-ID lu 

 unsigned   long  TAGid1 =  1702536620 ;  // Les ID à accepter peuvent être saisis ici 
 unsigned   long  TAGid2 =  4070796058 ;  // Sinon, laisser libre. L&#039;ID d&#039;un TAG peut être modifié avec 
 unsigned   long  TAGid3 ;  // le moniteur série est lu (régler 115200 baud) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET) ;  // créer une instance avec le protocole I2C 


 void   setup () {  // Début de la fonction setup 
  pinMode (AlarmPin,  OUTPUT ) ;  // définir le PIN comme sortie 
   pinMode (OutputPin,  OUTPUT ) ;  // définir le PIN comme sortie 
  Serial  .begin  (115200 ) ;  // ouvrir la transmission série à 115200 bauds (moniteur ser même réglage de bauds !) 
  Serial  .println ( &quot;Bonjour !&quot; ) ;  // Envoie le texte &quot;Bonjour !&quot; sur le moniteur série 
  nfc .begin ()  // Démarre la communication avec le lecteur RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion() ;  // lire le numéro de version du firmware 
  if  ( ! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial  .print ( &quot;Puce PN5 trouvée&quot; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX) ;  // Envoie le texte et les infos de version à la ligne série 
  Serial  .print ( &quot;Firmware ver. &quot; ) ;  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC) ;  // Moniteur quand la réponse vient de la carte 
  Serial  .print ( &#039;.&#039; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC) ;  //  
  
  nfc.SAMConfig() ;  // Configurer la carte pour lire les tags RFID 

  Serial  .println ( &quot;En attente d&#039;une puce ISO14443A ...&quot; ) ;  // Envoie le texte d&#039;attente au moniteur série 
}


 void   loop () {  // Démarrer la fonction de boucle 
  uint8_t success ;  // créer une variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // tampon pour stocker l&#039;UID 
  uint8_t uidLength ;  // longueur de l&#039;UID (4 ou 7 octets selon le type de carte/puce ISO14443A) 

  // Attendre une puce ISO14443A. Si une telle puce est détectée, la variable 
  // remplit avec l&#039;UID. En fonction de la longueur (4 octets (Mifare Classic) ou 
  // 7 octets (Mifare Ultralight), le type de carte est détecté. 
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength) ;

  if  (success) {  // Si détecté, travaille ...
    Serial  .println ( &quot;Found an ISO14443A card&quot; ) ;
    Serial  .print ( &quot; UID Length : &quot; ) ;  Serial  .print (uidLength, DEC) ;  Serial  .println ( &quot; bytes&quot; ) ;
    Serial  .print ( &quot; UID Value : &quot; ) ;
    nfc.PrintHex(uid, uidLength) ;  // donne des informations sur le moniteur en série 

    if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // demande si les TAGs 1..2..3 sont compatibles avec leur 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On ou Off 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la requête IF/boucle 
}  // Fin de la boucle  
 Le code du programme (version SPI) 
  //******************************************************************************************************* 
 //** Exemple de chaîne pour la lecture des tags ID. Si l&#039;ID correspond, PIN 13 est activé pendant 2 secondes **
  //** allume (LED). En cas de mauvaise ID, un son est émis sur la broche 12. (Buzzer / Piezzo PASSIF) ** 
 //** utiliser. Au lieu d&#039;une LED, il est également possible d&#039;activer une serrure de porte (via l&#039;amplificateur de commutation TIP120 **) 
 //******************************************************************************************************* 

  #include  &amp;lt;Wire  .h&amp;gt;   // bibliothèque pour le protocole I2C  
  #include  &amp;lt;SPI  .h&amp;gt;   // bibliothèque pour le protocole SPI  
  #include  &amp;lt;Adafruit_PN532  .h&amp;gt;   // bibliothèque pour le module NFC/RFID !   A charger via Arduino IDE !  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ;  // définir les connexions pour  
 const   byte  PN532_SS =  4 ;  // la connexion SPI au RFID  
 const   byte  PN532_MISO  =5 ;  // carte 

 const   int  AlarmPin =  12 ;  // définir les connexions pour  
 const   int  OutputPin =  13 ;  // les sorties (de commutation) 
 unsigned   long  cardid ;  // variable pour le TAG-ID lu 

 unsigned   long  TAGid1 =  1702536620 ;  // tu peux saisir ici les ID à accepter 
 unsigned   long  TAGid2 =  4070796058 ;  // Sinon, laisser libre. L&#039;ID d&#039;un TAG peut être modifié avec 
 unsigned   long  TAGid3 ;  // le moniteur série est lu (régler 115200 baud) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS) ;  // créer une instance avec le protocole SPI 

 void   setup () {  // Début de la fonction setup 
  pinMode (AlarmPin,  OUTPUT ) ;  // définir le PIN comme sortie 
   pinMode (OutputPin,  OUTPUT ) ;  // définir le PIN comme sortie 
  Serial  .begin  (115200 ) ;  // ouvrir la transmission sérielle à 115200 bauds (moniteur ser même réglage de bauds !) 
  Serial  .println ( &quot;Bonjour !&quot; ) ;  // Envoie le texte &quot;Bonjour !&quot; sur le moniteur série 
  nfc .begin ()  // Démarre la communication avec le lecteur RFID 
  unsigned   long  versiondata = nfc.getFirmwareVersion() ;  // lire le numéro de version du firmware 
  if  ( ! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

  Serial  .print ( &quot;Found chip PN5&quot; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX) ;  // envoie le texte et les infos de version au port série 
  Serial  .print ( &quot;Firmware ver. &quot; ) ;  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC) ;  // Moniteur quand la réponse vient de la carte 
  Serial  .print ( &#039;.&#039; ) ;  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC) ;  //  

  nfc.SAMConfig() ;  // Configurer la carte pour lire les tags RFID 

  Serial  .println ( &quot;En attente d&#039;une puce ISO14443A ...&quot; ) ;  // Envoie le texte d&#039;attente au moniteur série 
}


 void   loop () {  // Démarrer la fonction de boucle 
  uint8_t success ;  // créer une variable 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // tampon pour stocker l&#039;UID 
  uint8_t uidLength ;  // longueur de l&#039;UID (4 ou 7 octets selon le type de carte/puce ISO14443A) 

  // Attendre une puce ISO14443A. Si une telle puce est détectée, la variable 
  // remplit avec l&#039;UID. En fonction de la longueur (4 octets (Mifare Classic) ou 
  // 7 octets (Mifare Ultralight), le type de carte est détecté. 
 
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength) ;

  if  (success) {  // Si détecté, travaille ...
    Serial  .println ( &quot;Found an ISO14443A card&quot; ) ;
    Serial  .print ( &quot; UID Length : &quot; ) ;  Serial  .print (uidLength, DEC) ;  Serial  .println ( &quot; bytes&quot; ) ;
    Serial  .print ( &quot; UID Value : &quot; ) ;
    nfc.PrintHex(uid, uidLength) ;  // donne des informations sur le moniteur en série 

    if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
      if  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // demande si les TAGs 1..2..3 sont compatibles avec leur 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // On ou Off 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }  // Fin de la requête IF/boucle 
}  // Fin de la boucle  
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Aéroglisseur de la classe WISENT</title>
            <id>https://funduinoshop.com/fr/aeroglisseur-de-la-classe-wisent</id>
            <link href="https://funduinoshop.com/fr/aeroglisseur-de-la-classe-wisent"/>
            <summary type="html">
                <![CDATA[
                
                                            Lors de nombreux défilés de maquettes de bateaux, la plupart des bateaux sont construits dans les moindres détails et avec une très grande qualité. Dommage que cela soit souvent négligé par les spectateurs. Des modèles spectaculaires et peu communs...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Modélisme : Aéroglisseur de la classe WISENT &quot;LCAC - Landing Craft Air Cushion&quot; 
 Lors de nombreux salons de maquettes de bateaux, la plupart des bateaux sont construits jusqu&#039;au dernier&amp;nbsp;détail et avec une très grande qualité. Dommage que cela soit souvent négligé par&amp;nbsp;les spectateurs. Les modèles spectaculaires et peu communs&amp;nbsp;attirent davantage l&#039;attention. Les aéroglisseurs (hovercraft) en font partie sans aucun doute&amp;nbsp;.&amp;nbsp;Pourquoi ne pas construire le plus grand de son genre en modèle réduit ?&amp;nbsp;Avec un déplacement de 550 tonnes, la classe Zubr (classe Wisent) est un géant.&amp;nbsp;Il existe un modèle en plastique au 1:110. C&#039;était trop petit pour moi. 1:75 je trouvais juste&amp;nbsp;correct. Alors, fais-le toi-même ! 
 Construire un aéroglisseur soi-même : Mais comment ? 
 Pour se familiariser avec ce sujet, le livre &quot;RC Aircraft Boats&quot; de&amp;nbsp;K.Jackson &amp;amp; M.Porter des éditions VTH a été une aide précieuse. Quels composants techniques&amp;nbsp;devaient faire flotter le modèle, il fallait les essayer&amp;nbsp;. Les calculs ne sont pas très utiles. A la fin du texte, une liste&amp;nbsp;de la technique de batterie et de propulsion utilisée. Il n&#039;existe pas de plan de construction pour&amp;nbsp;de ce type, il a donc fallu utiliser des photos et calculer beaucoup&amp;nbsp;. 
 Le gros œuvre a été réalisé avec une plaque de mousse PU et une colle Power&amp;nbsp;achetée dans un magasin de bricolage. Cela s&#039;est fait assez rapidement. Un impulseur de 70 mm , souvent utilisé pour les modèles réduits d&#039;avions en polystyrène, doit permettre au bison&amp;nbsp;de &quot;planer&quot;. La jupe gonflable est réalisée en nylon rip.&amp;nbsp;Un matériau utilisé pour les toiles de tente et par les parachutistes&amp;nbsp;. 
 L&#039;alimentation électrique de l&#039;aéroglisseur 
 Avec la taille prévue de 900 x 400 mm, il était clair dès le départ qu&#039;il ne s&#039;agirait pas d&#039;un modèle économe en énergie. Une batterie 18 V de 2,5 Ah de la gamme d&#039;outils&amp;nbsp;- combinée à un convertisseur de tension - doit fournir la tension souhaitée de 12 V réguliers.&amp;nbsp;Un deuxième convertisseur de tension abaisse encore les 12 V à 9 V&amp;nbsp;et fournit ainsi aux hélices et à l&#039;éclairage nautique une tension&amp;nbsp;régulière.&amp;nbsp;Ainsi, toute l&#039;alimentation électrique provient d&#039;une batterie.&amp;nbsp;Deux des hélices extérieures sont conçues pour la propulsion, le moteur central&amp;nbsp;a été inversé et cette hélice a été placée &quot;à l&#039;envers&quot; sur l&#039;arbre de transmission . Les déplacements en marche arrière sont donc possibles sans problème.&amp;nbsp;Les trois nacelles m&#039;ont été imprimées par la société - Ray Haller de Eibenstock - sur&amp;nbsp;l&#039;imprimante 3D. Elles sont commandées de manière synchrone par un servo.&amp;nbsp;Ce concept de propulsion a fait ses preuves.&amp;nbsp;Les hélices de 3,5 pouces (environ 9 cm) proviennent de la gamme de pièces détachées pour quadcoptères.&amp;nbsp;Malgré une construction légère conséquente, le modèle pèse 4,7 kg avec toutes les installations&amp;nbsp;. Il est donc possible d&#039;atterrir, mais il n&#039;est pas adapté aux trajets&amp;nbsp;sur la terre ferme. Même l&#039;original se déplace à 99% sur l&#039;eau&amp;nbsp;. Dix-huit exemplaires de ce &quot;bison géant&quot; ont été construits.&amp;nbsp;L&#039;Ukraine, la Corée, la Russie, la Chine et la Grèce les ont utilisés. 
 Composants utilisés de Funduino : 
 1x&amp;nbsp; R4-E-0-1 :  EDF Turbine Impeller 70mm ADF70-28XL PLUS KV3900  1x R6-C-7-4 :  Hobbywing SkyWalker 60A UBEC Brushless ESC&amp;nbsp;(le régulateur 40A devient trop chaud)  3x R5-E-4-3 :  Ready ToSky 1306 KV3100 pour quadricoptère 150  3x R6-E-1-4 :  Hobbywing SkyWalker 12AE Brushless ESC  2x R12-B-8-2 :  Module DC-DC Step Down 300W 20A 6-40V à 1,2-36V  
 1x batterie 2,5 Ah 18 V de Einhell (temps de conduite environ 15 min) Le modèle est contrôlé par une radiocommande Carson à 6 canaux 2,4 GHz. 
                ]]>
            </content>

                            <updated>2022-05-04T15:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Comment installer un pilote CH340/CH341 ?</title>
            <id>https://funduinoshop.com/fr/comment-installer-un-pilote-ch340/ch341</id>
            <link href="https://funduinoshop.com/fr/comment-installer-un-pilote-ch340/ch341"/>
            <summary type="html">
                <![CDATA[
                
                                            Tu nous contactes de plus en plus souvent pour nous demander comment installer le pilote CH340 pour les microcontrôleurs compatibles Arduino. Dans cet article de blog, nous souhaitons donc t&#039;expliquer...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Comment installer un pilote CH340/CH341 pour les microcontrôleurs compatibles Arduino ?  
 Tu nous contactes de plus en plus souvent pour nous demander comment installer le pilote CH340 pour les microcontrôleurs compatibles Arduino. Dans ce billet de blog, nous souhaitons donc t&#039;expliquer    - Quelle est la différence entre les cartes de microcontrôleur avec chipset CH340 et les &quot;originaux&quot;  - Où télécharger le pilote CH340  - Comment installer le pilote CH340 sous Windows  - Comment programmer les microcontrôleurs compatibles Arduino avec le pilote CH340 dans Arduino IDE 
 Après avoir lu cet article de blog, tu es informé de tous les pièges à éviter lors de la mise en service de clones Arduino bon marché ! 
  La différence entre les microcontrôleurs avec CH340 et le chipset ATmega328P  
 Tout d&#039;abord, les cartes de microcontrôleur compatibles Arduino avec le chipset CH340 sont un peu moins chères que les cartes classiques avec ATmega328p. Cela s&#039;explique notamment par le fait que les cartes classiques avec le chipset &quot;original&quot; peuvent être connectées à l&#039;ordinateur domestique via USB immédiatement après l&#039;achat et sont donc directement utilisables.     Avant de tirer des conclusions hâtives, nous devrions examiner en détail les principaux avantages et inconvénients des cartes CH340 : 
 Inconvénient 1 : &amp;nbsp;Le chipset CH340 n&#039;est pas compatible avec tous les systèmes d&#039;exploitation ! 
 C&#039;est surtout avec les systèmes Windows que le chipset CH340 entraîne souvent des frustrations : en règle générale, le système d&#039;exploitation Windows n&#039;est pas équipé en usine du pilote CH340. Les cartes compatibles Arduino avec le pilote CH340/CH341 qui sont connectées à un PC Windows ne sont souvent pas reconnues comme telles par ce dernier. Au sein de l&#039;IDE Arduino, des messages d&#039;erreur sont donc affichés lors du téléchargement de sketches. 
 Inconvénient 2 : le téléchargement de sketches sur des cartes CH340 prend plus de temps (testé à 5V) ! 
 Nous admettons que cet inconvénient est peut-être négligeable pour le prototypage à domicile, mais il existe. La différence est plus facile à voir si nous regardons la série de données suivante. 
 
 
 
 
 Taille de l&#039;esquisse (octets) 
 
 
 R3 Temps de téléchargement (secondes) 
 
 
 CH340 Temps de téléchargement (secondes) 
 
 
 
 
 500 
 
 
 5.3 
 
 
 5.6 
 
 
 
 
 5000 
 
 
 9.3 
 
 
 9.7 
 
 
 
 
 7000 
 
 
 9.6 
 
 
 10.2 
 
 
 
 
 &amp;nbsp;  En moyenne, le chargement du programme prend environ 0,4 seconde de plus avec les cartes CH340. 
 Avantage 1 : la consommation d&#039;énergie de la carte CH340/CH341 est plus faible ! 
 Bien sûr, on peut négliger le temps de téléchargement des sketches, surtout pour le prototypage rapide. Mais qu&#039;en est-il de la consommation d&#039;énergie ? Là encore, nous avons examiné le comportement de la carte avec deux sketches standard que chacun d&#039;entre toi connaît certainement : &quot;Bare Minimum&quot; et &quot;Blink&quot;. 
 
 
 
 
  Exemple de sketch  
 
 
  Consommation R3 (mA)  
 
 
  Consommation de puissance CH340 (mA)  
 
 
 
 
 Bare Minimum 
 
 
 32.3 
 
 
 14 
 
 
 
 
 Clignotant 
 
 
 37.1 
 
 
 20.1 
 
 
 
 
 Nous sommes aussi surpris que toi ! La consommation d&#039;énergie de la carte microcontrôleur CH340 est deux fois moins importante que celle de la R3... passionnant ! 
  Passons donc à la conclusion :  
 Pour ceux qui peuvent vivre avec le surcroît de travail lié à l&#039;installation du pilote supplémentaire nécessaire, les microcontrôleurs compatibles Arduino avec le chipset CH340/CH341 sont certainement une bonne alternative. L&#039;inconvénient technique de la version CH340, le temps de téléchargement, est certainement négligeable pour le bricoleur amateur. Le gain dû à la faible consommation d&#039;énergie l&#039;emporte même sur ce point ! 
 Où télécharger le pilote CH340 ? 
 C&#039;est maintenant que ça se corse un peu : nous te donnons ci-dessous les liens des pilotes CH340 pour les plates-formes Windows, OS et Linux. Les liens des pilotes de Windows et OS renvoient à une page web avec des caractères chinois. Ne te laisse pas déconcerter par cela : tu peux facilement télécharger le pilote en cliquant sur la barre bleue (symbole du nuage). Au moment de notre test, les sketches étaient bien sûr exempts de virus ! 
 Windows  : http://www.wch.cn/download/CH341SER_ZIP.html   Linux :&amp;nbsp;   https://github.com/juliagoda/CH341SER   OS  : http://www.wch.cn/download/CH341SER_MAC_ZIP.html  
 Mise à jour 21.11.2022 : un client nous a fait savoir que l&#039;utilisation du pilote ci-dessus pour OS peut, dans certaines circonstances, entraîner des complications. Nous recommandons donc le pilote suivant (payant).&amp;nbsp;   https://www.mac-usb-serial.com/dashboard/   Tu trouveras plus d&#039;informations sur&amp;nbsp; https://thingsmatic.com/2017/08/07/using-ch340-devices-with-osx/ &amp;nbsp;. 
 Nous tenons à préciser que l&#039;installation peut nécessiter des droits d&#039;administrateur. 
 Comment installer le pilote CH340 maintenant ? 
 Une fois que tu as téléchargé le fichier correspondant, tu peux le décompresser (par exemple avec WinRar). Ouvre ensuite le fichier Setup.exe. Une nouvelle fenêtre s&#039;ouvre ensuite. Dans celle-ci, tu choisis le fichier &quot;CH341SER.INF&quot; sous &quot;Select INF&quot;. Ensuite, tu confirmes ta sélection en cliquant sur le bouton &quot;Install&quot;. Si l&#039;installation est réussie, un popup s&#039;affiche pour confirmer l&#039;installation. 
 Et comment puis-je utiliser ma carte de microcontrôleur compatible avec le pilote CH340 ? 
 C&#039;est très simple : (presque) exactement comme une carte avec un chipset ATmega328p ou ATmega16U2. Commence par établir une connexion USB entre le microcontrôleur et ton ordinateur. Le microcontrôleur devrait ensuite être visible dans le gestionnaire de périphériques. 
 Ensuite, ouvre l&#039;IDE Arduino. Dans ce dernier, sélectionne le type de ton microcontrôleur sous &quot;Outils&quot; et &quot;Carte&quot;. Ensuite, sous &quot;Outils&quot; et &quot;Port&quot;, choisis le port COM de ton contrôleur. En règle générale, il s&#039;agit du port COM avec le chiffre le plus élevé.     Important : dans l&#039;étape suivante, tu dois sélectionner le ATmega329p (old bootloader) dans &quot;Outils&quot; et &quot;Processeur&quot;. Ce n&#039;est qu&#039;alors que tu pourras jouer avec le contrôleur CH340 !    Ce n&#039;était pas si difficile, n&#039;est-ce pas ? Si tu veux te lancer directement dans ton prochain projet, nous te recommandons notre plateforme d&#039;apprentissage gratuite  www.funduino.de  avec plus de 250 instructions gratuites sur les capteurs et actionneurs les plus populaires et bien plus encore ! 
                ]]>
            </content>

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

    
</feed>
