<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/nl/blog/raspberry-pi/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom feed</title>
    <id>https://funduinoshop.com/nl/blog/raspberry-pi/?sRss=1</id>
    <updated>2026-04-08T16:06:54+02:00</updated>
    
        <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">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">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">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>

    
</feed>
