<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/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/blog/raspberry-pi/?sRss=1</id>
    <updated>2026-05-06T17:48:50+02:00</updated>
    
        <entry>
            <title type="text">Taster am Raspberry Pi</title>
            <id>https://funduinoshop.com/taster-am-raspberry-pi</id>
            <link href="https://funduinoshop.com/taster-am-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                            In den ersten Beispielen haben wir die GPIO-Pins als Ausgänge kennengelernt, die wir auf HIGH geschaltet haben, um eine LED leuchten zu lassen. Aber GPIO steht für General Purpose Input/Output. Man kann die Pins also auch als Eingang...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  In den ersten Beispielen haben wir die GPIO-Pins als Ausgänge kennengelernt, die wir auf HIGH geschaltet haben, um eine LED leuchten zu lassen. Aber GPIO steht für General Purpose Input/Output. Man kann die Pins also auch als Eingang programmieren. Dann kann festgestellt werden, ob am Eingang eine Spannung anliegt (HIGH) oder eben nicht (LOW). Der Raspberry Pi hat nur digitale Eingänge (Abhilfe zur Messung analoger Spannungen werden wir später kennenlernen), dennoch muss die anliegende Spannung nicht exakt 3,3V sein, um als HIGH erkannt zu werden, und nicht 0V, um als LOW erkannt zu werden. Bis ca. 1,4V wird als LOW erkannt, alles über 1,9V wird sicher als HIGH erkannt. Problematisch sind nur der kleine Bereich um ½ von 3,3V und ein freier Pin, an dem nichts angeschlossen ist.  
  Wir werden mehrere digitale Sensoren kennenlernen, die in unserem Programm einen Alarm oder eine bestimmte Aktion auslösen sollen (z.B. Bewegungsmelder). Der einfachste dieser Sensoren ist der Taster (engl. button), ein federbelasteter Schalter, der einen Schaltkreis bei Tastendruck schließt und beim Loslassen wieder öffnet.  
  Wenn wir einen Kontakt des Tasters mit einem GPIO-Pin verbinden und die andere mit 3,3V, so wird bei Tastendruck eindeutig das Signal HIGH erfasst. Das Problem beginnt nach dem Loslassen des Tasters. Welchen Zustand hat der GPIO dann? Einen undefinierten! Damit kann man nicht programmieren. Im ausgeschalteten Zustand sollte der GPIO also dauerhaft auf GND Potenzial liegen. Das würde jedoch zu einem Kurzschluss führen, wenn der Taster gedrückt wird. Abhilfe schafft ein Widerstand, der so groß sein muss, dass nur ein kleiner Strom fließt. Üblich sind Widerstände von 4,7 k&amp;nbsp;(=4700 Ohm) oder 10 kΩ&amp;nbsp;(=10.000 Ohm). Man nennt diese Widerstände Pull-down-Resistor.  
  Man kann den GPIO aber auch so programmieren, dass er normalerweise HIGH anzeigt und den Tastendruck gegen GND als Änderung auf LOW erkennt. Dann heißt der Widerstand Pull-up-Resistor. Und um das Ganze noch unübersichtlicher für Anfänger zu machen, haben die Raspberry Pi GPIOs einen internen Pull-up oder Pull-down-Resistor, der im Programm aktiviert oder deaktiviert werden kann. Zum Glück werden die ersten Schaltungen dadurch sehr einfach.  
  Der Schaltplan: Taster am Raspberry Pi  
     
     
  Der Programmcode: Taster am Raspberry Pi  
  from gpiozero import LED, Button
from signal import pause
led = LED( 12 )
 button  = Button( 16 )
 button  .when_pressed  = led .on 
 button  .when_released  = led .off 
  pause  ()    
   Aus dem Modul gpiozero werden, mit Komma getrennt, die Klassen LED und Button importiert, dann die Objekte led und button mit den jeweiligen GPIO-Nummern instanziiert.     Anstelle der    sleep()   -Funktion aus dem Modul    time   &amp;nbsp;wird    pause   &amp;nbsp;aus dem Modul    signal   &amp;nbsp;verwendet. sleep() würde kompletten Stillstand bedeuten, der Tastendruck würde in der Zeit nicht bemerkt. Ohne pause() würde das Programm beendet und nichts mehr geschehen.     Die Instanziierung von button war sehr einfach, weil wir nur die GPIO-Nummer angegeben haben und ansonsten die Voreinstellungen (siehe Klassendefinition nächste Zeile) verwendet haben. Wer davon abweichen möchte, muss weitere Parameter als Schlüsselwort-Argumente eingeben.   
   class  gpiozero. Button ( pin , *,  pull_up = True ,  active_state = None ,  bounce_time = None ,
 hold_time =1,  hold_repeat = False ,  pin_factory = None )  
   Weitere Einzelheiten zu gpiozero findet man      hier     .    
  Erweiterung des Versuchsaufbaus: Eine Ampelzyklus soll mit einem Raspberry Pi gestartet werden, wenn ein Taster betätigt wird.  
  Der Versuchsaufbau orientiert sich am ersten Beispiel. Anstelle einer LED wird die LED-Ampel verwendet. Diese hat eingebaute Vorwiderstände. Wir instanziieren drei LED-Objekte und definieren eine Funktion trafficLight, die bei Tastendruck aufgerufen wird.  
  Der Programmcode: Ampelzyklus am Raspberry Pi   
  from gpiozero  import  LED, Button
from signal  import  pause
from time  import  sleep
redled = LED( 16 )
yellowled = LED( 20 )
greenled = LED( 21 )
button = Button( 12 )
def trafficLight():
       redled.on()
    sleep(1)
    yellowled.on()
    sleep(1)
    greenled.on()
    redled.off()
    yellowled.off()
    sleep(1)
    yellowled.on()
    greenled.off()
    sleep(1)
    redled.on()
    yellowled.off()
    sleep(1)
    redled.off()
button.when_pressed = trafficLight
pause()  
  Erweiterung: Reaktionsspiel mit zwei Tastern am Raspberry Pi  
   Man benötigt zwei Taster, einen Buzzer sowie eine rote und eine gelbe LED. Nach dem Start des Reaction Game leuchtet zunächst die gelbe LED. Mit    time = uniform(5, 10)   &amp;nbsp;leuchtet nach einer zufälligen Zeit zwischen fünf und zehn Sekunden die rote LED auf. Dann können zwei Spieler jeweils ihren Taster so schnell wie möglich drücken. Wer zu früh drückt, wird beim Mogeln erwischt, der Buzzer ertönt für eine halbe Sekunde.   
  Der Programmcode: Reaktionsspeil mit zwei Tastern am Raspberry Pi   
   #! /usr/bin/python3 
 # Reaction Game - push button, when red LED lights-up 
 # based on gpiozero documentation, Basic Recipes 
 # enhanced to recognize cheating by Bernd Albrecht 
 # Red LED lights-up 5 - 10 sec after the yellow LED 
 from  gpiozero  import  Button, LED, Buzzer
 from  time  import  sleep
 from  random  import  uniform
 from  sys  import  exit
led_red = LED( 16 )
led_yellow = LED( 20 )
buzzer = Buzzer( 12 )
player_1 = Button( 23 )
player_2 = Button( 18 )

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

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

    
    
        <entry>
            <title type="text">RGB LED am Raspberry Pi</title>
            <id>https://funduinoshop.com/rgb-led-am-raspberry-pi</id>
            <link href="https://funduinoshop.com/rgb-led-am-raspberry-pi"/>
            <summary type="html">
                <![CDATA[
                
                                             Eine RGB-LED ist die Vereinigung von drei LEDs verschiedener Farben in einem Gehäuse. Hinter der Bezeichnung RGB verbergen sich die Farben „Rot“, „Grün“ und „Blau“. Die jeweiligen LEDs können mit Pulsweitenmodulation (PWM) angesteuert...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Mit einem Raspberry Pi Mikrocontroller eine RGB LED ansteuern 
 Was ist überhaupt eine RGB LED? 
 Eine RGB-LED ist die Vereinigung von drei LEDs verschiedener Farben in einem Gehäuse. Hinter der Bezeichnung RGB verbergen sich die Farben „Rot“, „Grün“ und „Blau“. Die jeweiligen LEDs können mit Pulsweitenmodulation (PWM) angesteuert werden. So ist eine Vielzahl von Farbkombinationen möglich. 
 Eine RGB-LED hat vier Beinchen, eins für jede Farbe und ein gemeinsames für alle drei Farben. Das längste der vier Beinchen ist je nach Version die gemeinsame Anode (+) bzw. Kathode (-). Das einzelne Beinchen neben diesem längsten ist der Anschluss für den Rot-Anteil. Über die Beinchen auf der anderen Seite werden die Grün- und Blau-Anteile angesteuert.    
 Welchen Typ RGB-LED man hat, gemeinsame Anode (common anode) oder gemeinsame Kathode (common cathode), ist äußerlich nicht erkennbar. Zum Glück kann man mit Ausprobieren nichts beschädigen. In Sperrrichtung leuchtet die RGB-LED eben nicht. Wichtig: Auch die drei implementierten LEDs benötigen Vorwiderstände. Wer es akademisch betreiben möchte, kann unterschiedliche Vorwiderstände aus den jeweiligen Flussspannungen berechnen. Der Einfachheit halber kann man auch gleiche Widerstände zwischen 100 und 330 Ω (Ohm) nehmen. 
 Version a: „Common cathode“ – Das längste Beinchen der LED ist „-“ und die drei kürzeren Beinchen werden an den GPIOs mit &amp;nbsp;„+“ (Spannung) angesteuert. 
 Version b) „Common anode“ – Das längste Beinchen der LED ist „+“ und die drei kürzeren Beinchen werden an den GPIOs mit „-“ (GND) angesteuert. 
 Durch eine Mischung der Farben können noch sehr viele weitere Farben erzeugt werden. Zum Beispiel entsteht durch die Ansteuerung der Farben „Blau“ und „Grün“ die Farbe „Türkis“, Rot und Grün ergibt Gelb, Rot und Blau Magenta, und alle drei Farben mit gleichem Anteil ergeben Weiß. 
       Der Schaltplan: RGB LED am Raspberry Pi   
 Der Programmcode: RGB LED am Raspberry Pi 
 Beispielprogramm für eine RGB-LED mit gemeinsamer Kathode: 
 from gpiozero  import  RGBLED
from time  import  sleep
 led  = RGBLED( red=14,   green=15,   blue=18) 
 duration  =  2 

 # slowly increase intensity of all colours (5sec) 
for n  in  range( 100 ):
    led. blue  = n/ 100 
    led. red  = n/ 100 
    led. green  = n/ 100     
    sleep( 0.05 )
led. color  = ( 0 ,  0 ,  0 )  # off 
sleep(duration)
led. red  =  1   # full red 
sleep(duration)
led. red  =  0.5   # half red 
sleep(duration)
led. color  = ( 1 ,  1 ,  0 )  # yellow 
sleep(duration)
led. color  = ( 0 ,  1 ,  0 )  # full green 
sleep(duration)
led. color  = ( 0 ,  1 ,  1 )  # cyan 
sleep(duration)
led. color  = ( 0 ,  0 ,  1 )  # full blue 
sleep(duration)
led. color  = ( 1 ,  0 ,  1 )  # magenta 
sleep(duration)
led. color  = ( 1 ,  1 ,  1 )  # white 
sleep(duration)
led. color  = ( 0 ,  0 ,  0 )  # off 
sleep(duration) 
 Später werden wir sehen, wie man mit Hilfe von drei Potentiometern die Farbanteile festlegen kann. Dafür benötigen wir allerdings einen externen Analog-Digital-Wandler, denn der Raspberry Pi kennt nur digitale Signale – HIGH oder LOW. 
    
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Pulsierende LED am Raspberry Pi (Pulsweitenmodulation)</title>
            <id>https://funduinoshop.com/pulsierende-led-am-raspberry-pi-pulsweitenmodulation</id>
            <link href="https://funduinoshop.com/pulsierende-led-am-raspberry-pi-pulsweitenmodulation"/>
            <summary type="html">
                <![CDATA[
                
                                            Eine LED soll pulsierend heller und dunkler werden. (Auch als „faden“ bezeichnet, nach dem engl. Verb to fade= abklingen, abnehmen). Umsetzen möchten wir dies mit der sogenannten Pulsweitenmodulation...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Eine LED soll pulsierend heller und dunkler werden. (Auch als „ faden “ bezeichnet, nach dem engl. Verb  to fade  = abklingen, abnehmen). Umsetzen möchten wir dies mit der sogenannten Pulsweitenmodulation. Weitere Informationen zur Puslweitenmodulation am Raspberry Pi findet Ihr etwas weiter unten.  Im ersten Schritt schauen wir uns den Schaltplan an. 
 Der Schaltplan: Pulsierende LED am Raspberry Pi (PWM) 
   
  Um die Helligkeit einer LED zu variieren, reicht es nicht aus, die Spannung zu variieren. Bauartbedingt (Diode!) wird eine gewisse Mindestspannung benötigt; diese sogenannte Flussspannung (engl. forward voltage) liegt in Abhängigkeit von der Farbe der LED zwischen ca. 1,6 und ca. 3 V. Oberhalb dieser Flussspannung wird die LED leitend, der Strom wird über einen Vorwiderstand begrenzt. Also: Anders als bei Glühlampen, wird die Helligkeit nicht über die Höhe der Spannung reguliert. Im Übrigen liefern die GPIO-Pins ohnehin nur genau 3,3V. 
 Abhilfe schafft hier die Pulsweitenmodulation (engl. pulse width modulation oder PWM). Dabei wird die Gleichspannung mit hoher Frequenz ein- und ausgeschaltet. Die insgesamt übertragene Energie wird durch das Verhältnis der Einschaltdauer zur gesamten Dauer eines Zyklus bestimmt. Dieser Tastgrad (engl. duty cycle) kann zwischen 0 und 100% liegen. 
 Bei dem Raspberry Pi kann man auf allen GPIO-Pins die software PWM benutzen. Es gibt aber auch zwei spezielle Hardware PWM Pins. Los geht’s! 
 Der erste Programmcode: Pulsierende LED am Raspberry Pi mit Pulsweitenmodulation 
  # Wir starten mit dem Importieren der Programm-Module 
import RPi.GPIO as GPIO	        # Achtung: Schreibweise beachten: kleines i 
import  time 
GPIO.setmode(GPIO.BCM)            # Wir stellen den Modus auf BCM ein 
LED= 23                                                # Das Wort „LED“ steht jetzt für die Zahl „ 23 “. 
GPIO.setup(LED,GPIO.OUT)           # „LED” (Pin  23 ) ist ein Ausgang. 
Dimmer = GPIO.PWM(LED, 100 )   # Wir legen die LED als PWM mit einer Frequenz von  100  fest 
Dimmer.start( 0 )                                # Dimmer wird gestartet 
 # Hier beginnt die Schleife 
 try :
     while   True :                                      #while-Schleife damit das Programm durchgehend läuft 
         for  dc  in  range( 0 , 101 , 5 ):           # Schleife des Tastgrads in  5 er-Schritten. 
             Dimmer.ChangeDutyCycle(dc)  # Ändern des Tastgrads des Dimmers. 
             time . sleep ( 0.1 )                         # Warte  0.1  Sekunde. 
         for  dc  in  range( 100 ,- 1 ,- 5 ):       # Schleife des Tastgrads in - 5 er-Schritten. 
            Dimmer.ChangeDutyCycle(dc)  # Ändern des Tastgrads des Dimmers. 
             time . sleep ( 0.1 )                        # Warte  0.1  Sekunde. 
except KeyboardInterrupt:             # Mit STRG+C unterbrechen wir das Programm 
    print (“Beendet”)                             # Schreibe “Beendet” in das Shell-Fenster 
    Dimmer. stop ()                                  # Stop des Dimmers. 
    GPIO.cleanup()                                  # Beende das Programm.  
 In diesem Beispiel lernen wir eine weitere Form der Schleife kennen: die for-Schleife. Auch diese Befehlszeile endet mit einem Doppelpunkt und anschließender Einrückung (engl. indentation) der zu wiederholenden Zeilen. 
 Die Variable dc (für duty cycle) wird im Bereich (engl. range) 0 bis ausschließlich 101 in Fünfer-Zählschritten vergrößert:  for dc in range(0,101,5):  
 In der zweiten for-Schleife wird von 100 bis ausschließlich -1 rückwärts gezählt um -5:  for dc in range(100,-1,-5):  
 Der zweite Programmcode: Pulsierende LED am Raspberry Pi mit Pulsweitenmodulation mit gpiozero Befehl    
 # Wir starten mit dem Importieren der Programm-Module
from gpiozero import PWMLED
import time
pwmled = PWMLED( 23 )                 # optionaler  Parameter  frequency=xxx  (default 100) 

# Hier  beginnt die Schleife 
try:
    while  True:                     # while-Schleife damit das Programm durchgehend l ä uft 
        for  dc in range(0,101,5):   # Hochz ä hlen des Tasgrads in 5er-Schritten. 
            pwmled.value  = (dc / 100 ) # Ändern des Tastgrads (zwischen  0  und  1 ) des Dimmers.
            time. sleep ( 0.1 )         # Warte  0.1  Sekunde.
         for  dc in range( 100 , -1 , -5 ): # Herunterzählen des Tastgrads in  -5 er-Schritten.
            pwmled.value = (dc/ 100) #  Ä ndern des Tastgrads (zwischen 0 und 1) des Dimmers. 
            time.sleep(0.1)         # Warte  0.1 Sekunde. 

except  KeyboardInterrupt:           # Mit STRG+C unterbrechen wir das Programm 
    print  (  &quot;Beendet&quot;  )               # Schreibe  “ Beendet ”  in das Shell-Fenster 
#    pwmled.value  = 0                # 1. Methode zum L ö schen der LED bei Programmende 
    pwmled.close()                   # 2. Methode zum L ö schen der LED bei Programmende  
 Insgesamt ist der Programm-Code bei gpiozero schlanker. 
 Bitte beachten: Der Tastgrad liegt zwischen 0 und 100%. Während das Argument für den Tastgrad bei RPi.GPIO der %-Wert ist, erwartet gpiozero den Wert als Gleitkommazahl (engl. floating  point &amp;nbsp;number) zwischen 0.0 und 1. 0, also statt 50 [%] 0.5. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Buzzer und LED am Raspberry Pi anschließen</title>
            <id>https://funduinoshop.com/buzzer-und-led-am-raspberry-pi-anschliessen</id>
            <link href="https://funduinoshop.com/buzzer-und-led-am-raspberry-pi-anschliessen"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Blogbeitrag möchten wir einen Buzzer und eine LED mit Hilfe eines Raspberry Pi Mikorcontrollers zum Leuchten bzw. Ertönen bringen. Dieses Programm wird in Schulen gerne dafür verwendet, um aufzuzeigen...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hinweis: Für dieses Programm ist ein aktiver Buzzer erforderlich (Erklärung folgt später), auf die Polarität ist zu achten. Es wird kein Vorwiderstand beim Buzzer (Lautsprecher) benötigt. 
 In diesem Blogbeitrag möchten wir einen Buzzer und eine LED mit Hilfe eines Raspberry Pi Mikorcontrollers zum Leuchten bzw. Ertönen bringen. Dieses Programm wird in Schulen gerne dafür verwendet, um aufzuzeigen, wie einfache Ausgangssignale unter Verwendung eines Raspberry Pi mit einfachen Bauteilen verwertet werden können.  Bevor wir uns der Frage widmen, worin der Unterschied zwischen einem aktiven und einem passiven Lautsprecher besteht, schauen wir uns zunächst den Schaltplan und den Programmcode an. 
 Der Schaltplan: Buzzer und LED am Raspberry Pi anschließen 
   
 Der Quellcode: Buzzer und LED am Raspberry Pi anschließen 
  # Dieses Mal nutzen wir auch den ersten Programmabschnitt. Hier werden Variablen eingetragen. Das bedeutet, dass sich hinter einem Buchstaben oder einem Wort eine Zahl verbirgt. Bei uns ist die LED an Pin 23 angeschlossen und der Piezo-Speaker an Pin 4. Damit man die beiden Pins später nicht verwechselt, benennen wir Pin 23 und Pin 24 einfach um. 
 # Wir starten mit dem Importieren der Programm-Module 
 import  RPI.GPIO  as  GPIO
 import  time
GPIO.setmode(GPIO.BCM)  # Wir stellen den Modus auf BCM ein 
LED= 23 ;  # Das Wort „LED“ steht jetzt für die Zahl „23“. 
Pieps= 24 ;  # Das Wort „Pieps“ steht jetzt für die Zahl „24“. 
GPIO.setup(LED,GPIO.OUT)  # Pin „LED“ (Pin 23) ist ein Ausgang. 
GPIO.setup(Pieps,GPIO.OUT)  # Pin „Pieps“ (Pin 24) ist ein Ausgang 
 # Hier beginnt die Schleife 
 try :
 while   True :  # While-Schleife damit das Programm durchgehend läuft 
GPIO.output(LED,GPIO.HIGH)  # Schaltet die LED an. 
GPIO.output(Pieps,GPIO.HIGH)  # Schaltet den Piezo-Lautsprecher an. 
time.sleep( 1 )  # Warte 1 Sekunde 
GPIO.output(LED,GPIO.LOW)  # Schaltet die LED aus. 
GPIO.output(Pieps,GPIO.LOW)  # Schaltet den Piezo-Lautsprecher aus. 
time.sleep( 1 )
 # Hier am Ende springt das Programm an den Start der while-Schleife. Also wird es gleich wieder piepsen und leuchten. Wenn man die Pause (time.sleep) verkleinert oder vergrößert,piepst und leuchtet es schneller oder langsamer. 
 except  KeyboardInterrupt:  # Mit STRG+C unterbrechen wir das Programm 
 print  (“Beendet”)  # Schreibe “Beendet” in das Shell-Fenster 
GPIO.cleanup()  # Beende das Programm  
 Unterschied aktiver und passiver Buzzer 
 Der aktive Buzzer hat eine eingebaute Schwingkreis-Elektronik (Oszillator), die bei Anlegen der Spannung von 3,3V oder 5V einen Summton (engl.  to buzz, Summen ) erzeugt. Bauartbedingt muss man hier deshalb auf die Polarität des Buzzers achten. Bei Auslieferung haben diese Buzzer meist einen kleinen Aufkleber mit dem Pluszeichen und „REMOVE SEAL AFTER WASHING“ Aufkleber. Auch auf dem Gehäuse des Bauteils selbst befindet sich ein Plus + wieder. Um das längere Beinchen zu erkennen, muss man zweimal hinschauen. Oder man nimmt gleich ein kleines Breakoutboard; hier sind die Kontakte mit S (steht für Signal) und – (Minus, Ground) gekennzeichnet.&amp;nbsp; 
 Ausprobieren kann man den Buzzer mit einem einfachen Programm wie für die blinkende LED, bei dem der (fast) beliebige Pin jeweils eine Sekunde auf HIGH und eine Sekunde auf LOW geschaltet wird. 
 Der passive Buzzer hat keinen eingebauten Oszillator, deshalb muss der Raspberry Pi diese Funktion übernehmen. Wenn man das obige Programm an einem passiven Buzzer ausprobiert, hört man im Sekundentakt ein leises &quot;Klick&quot;-Geräusch. Wenn man jedoch die Pausenzeit extrem verkürzt (sleep(0.001) oder sleep(0.002)) und das Ein- und Ausschalten für eine gewisse Dauer wiederholt, kann man einen Ton hören, dessen Frequenz wir leicht berechnen können: jeweils eine Millisekunde HIGH bzw. LOW bedeutet (unter Vernachlässigung der Ausführungszeit der weiteren Befehle) rund 500 Zyklen on/off je Sekunde, also ca. 500Hz. 
 Wer einen kurzen Warnton ausgeben möchte, sollte einen aktiven Buzzer verwenden, der wie eine LED ein- und ausgeschaltet wird. Dabei ist auf die Polarität zu achten. 
 Wer eine Zweiton-Sirene (die man deutlicher hört) oder eine kurze Erkennungsmelodie (Jingle) programmieren möchte, sollte zum passiven Buzzer oder einem kleinen Lautsprecher greifen. 
    
 &amp;nbsp; 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Abwechselnd blinkende LEDs am Raspberry Pi Mikrocontroller</title>
            <id>https://funduinoshop.com/abwechselnd-blinkende-leds-am-raspberry-pi-mikrocontroller</id>
            <link href="https://funduinoshop.com/abwechselnd-blinkende-leds-am-raspberry-pi-mikrocontroller"/>
            <summary type="html">
                <![CDATA[
                
                                            Man kann die elektronischen Bauteile auf dem Breadboard auch ohne T-Cobbler anschließen. Dann benötigt man jedoch für die Verbindung zur J6-Steckerleiste des Raspberry Pi Steckkabel (engl. jumper wire) vom Typ female – male...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Wie lässt man zwei LEDs am Raspberry Pi abwechselnd blinken? 
 Man kann die elektronischen Bauteile auf dem Breadboard auch ohne T-Cobbler anschließen. Dann benötigt man jedoch für die Verbindung zur J6-Steckerleiste des Raspberry Pi Steckkabel (engl. jumper wire) vom Typ female – male, also Buchse für den Raspberry Pi und Stecker für das Breadboard. 
   
  Der Programmcode (abwechselnd blinkende LED am Raspberry Pi)   
  # Ab hier kann der Code direkt in die Python Software kopiert werden. 
 # Schwarz, bunt = Code und Grau = Erklärungen 
 #Wir starten mit dem Importieren der Programm-Module 
import RPI.GPIO  as  GPIO
import  time 
GPIO.setmode(GPIO.BCM)    # Wir stellen den Modus auf BCM ein 
GPIO.setup( 23 ,GPIO.OUT)    #Pin 23 ist ein Ausgang. 
GPIO.setup( 24 ,GPIO.OUT)    #Pin 24 ist ein Ausgang. 
 # Hier beginnt die Schleife 
 try :
     while  True:       #While-Schleife damit das Programm durchgehend läuft 
        GPIO.output( 23 ,GPIO.HIGH)  # Schaltet die LED an Pin 23 an. 
        GPIO.output( 24 ,GPIO.LOW)  # Schaltet die LED an Pin 24 aus. 
         time .sleep( 1 )  # Warte 1 Sekunde 
        GPIO.output( 23 ,GPIO.LOW)  # Schaltet die LED an Pin 23 aus. 
        GPIO.output( 24 ,GPIO.HIGH)  # Schaltet die LED an Pin 24 an. 
         time .sleep( 1 )
 # Hier am Ende springt das Programm an den Start des Loop-Teils. Also… 
 # …schalte die LED an Pin 23 an. 
 # … usw… usw… usw… 
except KeyboardInterrupt:  # Mit STRG+C unterbrechen wir das Programm 
    print ( &quot;Beendet”)   # Schreibe “Beendet” in das Shell-Fenster
    GPIO.cleanup()       # Beende das Programm
  
 Im Beispiel Nr. 01 Blinkende LED hatten wir die Endlosschleife mit while True und Einrückung der folgenden Codezeilen realisiert. Wer diese Endlosschleife mit der Tastenkombination Strg-C abgebrochen hat, wird bemerkt haben, dass er erstens eine Fehlermeldung erhält und zweitens ggf. die LED weiterhin leuchtet. Um diese beiden unerwünschten Effekte zu verhindern, sind in diesem Beispiel einige Codezeilen ergänzt worden. Vor der while True-Schleife wird die Zeile  try:  eingefügt. Der Doppelpunkt führt zum Einrücken der gesamten Schleife. Wenn in dieser Schleife beim Programmablauf ein Fehler auftritt, erfolgt keine Fehlermeldung, sondern das Programm wird bei  except KeyboardInterrupt:  fortgesetzt. Mit dem print-Befehl wird das Programmende in der Python Shell (unteres Fenster bei Thonny) ausgegeben, mit GPIO.cleanup() werden die GPIOs (also unsere LEDs) ausgeschaltet und freigegeben für andere Zwecke. 
 Beispiel: Ampelzyklus am Raspberry Pi 
 Hier ein Lösungsvorschlag für einen Ampelzyklus unter Verwendung des Moduls gpiozero: 
   
   
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Blinkende LED am Raspberry Pi Mikrocontroller</title>
            <id>https://funduinoshop.com/blinkende-led-am-raspberry-pi-mikrocontroller</id>
            <link href="https://funduinoshop.com/blinkende-led-am-raspberry-pi-mikrocontroller"/>
            <summary type="html">
                <![CDATA[
                
                                            Anders als beim Arduino, hat man beim Raspberry Pi keinen Zugriff auf die eingebauten LEDs. Diese zeigen lediglich Spannungsversorgung und Zugriff auf die µSD-Karte an. Um eine LED blinken zu lassen, werden also eine externe LED mit einem...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Wie lässt man eine LED am Raspberry Pi blinken? 
  Anders als beim Arduino, hat man beim Raspberry Pi keinen Zugriff auf die eingebauten LEDs. Diese zeigen lediglich Spannungsversorgung und Zugriff auf die µSD-Karte an.  
 Um eine LED blinken zu lassen, werden also eine externe LED mit einem passenden Vorwiderstand sowie Jumperkabel benötigt. Am sinnvollsten ist der Aufbau der Schaltung auf einem Breadboard mit einem T-Cobbler. Diese Art der Anordnung erleichtert auch spätere Versuche mit mehreren LEDs, Tastern und Sensoren. Die Programmierung erfolgt in der Programmiersprache Python. 
 Der Schaltplan (Blinkende LED am Raspberry Pi) 
   
 Was ist eigentlich eine LED? 
 LED steht für Light Emitting Diode. Das letzte Wort deutet auf die elektronischen Eigenschaften hin. Eine Diode ist ein Halbleiter, der den Strom nur in einer Richtung durchlässt, in der anderen Richtung sperrt. Die beiden „Beinchen“ heißen Anode und Kathode. Wenn man genau hinschaut, erkennt man, dass die Beinchen unterschiedlich lang sind. Am längeren Beinchen, der Anode, wird die positive Spannung angelegt; das kürzere, die Kathode, wird über einen Widerstand mit Ground verbunden. Der Widerstand ist wegen einer weiteren Eigenschaft von Dioden erforderlich. Zunächst einmal bedarf es einer Mindestspannung, damit überhaupt ein Strom fließen kann: Diese nennt man Flussspannung (engl. forward voltage). Bei höheren Spannungen wird die Diode voll leitend. Deshalb benötigt man einen Vorwiderstand, um die Stromstärke zu begrenzen, denn die Pins der Mikro Controller und auch des Raspberry Pi sollen maximal mit 15 bis 20 mA beaufschlagt werden. Wir verwenden Vorwiderstände im Bereich 100 bis 330 Ω (Ohm). 
 Die Programmiersprache Python kann, ähnlich wie. bei C/C++ mit den Bibliotheken (libraries), durch Programm-Module erweitert werden. Für unsere blinkende LED benötigen wir zwei dieser Module: erstens „time“, um die Blinkdauer festzulegen. Und zweitens ein Modul für den Zugriff auf die GPIOs (General Purpose Input/Output). 
 Wie steuere ich eine LED mit einem Raspberry Pi an? 
 Das Importieren der Module erfolgt zu Beginn des Python-Programms; dazu hat man mehrere Möglichkeiten. Beispiele: 
 Mit der folgenden Zeile wird das Modul  time  importiert: 
  import   time  
 Bei Aufruf der Methode  sleep  muss der Modulname  time  mit Punkt vorangestellt werden: 
  time . sleep ( 1 ) 
 Im Gegensatz zu delay(), bei dem das Zeitintervall als Argument in Millisekunden angegeben wird, werden bei  time.sleep()  die Werte in Sekunden, ggf. mit Dezimalpunkt angegeben. 
  import  RPi.GPIO  as  GPIO 
 Das vereinfacht die Aufrufe der Methoden im Programm, z.B. 
  GPIO  .setmode ( GPIO  .BCM ) 
 Drittes Beispiel für ein anderes Modul für den GPIO-Zugriff: 
 from gpiozero  import  LED 
 Aus dem Modul  gpiozero  wird nur die Klasse LED importiert. Bei dieser Import-Methode wird beim Aufruf der Methode/Funktion der Modulname nicht mehr vorangestellt. 
 Beispielprogramme zum Ansteuern einer LED mit einem Raspberry Pi Mikrocontroller 
 Erstes Beispiel mit dem Modul RPi.GPIO: 
 import RPi.GPIO as GPIO
import  time 
GPIO.setmode(GPIO.BCM)	 # Pinbezeichnung für Broadcomm-Prozessor 
GPIO.setup( 26 ,GPIO.OUT)	 # GPIO26 (=phys. Pin 37) wird Ausgang 

 while  True:	 # Endlosschleife, mit Strg-C abbrechen 
    GPIO. output ( 26 , 1 )	 # GPIO 26 wird HIGH geschaltet 
     time . sleep ( 1 )
    GPIO. output ( 26 , 0 ) 	 # GPIO 26 wird LOW geschaltet 
     time . sleep ( 1 )
 
 Zweites Beispiel mit dem Modul gpiozero. Es werden nur  LED  und  sleep  importiert. 
  from  gpiozero import LED
 from   time  import  sleep 
redLED = LED( 26 )	 # redLED wird an GPIO  26  instanziiert 

 while   True :
    redLED.on()	 # redLED wird angeschaltet 
     sleep ( 1 )
    redLED.off()	 # redLED wird ausgeschaltet 
     sleep ( 1 )
 
 Challenge: Schaltung und Programm erweitern für einen Ampelzyklus, z.B. rot(3s), rot/gelb(1s), grün(3s), gelb(1s), Wiederbeginn mit rot. 
 Lösungsvorschlag siehe Nr. 02 Der Wechselblinker 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Einstieg in den Raspberry Pi - Teil 3: Programmieren</title>
            <id>https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-3-programmieren</id>
            <link href="https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-3-programmieren"/>
            <summary type="html">
                <![CDATA[
                
                                            Grundsätzlich kann man auch die Arduino IDE auf dem Raspberry Pi installieren oder mit dem vorinstallierten Programm Geany, einem sehr funktionalen Editor, in verschiedenen Programmiersprache...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Grundsätzlich kann man auch die Arduino IDE auf dem Raspberry Pi installieren oder mit dem vorinstallierten Programm Geany, einem sehr funktionalen Editor, in verschiedenen Programmiersprache programmieren, aber seinen Namen hat der Raspberry Pi von der Programmiersprache Python; ursprünglich war er nur als  P ython  i nterpreter geplant. Also: Wer Programmieren des Raspberry Pi sagt, meint meist die sehr weit verbreitete und einfach zu erlernende Sprache Python. 
 In den letzten Jahren hat sich das Programm Thonny als Integrierte Entwicklungsumgebung (IDE=Integrated Development Environment) für Pyth o n-Programme etabliert. 
 &amp;nbsp;  
 Man unterscheidet grundsätzlich den Editor im oberen Teil des Fensters, hier werden die Programme geschrieben, und die Shell im unteren Teil, hier laufen die Programme mit möglichen Ein- und Ausgaben ab. Man kann aber auch in der Shell direkt kurze Befehle eingegeben. 
 Fortgeschrittene Programmierer sollten im Bild oben rechts auf „Switch to regular mode“ klicken, um auch die Menüleiste angezeigt zu bekommen. 
 &amp;nbsp;  
 Wer die Programmiersprache autodidaktisch erlernen möchte, kann dies anhand einer Vielzahl von Büchern tun. An dieser Stelle wird die Methode „Learning by doing“ empfohlen, also einfach die Programmbeispiele nachmachen. Meist ist der Programmcode selbsterklärend. Das ist das Schöne an Python. 
 Um unnötigen Frust zu vermeiden, sollen an dieser Stelle einige wenige Regeln genannt werden, die sich vornehmlich an Umsteiger von Arduino C/C++ richten: 
 Der Variablentyp muss im Gegensatz zu C/C++ nicht deklariert werden. Den Typ erkennt Python bei der ersten Benutzung. Wenn man z.B. in der Shell  type(„abc“)  eingibt, erhält man als Ausgabe &amp;lt;class ‚str‘&amp;gt;; es wird also der Typ String wegen der Hochkommata erkannt. 
 Die Befehlszeile wir nicht mit einem Semikolon abgeschlossen. Stattdessen muss bei Python sorgfältig auf Einrückungen geachtet werden. Also: jeder Befehl beginnt grundsätzlich an der ersten Stelle des Absatzes. 
 Einrückungen (engl. indentations) (meist Tab=vier Leerzeichen) erfolgen (meist automatisch) bei Verzweigungen, Schleifen oder Selbst-definierten Funktionen, ggf. auch mehrfach. 
 Programm- und Variablennamen beginnen immer mit einem Buchstaben oder dem Unterstrich ­­_. Danach können auch Ziffern verwendet werden. Der Unterstrich ist das einzige erlaubte Sonderzeichen und wird meist für besondere Zwecke verwendet. 
 Wie gesagt: Weitere Erklärungen zu Python mit den Programm-Beispielen. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Einstieg in den Raspberry Pi - Teil 2: Hardware und Software</title>
            <id>https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-2-hardware-und-software</id>
            <link href="https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-2-hardware-und-software"/>
            <summary type="html">
                <![CDATA[
                
                                            Eine kurze Einführung in die wichtigsten Komponenten für den Raspberry Pi. Obgleich Steckkabel, Widerstand oder LED, wir zeigen dir, welche Bauteile du für den Start brauchst. Zudem gehen wir auf die Installation der Software für den Raspberry Pi ein und...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Hardware und Software für den Raspberry Pi 
 Hardware für den Raspberry Pi 
     
 Grundlegendes Zubehör für den Raspberry Pi 
 Neben Sensoren und Aktoren benötigt man als Basis für schnelle und flexible Versuchsaufbauten&amp;nbsp; Steckkabel &amp;nbsp;in Verbindung mit einem&amp;nbsp; Breadboard . Dadurch erspart man sich zeitraubende Lötarbeiten. Des Weiteren eignen sich&amp;nbsp; Leuchtdioden &amp;nbsp;sehr gut, um die Signalausgabe des Boards zu überprüfen. 
 Das Breadboard 
 Ein Breadboard oder auch „Steckbrett“ ist ein gutes Hilfsmittel, um Schaltungen aufzubauen ohne zu löten. In einem Breadboard sind immer mehrere Kontakte in einer Reihe miteinander verbunden. Daher können an diesen Stellen viele Kabel miteinander verbunden werden, ohne dass sie verlötet oder verschraubt werden müssen. 
 Im folgenden Bild ist farbig dargestellt, welche Kontakte miteinander verbunden sind. 
 &amp;nbsp;  
 Standard Steckbrett für Raspberry Pi und Mikrocontroller.   Die grünen Linien im Bild zeigen den Verlauf der Leiterbahnen auf. 
 Für eine gute Verbindung des Raspberry Pi mit dem Breadboard gibt es sogenannte T-Cobbler mit einem Flachbandkabel, das alle 40 Pins herausführt. 
   
 Leuchtdioden, LED (light emitting diode) für den Raspberry Pi 
 Mit LEDs kann man sehr schnell die Ergebnisse eines Projekts testen. Daher sind sie für nahezu alle Arduino-Projekte nützlich. Über LEDs kann man vieles im Netz nachlesen. Hier nur die wichtigsten Infos. 
   
 
 Der Strom kann nur in einer Richtung durch die LED fließen. Daher muss sie korrekt angeschlossen werden. Eine LED hat einen längeren und einen kürzeren Kontakt. Der längere Kontakt ist + und der kürzere ist -. 
 Eine LED ist für eine bestimmte Spannung ausgelegt. Wird diese Spannung unterschritten, leuchtet die LED weniger hell oder sie bleibt aus. Wird die Spannung jedoch überschritten, brennt die LED sehr schnell durch und wird an den Kontakten sehr heiß (ACHTUNG!). 
 Typische Spannungswerte nach LED Farben: Blau:3,1V, Weiß:3,3V, Grün:3,7V, Gelb:2,2V, Rot:2,1V Die Spannung an den Digitalen Ports des Boards beträgt 5V. Beim direkten Anschluss an diese Ports gibt jede LED recht schnell den Geist auf. Daher muss ein Widerstand mit in den Stromkreis geschaltet werden. Im Internet gibt es unter dem Suchbegriff „Widerstandsrechner LED“ sehr gute Hilfen dazu. 
 Unverbindliche Empfehlung für Widerstände an folgenden LEDs (Bei Anschluss an die 5V Pins des Mikrocontroller-Boards.   
 
 
 
 
 LED 
 Weiß 
 Rot 
 Gelb 
 Grün 
 Blau 
 Infrarot (IR) 
 
 
 Widerstand 
 100 Ohm 
 200 Ohm 
 200 Ohm 
 100 Ohm 
 100 Ohm 
 100 Ohm 
 
 
 
 &amp;nbsp; 
 Steckkabel oder Jumper Wire für den Raspberry Pi 
 Die Steckkabel erhält man in unterschiedlichen Ausführungen, meist in 10cm oder 20cm Länge sowohl mit Steckern als auch mit Buchsen. Dabei bedeutet mm=male-male=Stecker an beiden Seiten, mf=male-female=Stecker an einer Seite, Buchse an der anderen Seite, und ff=female-female= mit Buchsen an beiden Seiten. 
   
 Taster und Schalter für den Raspberry Pi 
 Der erste und einfachste Sensor ist der Taster (engl. &quot;button&quot;), ein federbelasteter Schalter, der beim Loslassen den elektrischen Kontakt wieder öffnet. 
   
 Software für den Raspberry Pi 
 Das Betriebssystem Raspberry Pi OS kann von der  Homepage der Raspberry Pi Foundation  kostenlos heruntergeladen werden. Die 32-Bit Version ist zurzeit noch für alle Modelle identisch. Für das Beschreiben der µSD-Karte (8 bis 32 GB) am PC wird das Programm Imager empfohlen, dass ebenfalls von der Homepage der Foundation heruntergeladen werden kann. 
 Installation der Software 
   
 Inbetriebnahme des Raspberry Pi 
 Beim ersten Start wird das Betriebssystem eingerichtet. Dabei werden u.a. die Zugangsdaten zum heimischen WLAN eingegeben. Seit dem Frühjahr wird nicht mehr automatisch der Benutzername pi verwendet, sondern man wird zur Eingabe eines Benutzernamens und eines Kennworts aufgefordert. Nach einem Neustart am Ende der Initialisierung startet eine grafische Benutzeroberfläche. Dieser Vorgang dauert etwas länger als eine Minute. 
 Beim Anklicken des Symbols wird man gefragt, ob man die möglichen Aktualisierungen nur angezeigt bekommen möchte oder diese direkt starten. 
 Das folgende Bildschirmfoto wurde mit dem vorinstallierten Programm &quot;scrot&quot; (für  scr een sh ot ) aufgenommen. 
 &amp;nbsp;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Einstieg in den Raspberry Pi - Teil 1: Das Vorwort</title>
            <id>https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-1-das-vorwort</id>
            <link href="https://funduinoshop.com/einstieg-in-den-raspberry-pi-teil-1-das-vorwort"/>
            <summary type="html">
                <![CDATA[
                
                                            Diese Anleitung soll als Grundlage zum Erlernen des Betriebssystems Raspberry Pi OS mit Schwerpunkt auf der Programmiersprache Python dienen. Sie soll Anfängern einen einfachen, interessanten und eng geleiteten Einstieg...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Was ist eigentlich „Raspberry Pi“?  
 Diese Anleitung soll als Grundlage zum Erlernen des Betriebssystems Raspberry Pi OS mit Schwerpunkt auf der Programmiersprache Python dienen. Sie soll Anfängern einen einfachen, interessanten und eng geleiteten Einstieg in die Thematiken „Computational Thinking“ und „Physical Computing“ geben. Die Anleitung orientiert sich dabei hauptsächlich an praxisorientierten Aufgaben mit einer theoretischen Einführung vorab. Diese sollte man vorher unbedingt lesen, um bei den späteren Praxisaufgaben nicht an Kleinigkeiten zu scheitern. 
 Diese Anleitung ist im Rahmen einer Unterrichtstätigkeit entstanden. Sie kann kostenlos zum Erlernen der Grundlagen über Raspberry Pi-Computer verwendet, jedoch nicht ohne Erlaubnis kopiert oder anderweitig verwendet werden. Die Anleitung wurde sorgfältig erstellt und wird kontinuierlich gepflegt, jedoch wird keine Garantie für die Richtigkeit und Vollständigkeit übernommen. 
 Für die praktischen Aufgaben sollte man mit einigen elektronischen Bauteilen versorgt sein. Auf der Internetseite funduinoshop.de können sie passende Sensor-Sets bestellen, die speziell auf diese Anleitungen zugeschnitten sind. 
 Der Raspberry Pi mit inzwischen einer Vielzahl unterschiedlicher Modelle ist im Gegensatz zum Mikro Controller (z.B. Funduino Uno oder Nano) ein echter Computer mit einem Linux-basierten Betriebssystem (Raspberry Pi OS, früher Raspbian). Das Betriebssystem sowie Anwendungsprogramme und Daten befinden sich auf einer µSD-Karte (8 bis 32 GB), das beim Starten geladen wird. Die wichtigsten Schnittstellen sind zunächst die USB-Buchsen für Tastatur und Maus sowie die HDMI-Schnittstelle(n) zum Monitor.    
 Raspberry Pi B (2012) 
 Der große Erfolg des Raspberry Pi basiert sowohl auf der Programmierung mit der weit verbreiteten Programmiersprache Python als auch auf der Anschlussmöglichkeit von elektronischen Bauteilen am 40-poligen J6 Header (häufig GPIO-Leiste genannt). Dieser ist bei allen Modellen seit 2014 identisch. Bei der Nomenklatur muss man aufpassen, ob der physikalische Pin (im Bild links die ungeraden Nummern von 1 bis 39, rechts die geraden Nummern von 2 bis 40) oder die GPIO-Bezeichnung gemeint ist. So entspricht beispielsweise der physikalische Pin 11 dem GPIO17 (General Purpose Input Output Anschluss 17 des Prozessors). GPIOs sind also wie beim Mikro Controller digitale Ein- oder Ausgänge. 
   
 Bild J6-Header: 40 Pins, davon 2x3,3V, 2x5V, 8xGround, 26xGPIOs, 2 reserviert 
  Einige der Pins haben eine Zweitbelegung als elektronische Schnittstelle (engl. Interface), z.B. One Wire an Pin 7, I2C(= Inter-Integrated Circuit) an Pins 3 und 5, UART (= Universal Asynchronous Receiver and Transmitter) an Pins 8 und 10 sowie SPI (=Serial Peripheral Interface) an Pins 19, 21, 23 und 24 oder 26. Diese Zweitbelegung wird im Betriebssystem in der Raspberry Pi Konfiguration festgelegt. Mehr dazu bei den jeweiligen Beispielen. 
                ]]>
            </content>

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

    
</feed>
