<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/nl/blog/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom feed</title>
    <id>https://funduinoshop.com/nl/blog/?sRss=1</id>
    <updated>2026-05-04T03:58:32+02:00</updated>
    
        <entry>
            <title type="text">WRO Duitsland Finale 2025</title>
            <id>https://funduinoshop.com/nl/wro-duitsland-finale-2025</id>
            <link href="https://funduinoshop.com/nl/wro-duitsland-finale-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Ook dit jaar mochten we weer exposeren tijdens de Duitse finale van de World Robot Olympiad - dit keer van 27-28 juni 2025 in de Westfalenhalle Dortmund.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Ook dit jaar hadden we weer de eer om deel te nemen aan de Duitse finale van de World Robot   Olympiade   - deze keer   van 27-28 juni 2025   in   de Westfalenhalle   Dortmund. In 2024 stonden we al aan de start in Passau en dat was voor ons een geweldige ervaring   geweldig   Gevoel om deel uit te maken van deze bijzondere (en   (en voortdurend groeiend!)   Evenement voor de tweede keer.   
 
 
       
   We hebben ongelooflijk veel indrukken en   geweldige   En geweldige gesprekken gehad, vooral met kinderen en jongeren uit allerlei leeftijdsgroepen. Het enthousiasme en de nieuwsgierigheid waarmee ze technologie en robotica benaderen is gewoon aanstekelijk en een waar genot. Voor ons was de finale niet alleen spannend, maar ook absoluut verrijkend.   
 
 
   We willen graag van deze gelegenheid gebruik maken om Markus   Fleige   en zijn team, die opnieuw geweldig werk hebben geleverd met de organisatie van het evenement. Je kon overal voelen hoeveel hart en ziel er in het evenement zat.   
 
 
   Op de   Funduino  -Stand presenteerden we een aantal van onze producten - waaronder de Starter Kit   en de Cube   de   Unitree   Go2 robothond. Het jonge publiek was bijzonder enthousiast, stelde talloze vragen en bewonderde de hond met stralende ogen.   
 
 
   Al met al was het een geslaagd weekend vol inspiratie, dialoog en leuke ontmoetingen. We zijn dankbaar dat we erbij mochten zijn - en kijken nu al uit naar de volgende keer!   
    Jullie team van Funduino       
 &amp;nbsp; 
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Europees Robotica Forum 2025</title>
            <id>https://funduinoshop.com/nl/europees-robotica-forum-2025</id>
            <link href="https://funduinoshop.com/nl/europees-robotica-forum-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Van 25 tot 27 maart 2025 waren we vertegenwoordigd op het European Robotics Forum in Stuttgart - een van de belangrijkste ontmoetingsplaatsen voor robotica-experts uit heel Europa.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Van     25. tot 27 maart 2025     waren we op het     Europese Robotica Forum in Stuttgart     een van de belangrijkste ontmoetingsplaatsen voor robotica-experts uit heel Europa.   
 
 
   Deze keer   waren we daar exclusief met de     Robotarmen van   Dobot     i  t het cultuur- en congrescentrum in   Stuttgart   en konden ze presenteren aan een internationaal publiek van experts. Het was voor ons een spannende gelegenheid om de veelzijdige toepassingsmogelijkheden van de   Dobot  -Systemen live te demonstreren en de dialoog aan te gaan met geïnteresseerde bezoekers.   
 
 
       
   De respons was geweldig: veel experts uit onderzoek, industrie en onderwijs maakten van de gelegenheid gebruik om de robots in actie te zien. We waren vooral blij met de verbazing en het enthousiasme die we bij onze stand konden voelen - of het nu tijdens de eerste ontmoeting was of tijdens de intensieve technische discussies die volgden.   
 
 
   We keren met veel nieuwe indrukken terug uit Stuttgart. Het was bijzonder waardevol voor ons om deel uit te maken van dit internationale netwerk en om de   Dobots   te presenteren aan zo&#039;n breed gespecialiseerd publiek. De discussies en feedback moedigen ons aan om robotica actief te blijven promoten in het onderwijs en in de praktijk. Voor ons was het eerste optreden op het     Europese Robotica Forum     een belangrijke stap voor ons - en zeker niet de laatste.   
    Jouw team van Funduino   
       
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Didacta 2025 in Stuttgart</title>
            <id>https://funduinoshop.com/nl/didacta-2025-in-stuttgart</id>
            <link href="https://funduinoshop.com/nl/didacta-2025-in-stuttgart"/>
            <summary type="html">
                <![CDATA[
                
                                            Van 11 tot 15 februari 2025 waren we weer vertegenwoordigd op de Didacta in Stuttgart - en net als in voorgaande jaren maakte de beurs zijn belofte weer waar.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Van     11. tot 15 februari 2025     waren we weer te vinden op de     Didacta in Stuttgart     en net als voorgaande jaren heeft de beurs weer   opnieuw   opnieuw   geleverd wat het beloofde  .   
 
 
   We hebben veel boeiende gesprekken   met jullie en waren blij met de grote belangstelling voor onze producten. We presenteerden een kleurrijke mix op onze stand: van onze   onze   klassieke     Funduino  -Producten     tot de     Dobot  -Robotarmen     tot    Flux lasersnijders    . Het was vooral leuk om te zien dat bezoekers uit alle leeftijdsgroepen enthousiast waren over onze technologie - van nieuwsgierige leerlingen tot ervaren leerkrachten. Juist deze dialoog met zoveel verschillende mensen maakt Didacta zo speciaal voor ons.   
     
 
 
   Een echt hoogtepunt dit jaar   w  was   de     Unitree   Go2    . De behendige robothond trok meteen ieders aandacht, liet ogen oplichten en werd een publiekstrekker. Er werden talloze foto&#039;s genomen en velen maakten van de gelegenheid gebruik om er zelf mee te spelen. Het enthousiasme   was ronduit   voelbaar - en wij genoten er ook van.   
 
 
     
   We kunnen terugkijken op vijf intensieve dagen op de beurs, vol inspiratie, dialoog en nieuwe ideeën. Naast vele indrukken nemen we ook mee   EUER   waardevolle feedback en nieuwe impulsen mee die ons zullen stimuleren in ons werk. Hartelijk dank aan iedereen die ons bezocht heeft - jullie hebben Didacta 2025 voor ons tot een heel bijzonder evenement gemaakt   zeer   een heel bijzondere ervaring voor ons. We kijken er nu al naar uit om jullie volgend jaar weer te zien!   
 &amp;nbsp; 
 
 
    Jullie team   van   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/nl/led-halloween-kuerbis</id>
            <link href="https://funduinoshop.com/nl/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">Knop op de Raspberry Pi</title>
            <id>https://funduinoshop.com/nl/knop-op-de-raspberry-pi</id>
            <link href="https://funduinoshop.com/nl/knop-op-de-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            In de eerste voorbeelden leerden we de GPIO-pinnen kennen als uitgangen die we op HIGH zetten om een LED te laten oplichten. Maar GPIO staat voor General Purpose Input/Output. Je kunt de pinnen dus ook als ingang gebruiken...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  In de eerste voorbeelden leerden we de GPIO-pinnen kennen als uitgangen die we op HIGH zetten om een LED te laten oplichten. Maar GPIO staat voor General Purpose Input/Output. Je kunt de pinnen dus ook als ingangen programmeren. Dan kan worden bepaald of er spanning op de ingang staat (HIGH) of niet (LOW). De Raspberry Pi heeft alleen digitale ingangen (we zullen later een workaround leren kennen voor het meten van analoge spanningen), maar de aangelegde spanning hoeft niet precies 3,3V te zijn om als HOOG herkend te worden en niet 0V om als LAAG herkend te worden. Tot ongeveer 1,4V wordt herkend als LAAG, alles boven 1,9V wordt zeker herkend als HOOG. Alleen het kleine bereik rond ½ van 3,3V en een vrije pin waar niets op is aangesloten zijn problematisch.  
  We zullen verschillende digitale sensoren leren kennen die een alarm of een bepaalde actie in ons programma moeten triggeren (bijvoorbeeld een bewegingsmelder). De eenvoudigste van deze sensoren is de knop, een verende schakelaar die een circuit sluit wanneer de knop wordt ingedrukt en weer opent wanneer de knop wordt losgelaten.  
  Als we één contact van de knop verbinden met een GPIO pin en het andere met 3,3V, wordt het signaal HIGH duidelijk gedetecteerd wanneer de knop wordt ingedrukt. Het probleem begint nadat de knop wordt losgelaten. Welke status heeft de GPIO dan? Een ongedefinieerde! Je kunt hier niet mee programmeren. In uitgeschakelde toestand zou de GPIO dus permanent op GND moeten staan. Dit zou echter leiden tot kortsluiting wanneer de knop wordt ingedrukt. Een oplossing is een weerstand die groot genoeg moet zijn zodat er slechts een kleine stroom vloeit. Weerstanden van 4,7 k&amp;nbsp;(=4700 Ohm) of 10 kΩ&amp;nbsp;(=10.000 Ohm) zijn gebruikelijk. Deze weerstanden worden pull-down weerstanden genoemd.  
  Je kunt de GPIO echter ook zo programmeren dat hij normaal HIGH aangeeft en het indrukken van een toets tegen GND herkent als een verandering naar LOW. Dan wordt de weerstand een pull-up weerstand genoemd. En om het nog verwarrender te maken voor beginners, hebben de Raspberry Pi GPIO&#039;s een interne pull-up of pull-down weerstand die in het programma kan worden geactiveerd of gedeactiveerd. Gelukkig maakt dit de eerste schakelingen heel eenvoudig.  
  Het schakelschema: Drukknop op de Raspberry Pi  
     
     
  De programmacode: Drukknop op de Raspberry Pi  
  uit gpiozero importeer LED, Knop
uit signaal importeer pauze
led = LED (12 )
 knop  = knop (16 )
 knop  .wanneer_ingedrukt  = led .aan 
 button  .when_released  = led .off 
  pauze  ()    
   Uit de module gpiozero worden de klassen LED en button geïmporteerd, gescheiden door komma&#039;s, waarna de objecten led en button worden geïnstantieerd met de respectievelijke GPIO-nummers.     In plaats van de    slaap()   -Functie uit de module    tijd   &amp;nbsp;module,    pauze   &amp;nbsp;van de module    signaal   &amp;nbsp;sleep() zou volledige stilstand betekenen, de toetsaanslag zou gedurende die tijd niet worden opgemerkt. Zonder pause() zou het programma stoppen en zou er niets gebeuren.     De instantiëring van de knop was heel eenvoudig omdat we alleen het GPIO-nummer hebben opgegeven en verder de standaardinstellingen hebben gebruikt (zie de class definitie op de volgende regel). Als je hiervan wilt afwijken, moet je verdere parameters invoeren als sleutelwoordargumenten.   
   klasse  gpiozero .Button  (pin , *,  pull_up=True ,  active_state=None ,  bounce_time=None ,
 hold_time=1 ,  hold_repeat=False ,  pin_factory=None )  
   Meer details over gpiozero kunnen worden gevonden      hier     .    
  Uitbreiding van de experimentele opstelling: Een stoplichtcyclus moet worden gestart met een Raspberry Pi wanneer er op een knop wordt gedrukt.  
  De experimentele opstelling is gebaseerd op het eerste voorbeeld. In plaats van een LED wordt het LED stoplicht gebruikt. Deze heeft ingebouwde serieweerstanden. We instantiëren drie LED-objecten en definiëren een functie trafficLight, die wordt aangeroepen wanneer er op een knop wordt gedrukt.  
  De programmacode: Verkeerslichtcyclus op de Raspberry Pi   
  van gpiozero  importeer  LED, Knop
van signaal  importeer  pauze
uit tijd  importeer  slaap
roodled = LED (16 )
geelled = LED (20 )
groenled = LED( 21 )
knop = knop (12 )
def verkeerslicht():
       redled.on()
    slaap(1)
    geelled.aan()
    slaap(1)
    groenled.aan()
    roodled.uit()
    geelled.uit()
    slaap(1)
    geelled.aan()
    groenled.uit()
    slaap(1)
    roodled.aan()
    geelled.uit()
    slaap(1)
    roodled.uit()
knop.wanneer_ingedrukt = verkeerslicht
pauze()  
  Uitbreiding: Reactiespel met twee knoppen op de Raspberry Pi  
   Je hebt twee knoppen nodig, een zoemer en een rode en een gele LED. Na het starten van het reactiespel gaat de gele LED als eerste branden. Met    tijd = uniform(5, 10)   &amp;nbsp;gaat de rode LED branden na een willekeurige tijd tussen vijf en tien seconden. Dan mogen twee spelers elk zo snel mogelijk op hun knop drukken. Als je te snel drukt, word je betrapt op vals spelen en gaat de zoemer een halve seconde af.   
  De programmacode: Reactiesonde met twee knoppen op de Raspberry Pi   
   #! /usr/bin/python3 
 # Reactiespel - druk op knop, wanneer rode LED oplicht 
 # gebaseerd op gpiozero documentatie, Basis Recepten 
 # verbeterd om valsspelen te herkennen door Bernd Albrecht 
 # Rode LED brandt 5 - 10 seconden na de gele LED 
 uit  gpiozero  importeer  Button, LED, Buzzer
 uit  tijd  importeer  slaap
 uit  random  importeer  uniform
 uit  sys  importeer  exit
led_red = LED (16 )
led_geel = LED( 20 )
zoemer = zoemer (12 )
speler_1 = Knop (23 )
speler_2 = Knop( 18 )

led_geel .aan ()
tijd = gelijkmatig (5 ,  10 )
slaap(tijd)
 als  player_1.is_gedrukt:
    print ( &quot;Speler_1 speelt vals!&quot; )
    zoemer .aan ()
    slaap (0,5 )
    zoemer .uit ()
    led_geel .uit ()
    afsluiten()
 als  speler_2.is_ingedrukt:
    print ( &quot;Speler 2 speelt vals!&quot; )
    zoemer .aan ()
    slaap (0.5 )
    zoemer .uit ()
    led_geel .uit ()
    afsluiten()
led_rood .aan ()
led_geel .uit ()
 while  True:
    if  player_1.is_pressed:
        print ( &quot;Speler_1 wint!&quot; )
        break 
    als  player_2.is_gedrukt:
        print ( &quot;Speler 2 wint! &quot;)
        break 
led_red .uit ()  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">RGB LED op de Raspberry Pi</title>
            <id>https://funduinoshop.com/nl/rgb-led-op-de-raspberry-pi</id>
            <link href="https://funduinoshop.com/nl/rgb-led-op-de-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                             Een RGB LED is de combinatie van drie LED&#039;s van verschillende kleuren in één behuizing. De term RGB verwijst naar de kleuren &quot;rood&quot;, &quot;groen&quot; en &quot;blauw&quot;. De respectievelijke LED&#039;s kunnen worden aangestuurd door pulsbreedtemodulatie (PWM).
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Een RGB LED besturen met een Raspberry Pi microcontroller 
 Wat is een RGB LED eigenlijk? 
 Een RGB LED is de combinatie van drie LED&#039;s met verschillende kleuren in één behuizing. De term RGB verwijst naar de kleuren &quot;rood&quot;, &quot;groen&quot; en &quot;blauw&quot;. De respectievelijke LED&#039;s kunnen worden aangestuurd met pulsbreedtemodulatie (PWM). Dit maakt een veelheid aan kleurencombinaties mogelijk. 
 Een RGB LED heeft vier pootjes, één voor elke kleur en één gemeenschappelijke voor alle drie de kleuren. Afhankelijk van de uitvoering is de langste van de vier pootjes de gemeenschappelijke anode (+) of kathode (-). De enkele poot naast deze langste poot is de aansluiting voor de rode component. De groene en blauwe componenten worden aangestuurd via de pootjes aan de andere kant.    
 Welk type RGB LED je hebt, gemeenschappelijke anode of gemeenschappelijke kathode, is aan de buitenkant niet te zien. Gelukkig kan er met vallen en opstaan niets beschadigd raken. De RGB LED licht niet op in de blokkeerrichting. Belangrijk: De drie geïmplementeerde LED&#039;s hebben ook serieweerstanden nodig. Als je het academisch wilt doen, kun je verschillende serieweerstanden berekenen uit de respectieve fluxspanningen. Voor de eenvoud kun je ook dezelfde weerstanden tussen 100 en 330 Ω (Ohm) gebruiken. 
 Versie a: &quot;Gemeenschappelijke kathode&quot; - De langste poot van de LED is &quot;-&quot; en de drie kortere poten worden aangestuurd op de GPIO&#039;s met &amp;nbsp;&quot;+&quot; (spanning). 
 Versie b: &quot;Gemeenschappelijke anode&quot; - De langste poot van de LED is &quot;+&quot; en de drie kortere poten worden aangestuurd met &quot;-&quot; (GND) op de GPIO&#039;s. 
 Door de kleuren te mengen kunnen veel meer kleuren worden gemaakt. Door bijvoorbeeld de kleuren &quot;blauw&quot; en &quot;groen&quot; te mengen ontstaat de kleur &quot;turquoise&quot;, rood en groen produceren geel, rood en blauw produceren magenta en alle drie de kleuren in gelijke hoeveelheden produceren wit. 
       Het schakelschema: RGB LED op de Raspberry Pi   
 De programmacode: RGB LED op de Raspberry Pi 
 Voorbeeldprogramma voor een RGB-LED met een gemeenschappelijke kathode: 
 uit gpiozero  importeer  RGBLED
van tijd  importeer  sleep
 led  = RGBLED (rood=14,   groen=15,   blauw=18) 
 duur  =  2 

 # langzaam intensiteit van alle kleuren verhogen (5sec) 
voor n  in  range (100 ):
    led .blauw  =  n/100 
    led .rood  =  n/100 
    led .groen  =  n/100    
    slaap (0.05 )
led .kleur  = (0 ,  0 ,  0 )  # uit 
slaap(duur)
led .rood  =  1   # volledig rood 
slaap(duur)
led .rood  =  0.5   # half rood 
slaap(duur)
led .kleur  = (1 ,  1 ,  0 )  # geel 
slaap(duur)
led .kleur  = (0 ,  1 ,  0 )  # volledig groen 
slaap(duur)
led .kleur  = ( 0 ,  1 ,  1 )  # cyaan 
slaap(duur)
led .color  = ( 0 ,  0 ,  1 )  # volledig blauw 
slaap(duur)
led .color  = ( 1 ,  0 ,  1 )  # magenta 
slaap(duur)
led .color  = ( 1 ,  1 ,  1 )  # wit 
slaap(duur)
led .color  = ( 0 ,  0 ,  0 )  # uit 
slaap(duur) 
 Later zullen we zien hoe we drie potentiometers kunnen gebruiken om de kleurcomponenten in te stellen. Hiervoor hebben we echter een externe analoog-digitaal converter nodig, omdat de Raspberry Pi alleen digitale signalen kent - HIGH of LOW. 
    
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">RC auto bouwen voor Arduino: Autonoom Voertuig - Deel 3</title>
            <id>https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-3</id>
            <link href="https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-3"/>
            <summary type="html">
                <![CDATA[
                
                                            Welkom bij het derde deel van onze blogserie over robotauto&#039;s. In het eerste deel hebben we de basisbeginselen van het basisvoertuig geleerd. In het tweede deel hebben we een universeel codesysteem ontwikkeld dat we kunnen gebruiken om de rijniveaus voor de robotauto in te ste...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Inzicht in de mobiliteit van de toekomst met robotauto&#039;s, deel 3  
 Welkom bij het derde deel van onze blogserie over robotauto&#039;s. In het   eerste deel  &amp;nbsp;leerden we over de basisprincipes van het basisvoertuig. In het   tweede deel  &amp;nbsp;ontwikkelden we een universeel codesysteem om de rijstappen van de robotauto te definiëren en realiseerden we een eenvoudige afstandsbediening met een infrarood afstandsbediening. Vanwege de fysieke beperkingen van deze afstandsbediening, wil ik in deze aflevering de overdracht van rij-instructies met Bluetooth laten zien, bijvoorbeeld van een smartphone naar de BT-ontvanger HC-05. Bluetooth is een 2,4GHz radiosignaal met een kort bereik. Veilig tot ca. 10 m en storingsvrij in zonlicht. 
 De Bluetooth module HC-05 is eigenlijk een  transceiver=zender + ontvanger . We gebruiken hem echter alleen als ontvanger, voor het verzenden van de rij-instructies gebruiken we een Bluetooth APP op een Android smartphone (vanwege de speciale manier waarop Apple met Bluetooth omgaat, werkt het niet met een iPhone). In principe is het ook mogelijk om een Bluetooth afstandsbediening te bouwen met de HC-05; hiervoor zijn echter een tweede HC-05, een microcontroller en een invoerapparaat (joystickcontroller) nodig. 
 &amp;nbsp;  
  Van de zes pinnen op de HC-05 module zijn er slechts vier nodig: VCC (5V) en GND voor de voeding van de module en RXD en TXD voor de verbinding met twee pinnen van de microcontroller waarop SoftwareSerial is ingesteld. Je kunt het opschrift LEVEL: 3.3V echter niet negeren om de module niet te beschadigen. Op onze microcontroller met 5V logica hebben we een spanningsdeler nodig van 5V naar 3,3V op zijn minst voor de RXD pin, bijvoorbeeld weerstanden van 1 kOhm en 2,2 kOhm. 
 Het schakelschema: HC-05 module op de microcontroller    
 De AT-commando&#039;s van de HC-05 module voor Arduino microcontrollers 
 Links van de connector met het opschrift Key zit een klein knopje dat belangrijk is voor de configuratie. Als dit knopje wordt ingedrukt als de module is ingeschakeld, komen we in de AT-commando-modus (de LED knippert langzaam in een ritme van 2s), waarin we de instellingen uitvoeren met zogenaamde AT-commando&#039;s (voor Attention, Achtung). Hiervoor gebruiken we een aangepast voorbeeldprogramma, waarbij de gebruikelijke seriële interface is aangesloten op de Seriële Monitor van de Arduino IDE en de HC-05 via SoftwareSerial. 
  /*
  SoftwareSerial meervoudige seriële test
 Ontvangt van de hardware-serieel, stuurt naar software-serieel.
 Ontvangt van de software-serieel, stuurt naar de hardware-serieel.
 Het circuit:
 * RX is digitale pin 10 (aansluiten op TX van ander apparaat)
 * TX is digitale pin 11 (aansluiten op RX van ander apparaat) // spanningsdeler!
 gemaakt in de nevelen der tijd
 gewijzigd 25 mei 2012
 door Tom Igoe
 gebaseerd op het voorbeeld van Mikal Hart
 Deze voorbeeldcode is publiek domein.
 */ 
  #include   &amp;lt;SoftwareSerial.h&amp;gt;  
 SoftwareSerial  BTSerial (10 ,  11 );  // RX, TX // mySerial veranderd in BTSerial 
 char  c= &#039; &#039; ;  // Declaratie van variabele voor verzending 

 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 () {  // steeds opnieuw uitvoeren 
  als  (BTSerial .available ()) {
    c=BTSerial. read ();
     Serial . write (c);
  }
  als  ( Serial  .available ()) {
    c= Serial . read ();
    BTSerial. write (c);
     Serial . write (c);                                                                                        // re-transmission of input in Serial Monitor 
  }
} 
 In de volgende afbeelding worden de essentiële AT-commando&#039;s gebruikt. Het externe station, de HC-05, stuurt indien nodig een antwoord en bevestigt met OK. 
 We zijn vooral geïnteresseerd in de naam en het HEX-adres om de module later op de smartphone te kunnen identificeren. De AT commando&#039;s worden ingevoerd in de seriële monitor van de microcontroller. In de volgende afbeelding zie je de seriële monitor van de Arduino IDE. 
 Als je wilt, kun je het standaard wachtwoord 1234 wijzigen met &quot;AT+PSWD=xxxx &quot;, waarbij x staat voor een cijfer van 0 tot 9. Controleer vervolgens met &quot;AT+PSWD? &quot; of de invoer is gelukt.    Nadat de invoer is voltooid, wordt de module even losgekoppeld van de voeding. Na het opnieuw inschakelen zonder op een knop te drukken, staat de HC-05 module in de standaardmodus. De LED knippert snel (ca. 5 keer/s). 
 Aanpassingen aan de RC auto: ander motorschild 
 Nu naar de robotauto. Nadat we de vorige keer de Motorcontroller V2 hadden gebruikt, die alleen de twee I2C-connectoren SDA=A4 en SCL=A5 nodig heeft voor de besturingssignalen, wil ik deze keer de oudere Motorcontroller V1 introduceren, die veel digitale pinnen blokkeert, maar vaak voor een spotprijsje te koop is.     Ik heb dit Motorshield ook een beetje aangepast om toegang te krijgen voor sensoren en radio-ontvangers. Aan de digitale pinnenkant is er maar één pin die toegankelijk is met een haakse connector: Pen 2. Dit is goed voor degenen die hier de IR-ontvanger willen aansluiten. Er zijn meer uitbreidingsmogelijkheden aan de andere kant, waar je toegang hebt tot alle analoge ingangen en de voeding met behulp van vrouwelijke connectors (ook wel socket connectors genoemd). 
 Omdat alle analoge ingangen ook als digitale in- of uitgangen kunnen worden gebruikt, hebben we hier de mogelijkheid om onze radio-ontvangers aan te sluiten. Dit werkt uitstekend met de 433 MHz zendontvanger HC-12 (zie volgende aflevering), maar voor de BT ontvanger HC-05 alleen met beperkingen. Ten eerste kunnen we de RXD-pin niet rechtstreeks aansluiten, daarvoor hebben we de spanningsdeler nodig, en ten tweede leveren de pinnen niet genoeg stroom om de module op deze pinnen van stroom te voorzien. 
 De volgende afbeelding toont een kleine adapter die we zelf hebben gemaakt, die de HC-05 van 5V en massa voorziet via de juiste pinnen, TXD rechtstreeks aansluit op RX van de SoftwareSeriële interface A1 =D15 en RXD via de spanningsdeler op A2 = D16.   
 Het aansluitschema: HC-05 module met L293D Motorshield op de Arduino microcontroller     
 De schakeling kan natuurlijk ook worden gerealiseerd op een mini breadboard met jumper kabels. 
 Net als de vorige keer wordt de code voor de rij-instructies verhoogd of verlaagd met een druk op de knop; deze keer echter niet met IR-afstandsbediening, maar met de aanraakfunctie in de APP van de smartphone en de Bluetooth-vraag via SoftwareSerial. 
 De HC-05 Bluetooth-module koppelen met een Android-toepassing (APP) 
 Voordat de APP verbinding kan maken met de Robot Car, moeten we deze in de instellingen koppelen met de Bluetooth-module. Dit zou vrij eenvoudig moeten zijn, aangezien we eerder de AT-commando&#039;s hebben gebruikt om de naam en het HEX-adres van de HC-05 op te vragen. 
 Als het koppelen is gelukt en een geschikte BT app is geïnstalleerd, kan de app worden gestart en ingesteld. Door op het vergrootglas in de linker afbeelding te tikken, worden geschikte apparaten weergegeven. We tikken op de HC-05 en krijgen de melding &quot;connected&quot;. De app die ik gebruik biedt verschillende interfaces voor de bediening (middelste afbeelding). Ik heb besloten om de spelcontroller te gebruiken. Rechtsboven in de middelste afbeelding staan twee pijlen die een kleine cirkel vormen. Tik hier op als de verbinding verbroken is. 
 De rechterafbeelding toont de knoppen van een spelcontroller. Voordat je ze voor het eerst gebruikt, moet je aan de knoppen de numerieke waarden toewijzen die moeten worden doorgegeven als je erop tikt. 
 Voor de cursorknoppen heb ik de numerieke waarden 1 tot en met 4 met de klok mee gegeven. Aan de andere knoppen heb ik de numerieke waarde 5 toegekend. Deze waarden worden in de sketch doorgegeven aan de variabele  blueToothVal &amp;nbsp;en leiden in de &amp;nbsp;if-pointers van  de functie  loop()  tot de bepaling van de code voor het besturingsniveau.    
 De veranderingen van Infrarood naar Bluetooth en Motorcontroller V2 naar V1 veroorzaken enkele wijzigingen in het hoofdgedeelte van de schets. Aan de andere kant verandert er bijna niets in de motor() functie. Alleen in de notatie worden de functies motor1-&amp;gt;setSpeed() nu motor1.setSpeed() vanwege de verschillende programmabibliotheken (libraries). 
 De programmacode: Een RC-auto bouwen voor Arduino 
 * Voorbeeldcode  voor  robotauto met motorschild V1 en BT-ontvanger   HC-05 , vanaf  20220515 
* gebaseerd op Adafruit Motor shield V2 bibliotheek, copyright Adafruit Industries LLC
*  deze  code is  publiek  domein, veel plezier!
* aangepast  voor  Funduino
* Pinnen
* BT VCC naar Arduino  5V uit.
* BT GND naar GND
* Arduino  A1=15  (SS RX) - BT TX geen spanningsdeler nodig
* Arduino  A2=16  (SS TX) - BT RX via een spanningsdeler (5v naar  3,3v )
*/

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

  #include   &amp;lt;SoftwareSerial.h&amp;gt;  
 // HC-05 initialiseren 
 SoftwareSerial  BTSerial (15 ,  16 );  // RX, TX kruisen naar TX, RX(spanningsdeler) 
 char  blueToothVal;
 int  x =  0 ;
 int  y =  0 ;
 int  links =  0 ;
 int  rechts =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correctie voor 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; );
}  // einde setup 

 void   loop () {
  if (BTSerial .available ())  //als data is ontvangen  ... 
 Serial.print(&quot;beschikbaar&quot;);     
{
    blueToothVal=BTSerial. read (); //..sollen diese ausgelesen werden 
 Serial.println(blueToothVal); 
  }
    if  (blueToothVal== &#039;1&#039; )  //als de Bluetooth-module een &quot;1&quot;.... ontvangt 
   {
       if  (code&amp;lt; 9000 )   code = code +  1000 ;      
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    anders   als  (blueToothVal== &#039;2&#039; ) //als   de Bluetooth-module een &quot;2&quot;.... ontvangt
   {
       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; ) //als de   Bluetooth-module een &quot;3 &quot;ontvangt ....
   {
       if  (code&amp;gt; 2000 )   code = code -  1000 ;        
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
    else   if  (blueToothVal== &#039;4&#039; ) //als de   Bluetooth-module een &quot;4&quot; ontvangt ....
    {
     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; ) //als de   Bluetooth-module een &quot;5&quot; ontvangt...
   {           
      code =  5555 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);    
    }
    delay  (200 );  //kleine vertraging voor betere seriële communicatie en om stuiteren te voorkomen 
    motor();
}  // einde lus 

 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);

  //Correctie van de snelheidsstappen voor bochten 
  als   (x==1 ){
    right = speedL+ 20 ;
    left = speedL -20 ;
  }
  anders   als  ( x==2 ){
    right = speedL+ 15 ;
    left = speedL -15 ;
  }
  anders   als  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  anders   als  ( x==4 ) {
    right = speedL+ 5 ;
    left = speedL -5 ;
  }
  anders   als  ( x==6 ) {
    right = speedL  -5 ;
    left = speedL+ 5 ;
  }
  anders   als  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  anders   als  ( x==8 ) {
    right = speedL -15 ;
    left = speedL+ 15 ;
  }
  anders   als  ( x==9 ) {
    right = speedL -20 ;
    left = speedL+ 20 ;
  }
  anders  {
    right = speedL;
    left = speedL;
  }

  //Invoer van de rijstappen voor &quot;links&quot; en &quot;rechts 
  Serial  .print ( &quot;links = &quot; );
  Serial . print (left);
  Serial  . print( &quot; rechts = &quot; );
  Serial  .println (rechts);

  als  (links &amp;lt;  40  &amp;amp; links &amp;gt;  -40 ) {
    motor1. run (RELEASE);
  }
  als  (rechts &amp;lt;  40  &amp;amp; rechts &amp;gt;  -40 ) {
    motor2. run (RELEASE);
  }
  als  ( links&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1. run (FORWARD);
      motor1. setSpeed (left * factor);
  }
  als  ( rechts&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2. run (FORWARD);
      motor2. setSpeed (right * factor);
  }
  als  (links&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1. run (BACKWARD);
      left = -left;
      motor1. setSpeed (left * factor);
  }
  als  (rechts&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2. run (BACKWARD);
      right = -right;
      motor2. setSpeed (right * factor);
  }
}  // einde motor  
 Tot zover de op één na goedkoopste oplossing voor een robotauto met afstandsbediening (ervan uitgaande dat je een Android smartphone hebt). De volgende keer zal ik laten zien hoe eenvoudig het is om een 433 MHz zendontvanger HC-12 te integreren. Hiermee kan zelfs een bereik van enkele honderden meters worden bereikt. De kosten nemen echter toe omdat er nu twee zendontvangers en nog een microcontroller nodig zijn. Tot dan. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Pulserende LED op de Raspberry Pi (pulsbreedtemodulatie)</title>
            <id>https://funduinoshop.com/nl/pulserende-led-op-de-raspberry-pi-pulsbreedtemodulatie</id>
            <link href="https://funduinoshop.com/nl/pulserende-led-op-de-raspberry-pi-pulsbreedtemodulatie"/>
            <summary type="html">
                <![CDATA[
                
                                            Van een LED wordt gezegd dat hij pulserend helderder en donkerder wordt. (Ook wel &quot;fade&quot; genoemd, naar het werkwoord &quot;vervagen&quot;). We willen dit graag implementeren met de zogenaamde pulsbreedtemodulatie...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Van een LED wordt gezegd dat hij pulserend feller en donkerder wordt. (Ook wel &quot;fade&quot; genoemd, naar het Engelse werkwoord  to fade  =  vervagen , verminderen). We willen dit graag implementeren met de zogenaamde pulsbreedtemodulatie. Je kunt hieronder meer informatie vinden over pulsbreedtemodulatie op de Raspberry Pi.  In de eerste stap bekijken we het schakelschema. 
 Het schakelschema: Pulserende LED op de Raspberry Pi (PWM) 
   
  Om de helderheid van een LED te variëren, is het niet voldoende om de spanning te variëren. Door het ontwerp (diode!) is er een bepaalde minimumspanning nodig; deze zogenaamde voorwaartse spanning ligt tussen ongeveer 1,6 en ongeveer 3 V, afhankelijk van de kleur van de LED. Boven deze voorwaartse spanning wordt de LED geleidend en wordt de stroom beperkt door een serieweerstand. Dus: in tegenstelling tot gloeilampen wordt de helderheid niet geregeld door het spanningsniveau. Overigens leveren de GPIO pinnen sowieso maar precies 3,3V. 
 De oplossing hiervoor is pulsbreedtemodulatie (PWM). Dit schakelt de gelijkspanning aan en uit met een hoge frequentie. De totale uitgezonden energie wordt bepaald door de verhouding tussen de duty cycle en de totale duur van een cyclus. Deze duty cycle kan tussen 0 en 100% liggen. 
 Op de Raspberry Pi kun je de softwarematige PWM op alle GPIO-pinnen gebruiken. Maar er zijn ook twee speciale hardware PWM pinnen. Aan de slag! 
 De eerste programmacode: Pulserende LED op de Raspberry Pi met pulsbreedtemodulatie 
  # We beginnen met het importeren van de programmamodules 
import RPi.GPIO als GPIO  # Let op: Let op de notatie: kleine i 
importeer  tijd 
GPIO.setmode(GPIO.BCM)  # We stellen de modus in op BCM 
 LED=23   # Het woord &quot;LED&quot; staat nu voor het getal &quot; 23 &quot; .
GPIO.setup(LED,GPIO.OUT) #  &quot;LED&quot; (pin  23 ) is een uitgang .
Dimmer = GPIO.PWM(LED ,100 )  # We stellen de LED in als PWM met een frequentie van  100  
Dimmer.start (0 )  # Dimmer wordt gestart 
 # De lus begint hier 
 proberen :
    while   True :  #while loop zodat het programma continu doorloopt 
        voor  dc  in  range (0  ,101  ,5 ):          # Lus de duty cycle in  stappen van 5 . 
             Dimmer.ChangeDutyCycle(dc)  # Verander de duty cycle van de dimmer. 
            time  .sleep  (0,1 )  # Wacht  0,1  seconde. 
        for  dc  in  range (100  ,-1  ,-5 ):      # Lus de activiteitscyclus in stappen van -5 . 
            Dimmer.ChangeDutyCycle(dc)  # Verander de duty cycle van de dimmer. 
            time  .sleep  (0.1 )  # Wacht  0.1  seconde. 
except KeyboardInterrupt:  # Met CTRL+C onderbreken we het programma 
    print (&quot;Finished&quot;)  # Schrijf &quot;Finished&quot; in het commandoregelvenster 
    Dimmer .stop ()  # Stop de dimmer. 
    GPIO.cleanup()  # Beëindig het programma.  
 In dit voorbeeld leren we een andere vorm van een lus kennen: de for-lus. Deze opdrachtregel eindigt ook met een dubbele punt gevolgd door inspringen van de regels die herhaald moeten worden. 
 De variabele dc (voor duty cycle) wordt verhoogd in het bereik 0 tot en met 101 in stappen van vijf:  for dc in range(0,101,5) : 
 De tweede for-lus telt terug van 100 naar -1 met -5:  for dc in range(100,-1,-5):  
 De tweede programmacode: Pulserende LED op Raspberry Pi met pulsbreedtemodulatie met gpiozero commando    
 # We beginnen met het importeren van de programmamodules
van gpiozero importeer PWMLED
import tijd
pwmled = PWMLED (23 ) # optionele  parameter  frequentie=xxx  (standaard 100) 

#  De lus begint hier
proberen:
    while  True: # while-lus zodat het programma continu  draait 
        for  dc in range(0,101,5):   # Verhoog de tasgrade in stappen van 5. 
            pwmled.value  = (  dc/100 ) # Verander de duty cycle (tussen  0  en  1 ) van de dimmer.
            time .sleep  (0.1 ) # Wacht  0.1  seconde.
        voor  dc in range (100  ,-1  ,-5 ): # Tel de activiteitscyclus af in   stappen van -5 .
            pwmled.value = (dc/100 ) #  Verander de duty cycle (tussen 0 en 1) van de dimmer. 
            time.sleep(0,1) # Wacht  0,1 seconde .

except  KeyboardInterrupt: # Met CTRL+C onderbreken we het programma 
    print  (  &quot;Finished&quot;  ) # Schrijf  &quot;Finished &quot;  in het commandoregelvenster 
# pwmled.value  = 0 # 1e methode om  de LED te wissen aan het einde van het programma 
    pwmled.close()  # 2e methode om de LED  te wissen aan het einde van het programma 
 Over het algemeen is de programmacode slanker met gpiozero. 
 Let op: De duty cycle ligt tussen 0 en 100%. Terwijl het argument voor de duty cycle in RPi.GPIO de %-waarde is, verwacht gpiozero de waarde als een floating  point  getal (&amp;nbsp;getal) tussen 0,0 en 1. 0, dus 0,5 in plaats van 50 [%]. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">De buzzer en LED aansluiten op de Raspberry Pi</title>
            <id>https://funduinoshop.com/nl/de-buzzer-en-led-aansluiten-op-de-raspberry-pi</id>
            <link href="https://funduinoshop.com/nl/de-buzzer-en-led-aansluiten-op-de-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            In deze blogpost willen we een zoemer en een LED laten oplichten of laten klinken met behulp van een Raspberry Pi microcontroller. Dit programma wordt vaak gebruikt op scholen om te demonstreren...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Opmerking: Voor dit programma is een actieve zoemer nodig (uitleg volgt later), let op de polariteit. Er is geen serieweerstand nodig voor de zoemer (luidspreker). 
 In deze blogpost willen we een zoemer en een LED laten oplichten of laten klinken met behulp van een Raspberry Pi microcontroller. Dit programma wordt vaak gebruikt op scholen om te laten zien hoe eenvoudige uitgangssignalen kunnen worden gebruikt met behulp van een Raspberry Pi met eenvoudige componenten.  Voordat we ingaan op de vraag wat het verschil is tussen een actieve en een passieve luidspreker, laten we eerst het schakelschema en de programmacode bekijken. 
 Het schakelschema: De zoemer en LED aansluiten op de Raspberry Pi 
   
 De broncode: Buzzer en LED aansluiten op de Raspberry Pi 
  # Deze keer gebruiken we ook het eerste programmadeel. Hier worden variabelen ingevoerd. Dit betekent dat er een cijfer achter een letter of een woord staat. In ons geval is de LED aangesloten op pin 23 en de piëzospeaker op pin 4. Om de twee pinnen later niet door elkaar te halen, hernoemen we pin 23 en pin 24 gewoon. 
 # We beginnen met het importeren van de programmamodules 
 importeer  RPI.GPIO  als  GPIO
 importeer  tijd
GPIO.setmode(GPIO.BCM)  # We stellen de modus in op BCM 
 LED=23 ;  # Het woord &quot;LED&quot; staat nu voor het getal &quot;23&quot; .
 Beep=24 ;  # Het woord &quot;Beep&quot; staat nu voor het getal &quot;24&quot; .
GPIO.setup(LED,GPIO.OUT)  # Pin &quot;LED&quot; (pin 23) is een uitgang .
GPIO.setup(Pieps,GPIO.OUT)  # Pin &quot;Pieps&quot; (pin 24) is een uitgang
 # De lus begint hier 
 proberen :
 while   True :  # While-lus zodat het programma continu draait 
GPIO.output(LED,GPIO.HIGH)  # Schakelt de LED in. 
GPIO.output(Pieps,GPIO.HIGH)  # Schakelt de piëzoluidspreker in .
time.sleep (1 )  # Wacht 1 seconde 
GPIO.output(LED,GPIO.LOW)  # Schakelt de LED uit. 
GPIO.output(Pieps,GPIO.LOW)  # Schakelt de piëzoluidspreker uit. 
time.sleep (1 )
 # Hier aan het einde springt het programma naar het begin van de while-lus. Het staat dus op het punt om weer te piepen en op te lichten. Als je de pauze (time.sleep) vergroot of verkleint, piept en licht hij sneller of langzamer op. 
 except  KeyboardInterrupt:  # Met CTRL+C onderbreken we het programma 
 print  (&quot;Finished&quot;)  # Schrijf &quot;Finished&quot; in het commandoregelvenster 
GPIO.cleanup()  # Sluit het programma af  
 Verschil tussen actieve en passieve zoemer 
 De actieve zoemer heeft een ingebouwde oscillator die een  zoemend  geluid produceert wanneer er een spanning van 3,3V of 5V wordt toegepast. Door het ontwerp moet je letten op de polariteit van de zoemer. Bij levering hebben deze zoemers meestal een kleine sticker met het plusteken en de sticker &quot;REMOVE SEAL AFTER WASHING&quot;. Er staat ook weer een plus + op de behuizing van het onderdeel zelf. Je moet twee keer kijken om het langere pootje te zien. Je kunt ook een klein breakout bordje nemen; hier zijn de contacten gemarkeerd met S (staat voor signaal) en - (min, massa).&amp;nbsp; 
 Je kunt de zoemer uitproberen met een eenvoudig programma zoals dat voor de knipperende LED, waarbij de (bijna) elke pin een seconde lang op HOOG en een seconde lang op LAAG wordt gezet. 
 De passieve zoemer heeft geen ingebouwde oscillator, dus de Raspberry Pi moet deze functie overnemen. Als je het bovenstaande programma uitprobeert op een passieve buzzer, zul je elke seconde een zacht &quot;klik&quot;-geluid horen. Als je echter de pauzetijd extreem verkort (sleep(0.001) of sleep(0.002)) en het aan/uit gedurende een bepaalde tijd herhaalt, kun je een geluid horen waarvan we de frequentie eenvoudig kunnen berekenen: één milliseconde elk van HIGH of LOW betekent (zonder rekening te houden met de uitvoeringstijd van de andere commando&#039;s) ongeveer 500 cycli aan/uit per seconde, dus ongeveer 500Hz. 
 Als je een korte waarschuwingstoon wilt laten horen, moet je een actieve zoemer gebruiken die net als een LED wordt in- en uitgeschakeld. Let op de polariteit. 
 Als je een tweetonige sirene (die duidelijker te horen is) of een korte herkenningsmelodie (jingle) wilt programmeren, moet je een passieve zoemer of een kleine luidspreker gebruiken. 
    
 &amp;nbsp; 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">RC auto bouwen voor Arduino: Autonoom Voertuig - Deel 2</title>
            <id>https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-2</id>
            <link href="https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-2"/>
            <summary type="html">
                <![CDATA[
                
                                            Welkom bij het tweede deel van onze nieuwe blogserie over robotauto&#039;s. In het eerste deel leerden we de basis van het basisvoertuig kennen. Deze keer willen we de mogelijkheden van afstandsbediening bespreken, een codesysteem ontwikkelen...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Inzicht in de mobiliteit van de toekomst met robotauto&#039;s, deel 2  
 Welkom bij het tweede deel van onze nieuwe blogserie over robotauto&#039;s. In het  eerste deel  hebben we de basisbeginselen van het basisvoertuig leren kennen. Deze keer willen we de mogelijkheden van afstandsbediening bespreken, een codesysteem ontwikkelen waarmee we de snelheidsstappen van de robotauto kunnen bepalen en tot slot een eenvoudige afstandsbediening realiseren met een infrarood afstandsbediening. 
 Waarom heb ik snelheidsstappen nodig voor een RC auto voor Arduino microcontrollers? 
 1. Voor het regelen van de motorsnelheden vanaf een ander apparaat is er in principe de mogelijkheid om continu waarden te bepalen en door te geven met een potentiometer (poti), of om de waarde van de snelheidstrap te verhogen of te verlagen door op een knop te drukken. De volgende afbeeldingen tonen enkele geselecteerde voorbeelden, in de eerste afbeelding joystickbediening: 
 &amp;nbsp;  
 &amp;nbsp; 
 In de tweede afbeelding zien we onder andere infrarood afstandsbedieningen, een smartphone app met Bluetooth ontvanger en het LCD1602 toetsenbordschild, dat bediend kan worden met een 433 MHz transceiver: 
 &amp;nbsp;  
 &amp;nbsp; 
 Om een uniform schema te krijgen, is het zinvol om de map() functie te gebruiken om de analoge waarden van de pot te reduceren tot waarden die via radio kunnen worden verzonden. De analoog-digitaal omzetter levert 10-bits getallen, dat wil zeggen waarden tussen 0 en 1023. De middelste stand van de mini-joysticks is ongeveer 511. Door de waarde door 100 te delen, kan één joystick twee waarden (x- en y-richting) bepalen die tussen 0 en 10 liggen of, bij gebruik van de map()-functie, tussen 1 en 9. Dit is voldoende voor het invoeren van de snelheid en de snelheid. Dit is voldoende voor het invoeren van de snelheid en voor het nemen van bochten. Ongeacht of we 11 of 9 waarden bepalen, betekent stilstand waarde 5 in de y-richting en voor rechtuit rijden ook waarde 5. 
 Kijkend naar de controller met de twee joysticks (onderdeel van de  4DOF Mini robotarm kit met joysticks en servoaandrijving ), gezien de verscheidenheid aan verschillende systemen, kies ik voor een code tussen 1111 en 9999 die eenvoudig is over te brengen. Het eerste cijfer kan worden gebruikt voor de y-richting van de linker joystick, het tweede cijfer voor de x-richting van de linker joystick, het derde en vierde cijfer voor een optionele tweede joystick of bepaalde toetsen. In het eerste voorbeeld met de IR afstandsbediening hebben we alleen de eerste twee cijfers van de viercijferige code nodig. 
 De snelheidsregeling van de RC Car voor Arduino 
 De snelheidsregeling van de motoren gebeurt met pulsbreedtemodulatie (PWM). De waarde voor de zogenaamde duty cycle is een 8-bits getal, dat wil zeggen een waarde tussen 0 en 255 (=2 tot de macht 8 -1). Als je met een regelbare voeding spanningen tussen 0 en 6 V op de motor zet, zul je merken dat er tot ongeveer 1,5 V niets merkbaar is. Daarna begint de motor te zoemen, maar beweegt niet. Als je tegelijkertijd de stroom meet, zie je een relatief hoge waarde. De energie wordt omgezet in warmte en brommen - niet echt goed. Vanaf 2,4 - 3 volt begint de motor te draaien, de stroomsterkte daalt een beetje als de motor onbelast is. Daarna neemt de snelheid toe, afhankelijk van de toegepaste spanning. Als je de spanning omlaag regelt, zal de motor tot onder 2 volt draaien, maar als hij tot stilstand komt, bijvoorbeeld door verhoogde wrijvingsweerstand of een obstakel, zal hij niet opnieuw starten. Conclusie: Waarden onder ongeveer 2,4 volt moeten worden vermeden, de ingang moet gelijk worden gezet aan 0 (nul) om onnodige slijtage en stroomverbruik te voorkomen. Behalve voor stilstand (code=5) hebben we een Duty Cycle nodig tussen ongeveer 40% en 100% met een voedingsspanning van 6V voor de motoren. 
 De voeding voor de RC Car voor Arduino 
 We hebben in het eerste deel al verschillende mogelijkheden voor de voeding besproken. Vier AA-batterijen van elk 1,5V geven 6V, de maximale spanning van de kleine gele motortjes. Vier AA-batterijen van elk 1,2 V zijn niet genoeg voor de voeding. Je hebt dan een batterijhouder nodig voor 6 batterijen en dat geeft 7,2 volt. En twee lithium-ion batterijen (nominale spanning 3,7 V) leveren meer dan 8 volt als ze volledig zijn opgeladen. Het is dus logisch om in het programma een factor in te stellen die de spanning van het hoogste aandrijfniveau beperkt tot 6V. 
 De RC auto besturen voor Arduino 
 Als de rij-instructies worden gegeven met knoppen, mogelijk zelfs in een smartphone app, wordt de juiste waarde verhoogd of verlaagd voor de uitgangswaarde 55xx (stilstand) zonder het maximum te overschrijden. 
 De code correct uitlezen 
 De toewijzing van het eerste cijfer van de code aan de vereiste waarden van de bewegingstrappen gebeurt via de index van een lijst met de respectieve numerieke waarden. 
 Conclusie: Met een code van vier cijfers kunnen we de snelheid en het bochtenwerk regelen met de eerste twee cijfers, de achterste twee cijfers worden gebruikt voor andere functies (die in eerste instantie niet nodig zijn). Dus, bijvoorbeeld, code95xx voor snelste rechtuit, 55xx voor stilstand, 77xx voor vooruit rijden naar rechts.&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; 
 Nu willen we onze eerste Smart Robot Car bouwen met de kit, een ATmega328 microcontroller (UNO R3 ontwerp), een MotorShield V2 en IR zender en ontvanger. 
 Het MotorShield V2 kan maximaal vier motoren aansturen, met behulp van de zogenaamde I2C bus met de aansluitingen SDA (=Serial Data) op de analoge ingang A4 en SCL (=Serial Clock) op A5 voor het aansluiten van de stuurlijnen. Adafruit heeft hiervoor ook een geschikte programmabibliotheek ontwikkeld en beschikbaar gesteld. Let op: De bibliotheken voor Motor Shields V1 en V2 zijn niet compatibel. 
 &amp;nbsp;  
 Afbeelding Motor Shield V2 met modificatie:  Gesoldeerde busconnectoren (vrouwelijke connectoren) voor het aansluiten van extra apparatuur 
 Het maakt niet uit welk Motor Shield je wilt gebruiken - V1 of V2 -,&amp;nbsp; het is zinvol om extra busconnectoren te solderen voor beide Motor Shields om later Bluetooth of 433 MHz zenders/ontvangers of sensoren aan te sluiten. Meer hierover in de volgende blogposts. De IR-ontvanger heeft alleen voeding nodig van pin 3 en 4 en pin 2 voor de IR-ontvanger. De soldeerbout kan dan nog koud blijven. 
 Voor de besturing gebruiken we eerst de kleine infrarood afstandsbediening van Funduino en een IR ontvanger. Hoewel de &quot;naakte&quot; IR-sensor voldoende is, raad ik het kleine breakout bord aan, omdat hier een LED flikkert wanneer IR-signalen worden ontvangen; een waardevol hulpmiddel bij het zoeken naar een storing. 
 De schets is samengesteld uit twee beproefde onderdelen: Armin Joachimsmeyer&#039;s voorbeeldschets, die hij toevoegde aan zijn geweldige IRremote programmabibliotheek, en een Robot Car schets van de auteur op basis van Adafruit&#039;s programmabibliotheek. 
 De programmacode voor de RC Car voor Arduino 
  /* Voorbeeldcode voor robotauto met motorschild V2 en IR-ontvanger, vanaf 20220515
* gebaseerd op Adafruit Motor shield V2 bibliotheek, copyright Adafruit Industries LLC, 2009
* en SimpleReceiver.cpp, onderdeel van Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* MIT-licentie Copyright (c) 2020-2022 Armin Joachimsmeyer
* aangepast voor Funduino
* Motor Shield V2 gebruikt I2C met SDA=A4 en SCL=A5
* IR-ontvanger gebruikt pin 2
 ************************************************************************************
 * Hierbij wordt gratis toestemming verleend aan iedereen die een kopie verkrijgt van
 * van deze software en bijbehorende documentatiebestanden (de &quot;Software&quot;), om te handelen
 * in de Software zonder beperking, inclusief zonder beperking de rechten
 * de Software te gebruiken, te kopiëren, te wijzigen, samen te voegen, te publiceren, te distribueren, in sublicentie te geven en/of te verkopen, en kopieën van de Software toe te staan
 * kopieën van de Software, en om personen aan wie de Software is geleverd toe te staan
 * om dit te doen, onder de volgende voorwaarden:
 *
 * De bovenstaande copyrightmelding en deze toestemmingsmelding moeten worden opgenomen in alle
 * kopieën of substantiële delen van de Software.
 *
 * DE SOFTWARE WORDT GELEVERD &quot;ZOALS DEZE IS&quot;, ZONDER ENIGE VORM VAN GARANTIE, EXPLICIET OF IMPLICIET,
 * INCLUSIEF MAAR NIET BEPERKT TOT DE GARANTIES VAN VERKOOPBAARHEID, GESCHIKTHEID VOOR EEN
 * BEPAALD DOEL EN NIET-INBREUK. IN GEEN GEVAL ZULLEN DE AUTEURS OF
 * HOUDERS AANSPRAKELIJK ZIJN VOOR ENIGE CLAIM, SCHADE OF ANDERE AANSPRAKELIJKHEID, HETZIJ IN EEN ACTIE VAN
 * CONTRACT, ONRECHTMATIGE DAAD OF ANDERSZINS, VOORTVLOEIEND UIT, UIT OF IN VERBAND MET DE SOFTWARE
 * OF HET GEBRUIK VAN OF ANDERE OMGANG MET DE SOFTWARE.
 *************************************************************************************/ 
 
  #include   &amp;lt;Adafruit_MotorShield.h&amp;gt;  
 // Maak het motorschildobject aan met het standaard I2C-adres 0x60 
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
 // Selecteer welke &#039;poort&#039; M1, M2, M3 of M4.  
Adafruit_DCMotor *motor1 = AFMS.getMotor (2 );
Adafruit_DCMotor *motor2 = AFMS.getMotor( 3 );

 // definieer protocol voor afstandsbediening, voor meer zie voorbeeldcode SimpleReceiver.cpp 
  #define  DECODE_NEC  // Inclusief Apple en Onkyo, ook voor kleine Funduino afstandsbediening  
 //#define INFO // Om waardevolle informatie te zien van universele decoder voor pulsbreedte- of pulsafstandprotocollen 
  #define  IR_RECEIVE_PIN 2  // in plaats van #include &quot;PinDefinitionsAndMore.h&quot;
    #include   &amp;lt;Arduino.h&amp;gt;  
  #include   &amp;lt;IRremote.hpp&amp;gt;  

 // IR ontvanger signaal aangesloten op pin2, VCC op pin3, GND op pin4 
 int  IR_GND =  4 ;  
 int  IR_VCC =  3 ;

 int  x =  0 ;
 int  y =  0 ;
 int  links =  0 ;
 int  rechts =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correctie voor speedLevel 255/100 * 6V/VBatt 

 id   setup () {
  Serial  .begin  (9600 );
  Serial  .println ( &quot;Motortest! &quot;);
  Serial  .println ( &quot;Motorshield v2 - DC Motortest!&quot; );
  als  (!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;Motor Shield gevonden.&quot; );
  // Gewoon om te weten welk programma draait op mijn Arduino 
  Serial  .println (F( &quot;START &quot;  __FILE__  &quot; from &quot;  __DATE__  &quot;\rUsing library version &quot;  VERSION_IRREMOTE));
  // De ontvanger starten 
  IrReceiver .begin (IR_RECEIVE_PIN);  //, ENABLE_LED_FEEDBACK); 
  Serial  .print (F( &quot;Klaar om IR-signalen van protocollen te ontvangen: &quot; ));
  printActiveIRProtocols (&amp;amp;Serial );
  Serial  . print(F( &quot;op pin &quot; ));
  Serial  .println (IR_RECEIVE_PIN);  
  // initialiseer digitale pinnen als uitgang voor voeding 
  pinMode (IR_GND ,OUTPUT );
  pinMode (IR_VCC ,OUTPUT );
  digitalWrite (IR_GND ,LOW );
  digitalWrite (IR_VCC ,HIGH );    
}  // einde setup 

 void   loop () {
  if  (IrReceiver.decode()) {
      // Druk een korte samenvatting van ontvangen gegevens af 
      IrReceiver.printIRResultShort (&amp;amp;Serial );
      als  (IrReceiver.decodedIRData.protocol == UNKNOWN) {
           // We have an unknown protocol here, print more info 
          IrReceiver.printIRResultRawFormatted(&amp;amp; Serial , true);
      }
      Serial  .println ();
      /*
       * belangrijk!!! Schakel het ontvangen van de volgende waarde in,
       * omdat het ontvangen is gestopt na het einde van het huidige ontvangen gegevenspakket.
       */ 
      delay  (100 );  // Debounce, geen snel opnieuw proberen      
      IrReceiver.resume(); // Ontvangst van de   volgende waarde inschakelen
      /*
       * Controleer ten slotte de ontvangen gegevens en voer acties uit volgens het ontvangen commando
       */ 
  als  (IrReceiver.decodedIRData.command ==  0x46 )  {
     if  (code&amp;lt; 9000 )   code = code +  1000 ;         
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  anders   als  (IrReceiver.decodedIRData.command ==  0x15 ) {
     if  (code&amp;gt; 2000 )   code = code -  1000 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    } 
  anders   als  (IrReceiver.decodedIRData.command ==  0x43 )  {
     if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  anders   als  (IrReceiver.decodedIRData.command ==  0x44 )  {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  anders   als  (IrReceiver.decodedIRData.command ==  0x40 )  {
    code =  5555 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
  anders  {
     Serial . print ( &quot;invalid code&quot; );
    }
  motor();
  }
}  // einde lus 

 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);

  //Correctie van de snelheidsstappen voor bochten 
  als   (x==1 ){
    right = speedL+ 16 ;
    left = speedL -16 ;
  }
  anders   als  ( x==2 ){
    right = speedL+ 13 ;
    left = speedL -13 ;
  }
  anders   als  ( x==3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
  anders   als  ( x==4 ) {
    right = speedL+ 7 ;
    left = speedL -7 ;
  }
  anders   als  ( x==6 ) {
    right = speedL  -7 ;
    left = speedL+ 7 ;
  }
  anders   als  ( x==7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
  anders   als  ( x==8 ) {
    right = speedL -13 ;
    left = speedL+ 13 ;
  }
  anders   als  ( x==9 ) {
    right = speedL -16 ;
    left = speedL+ 16 ;
  }
  anders  {
    right = speedL;
    left = speedL;
  }

  //Invoer van de rijstappen voor &quot;links&quot; en &quot;rechts 
  Serial  .print ( &quot;links = &quot; );
  Serial . print (left);
  Serial  . print( &quot; rechts = &quot; );
  Serial  .println (rechts);

  als  (links &amp;lt;  40  &amp;amp; links &amp;gt;  -40 ) {
    motor1-&amp;gt; run (RELEASE);
  }
  als  (rechts &amp;lt;  40  &amp;amp; rechts &amp;gt;  -40 ) {
    motor2-&amp;gt; run (RELEASE);
  }
  als  ( links&amp;gt;=40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1-&amp;gt; run (FORWARD);
      motor1-&amp;gt; setSpeed (left * factor);
  }
  als  ( rechts&amp;gt;=40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2-&amp;gt; run (FORWARD);
      motor2-&amp;gt; setSpeed (right * factor);
  }
  als  (links&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1-&amp;gt; run (BACKWARD);
      motor1-&amp;gt; setSpeed (-left * factor);
  }
  als  (rechts&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2-&amp;gt; run (BACKWARD);
      motor2-&amp;gt; setSpeed (-right * factor);
  }
}  // einde motor 
 
 Uitleg van de programmacode voor de RC Car 
 Na het opnemen van de bibliotheken voor het Motor Shield V2 en IRremote, worden twee motoren geïnitialiseerd met het nummer op het aansluitblok van de controller en worden enkele globale variabelen gedeclareerd (datatype) en geïnitialiseerd (beginwaarde). 
 In de functie  setup(  ) worden de seriële interface en de IR-ontvanger geïnitialiseerd en worden de pinnen voor de voeding van de IR-ontvanger ingesteld als uitgangen met de status HIGH of LOW. 
 In de  loop()  functie wordt eerst het signaal van de IR afstandsbediening ontvangen, daarna wordt de code voor de motorbesturing gewijzigd afhankelijk van de ingedrukte toets. De cursortoetsen omhoog en omlaag veranderen het eerste cijfer, links en rechts het tweede cijfer van de code in het waardebereik van 1 tot 9. De toets X leidt tot stilstand met code 5555. Het derde en vierde cijfer van de code zijn momenteel nog niet significant. Aan het einde wordt de zelfgedefinieerde functie  motor()  aangeroepen zonder argumenten, omdat we de variabelen globaal hadden gedefinieerd, d.w.z. geldig in alle functies. 
 In de zelfgedefinieerde functie  motor() , die we ook in andere configuraties met andere afstandsbedieningen zullen gebruiken, worden de snelheidsstappen voor de linker- en rechtermotor bepaald vanuit de code. De procentuele waarde van het snelheidsniveau wordt uiteindelijk omgezet in de PWM-waarde voor  setSpeed  met behulp van de factor die aan het begin is gedefinieerd. 
 &amp;nbsp;  
 De robotauto is nu klaar voor gebruik. Hij werkt prima zolang je de optische verbinding tussen de afstandsbediening en de IR-ontvanger in stand kunt houden. Tijdens het rijden op de weg heb ik echter ervaren dat sterk zonlicht de ontvangst belemmert. Daarom stap ik over op radioafstandsbediening. Tot snel. 
                ]]>
            </content>

                            <updated>2022-06-09T07:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Afwisselend knipperende LED&#039;s op de Raspberry Pi microcontroller</title>
            <id>https://funduinoshop.com/nl/afwisselend-knipperende-led-s-op-de-raspberry-pi-microcontroller</id>
            <link href="https://funduinoshop.com/nl/afwisselend-knipperende-led-s-op-de-raspberry-pi-microcontroller"/>
            <summary type="html">
                <![CDATA[
                
                                            Je kunt de elektronische componenten ook zonder T-cobbler op het breadboard aansluiten. In dit geval heb je echter verbindingsdraden van het type vrouwelijk - mannelijk nodig voor de aansluiting op de J6-connectorstrip van de Raspberry Pi.....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hoe laat je twee LED&#039;s op de Raspberry Pi afwisselend knipperen? 
 Je kunt de elektronische componenten ook zonder T-cobbler op het breadboard aansluiten. In dit geval heb je echter een verbindingsdraad nodig van het type female - male voor de verbinding met de J6 connectorstrip van de Raspberry Pi, d.w.z. een bus voor de Raspberry Pi en een stekker voor het breadboard. 
   
  De programmacode (afwisselend knipperende LED op de Raspberry Pi)   
  # Vanaf hier kan de code direct in de Python software worden gekopieerd. 
 # Zwart, gekleurd = code en grijs = uitleg 
 #We beginnen met het importeren van de programmamodules 
importeer RPI.GPIO  als  GPIO
importeer  tijd 
GPIO.setmode(GPIO.BCM)  #We stellen de modus in op BCM 
GPIO.setup (23 ,GPIO.OUT)  #Pin 23 is een uitgang .
GPIO.setup( 24 ,GPIO.OUT) #Pin   24 is een uitgang. 
 # De lus begint hier 
 proberen :
    while  True:  #While loop zodat het programma continu draait 
        GPIO.output (23 ,GPIO.HIGH)  #Start de LED op pin 23 .
        GPIO.output( 24 ,GPIO.LOW)  # Schakelt de LED op pin 24 uit .
        time .sleep (1 )  # Wacht 1 seconde 
        GPIO.output( 23 ,GPIO.LOW)  # Schakelt de LED op pin 23 uit .
        GPIO.output (24 ,GPIO.HIGH) # Schakelt   de LED op pin 24 in .
        time .sleep (1 )
 # Hier springt het programma aan het einde naar het begin van de lus. Dus.. 
 # ...zet de LED aan op pin 23. 
 # ... enz... enz... enz.. 
except KeyboardInterrupt:  # Met CTRL+C onderbreken we het programma 
    print ( &quot;Finished &quot; ) # Schrijf &quot;Finished&quot; in het commandoregelvenster
    GPIO.cleanup() # Beëindig het programma
  
 In voorbeeld nr. 01 Knipperende LED hadden we de oneindige lus gerealiseerd met while True en inspringing van de volgende coderegels. Als je deze oneindige lus hebt afgebroken met de toetscombinatie Ctrl-C, zul je gemerkt hebben dat je ten eerste een foutmelding krijgt en ten tweede de LED kan blijven branden. Om deze twee ongewenste effecten te voorkomen, zijn er een paar regels code toegevoegd aan dit voorbeeld. De regel  try:  is ingevoegd vóór de while true-lus. De dubbele punt leidt tot het inspringen van de hele lus. Als er een fout optreedt in deze lus terwijl het programma draait, is er geen foutmelding, maar wordt het programma voortgezet bij  except KeyboardInterrupt: . Met het print-commando wordt het einde van het programma afgedrukt in de Python-shell (onderste venster bij Thonny), met GPIO.cleanup() worden de GPIO&#039;s (dus onze LED&#039;s) uitgeschakeld en vrijgegeven voor andere doeleinden. 
 Voorbeeld: Verkeerslichtcyclus op de Raspberry Pi 
 Hier is een voorgestelde oplossing voor een verkeerslichtcyclus met behulp van de module gpiozero: 
   
   
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">RC auto bouwen voor Arduino: Autonoom voertuig - Deel 1</title>
            <id>https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-1</id>
            <link href="https://funduinoshop.com/nl/rc-auto-bouwen-voor-arduino-autonoom-voertuig-deel-1"/>
            <summary type="html">
                <![CDATA[
                
                                            Welkom bij een nieuwe blogserie over robotauto&#039;s. In het eerste deel maken we kennis met de basis, om zo te zeggen als hulpmiddel bij de aankoopbeslissing, welk chassis, welke microcontroller en welk type afstandsbediening...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Inzicht in de mobiliteit van de toekomst met robotauto&#039;s  
 Welkom bij een nieuwe blogserie over robotauto&#039;s. In het eerste deel maken we als het ware kennis met de basis, als hulpmiddel bij de besluitvorming over welk chassis, welke microcontroller en welk type afstandsbediening het meest geschikt zijn. 
 Twee of vier wielen - de voor- en nadelen van het bouwen van RC auto&#039;s voor Arduino tegen elkaar afwegen 
 Laten we beginnen met het chassis en kijken naar de voor- en nadelen van de goedkope kits met twee of vier aangedreven wielen. Ze hebben allemaal elektromotoren gemeen, dus deze alleen zijn geen selectiecriterium. De robotauto&#039;s met twee wielen zijn in eerste instantie goedkoper omdat ze niet de kosten hebben van nog eens twee elektromotoren en wielen. In plaats daarvan hebben ze één of twee steunwielen, die de RC auto&#039;s een grote wendbaarheid geven. Dus als je wilt &quot;draaien op de plaat&quot;, dan is dit de manier om te gaan. In deze prijsklasse van gelijkstroommotoren kun je echter niet verwachten dat ze vloeiend lopen met een hoge precisie. Daarom is het rechtuit lopen niet zo goed als bij de versie met vier wielen. Vooral bij het opstarten vertonen de motoren een grotere richtingsstabiliteit, maar bochten nemen is alleen mogelijk met aanzienlijk grotere radii. Een ander voordeel van het chassis met vier wielen is meer ruimte voor accu&#039;s, microcontroller, eventueel DC/DC converter en sensoren. 
   
 De keuze van microcontroller voor het bouwen van een RC auto 
 De volgende vraag heeft betrekking op de microcontroller en hoe deze wordt geprogrammeerd. Een microcomputer van het type Raspberry Pi heeft bijvoorbeeld de grootste rekenkracht op het kleine chassis. Vooral wat betreft afstandsbediening bieden de types met ingebouwde WiFi en Bluetooth voordelen en je kunt zelfs beelden van een Raspberry Pi camera doorsturen. Programmeren doe je in de veelgebruikte programmeertaal Python, maar het opstarten van het op Linux gebaseerde besturingssysteem Raspberry Pi OS duurt ongeveer een minuut. Een ander nadeel van de Raspis (kort voor Raspberry Pi) is de noodzaak van een goede 5V voeding. Hiervoor is een goede DC/DC converter nodig. 
 In verband met het onderwerp Bluetooth afstandsbediening wordt in een latere aflevering een voorbeeld getoond met de Raspberry Pi en de Android APP BlueDot van Martin O&#039;Hanlon (medewerker van de Raspberry Pi Foundation). 
 Het opstarten van het systeem gaat veel sneller met een microcontroller gebaseerd op de ATmega 328, bijvoorbeeld de  Funduino Uno  of  Funduino&amp;nbsp;Nano . Ongeveer een seconde na het inschakelen kun je beginnen met de besturingsingangen, je hoeft niet op te starten vanaf een microSD-kaart, het programma dat eenmaal is geüpload wordt niet vergeten. De ingangsspanning kan tussen 5 en 9 volt liggen. Programmeren doe je in de  Arduino IDE , een ontwikkelomgeving die lijkt op C/C++ (voor meer uitleg zie  https://funduino.de/hardware-software) . Daarom zullen we eerst kijken naar voorbeelden met de Funduino Uno R3, waarvoor perfecte motorcontrollers beschikbaar zijn als zogenaamde shields. Deze worden eenvoudig op de Uno geplugd en zogenaamde bibliotheken helpen ons bij het programmeren. 
 Excursus: Wat is een motorcontroller/motordriver? 
 Vanwege de zeer beperkte stroom aan de uitgangen van de microcontrollers hebben grotere verbruikers - en dit omvat alle soorten elektromotoren en relais - een externe voeding nodig en een elektronisch circuit dat het stuursignaal van de microcontroller omzet. De eisen voor deze geïntegreerde schakeling zijn echter nog hoger: aan de ene kant moet deze een variabele snelheid van de motor mogelijk maken en aan de andere kant willen we ook de draairichting van de motor kunnen veranderen door de polariteit om te keren. 
 Met IC L293D als voorbeeld zullen we nu uitleggen hoe het werkt. In principe is dit DIP-component met zestien &quot;pootjes&quot;/aansluitingen voldoende als motorcontroller voor twee elektromotoren.     
 Het IC krijgt spanning via de aansluitingen VCC1 en Ground. We kunnen deze spanning aftappen op de microcontroller. De voeding voor de motoren gaat via VCC2 en Ground. Hier sluiten we de batterij(en) op aan (bijvoorbeeld 6 of 9 volt). Bij grotere motoren moet het IC gekoeld worden, bij de kleine gele uit de kit niet. 
 We sluiten de ene motor aan op 1Y en 2Y, de corresponderende stuurlijnen naar de MCU (Micro Controller Unit) zijn 1A, 2A en 1,2EN. 
 Het omkeren van de polariteit van de motoren om de rijrichting te veranderen gebeurt in principe met een zogenaamde H-schakeling. We realiseren dit met onze microcontroller door twee uitgangspennen (deze gaan naar 1A en 1B) op HIGH of LOW te zetten. 
 De snelheidsverandering wordt gedaan zoals in  voorbeeld nr. 04 - pulserende LED  met pulsbreedtemodulatie (PWM), d.w.z. het zeer snel in- en uitschakelen van de spanning. Daarom hebben we voor aansluiting 1,2EN (&quot;Enable&quot;) een PWM-geschikte uitgang op de MCU nodig (dit zijn de pinnen met de tilde ~). 
 Voor de tweede motor worden de aansluitingen 3A, 4A en 3,4EN aangesloten op pinnen van de MCU. 
 De afbeelding rechts (Logic Diagram) legt uit hoe het IC werkt. We zien de vier versterkers die de ingangssignalen 1A tot 4A respectievelijk met de accuspanning aan de uitgangen 1Y tot 4Y geven. Dit gebeurt echter alleen als de PWM ingangen 1,2EN en 3,4EN ook HOOG worden geschakeld. 
 Twee van deze IC&#039;s L293D zijn geïnstalleerd op het Motor Shield V1, zodat hier maximaal vier motoren kunnen worden aangesloten. 
 Om niet te veel pinnen te gebruiken, zit er een zogenaamd schuifregister (SN74HC595) in het midden van het Motor Shield V1. Uitleggen hoe het werkt zou buiten het bestek van dit artikel vallen. Gelukkig hebben onze collega&#039;s van Adafruit in New York het meeste programmeerwerk voor ons gedaan en een bibliotheek meegeleverd om de motoren eenvoudig aan te sturen.    
 Afbeelding Motor Shield V1 met modificatie:   Gesoldeerde socket connectoren (vrouwelijke connectoren) voor het aansluiten van extra apparatuur 
 &amp;nbsp; 
 Het Motor Shield V2 kan ook maximaal vier motoren aansturen en gebruikt een vergelijkbaar IC, maar dan voor het aansluiten van de stuurlijnen de zogenaamde I2C bus met de aansluitingen SDA (=Serial Data) op de analoge ingang A4 en SCL (=Serial Clock) op A5. Adafruit heeft hiervoor ook een geschikte programmabibliotheek ontwikkeld en beschikbaar gesteld. 
   
 Afbeelding Motor Shield V2 met modificatie:  Gesoldeerde busconnectoren (vrouwelijke connectoren) voor het aansluiten van extra apparatuur 
 Op beide Motor Shields zijn extra vrouwelijke connectoren gesoldeerd om later Bluetooth of 433 MHz zenders/ontvangers of sensoren aan te sluiten. Meer hierover in een van de volgende blogposts. 
 Voeding en besturing voor een RC auto voor Arduino microcontrollers 
 Als we willen dat onze robotauto zelfstandig rijdt, moeten we hem loskoppelen van de USB-poort van de PC. Dit betekent dat de stroomvoorziening ook wegvalt. Vanaf nu worden het commandocentrum (MCU) en de elektromotoren gevoed door batterijen of oplaadbare accu&#039;s. De motoren zijn verreweg de grootste verbruikers. De batterijhouder die bij de meeste kits wordt geleverd is voor vier Mignon (AA) batterijen, dus 6 volt voor de MCU en de motoren. Als je oplaadbare batterijen wilt gebruiken, moet je of zes Mignon (AA) batterijen of twee 18650 lithium-ion batterijen gebruiken vanwege het lagere voltage. 
 Als besturing zullen we in de volgende afleveringen eerst kennismaken met afstandsbedieningen met infrarood afstandsbediening, Bluetooth transceivers met smartphone APP of een tweede microcontroller ook met de BT transceiver HC-05 en met radiografische afstandsbedieningen met 433Mhz en 2,4 GHz. De blogserie wordt afgesloten met aspecten van autonoom rijden, voornamelijk obstakeldetectie. Tot snel. 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Knipperende LED op de Raspberry Pi microcontroller</title>
            <id>https://funduinoshop.com/nl/knipperende-led-op-de-raspberry-pi-microcontroller</id>
            <link href="https://funduinoshop.com/nl/knipperende-led-op-de-raspberry-pi-microcontroller"/>
            <summary type="html">
                <![CDATA[
                
                                            In tegenstelling tot de Arduino heeft de Raspberry Pi geen toegang tot de ingebouwde LEDs. Ze geven alleen de voeding en toegang tot de µSD-kaart aan. Om een LED te laten knipperen, moet een externe...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hoe laat je een LED knipperen op de Raspberry Pi? 
  In tegenstelling tot de Arduino heb je geen toegang tot de ingebouwde LED&#039;s op de Raspberry Pi. Ze geven alleen de voeding en toegang tot de µSD-kaart aan.  
 Om een LED te laten knipperen, heb je een externe LED nodig met een geschikte serieweerstand en startkabels. De meest verstandige manier om de schakeling op te zetten is op een breadboard met een T-cobbler. Deze opstelling vergemakkelijkt ook latere experimenten met meerdere LED&#039;s, knoppen en sensoren. Het programmeren gebeurt in de programmeertaal Python. 
 Het schema van de schakeling (knipperende LED op de Raspberry Pi) 
   
 Wat is een LED? 
 LED staat voor Light Emitting Diode (lichtdiode). Het laatste woord geeft de elektronische eigenschappen aan. Een diode is een halfgeleider die alleen stroom doorlaat in de ene richting en blokkeert in de andere richting. De twee &quot;pootjes&quot; worden anode en kathode genoemd. Als je goed kijkt, zie je dat de pootjes verschillende lengtes hebben. De positieve spanning wordt toegepast op het langere been, de anode; het kortere been, de kathode, is via een weerstand verbonden met massa. De weerstand is nodig vanwege een andere eigenschap van diodes. Allereerst is er een minimale spanning nodig om überhaupt een stroom te kunnen laten lopen: Dit wordt voorwaartse spanning genoemd. Bij hogere spanningen wordt de diode volledig geleidend. Daarom heb je een serieweerstand nodig om de stroom te beperken, omdat de pinnen van de microcontroller en ook van de Raspberry Pi maximaal met 15 tot 20 mA moeten worden belast. We gebruiken serieweerstanden in het bereik van 100 tot 330 Ω (Ohm). 
 De programmeertaal Python kan worden uitgebreid met programmamodules, vergelijkbaar met C/C++ met de bibliotheken. Voor onze knipperende LED hebben we twee van deze modules nodig: ten eerste &quot;tijd&quot; om de duur van het knipperen te definiëren. En ten tweede een module voor toegang tot de GPIO&#039;s (General Purpose Input/Output). 
 Hoe bestuur ik een LED met een Raspberry Pi? 
 Het importeren van de modules doe je aan het begin van het Python-programma; je hebt verschillende opties om dit te doen. Voorbeelden: 
 De volgende regel importeert de module  tijd : 
  import   tijd  
 Wanneer je de methode  sleep  aanroept, moet de modulenaam  time  voorafgegaan worden door een punt: 
  time  .sleep  (1 ) 
 In tegenstelling tot delay(), waar het tijdsinterval als argument in milliseconden wordt gegeven, worden bij  time.sleep()  de waarden in seconden gegeven, eventueel met een decimaalteken. 
  importeer  RPi.GPIO  als  GPIO 
 Dit vereenvoudigt het aanroepen van de methoden in het programma, bijv. 
  GPIO  .setmode  (GPIO  .BCM ) 
 Derde voorbeeld voor een andere module voor GPIO-toegang: 
 uit gpiozero  importeer  LED 
 Alleen de klasse LED wordt geïmporteerd uit de module  gpiozero . Met deze importmethode wordt de naam van de module niet meer voorafgegaan wanneer de methode/functie wordt aangeroepen. 
 Voorbeeldprogramma&#039;s voor het aansturen van een LED met een Raspberry Pi microcontroller 
 Eerste voorbeeld met de module RPi.GPIO: 
 importeer RPi.GPIO als GPIO
importeer  tijd 
GPIO.setmode(GPIO.BCM) # Pinnaam voor Broadcomm processor 
GPIO.setup (26 ,GPIO.OUT) # GPIO26 (=phys. pin 37) wordt uitgang 

 while  True: # Eindeloze lus, annuleren met Ctrl-C 
    GPIO .output  (26  ,1 ) # GPIO 26 wordt HOOG geschakeld 
    time  .sleep  (1 )
    GPIO. output  (26  ,0 ) # GPIO 26 wordt LAAG geschakeld
    time  .sleep  (1 )
 
 Tweede voorbeeld met de module gpiozero. Alleen  LED  en  sleep  zijn geïmporteerd. 
  uit  gpiozero importeer LED
 uit   time  importeer  sleep 
redLED = LED (26 ) # redLED is ingesteld op GPIO  26  

 while   True :
    redLED.on() # redLED is ingeschakeld 
    slaap  (1 )
    redLED.off() # redLED is uitgeschakeld
    slaap  (1 )
 
 Uitdaging: circuit uitbreiden en programmeren voor een verkeerslichtcyclus, bijv. rood(3s), rood/geel(1s), groen(3s), geel(1s), opnieuw starten met rood. 
 Voorgestelde oplossing zie nr. 02 De wisselende richtingaanwijzer 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Aan de slag met de Raspberry Pi - Deel 3: Programmeren</title>
            <id>https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-3-programmeren</id>
            <link href="https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-3-programmeren"/>
            <summary type="html">
                <![CDATA[
                
                                            In principe kun je ook de Arduino IDE op de Raspberry Pi installeren of het voorgeïnstalleerde programma Geany gebruiken, een zeer functionele editor, in verschillende programmeertalen....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 In principe kun je ook de Arduino IDE op de Raspberry Pi installeren of in verschillende programmeertalen programmeren met het voorgeïnstalleerde programma Geany, een zeer functionele editor, maar de Raspberry Pi ontleent zijn naam aan de programmeertaal Python; oorspronkelijk was hij alleen gepland als  Python-interpreter . Dus: wie zegt dat de Raspberry Pi programmeert, bedoelt meestal de zeer wijdverspreide en eenvoudig te leren taal Python. 
 In de afgelopen jaren heeft het programma Thonny zich gevestigd als een Integrated Development Environment (IDE) voor  Python-programma&#039;s . 
 &amp;nbsp;  
 Er wordt een fundamenteel onderscheid gemaakt tussen de editor in het bovenste deel van het venster, waar de programma&#039;s worden geschreven, en de shell in het onderste deel, waar de programma&#039;s worden uitgevoerd met mogelijke invoer en uitvoer. Je kunt echter ook korte commando&#039;s direct in de shell invoeren. 
 Gevorderde programmeurs moeten klikken op &quot;Switch to regular mode&quot; in de rechterbovenhoek van het scherm om de menubalk weer te geven. 
 &amp;nbsp;  
 Als je de programmeertaal autodidactisch wilt leren, kun je dat doen met behulp van een groot aantal boeken. Op dit punt wordt de methode &quot;leren door te doen&quot; aanbevolen, d.w.z. gewoon de programmeervoorbeelden kopiëren. De meeste programmacode spreekt voor zich. Dat is het mooie van Python. 
 Om onnodige frustratie te voorkomen, moeten op dit punt een paar regels worden genoemd, die vooral bedoeld zijn voor degenen die overstappen van Arduino C/C++: 
 In tegenstelling tot C/C++ hoeft het type variabele niet gedeclareerd te worden. Python herkent het type de eerste keer dat het wordt gebruikt. Als je bijvoorbeeld type  (&quot;abc&quot;)  invoert in de shell, krijg je &amp;lt;class &#039;str&#039;&amp;gt; als uitvoer; de tekenreeks van het type wordt herkend vanwege de aanhalingstekens. 
 De commandoregel wordt niet afgesloten met een puntkomma. In plaats daarvan moet je in Python goed letten op inspringen. Dus: elk commando begint altijd op de eerste positie van de alinea. 
 Inspringingen (meestal tab=vier spaties) worden (meestal automatisch) gemaakt voor vertakkingen, lussen of zelfgedefinieerde functies, mogelijk meerdere keren. 
 Namen van programma&#039;s en variabelen beginnen altijd met een letter of de underscore _. Daarna kunnen ook cijfers worden gebruikt. De underscore is het enige speciale teken dat is toegestaan en wordt meestal gebruikt voor speciale doeleinden. 
 Zoals gezegd: Verdere uitleg over Python bij de programmavoorbeelden. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Aan de slag met de Raspberry Pi - Deel 2: Hardware en software</title>
            <id>https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-2-hardware-en-software</id>
            <link href="https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-2-hardware-en-software"/>
            <summary type="html">
                <![CDATA[
                
                                            Een korte introductie tot de belangrijkste onderdelen voor de Raspberry Pi. Of het nu gaat om een insteekkabel, weerstand of LED, we laten je zien welke onderdelen je nodig hebt om aan de slag te gaan. We gaan ook in op de installatie van de software voor de Raspberry Pi en...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hardware en software voor de Raspberry Pi 
 Hardware voor de Raspberry Pi 
     
 Basisaccessoires voor de Raspberry Pi 
 Naast sensoren en actuatoren heb je&amp;nbsp; insteekkabels  nodig&amp;nbsp;in combinatie met een&amp;nbsp; breadboard als basis voor snelle en flexibele experimentele opstellingen. Dit bespaart tijdrovend soldeerwerk. Bovendien zijn&amp;nbsp; lichtgevende diodes &amp;nbsp;zeer geschikt om de signaaluitgang van het bord te controleren. 
 Het breadboard 
 Een breadboard is een goed hulpmiddel om schakelingen te bouwen zonder te solderen. Op een breadboard zijn altijd meerdere contacten achter elkaar aangesloten. Daarom kunnen veel kabels op deze punten met elkaar worden verbonden zonder dat ze aan elkaar gesoldeerd of geschroefd hoeven te worden. 
 De volgende afbeelding laat in kleur zien welke contacten met elkaar verbonden zijn. 
 &amp;nbsp;  
 Standaard insteekkaart voor Raspberry Pi en microcontroller.   De groene lijnen in de afbeelding geven het verloop van de geleiderpaden aan. 
 Voor een goede aansluiting van de Raspberry Pi op het breadboard zijn er zogenaamde T-cobbler met een lintkabel die alle 40 pinnen naar buiten leidt. 
   
 Lichtgevende diode (LED) voor de Raspberry Pi 
 Met LED&#039;s kun je heel snel de resultaten van een project testen. Daarom zijn ze handig voor bijna alle Arduino projecten. Je kunt op internet veel lezen over LED&#039;s. Hier is alleen de belangrijkste informatie. 
   
 
 De stroom kan maar in één richting door de LED lopen. Daarom moet hij op de juiste manier worden aangesloten. Een LED heeft een langer en een korter contact. Het langere contact is + en het kortere contact is -. 
 Een LED is ontworpen voor een bepaalde spanning. Als deze spanning wordt onderschreden, gaat de LED minder fel branden of blijft hij uit. Als de spanning echter wordt overschreden, brandt de LED zeer snel door en worden de contacten zeer heet (LET OP!). 
 Typische spanningswaarden volgens de kleuren van de LED: Blauw:3,1V, Wit:3,3V, Groen:3,7V, Geel:2,2V, Rood:2,1V De spanning op de digitale poorten van het bord is 5V. Als ze rechtstreeks op deze poorten worden aangesloten, geeft elke LED vrij snel de geest. Daarom moet er een weerstand op het circuit worden aangesloten. Er is zeer goede hulp te vinden op het internet onder de zoekterm &quot;resistor calculator LED&quot;. 
 Niet-bindende aanbevelingen voor weerstanden op de volgende LED&#039;s (Wanneer aangesloten op de 5V pinnen van het microcontroller bord.   
 
 
 
 
 LED 
 Wit 
 Rood 
 Geel 
 Groen 
 Blauw 
 Infrarood (IR) 
 
 
 Weerstand 
 100 Ohm 
 200 Ohm 
 200 Ohm 
 100 Ohm 
 100 Ohm 
 100 Ohm 
 
 
 
 &amp;nbsp; 
 Insteekkabel of jumper draad voor de Raspberry Pi 
 De jumper draden zijn verkrijgbaar in verschillende versies, meestal in 10cm of 20cm lengte met zowel stekkers als met bussen. Hier is mm=male-male=plug aan beide kanten, mf=male-female=plug aan de ene kant, socket aan de andere kant, en ff=female-female= met sockets aan beide kanten. 
   
 Knoppen en schakelaars voor de Raspberry Pi 
 De eerste en eenvoudigste sensor is de knop, een verende schakelaar die het elektrische contact weer opent als hij wordt losgelaten. 
   
 Software voor de Raspberry Pi 
 Het besturingssysteem Raspberry Pi OS kan gratis worden gedownload van de  homepage van de Raspberry Pi Foundation . De 32-bits versie is momenteel identiek voor alle modellen. Voor het schrijven naar de µSD-kaart (8 tot 32 GB) op de PC wordt het programma Imager aanbevolen, dat ook kan worden gedownload van de homepage van de Foundation. 
 De software installeren 
   
 De Raspberry Pi opstarten 
 Tijdens de eerste keer opstarten wordt het besturingssysteem ingesteld. Onder andere worden de toegangsgegevens voor het lokale WLAN ingevoerd. Sinds de lente wordt de gebruikersnaam pi niet meer automatisch gebruikt, maar wordt je gevraagd om een gebruikersnaam en een wachtwoord in te voeren. Na een herstart aan het einde van de initialisatie start een grafische gebruikersinterface. Dit proces duurt iets langer dan een minuut. 
 Als je op het pictogram klikt, wordt je gevraagd of je alleen de mogelijke updates wilt laten zien of dat je ze direct wilt starten. 
 De volgende schermafbeelding is gemaakt met het voorgeïnstalleerde programma &quot;scrot&quot; (voor schermafbeelding ). 
 &amp;nbsp;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Aan de slag met de Raspberry Pi - Deel 1: Het voorwoord</title>
            <id>https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-1-het-voorwoord</id>
            <link href="https://funduinoshop.com/nl/aan-de-slag-met-de-raspberry-pi-deel-1-het-voorwoord"/>
            <summary type="html">
                <![CDATA[
                
                                            Deze handleiding is bedoeld als basis voor het leren van het besturingssysteem Raspberry Pi OS met de nadruk op de programmeertaal Python. Het is bedoeld om beginners een gemakkelijke, interessante en...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Wat is &quot;Raspberry Pi&quot;?  
 Deze handleiding is bedoeld als basis voor het leren van het Raspberry Pi besturingssysteem met de nadruk op de programmeertaal Python. Het is bedoeld om beginners een eenvoudige, interessante en goed begeleide introductie te geven in de onderwerpen &quot;computational thinking&quot; en &quot;physical computing&quot;. De handleiding is vooral gericht op praktische taken met een theoretische inleiding vooraf. Het is essentieel om deze vooraf te lezen om niet te falen in de latere praktische taken door trivialiteiten. 
 Deze handleiding is ontwikkeld in het kader van een onderwijsactiviteit. De handleiding kan gratis worden gebruikt om de basisbeginselen van Raspberry Pi-computers te leren, maar mag niet zonder toestemming worden gekopieerd of op een andere manier worden gebruikt. De handleiding is zorgvuldig samengesteld en wordt voortdurend onderhouden, maar er wordt geen garantie gegeven voor de nauwkeurigheid en volledigheid. 
 Voor de praktische opdrachten moet je beschikken over een aantal elektronische onderdelen. Op de website funduinoshop.de kun je geschikte sensorsets bestellen die speciaal voor deze handleiding zijn ontworpen. 
 In tegenstelling tot de microcontroller (bijvoorbeeld Funduino Uno of Nano) is de Raspberry Pi, die inmiddels een groot aantal verschillende modellen kent, een echte computer met een op Linux gebaseerd besturingssysteem (Raspberry Pi OS, voorheen Raspbian). Het besturingssysteem en de toepassingsprogramma&#039;s en gegevens staan op een µSD-kaart (8 tot 32 GB), die bij het opstarten wordt geladen. De belangrijkste interfaces zijn in eerste instantie de USB-aansluitingen voor toetsenbord en muis en de HDMI-interface(s) naar de monitor.    
 Raspberry Pi B (2012) 
 Het grote succes van de Raspberry Pi is zowel gebaseerd op het programmeren met de veelgebruikte programmeertaal Python als op de mogelijkheid om elektronische componenten aan te sluiten op de 40-pins J6 header (vaak de GPIO strip genoemd). Dit is identiek voor alle modellen sinds 2014. Bij de naamgeving moet je goed opletten of je de fysieke pin bedoelt (in de afbeelding links de oneven nummers van 1 tot 39, rechts de even nummers van 2 tot 40) of de GPIO aanduiding. De fysieke pin 11 komt bijvoorbeeld overeen met GPIO17 (General Purpose Input Output connector 17 van de processor). GPIO&#039;s zijn dus digitale in- of uitgangen, net als bij de microcontroller. 
   
 Afbeelding J6 header: 40 pinnen, waarvan 2x3,3V, 2x5V, 8xGround, 26xGPIOs, 2 gereserveerd 
  Sommige pinnen hebben een secundaire toewijzing als elektronische interface, bijvoorbeeld One Wire op pin 7, I2C (= Inter-Integrated Circuit) op pin 3 en 5, UART (= Universal Asynchronous Receiver and Transmitter) op pin 8 en 10 en SPI (=Serial Peripheral Interface) op pin 19, 21, 23 en 24 of 26. Deze secundaire toewijzing wordt gedefinieerd in het besturingssysteem in de Raspberry Pi configuratie. Meer hierover in de respectievelijke voorbeelden. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Niveauregelaar in micro-elektronica</title>
            <id>https://funduinoshop.com/nl/niveauregelaar-in-micro-elektronica</id>
            <link href="https://funduinoshop.com/nl/niveauregelaar-in-micro-elektronica"/>
            <summary type="html">
                <![CDATA[
                
                                            Vaak moeten in elektronische schakelingen twee apparaten of modules met elkaar communiceren. Nog vaker hebben deze twee modules een verschillend spanningsniveau nodig. In micro-elektronica...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Waar worden niveauregelaars gebruikt in micro-elektronica? 
 Vaak moeten twee apparaten of modules met elkaar communiceren in elektronische schakelingen. Nog vaker hebben deze twee modules een verschillend spanningsniveau nodig. In de micro-elektronica, bijvoorbeeld in een Arduino microcontroller, is dit spanningsniveau meestal 3,3V of 5V. Als je een module met 3,3V en een module met 5V rechtstreeks met elkaar zou verbinden, zou de module met een maximale bedrijfsspanning van 3,3V kapot gaan als er een 5V niveau wordt toegepast.&amp;nbsp; 
 Om dit te vermijden worden zogenaamde level converters gebruikt. Niveauregelaars maken dus communicatie mogelijk tussen twee modules met verschillende spanningsniveaus. Het is vooral interessant dat level converters in twee richtingen werken zonder iets te hoeven veranderen aan de verbinding. Het signaal kan dus van de ene module naar de andere worden gestuurd. Niveauregelaars zijn daarom ook geschikt voor I2C lijnen. Bovendien is het mogelijk om het spanningsniveau van schakelende in- of uitgangen te verhogen of te verlagen.&amp;nbsp; 
   
 Niveauomzetters: hoe werken ze? 
 De afbeelding hierboven laat duidelijk zien hoe de signaaloverdracht binnen een niveauregelaar voor 3,3 en 5V werkt. Op de printplaat staan het 5V-niveau (HV, &quot;High Voltage&quot;) en het 3,3V-niveau (LV, &quot;Low Voltage&quot;) recht tegenover elkaar. Merk op dat de module die in dit voorbeeld wordt gebruikt (artikel is hieronder gelinkt) slechts een paar milliampère kan &quot;schakelen&quot;. De module is niet geschikt om bijvoorbeeld motoren of lampen te schakelen. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">De module MPU-6050: Gyroscoop en versnellingsmeter</title>
            <id>https://funduinoshop.com/nl/de-module-mpu-6050-gyroscoop-en-versnellingsmeter</id>
            <link href="https://funduinoshop.com/nl/de-module-mpu-6050-gyroscoop-en-versnellingsmeter"/>
            <summary type="html">
                <![CDATA[
                
                                            Er zijn maar weinig modules op de markt die de afgelopen maanden zo&#039;n hype hebben veroorzaakt als de MPU-6050 module. De twee-in-één printplaat combineert twee populaire...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Er zijn maar weinig modules op de markt die de afgelopen maanden zo&#039;n hype hebben veroorzaakt als de MPU-6050 module. Het twee-in-één bord combineert twee populaire sensoreigenschappen: De module kan tegelijkertijd gebruikt worden als gyroscoop en als versnellingssensor.  Hoe dan? De sensor bestaat uit een 3-assige gyroscoop en een 3-assige versnellingsmeter op één en dezelfde chip. Dit betekent dat&amp;nbsp;alle (!) sensorwaarden tegelijkertijd kan oproepen. Dit betekent dat hobbyisten altijd goed op de hoogte zijn van de huidige sensorpositie. Deze functie is vooral interessant voor modelbouw, met name voor het uitbalanceren van chassis of drones. Daarnaast zijn externe magnetometers of andere sensoren toegankelijk via een extra master I2C bus, zodat ook deze sensorgegevens volledig kunnen worden vastgelegd.&amp;nbsp; 
 De sensorgegevens van de MPU-6050 (GY-521) in één oogopslag: 
 
 Chipset: MPU-6050 (ook bekend als GY-521) 
 Voeding: 3,3 - 5V DC 
 Vrijheidslijn: 6* 
 Interface: I2C 
 Pinafstand: 2,54 mm   
 
 Nu komen we bij het spannende gedeelte: de praktijk. Om je een goed overzicht te geven van de nuttige functies van de MPU-6050 module, hebben we een voorbeeldschakelschema voor je ontwikkeld. De MPU-6050 module wordt uitgelezen door een Funduino UNO R3 en de geregistreerde gegevens worden geëvalueerd.  We zijn voornamelijk geïnteresseerd in de sensorgegevens van de gyroscoop. We willen de waarden van de X-, Y- en Z-as uitlezen en bepalen of er een verandering is opgetreden in de positie van de sensor. De verandering in positie moet ons worden getoond met gekleurde LED&#039;s. 
   
 Tot zover alles goed: maar hoe implementeren we dit? 
 De programmacode van de MPU-6050 module 
 Nu is het tijd voor het echte werk: nou ja, de helft ervan. Eerst moeten we de juiste bibliotheek voor de MPU6050 module downloaden en deze integreren in onze Arduino IDE. De bibliotheek heet &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; en kan direct worden gevonden en geïnstalleerd via het bibliotheekbeheer van de Arduino IDE. 
 Na deze eerste stap beginnen we met de eigenlijke code. Eerst definiëren we de LED-aansluitingen voor onze LED&#039;s, die ons moeten dienen als indicatoren voor de aspositie. Daarna definiëren we twee variabelen voor de aspositie van elk van de drie assen.&amp;nbsp; 
 Je vraagt je waarschijnlijk af waarom we twee variabelen per as nodig hebben. Omdat we willen bepalen of de positie van de betreffende as is veranderd, moeten we eerst bepalen welke waarde de sensor heeft geregistreerd voor de huidige positie. We slaan deze sensorwaarde van de MPU-6050 voor een korte periode op in de eerste variabele. De waarde van de aspositie wordt even later opnieuw opgeslagen in de tweede variabele. We kunnen nu de twee geregistreerde meetwaarden met elkaar vergelijken. Als er een afwijking van de positie met een eerder gedefinieerd minimum is geregistreerd (+-3 in ons codevoorbeeld), kunnen we aannemen dat de sensor de positie heeft gewijzigd. In dat geval schakelen we de toegewezen LED in.&amp;nbsp; 
 Extra leuk: de vastgelegde meetgegevens kunnen goed worden weergegeven in de seriële plotter van de Arduino IDE.   
  // Deze sketch vergelijkt de hoeken van de X/Y/Z assen met de vorige waarden. 
 // Als ze +/-3° verschillen, schakelt de sketch de LEDs om. (elk.1 voor POS of voor NEG) 
 // Let op: dit zijn niet de absolute waarden, maar RELATIEVE waarden vergeleken met de vorige meting 


  #include   &amp;lt;MPU6050_tockn.h&amp;gt;   // Include bibliotheken  
  #include   &amp;lt;Wire.h&amp;gt;   // &amp;lt;-  

MPU6050 mpu6050 (Wire ,  0.1 ,  0.1 );  // Demping van de waarden. Hoe kleiner (richting &quot;0&quot;), hoe nerveuzer de // waarden 
                                  // hoe groter (richting &quot;1&quot;), hoe trager de waarden 

 const   int  ledXpos  =2 ;  //*** 
 const   int  ledXneg  =3 ;  // * 
 const   int  ledYpos  =4 ;  // * Stel de LED-aansluitingen in 
 const   int  ledYneg  =5 ;  // *
 const   int  ledZpos  =6 ;  // *
 const   int  ledZneg  =7 ;  //*** 

 int  xNowPos;  // variabele HUIDIGE X-Pos 
 int  yNowPos;  // variabele HUIDIGE Y-Pos 
 int  zNowPos; // variabele HUIDIGE   Z-Pos 

 int  xPrePos; // variabele   HUIDIGE X-Pos 
 int  yPrePos; // Variabele   HUIDIGE Y-Pos 
 int  zPrePos; // Variabele VORIGE   Z-Pos 

 int  verschil =  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 () {  // begin van de l us

  mpu6050.update();  // Nieuwe gegevensset in de gyro aanmaken 

xNowPos=(mpu6050.getGyroAngleX());  // Vraag nieuwe dataset op van de gyro, schrijf naar X variabele 
yNowPos=(mpu6050.getGyroAngleY());  // Verzoek nieuwe dataset van gyro, schrijf naar Y variabele
zNowPos=(mpu6050.getGyroAngleZ()); // Verzoek nieuwe dataset van   de gyro, schrijf naar Z variabele 

 if  (xNowPos &amp;lt; xPrePos-(verschil))  // Vergelijk oude dataset met nieuwe. Verschil &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}  // Schakel dan de LEDs overeenkomstig 
 anders   als  (xNowPos &amp;gt; xVorPos+(verschil))  // Vergelijk oude dataset met nieuwe. Verschil &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}  // Schakel dan de LEDs overeenkomstig 
 anders   // Of schakel alle X LED&#039;s uit ...
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}  // Schakel dan de LEDs dienovereenkomstig 

 if  (yNowPos &amp;lt; yPrePos-(verschil))  // Vergelijk oude dataset met nieuwe. Verschil &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}  // Schakel dan de LEDs overeenkomstig 
 anders   als  (yNowPos &amp;gt; yVorPos+(verschil))  // Vergelijk oude dataset met nieuwe. Verschil &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}  // Schakel dan de LEDs overeenkomstig 
 anders   // Of schakel alle Y-LED&#039;s uit ...
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}  // Schakel dan de LEDs dienovereenkomstig 

 if  (zNowPos &amp;lt; zPrePos-(verschil))  // Vergelijk oude dataset met nieuwe. Verschil &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}  // Schakel dan de LEDs overeenkomstig 
 anders   als  (zNowPos &amp;gt; zPrePos+(verschil)) //   Vergelijk oude dataset met nieuwe. Verschil &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}  // Schakel dan de LEDs overeenkomstig 
 anders   // Of schakel alle Z-LED&#039;s uit ...
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}  // Schakel dan de LEDs dienovereenkomstig 

xVorPos=xJetztPos;  // Werk de (tot nu toe) oude dataset bij 
yVorPos=yJetztPos;  // Werk de (tot nu toe) oude dat aset bij
zVorPos=zJetztPos;  // Werk de (tot nu toe) oude gegevensreeks bij 
                                     // Dan kan het in de volgende run weer vergeleken worden met &quot;ervoor&quot; 

 Serial  .print (xNowPos);  // &amp;gt;&amp;gt; seriële plotter&amp;lt;&amp;lt; eerlijke spelling [output X] 
 Serial  .print ( &quot; &quot; ) ;Serial  .print (yJetztPos);  // (&quot; &quot;) = (\t) = Nieuwe kleur [output   Y] 
 Serial  . print(&quot; &quot; ) ;Serial  .println (zNowPos);  // (&quot; &quot;) = (\t) = Nieuwe kleur [output Z] 
  delay  (15 );  // (minimale vertraging kalmeert de seriële uitvoer) 
  // einde van de lus 


 // Voel je vrij om een beetje te experimenteren met de demping in de derde regel van het programma 
 //-&amp;gt; MPU6050 mpu6050(Draad, 0,3, 0,3); 
 // of met de delay() aan het einde. Observeer dan de waarden in de &amp;gt;&amp;gt;seriële PLOTTER &amp;lt;&amp;lt;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">PWM snelheidsregelaar in micro-elektronica</title>
            <id>https://funduinoshop.com/nl/pwm-snelheidsregelaar-in-micro-elektronica</id>
            <link href="https://funduinoshop.com/nl/pwm-snelheidsregelaar-in-micro-elektronica"/>
            <summary type="html">
                <![CDATA[
                
                                            Vóór de ontwikkeling van vermogenselektronica werd de snelheidsregeling van (borstel)gelijkstroommotoren opgelost met lineaire regelaars of serieweerstanden. Figuurlijk gesproken...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Oorsprong van PWM snelheidsregelaars 
 Vóór de ontwikkeling van vermogenselektronica werd snelheidsregeling&amp;nbsp;van (borstel)gelijkstroommotoren opgelost met lineaire regelaars of&amp;nbsp;serieweerstanden. Figuurlijk gesproken werd de spanning&amp;nbsp;(en dus ook de stroom) verlaagd om de snelheid te veranderen. 
 Dit heeft echter een aantal nadelen, die vooral duidelijk worden bij accugebruik&amp;nbsp;. Spanning en stroom worden omgezet in (ongebruikte) warmte-energie (&quot;verbrand&quot;) bij de besturingseenheid (of&amp;nbsp;de weerstand). 
 Het totale verbruik blijft erg hoog, terwijl het bruikbare&amp;nbsp;vermogen minder wordt.&amp;nbsp;Omdat het koppel afhankelijk is van de stroom, zakt dit ook in. 
 Hoe PWM snelheidsregelaars werken 
 Met de (verdere) ontwikkeling van vermogenselektronica is het probleem benaderd met een&amp;nbsp;ander idee.&amp;nbsp;Door de voedingsspanning&amp;nbsp;(zeer) snel aan en uit te schakelen, wordt de spanning (en dus de stroom) &quot;gepulst&quot;.&amp;nbsp;Tijdens de &quot;UIT&quot;-tijd valt er geen vermogen weg bij de (elektronische) schakelaar.&amp;nbsp;Dit betekent dat er (bijna) geen verliezen meer zijn bij de regelaar. 
 Tijdens de &quot;AAN&quot;-tijd wordt de VOLLEDIGE spanning op de motor gezet. Als gevolg hiervan is&amp;nbsp;de stroom - en dus het koppel - overeenkomstig hoog.&amp;nbsp;Helaas is een motor met zijn spoelen en ijzeren kern geen ideale&amp;nbsp;ohmse verbruiker, daarom is deze bewering vanuit fysisch oogpunt niet&amp;nbsp;helemaal correct.&amp;nbsp; 
 &amp;nbsp;De combinatie van spoelinductie en traagheid van de motor helpt&amp;nbsp;echter om de snelheid af te vlakken, zodat de motor zich gedraagt als&amp;nbsp;als hij zou werken met een continue gelijkspanning. 
 &amp;nbsp; 
   
 &amp;nbsp; 
 Dit brengt ons bij de nadelen van pulsbreedtemodulatie.&amp;nbsp;Modulatie met een blokspanning leidt tot de emissie van&amp;nbsp;meerdere radiofrequenties. Dit resulteert in EMC-interferentie, wat kan leiden tot verraderlijke fouten, vooral bij&amp;nbsp;regelaars. 
 In het lage PWM-frequentiebereik (1-2kHz) treden onaangename&amp;nbsp;fluittonen op bij de motor.&amp;nbsp;Men zou nu eenvoudig de schakelfrequentie verder kunnen verhogen.&amp;nbsp;De stroom heeft dan echter niet genoeg tijd om zijn maximale toestand&amp;nbsp;in de spoel/winding te bereiken.&amp;nbsp;De stroom schommelt dan tussen twee niet-stabiele toestandswaarden, wat leidt tot&amp;nbsp;een stroomrimpel. 
 Een te grote stroomrimpel verhoogt de verwarming in het wikkelpakket,&amp;nbsp;waardoor de motorprestaties afnemen en de levensduur van de motor wordt beïnvloed&amp;nbsp;. 
 ... nogal wat fysica voor een klein onderdeel. 
 Nu het goede nieuws:&amp;nbsp;Voor motoren in deze vermogensklasse zijn deze nadelen heel acceptabel&amp;nbsp;. Laten we blij zijn met de eerder beschreven voordelen. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">De PN532 NFC RFID-module - Near Field Communication</title>
            <id>https://funduinoshop.com/nl/de-pn532-nfc-rfid-module-near-field-communication</id>
            <link href="https://funduinoshop.com/nl/de-pn532-nfc-rfid-module-near-field-communication"/>
            <summary type="html">
                <![CDATA[
                
                                            In dit artikel laten we je zien hoe je ID-tags kunt lezen. De focus van het artikel is de PN532 NFC RFID module. De module is gebaseerd op de NXP PN532 chip. Deze chipset is vooral populair op het gebied van NFC (near field communication)....
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 RFID? NFC? Wat is dat eigenlijk? 
 In dit artikel laten we je zien hoe je ID-tags kunt lezen. De focus van het artikel is de PN532 NFC RFID module.&amp;nbsp; 
 De module is gebaseerd op de NXP PN532 chip. Deze chipset wordt veel gebruikt op het gebied van NFC (Near Field Communication). Een voorwerp dat NFC ondersteunt, vaak een chequekaart met een NFC-chip, wordt tegen een NFC-lezer gehouden. Hierdoor kan in een fractie van een seconde informatie worden uitgewisseld.&amp;nbsp; 
 Klinkt dat abstract? Als je een nieuwere EC-kaart hebt en die gebruikt voor contactloos betalen, dan ken je NFC zelfs uit het dagelijks leven. Door de kaart op de betaalterminal te leggen, wordt de transactie gestart - snel en eenvoudig. 
 We willen graag wat dieper ingaan op de technische processen hierachter. De PN532 module is hiervoor bij uitstek geschikt, omdat hij zowel I2C als SPI ondersteunt. Het gewenste communicatietype kan direct op het PN532 bord worden geselecteerd door de schakelaars om te zetten. De stand van de schakelaars die nodig zijn voor de respectieve interfaces vind je rechts van het schakelschema, dat iets verderop op de pagina staat. 
 &amp;nbsp; 
 Het schakelschema: 
   
 Tip: Je kunt  hier  een hoge resolutie versie van deze afbeelding vinden. Daar kun je de pintoewijzing wat beter zien.   
 De programmacode (I2C versie) 
  //******************************************************************************************************* 
 //** Voorbeeldschets voor het lezen van ID-tags. Als de ID overeenkomt, wordt PIN 13 gedurende 2 seconden ingeschakeld ** 
 //** ingeschakeld (LED). Als de ID fout is, wordt er een toon gegenereerd op pin 12. (PASSIEVE zoemer / piezzo) ** 
 //** gebruik. In plaats van een LED kan ook een deurslot worden geschakeld (via TIP120 schakelversterker ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Bibliotheek voor het I2C-protocol  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Bibliotheek voor de NFC/RFID module !!!   Gelieve te laden via Arduino IDE !!!  


  #define  PN532_IRQ (2)  // Definieer de IRQ connector  
  #define  PN532_RESET (3)  // Definieer de reset-aansluiting  

 const   int  AlarmPin =  12 ;  // Pin 12 uitgang voor piëzoluidspreker 
 const   int  OutputPin =  13 ;  // Pin 13 uitgang voor LED of via TIP120 naar een magnetisch slot 
 unsigned   long  cardid;  // Variabele voor het gelezen TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // Hier kunnen ID&#039;s worden ingevoerd die geaccepteerd moeten worden
 unsigned   long  TAGid2 =  4070796058 ;  // Anders leeg laten. De ID van individuele TAGs kunnen worden ingevoerd met 
 unsigned   long  TAGid3 ;  // de seriële monitor (stel 115200 baud in) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);  // instantie met I2C-protocol aanmaken 


 void    setup() // start setup-functie 
  pinMode (AlarmPin,  OUTPUT );  // Pin definiëren als uitgang 
   pinMode (OutputPin,  OUTPUT ); // Definieer   PIN als uitgang
  Serial  .begin  (115200 );  // Open seriële transmissie met 115200 baud (ser monitor dezelfde baud-instelling!) 
  Serial  .println ( &quot;Hello! &quot;); //   Stuur tekst &quot;Hello!&quot; naar seriële monitor 
  nfc .begin ();  // Start communicatie met RFID lezer 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Versienummer van firmware lezen 
  als  (! 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;Chip PN5 gevonden&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Stuur tekst en versie-info naar seriële poort van RFID-lezer
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controleer wanneer er antwoord komt van de printplaat 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  
  
  nfc.SAMConfig();  // Configureer het bord om RFID-tags te lezen 

  Serial  .println ( &quot;Wachten op een ISO14443A chip ...&quot; );  // Stuur tekst die wacht naar seriële monitor 
}


 void   loop () {  // Lusfunctie starten 
  uint8_t succes;  // Variabele aanmaken 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer om de UID op te slaan 
  uint8_t uidLength;  // Lengte van de UID (4 of 7 bytes afhankelijk van ISO14443A Card/Chip Type) 

  // Wacht op een ISO14443A chip. Als er een wordt gedetecteerd, wordt de variabele // gevuld met de UID 
  // gevuld met de UID. Afhankelijk van de // lengte (4 bytes (Mifare Classic) of 
   7 bytes (Mifare Ultralight) wordt het // kaarttype herkend. 
  
  succes = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (succes) {  // Indien gedetecteerd, proces.... 
    Serial  .println ( &quot;ISO14443A kaart gevonden&quot; );
    Serial  .print ( &quot; UID Lengte: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print(&quot;  UID Waarde: &quot; );
    nfc.PrintHex(uid, uidLength);  // informatie uitvoeren naar seriële monitor 

    als  (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; );                                      //  
    }
      als  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // vraag of de TAGs 1..2..3 verbonden zijn met de respectievelijke 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // aan of uit 
 anders 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    // Einde IF query/lus 
  // Einde van de lus  
 De programmacode (SPI-versie) 
  //******************************************************************************************************* 
 //** Voorbeeldschets voor het lezen van ID-tags. Als de ID geschikt is, wordt PIN 13 ** gedurende 2 seconden 
 //** ingeschakeld (LED). Als de ID fout is, wordt er een toon gegenereerd op pin 12. (PASSIEVE zoemer / piezzo) ** 
 //** gebruik. In plaats van een LED kan ook een deurslot worden geschakeld (via TIP120 schakelversterker ** 
 //******************************************************************************************************* 

  #include   &amp;lt;Wire.h&amp;gt;   // Bibliotheek voor het I2C-protocol  
  #include   &amp;lt;SPI.h&amp;gt;   // Bibliotheek voor het SPI-protocol  
  #include   &amp;lt;Adafruit_PN532.h&amp;gt;   // Bibliotheek voor de NFC/RFID module !!! Gelieve te laden via Arduino IDE !!!  

 const   byte  PN532_SCK =  2 ;  // 
 const   byte  PN532_MOSI  =3 ;  // Definieer de aansluitingen voor  
 const   byte  PN532_SS =  4 ;  // de SPI-verbinding naar de RFID  
 const   byte  PN532_MISO  =5 ;  // Board 

 const   int  AlarmPin =  12 ;  // Definieer  de aansluitingen voor 
 const   int  OutputPin =  13 ;  // de (schakelende) uitgangen 
 unsigned   long  cardid;  // Variabele voor de gelezen TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;  // Hier kunnen ID&#039;s worden ingevoerd die geaccepteerd moeten worden
 unsigned   long  TAGid2 =  4070796058 ;  // Anders leeg laten. De ID van individuele TAGs kunnen worden ingevoerd met 
 unsigned   long  TAGid3 ;  // de seriële monitor (stel 115200 baud in) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);  // instantie aanmaken met SPI-protocol 

 void    setup() // Start setup-functie 
  pinMode (AlarmPin,  OUTPUT );  // Pin definiëren als uitgang 
   pinMode (OutputPin,  OUTPUT );  // Definieer PIN als uitgang
  Serial  .begin  (115200 );  // Open seriële transmissie met 115200 baud (ser monitor dezelfde baud-instelling!) 
  Serial  .println ( &quot;Hello! &quot;); //   Stuur tekst &quot;Hello!&quot; naar seriële monitor 
  nfc .begin ();  // Start communicatie met RFID lezer 
  unsigned   long  versiondata = nfc.getFirmwareVersion();  // Versienummer van firmware lezen 
  als  (! 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;Chip PN5 gevonden&quot; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Stuur tekst en versie-informatie naar de   seriële poort van RFID-lezer
  Serial  .print ( &quot;Firmware ver. &quot; );  Serial  .print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);  // Controleer wanneer er antwoord komt van de printplaat 
  Serial  .print ( &#039;.&#039; );  Serial  .println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);  //  

  nfc.SAMConfig();  // Configureer het bord om RFID-tags te lezen 

  Serial  .println ( &quot;Wachten op een ISO14443A chip ...&quot; );  // Stuur tekst die wacht naar seriële monitor 
}


 void   loop () {  // Lusfunctie starten 
  uint8_t succes;  // Variabele aanmaken 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };  // Buffer om de UID op te slaan 
  uint8_t uidLength;  // Lengte van de UID (4 of 7 bytes afhankelijk van ISO14443A Card/Chip Type) 

  // Wacht op een ISO14443A chip. Als er een wordt gedetecteerd, wordt de variabele // gevuld met de UID 
  // gevuld met de UID. Afhankelijk van de // lengte (4 bytes (Mifare Classic) of 
   7 bytes (Mifare Ultralight) wordt het // kaarttype herkend. 
 
  succes = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

  if  (succes) {  // Indien gedetecteerd, proces.... 
    Serial  .println ( &quot;ISO14443A kaart gevonden&quot; );
    Serial  .print ( &quot; UID Lengte: &quot; );  Serial  .print (uidLength, DEC);  Serial  .println ( &quot; bytes&quot; );
    Serial  . print(&quot;  UID Waarde: &quot; );
    nfc.PrintHex(uid, uidLength);  // informatie uitvoeren naar seriële monitor 

    als  (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; );                                      //  
    }
      als  ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))  // vraag of de TAGs 1..2..3 verbonden zijn met de respectievelijke 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                // aan of uit 
 anders 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    // Einde IF query/lus 
  // Einde van de lus  
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">WISENT-klasse luchtkussenlandingsvaartuig</title>
            <id>https://funduinoshop.com/nl/wisent-klasse-luchtkussenlandingsvaartuig</id>
            <link href="https://funduinoshop.com/nl/wisent-klasse-luchtkussenlandingsvaartuig"/>
            <summary type="html">
                <![CDATA[
                
                                            Op veel modelboten shows zijn de meeste schepen tot in het kleinste detail en van zeer hoge kwaliteit gebouwd. Het is jammer dat dit vaak over het hoofd wordt gezien door de toeschouwers. Spectaculaire en niet alledaagse modellen...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Modelbouw: WISENT-Klasse Landing Craft Air Cushion &quot;LCAC&quot; 
 Op veel modelshows zijn de meeste schepen gebouwd met een zeer hoge kwaliteit en tot in het laatste&amp;nbsp;detail. Het is jammer dat dit vaak over het hoofd wordt gezien door&amp;nbsp;de toeschouwers. Spectaculaire en niet alledaagse&amp;nbsp;modellen trekken eerder de aandacht. Zonder&amp;nbsp;twijfel zijn de hovercrafts daar één van.&amp;nbsp;Waarom bouw je geen model van de grootste in zijn soort?&amp;nbsp;Met een waterverplaatsing van 550 ton is de Zubr klasse (Wisent klasse) een reus.&amp;nbsp;Er is een plastic model in 1:110. Dat was te klein voor mij. ik vond 1:75 precies goed&amp;nbsp;. Dus bouw je eigen model! 
 Bouw je eigen hovercraft: Maar hoe? 
 Het boek &quot;RC Luftkissenboote&quot; van&amp;nbsp;K.Jackson &amp;amp; M.Porter van uitgeverij VTH was een waardevolle hulp. Welke technische&amp;nbsp;componenten het model moesten laten zweven, moest worden uitgeprobeerd op&amp;nbsp;. Berekeningen waren hier niet erg nuttig. Aan het eind van de tekst staat een&amp;nbsp;lijst van de gebruikte batterij- en aandrijftechniek. Er bestaat geen bouwtekening voor&amp;nbsp;dit type, dus moesten er foto&#039;s worden gebruikt en veel&amp;nbsp;berekeningen worden gemaakt. 
 De schaal werd gebouwd met een PU-schuimplaat en een powerlijm&amp;nbsp;van de bouwmarkt. Dit ging vrij snel. Een 70 mm waaier, die vaak voor polystyreen modelvliegtuigen wordt gebruikt, zou de Wisent&amp;nbsp;moeten laten &quot;zweven&quot;. De luchtrok is gemaakt met rip-nylon.&amp;nbsp;Een materiaal dat wordt gebruikt voor tentzeilen en door parachutisten&amp;nbsp;. 
 De stroomvoorziening van de hovercraft 
 Met de geplande afmetingen van 900 x 400 mm was het vanaf het begin duidelijk dat het geen energiezuinig model zou worden. Een 18 V accu met 2,5 Ah uit de serie&amp;nbsp;gereedschap - gecombineerd met een spanningsomvormer - moet de gewenste spanning van gelijkmatig 12 V leveren.&amp;nbsp;Een tweede spanningsomvormer regelt de 12 V weer naar 9 V&amp;nbsp;en voorziet zo de propeller en de nautische verlichting van een&amp;nbsp;gelijkmatige spanning.&amp;nbsp;Zo komt de hele stroomvoorziening uit één accu.&amp;nbsp;Twee van de buitenste propellers zijn ontworpen voor voortstuwing, de middelste&amp;nbsp;motor is omgekeerd en deze propeller is &quot;ondersteboven&quot; op de  aandrijfas gestoken. Achteruit rijden is dus zonder problemen mogelijk.&amp;nbsp;De drie aandrijfgondels zijn voor mij geprint door het bedrijf - Ray Haller van Eibenstock - op&amp;nbsp;de 3D-printer. Ze worden synchroon aangestuurd door een servo.&amp;nbsp;Dit aandrijfconcept heeft zichzelf bewezen.&amp;nbsp;De propellers van 3,5 inch (ongeveer 9 cm) komen uit het assortiment reserveonderdelen voor quadcopters.&amp;nbsp;Ondanks de consequente lichtgewicht constructie weegt het model 4,7 kg met alle hulpstukken&amp;nbsp;. Dit maakt landen mogelijk, maar het is niet geschikt voor tochten&amp;nbsp;op het land. Zelfs het origineel is 99 % op het water&amp;nbsp;. Er zijn 18 van deze &quot;reuzenbizon&quot; gebouwd.&amp;nbsp;Oekraïne, Korea, Rusland, China en Griekenland hebben ze gebruikt. 
 Gebruikte componenten van 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;(40A controller wordt te heet)  3x R5-E-4-3:  Ready ToSky 1306 KV3100 voor 150 quadcopter  3x R6-E-1-4:  Hobbywing SkyWalker 12AE Brushless ESC  2x R12-B-8-2:  DC-DC Step Down Module 300W 20A 6-40V naar 1,2-36V  
 1x accu 2,5 Ah 18 V van Einhell (rijtijd ca. 15 min) Het model wordt bestuurd met een Carson 6-kanaals afstandsbediening 2,4 GHz. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Hoe installeer je een CH340/CH341 stuurprogramma?</title>
            <id>https://funduinoshop.com/nl/hoe-installeer-je-een-ch340/ch341-stuurprogramma</id>
            <link href="https://funduinoshop.com/nl/hoe-installeer-je-een-ch340/ch341-stuurprogramma"/>
            <summary type="html">
                <![CDATA[
                
                                            Steeds vaker worden we door jullie benaderd met de vraag hoe je het CH340 stuurprogramma voor Arduino compatibele microcontrollers installeert. In deze blogpost willen we daarom uitleggen...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Hoe installeer je een CH340/CH341 stuurprogramma voor Arduino-compatibele microcontrollers?  
 Steeds vaker krijgen we van jullie de vraag hoe je het CH340 stuurprogramma installeert voor Arduino compatibele microcontrollers. In deze blogpost willen we graag uitleggen    - Wat het verschil is tussen microcontroller boards met CH340 chipset en &quot;originelen&quot;  - Waar je de CH340 driver kunt downloaden  - Hoe je de CH340 driver installeert onder Windows  - Hoe je Arduino compatibele microcontrollers met CH340 driver kunt programmeren binnen de Arduino IDE 
 Na het lezen van deze blogpost ben je je bewust van alle valkuilen om goedkope Arduino klonen aan de praat te krijgen! 
  Het verschil tussen microcontrollers met CH340 en de ATmega328P chipset  
 Allereerst: Arduino-compatibele microcontrollerborden met CH340 chipset zijn iets goedkoper dan klassieke borden met ATmega328p. Dit komt deels doordat de klassieke borden met de &quot;originele&quot; chipset direct na aankoop via USB op de thuiscomputer kunnen worden aangesloten en dus klaar zijn voor gebruik.     Laten we, voordat we nu conclusies trekken, de belangrijkste voor- en nadelen van CH340-borden eens in detail bekijken: 
 Nadeel 1: &amp;nbsp;De CH340 chipset is niet compatibel met alle besturingssystemen! 
 Vooral met Windows systemen leidt de CH340 chipset vaak tot frustratie: het Windows besturingssysteem is meestal niet uitgerust met het CH340 stuurprogramma af-fabriek. Arduino-compatibele borden met CH340/CH341 drivers die zijn aangesloten op een Windows PC worden vaak niet als zodanig herkend door de PC. Daarom worden er foutmeldingen weergegeven in de Arduino IDE bij het uploaden van sketches. 
 Nadeel 2: Het uploaden van sketches naar CH340 borden duurt langer (getest bij 5V)! 
 We geven toe: misschien is dit nadeel te verwaarlozen bij prototyping thuis, maar het bestaat wel. De eenvoudigste manier om het verschil te zien is door naar de volgende datareeksen te kijken. 
 
 
 
 
 Grootte van de sketch (byte) 
 
 
 R3 Uploadtijd (seconden) 
 
 
 CH340 Uploadtijd (seconden) 
 
 
 
 
 500 
 
 
 5.3 
 
 
 5.6 
 
 
 
 
 5000 
 
 
 9.3 
 
 
 9.7 
 
 
 
 
 7000 
 
 
 9.6 
 
 
 10.2 
 
 
 
 
 &amp;nbsp;  Gemiddeld duurt het uploaden van programma&#039;s ongeveer 0,4 seconden langer met CH340-borden. 
 Voordeel 1: Het stroomverbruik van het CH340/CH341 bord is lager! 
 Natuurlijk kan de uploadtijd van schetsen worden verwaarloosd, vooral bij rapid prototyping. Maar hoe zit het met het stroomverbruik? We hebben opnieuw gekeken naar het gedrag van het bord met twee standaardschetsen die jullie ongetwijfeld allemaal kennen: &quot;Bare Minimum&quot; en &quot;Blink&quot;. 
 
 
 
 
  Voorbeeld schets  
 
 
  Stroomverbruik R3 (mA)  
 
 
  Stroomverbruik CH340 (mA)  
 
 
 
 
 Nauwkeurig minimum 
 
 
 32.3 
 
 
 14 
 
 
 
 
 Knipperen 
 
 
 37.1 
 
 
 20.1 
 
 
 
 
 Wij zijn net zo verbaasd als jij! Het stroomverbruik van het CH340 microcontroller bord is slechts de helft van dat van de R3... spannend! 
  Dus laten we tot de conclusie komen:  
 Voor degenen die kunnen leven met de extra inspanning vanwege de installatie van het extra benodigde stuurprogramma, zijn Arduino-compatibele microcontrollers met CH340/CH341 chipset zeker een goed alternatief. Het technische nadeel van de CH340 versie, de uploadtijd, is zeker te verwaarlozen voor de hobbyist. In dit geval weegt de winst door het lage stroomverbruik zelfs op tegen het nadeel! 
 Waar kun je het CH340 stuurprogramma downloaden? 
 Nu wordt het een beetje lastig: In het volgende linken we je naar de CH340 stuurprogramma&#039;s voor de platforms Windows, OS en Linux. De links voor de Windows en OS drivers linken naar een website met Chinese karakters. Laat je hierdoor niet afschrikken: je kunt het stuurprogramma gewoon downloaden door op de blauwe balk (wolkensymbool) te klikken. Ten tijde van onze test waren de schetsen natuurlijk virusvrij! 
 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  
 Update 21.11.2022: We kregen van een klant te horen dat het gebruik van het bovenstaande stuurprogramma voor OS tot complicaties kan leiden. We raden daarom het volgende stuurprogramma aan (tegen betaling).&amp;nbsp;   https://www.mac-usb-serial.com/dashboard/   Meer informatie is te vinden op&amp;nbsp; https://thingsmatic.com/2017/08/07/using-ch340-devices-with-osx/ &amp;nbsp;. 
 Op dit punt willen we erop wijzen dat voor de installatie administratorrechten nodig kunnen zijn. 
 Hoe installeer ik nu het CH340 stuurprogramma? 
 Als je het bijbehorende bestand hebt gedownload, kun je het uitpakken (bijvoorbeeld met WinRar). Open vervolgens het bestand Setup.exe. Er wordt een nieuw venster geopend. Selecteer in dit venster onder &quot;Select INF&quot; het bestand &quot;CH341SER.INF&quot;. Bevestig je selectie vervolgens met de knop &quot;Installeren&quot;. Als de installatie is gelukt, verschijnt er een pop-up die de installatie bevestigt. 
 En hoe kan ik mijn compatibele microcontrollerbord nu gebruiken met het CH340 stuurprogramma? 
 Heel eenvoudig: (bijna) precies zoals een bord met ATmega328p of ATmega16U2 chipset. Maak eerst de USB-verbinding tussen de microcontroller en je computer. De microcontroller moet dan zichtbaar zijn in apparaatbeheer. 
 Open dan de Arduino IDE. Selecteer onder &quot;Tools&quot; en &quot;Board&quot; het type van je microcontroller. Selecteer vervolgens onder &quot;Extra&quot; en &quot;Poort&quot; de zogenaamde COM-poort van je controller. In de regel is dit de COM-poort met het hoogste nummer.     Belangrijk: In de volgende stap moet je onder &quot;Tools&quot; en &quot;Processor&quot; de ATmega329p (oude bootloader) selecteren. Alleen dan kun je de CH340 controller laden!    Dat was niet zo moeilijk, toch? Als je meteen aan je volgende project wilt beginnen, raden we je ons gratis leerplatform  www.funduino.de  aan met meer dan 250 gratis tutorials over de populairste sensoren, actuatoren en nog veel meer! 
                ]]>
            </content>

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

    
</feed>
