<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://funduinoshop.com/blog/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Funduinoshop</name>
    </author>
    <title>Blog / Atom Feed</title>
    <id>https://funduinoshop.com/blog/?sRss=1</id>
    <updated>2026-05-01T05:47:43+02:00</updated>
    
        <entry>
            <title type="text">Arduino, ESP32 &amp; Co.: Welcher Mikrocontroller ist der richtige?</title>
            <id>https://funduinoshop.com/arduino-esp32-co.-welcher-mikrocontroller-ist-der-richtige</id>
            <link href="https://funduinoshop.com/arduino-esp32-co.-welcher-mikrocontroller-ist-der-richtige"/>
            <summary type="html">
                <![CDATA[
                
                                            Arduino oder ESP32? Wir erklären die Unterschiede zwischen Uno, Nano, Mega &amp; ESP32 – verständlich für Schule, Einsteiger und Technikprojekte.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Arduino, ESP32 &amp;amp; Co.: Welcher Mikrocontroller ist der richtige?  
 Mikrocontroller stecken in unzähligen Geräten und sind gleichzeitig ein idealer Einstieg in Technik, Programmierung und Elektronik. Vom ersten Blinkversuch mit einer LED hin zu vernetzten Smart-Home-Anwendungen entstehen schnell Fragen wie: Welches Board passt eigentlich zu meinem Projekt und worin unterscheiden sich die Varianten wirklich? 
 Dieser Beitrag richtet sich an Lehrkräfte, Schüler, Technikbegeisterte und Quereinsteiger. Du erhältst eine klare Orientierung mit praxisnahen Empfehlungen für Unterricht, Einstieg und vernetzte Projekte. 
 
  Schnellentscheidung:  
 
  Uno:  Ideal für Einstieg, Unterricht und klassische Elektronikprojekte 
  ESP32:  Ideal für WLAN, IoT und vernetzte Anwendungen 
  Mega:  Sinnvoll bei vielen Sensoren und Aktoren 
 
 
  Was ist ein Mikrocontroller und was ist ein Mikrocontroller-Board?  
 Ein Mikrocontroller ist im technischen Sinn der eigentliche Chip, etwa der ATmega328P. Im Alltag wird der Begriff jedoch häufig für das komplette Board verwendet. Gemeint ist also die kleine Platine, auf der sich der Mikrocontroller-Chip sowie zusätzliche Bauteile befinden. 
 Zu diesen Bauteilen gehören unter anderem eine USB-Schnittstelle, eine Spannungsversorgung, Status-LEDs und Anschlussleisten. Über diese Anschlüsse lassen sich Sensoren, Taster, Motoren oder Displays direkt verbinden. Dadurch wird der Einstieg deutlich vereinfacht. 
 Gerade im Unterricht zeigt sich der Vorteil dieser Struktur sehr deutlich. Ursache und Wirkung sind sofort sichtbar. Ein Sensorwert verändert sich und eine LED reagiert. Ein Taster wird gedrückt und ein Motor startet. Diese direkte Rückmeldung erleichtert das Verständnis technischer Zusammenhänge erheblich. 
  Der Uno als Standard für Einstieg und Unterricht  
 Der Uno ist das bekannteste Board im Arduino-Umfeld und hat sich im Bildungsbereich als Standard etabliert. Die Bauform ist übersichtlich, die Pins sind klar beschriftet und es existiert eine große Auswahl an passenden Modulen und Lernmaterialien.  
 
  Typischer Einsatz:  Unterricht, Einstieg in Programmierung und Elektronik, Sensorprojekte 
  Stärken:  große Community, viele Beispiele, hohe Kompatibilität 
  Didaktischer Vorteil:  strukturierte und reproduzierbare Versuchsaufbauten 
 
  Für viele Lernprojekte ist der Uno daher die sinnvollste erste Wahl. 
  Arduino und kompatible Boards wie Funduino  
 Der Name Arduino ist markenrechtlich geschützt. Die zugrunde liegenden Hardware-Designs sind jedoch als Open-Source-Hardware veröffentlicht. Das bedeutet, dass die Schaltungen frei einsehbar sind und von anderen Herstellern produziert werden dürfen. Der Markenname darf dabei allerdings nicht verwendet werden. 
 Kompatible Boards wie der Funduino Uno R3 basieren auf demselben Mikrocontroller und besitzen die gleiche Pinbelegung. Sie werden mit der identischen Software, der Arduino IDE, programmiert. Bibliotheken und Beispielprogramme funktionieren daher ohne Anpassung. 
 Im Bildungsbereich spielt auch die Wirtschaftlichkeit eine Rolle. Kompatible Boards sind häufig günstiger erhältlich. Dadurch können mehr Arbeitsplätze ausgestattet werden. Das führt zu mehr eigenständiger Praxiszeit pro Teilnehmer. 
  Nano, Mega und weitere Varianten  
 Neben dem Uno existieren weitere Varianten, die je nach Projekt gewisse Vorteile bieten. 
  Arduino Nano  
 Der Nano ist technisch sehr nah am Uno, aber deutlich kompakter. Er eignet sich besonders gut für Breadboard-Aufbauten oder wenn ein Projekt platzsparend umgesetzt werden soll. 
 
  Geeignet für:  kompakte Projekte und Prototypen 
  Vorteil:  kleine Bauform bei vertrauter Programmierumgebung 
 
  Arduino Mega  
 Der Mega bietet deutlich mehr Ein- und Ausgänge. Er ist sinnvoll, wenn viele Sensoren, Displays oder Motoren gleichzeitig betrieben werden sollen. Im Schulkontext wird er häufig in größeren Robotik- oder Steuerprojekten eingesetzt. 
 
  Geeignet für:  umfangreiche Projekte mit vielen Anschlüssen 
  Vorteil:  mehr Pins und größere Speicherreserven 
 
  ESP32 für vernetzte Anwendungen  
 Der ESP32 erweitert die Möglichkeiten um integriertes WLAN und Bluetooth. Damit eignet er sich besonders für Projekte, bei denen Daten ins Netzwerk übertragen oder Geräte per Smartphone gesteuert werden sollen. 
 
  Typische Anwendungen:  Smart Home, IoT, Webserver, vernetzte Sensorik 
  Stärke:  integrierte Funkmodule und höhere Rechenleistung 
 
  Der ESP32 ist nicht automatisch besser, sondern für andere Anforderungen optimiert. Für erste Lernschritte bleibt ein Uno oft übersichtlicher. Sobald Vernetzung im Fokus steht, wird der ESP32 interessant. 
  Welches Board passt zu welchem Zweck?  
 
 
  Ziel  Empfehlung  Begründung  
 
 
 
 Einstieg und Unterricht 
 Uno (z.&amp;nbsp;B. Funduino Uno) 
 Übersichtlich, viel Lernmaterial, einfache Fehlersuche 
 
 
 Kompakte Projekte 
 Nano (z.&amp;nbsp;B. Funduino Nano) 
 Platzsparende Bauform 
 
 
 Viele Sensoren und Aktoren 
 Mega (z.&amp;nbsp;B. Funduino Mega) 
 Große Anzahl an Ein- und Ausgängen 
 
 
 WLAN und IoT 
 ESP32 (z.&amp;nbsp;B. Funduino ESP32) 
 Integriertes WLAN und Bluetooth 
 
 
 
  Fazit  
 Für den Einstieg und für den Unterricht ist der Uno in den meisten Fällen die beste Wahl. Wenn ein Projekt vernetzt arbeiten soll oder Daten über WLAN übertragen werden müssen, ist der ESP32 die passende Plattform. Projekte mit vielen Anschlüssen profitieren vom Mega. 
 Entscheidend ist nicht, welches Board moderner wirkt, sondern welches am besten zum Lernziel oder Projekt passt. 
                ]]>
            </content>

                            <updated>2026-02-12T09:30:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">WRO Deutschlandfinale 2025</title>
            <id>https://funduinoshop.com/wro-deutschlandfinale-2025</id>
            <link href="https://funduinoshop.com/wro-deutschlandfinale-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Auch in diesem Jahr durften wir wieder als Aussteller beim Deutschlandfinale der World Robot Olympiad dabei sein – diesmal vom 27.-28.06.2025 in der Westfalenhalle Dortmund.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Auch in diesem Jahr durften wir wieder als Aussteller beim Deutschlandfinale der World Robot   Olympiad   dabei sein – diesmal   vom 27.-28.06.2025   in   der Westfalenhalle   Dortmund. Schon 2024 waren wir in Passau mit am Start, und es war für uns ein   tolles   Gefühl, nun zum zweiten Mal Teil dieser besonderen   (und stetig wachsenden!)   Veranstaltung zu sein.   &amp;nbsp;  
 
 
       
   Wir haben unglaublich viele Eindrücke gesammelt und   tolle   Gespräche geführt, besonders mit Kindern und Jugendlichen aus den verschiedensten Altersstufen. Die Begeisterung und die Neugier, mit der sie an Technik und Robotik herangehen, steckt einfach an und macht richtig Freude. Für uns war das Finale dadurch nicht nur spannend, sondern auch absolut bereichernd.   &amp;nbsp;  
 
 
   Ein großes Lob möchten wir an dieser Stelle an Markus   Fleige   und sein Team weitergeben, die das Event wieder einmal großartig organisiert haben. Man hat an jeder Ecke gespürt, wie viel Herzblut in der Veranstaltung steckt.   &amp;nbsp;  
 
 
   Am   Funduino  -Stand haben wir einige unserer Produkte vorgestellt – unter anderem das Starter Kit   und dem Cube auch   den   Unitree   Go2 Roboterhund. Vor allem das junge Publikum war begeistert, hat unzählige Fragen gestellt und den Hund mit leuchtenden Augen bestaunt.   &amp;nbsp;  
 
 
   Alles in allem war es für uns ein rundum gelungenes Wochenende voller Inspiration, Austausch und schöner Begegnungen. Wir sind dankbar, dabei gewesen zu sein – und freuen uns schon jetzt auf das nächste Mal!   &amp;nbsp;  
    Euer Team von Funduino       
 &amp;nbsp; 
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">European Robotics Forum 2025</title>
            <id>https://funduinoshop.com/european-robotics-forum-2025</id>
            <link href="https://funduinoshop.com/european-robotics-forum-2025"/>
            <summary type="html">
                <![CDATA[
                
                                            Vom 25. bis 27. März 2025 waren wir auf dem European Robotics Forum in Stuttgart vertreten – einem der wichtigsten Treffpunkte für Robotik-Expertinnen und -Experten aus ganz Europa. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Vom     25. bis 27. März 2025     waren wir auf dem     European Robotics Forum in Stuttgart     vertreten – einem der wichtigsten Treffpunkte für Robotik-Expertinnen und -Experten aus ganz Europa.   &amp;nbsp;  
 
 
   Dieses Mal   waren wir ausschließlich mit den     Roboterarmen von   Dobot     i  m Kultur- und Kongresszentrum in   Stuttgart   und durften diese einem internationalen Fachpublikum präsentieren. Für uns war es eine spannende Gelegenheit, die vielseitigen Einsatzmöglichkeiten der   Dobot  -Systeme live zu zeigen und mit interessierten Besucherinnen und Besuchern ins Gespräch zu kommen.   &amp;nbsp;  
 
 
       
   Die Resonanz war großartig: Viele Fachleute aus Forschung, Industrie und Bildung nutzten die Chance, die Roboter in Aktion zu erleben. Besonders gefreut hat uns das Staunen und die Begeisterung, die wir an unserem Stand spüren konnten – sei es beim ersten Kennenlernen oder in den intensiven Fachdiskussionen, die sich daraus ergaben.   &amp;nbsp;  
 
 
   Wir gehen mit vielen neuen Eindrücken aus Stuttgart nach Hause. Besonders wertvoll war für uns, Teil dieses internationalen Netzwerks zu sein und die   Dobots   einem so breiten Fachpublikum vorstellen zu dürfen. Die Gespräche und Rückmeldungen bestärken uns darin, die Robotik weiter aktiv in Bildung und Praxis voranzubringen. Für uns war der erste Auftritt auf dem     European Robotics Forum     ein wichtiger Schritt – und sicher nicht der letzte.   &amp;nbsp;  
    Euer Team von 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/didacta-2025-in-stuttgart</id>
            <link href="https://funduinoshop.com/didacta-2025-in-stuttgart"/>
            <summary type="html">
                <![CDATA[
                
                                            Vom 11. bis 15. Februar 2025 waren wir erneut auf der Didacta in Stuttgart vertreten – und wie schon in den vergangenen Jahren hat die Messe wieder einmal das gehalten, was sie verspricht. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
   Vom     11. bis 15. Februar 2025     waren wir erneut auf der     Didacta in Stuttgart     vertreten – und wie schon in den vergangenen Jahren hat die Messe   wieder   einmal   das gehalten, was sie verspricht  .   &amp;nbsp;  
 
 
   Wir durften viele spannende Gespräche   mit euch führen und haben uns über das große Interesse an unseren Produkten sehr gefreut. An unserem Stand präsentierten wir eine bunte Mischung: von   unseren   klassischen     Funduino  -Produkten     über die     Dobot  -Roboterarme     bis hin zu&amp;nbsp;  &amp;nbsp;     Flux-Lasercuttern    . Besonders schön war es zu sehen, dass sich Besucherinnen und Besucher aus allen Altersgruppen für unsere Technik begeistern konnten – von neugierigen Schülern bis hin zu erfahrenen Lehrkräften. Gerade dieser Austausch mit so vielen unterschiedlichen Menschen macht für uns den besonderen Reiz der Didacta aus.   &amp;nbsp;  
     
 
 
   Ein echtes Highlight in diesem Jahr   w  ar   der     Unitree   Go2    . Der agile Roboterhund zog sofort alle Blicke auf sich, sorgte für leuchtende Augen und wurde zum Publikumsmagneten. Zahlreiche Fotos wurden gemacht, und viele nutzten die Gelegenheit, selbst ein bisschen mit ihm zu interagieren. Die Begeisterung   war regelrecht   spürbar – und hat auch uns richtig Spaß gemacht.   &amp;nbsp;  
 
 
     
   Wir blicken auf fünf intensive Messetage zurück, voller Inspiration, Austausch und neuer Ideen. Neben vielen Eindrücken nehmen wir auch   EUER   wertvolles Feedback und neue Impulse mit, die uns in unserer Arbeit bestärken. Ein großes Dankeschön an alle, die uns besucht haben – ihr habt die Didacta 2025 für uns zu einem   ganz   besonderen Erlebnis gemacht. Wir freuen uns schon jetzt darauf, euch auch im nächsten Jahr wiederzusehen!   &amp;nbsp;  
 &amp;nbsp; 
 
 
    Euer Team   von   Funduino   &amp;nbsp;   
 
 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">LED Halloween Kürbis</title>
            <id>https://funduinoshop.com/led-halloween-kuerbis</id>
            <link href="https://funduinoshop.com/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">Arduino in der Schule</title>
            <id>https://funduinoshop.com/arduino-in-der-schule</id>
            <link href="https://funduinoshop.com/arduino-in-der-schule"/>
            <summary type="html">
                <![CDATA[
                
                                            Was ist eigentlich Arduino und wie kann es im Bildungsbereich eingesetzt werden? 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                   Wie Arduino in der Schule / im Bildungsbereich eingesetzt werden kann    
   Was&amp;nbsp;ist&amp;nbsp;Arduino?   
 Arduino ist eine Open-Source Hardwareplattform, die sich ideal für Bastler, Tüftler, Elektronikenthusiasten, als auch für Anfänger eignet. Diese Plattform wurde entwickelt, um das Erstellen von elektronischen Projekten und Prototypen so einfach wie möglich zu gestalten. Somit können Grundlagen der Elektronik und Programmierung in der Schule einfach vermittelt werden. 
 Der&amp;nbsp;Name&amp;nbsp;&quot;Arduino&quot;&amp;nbsp;bezieht&amp;nbsp;sich&amp;nbsp;sowohl&amp;nbsp;auf&amp;nbsp;die&amp;nbsp; Hardware &amp;nbsp;als&amp;nbsp;auch&amp;nbsp;auf&amp;nbsp;die&amp;nbsp;zugehörige&amp;nbsp; Softwareentwicklungsumgebung .&amp;nbsp;Die Kernkomponente des&amp;nbsp;Arduino-Systems ist die Arduino-Platine, den sogenannten Mikrocontroller. Der Mikrocontroller ist das Gehirn des Arduino und kann programmiert werden, um verschiedene Aufgaben auszuführen. 
 Da es sich um ein Open-Source-Projekt handelt, sind Dokumente zur Erstellung von Arduino kompatiblen Mikrocontrollern öffentlich zugänglich. Auch wir von Funduino vertreiben&amp;nbsp;Arduino kompatible Mikrocontroller, die sich in der Funktionsweise nicht vom Arduino Original unterscheiden. 
 &amp;nbsp; 
   Wofür&amp;nbsp;kann&amp;nbsp;ich&amp;nbsp;Arduino&amp;nbsp;einsetzen?&amp;nbsp;   
 Arduino&amp;nbsp;kann&amp;nbsp;in&amp;nbsp;einer&amp;nbsp;breiten&amp;nbsp;Palette&amp;nbsp;von&amp;nbsp;Projekten&amp;nbsp;eingesetzt&amp;nbsp;werden: 
 
 Steuerung&amp;nbsp;von&amp;nbsp;LEDs,&amp;nbsp;Motoren&amp;nbsp;und&amp;nbsp;Sensoren&amp;nbsp;(Temperatur,&amp;nbsp;Feuchtigkeit,&amp;nbsp;Licht&amp;nbsp;etc.) 
 Wissenschaftliche&amp;nbsp;Experimente:&amp;nbsp;in&amp;nbsp;Schulen&amp;nbsp;und&amp;nbsp;Laboratorien&amp;nbsp;für&amp;nbsp;wissenschaftliche&amp;nbsp;Experimente&amp;nbsp;und&amp;nbsp;Messungen&amp;nbsp;einsetzen 
 Automatisierungsprojekte:&amp;nbsp;z.&amp;nbsp;B.&amp;nbsp;Bewässerungsanlagen&amp;nbsp;für&amp;nbsp;Blumenbeete 
 Kommunikation:&amp;nbsp;drahtloser&amp;nbsp;Datenaustausch&amp;nbsp;über&amp;nbsp;Bluetooth,&amp;nbsp;WLAN&amp;nbsp;oder&amp;nbsp;RFID 
 Robotik:&amp;nbsp;Roboter&amp;nbsp;als&amp;nbsp;einfache&amp;nbsp;Spielzeuge&amp;nbsp;oder&amp;nbsp;komplexe&amp;nbsp;autonome&amp;nbsp;Maschinen&amp;nbsp;bauen&amp;nbsp;und&amp;nbsp;programmieren 
 
 &amp;nbsp; 
   Was&amp;nbsp;benötige&amp;nbsp;ich,&amp;nbsp;um&amp;nbsp;Arduino&amp;nbsp;im&amp;nbsp;Schulunterricht&amp;nbsp;zu&amp;nbsp;nutzen?   
 Arduino&amp;nbsp;kompatible&amp;nbsp;Boards&amp;nbsp;sind&amp;nbsp;allgemein&amp;nbsp;in&amp;nbsp;verschiedenen&amp;nbsp;Preisklassen,&amp;nbsp;Leistungsfähigkeiten&amp;nbsp;und&amp;nbsp;mit&amp;nbsp;erweiterten&amp;nbsp;Funktionen&amp;nbsp;erhältlich.&amp;nbsp; 
 In&amp;nbsp;unseren&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp; Lernsets &amp;nbsp;ist der Funduino UNO R3 oder MEGA 2560 R3 Mikrocontroller enthalten, welcher sowohl für Einsteiger als auch für Fortgeschrittene geeignet ist. Sie sind vollständig mit der Arduino IDE kompatibel. 
 Unsere Starter Kits eignen sich ideal für Einsteiger und den Unterricht. Je nach Unterrichtsgestaltung sind verschiedene Ausführungen wählbar, die sich lediglich im Lieferumfang unterscheiden (Basic, Education oder Ultimate Education). Die Sets lassen sich auch direkt als&amp;nbsp; Klassensatz &amp;nbsp;bestellen. 
 Pro&amp;nbsp;Set&amp;nbsp;ist&amp;nbsp;schon&amp;nbsp;direkt&amp;nbsp;ein&amp;nbsp; Arbeitsheft &amp;nbsp;enthalten, welches einem Schritt für Schritt die Arduino Entwicklungsumgebung näherbringt. Es gibt extra für die im Set enthaltenen Module Lernlektionen, sodass weder Anleitungen noch Komponenten mühsam zusammengesucht werden müssen. Für das Lernheft sind keine Vorkenntnisse nötig, sodass Schüler und Studenten ebenfalls eigenständig lernen können. Da die Programmcodes der einzelnen Lektionen abgetippt und nicht kopiert werden, wird so der Lerneffekt gesteigert. Zudem können Lehrkräfte für eine Lernstandkontrolle bearbeitete Lektionen in der Heftübersicht abhaken.&amp;nbsp; 
   
 &amp;nbsp; 
 Ebenfalls jetzt erhältlich: Der   Funduino All-In-One  . 
 Hierbei handelt es sich um eine Einplatinenlösung, bei welcher schon alle Komponenten übersichtlich angeordnet sind. Es müssen keine Verkabelungen und Schaltungen mehr vorgenommen werden, welche oft ein Hindernis beim Einstieg in die Mikroelektronik darstellen. Somit können schnelle Erfolge erzielt und die Motivation der Schüler gesteigert werden. Auch hier ist ein Lernheft enthalten, welches seine Lektionen nach den auf der Platine zugewiesenen Nummern aufbaut.&amp;nbsp; 
   
 &amp;nbsp; 
  Weitere&amp;nbsp;Einsatzmöglichkeiten&amp;nbsp;von&amp;nbsp;Arduino&amp;nbsp;im&amp;nbsp;Unterricht  
 Zusätzlich&amp;nbsp;zu&amp;nbsp;den&amp;nbsp;klassischen&amp;nbsp;Lernsets&amp;nbsp;bieten&amp;nbsp;wir&amp;nbsp;verschiedene&amp;nbsp;Projektsets&amp;nbsp;an. 
 Der&amp;nbsp;Bereich&amp;nbsp;Robotik&amp;nbsp;lässt&amp;nbsp;sich&amp;nbsp;leicht&amp;nbsp;mit&amp;nbsp;unserem&amp;nbsp; Düvelbot &amp;nbsp;oder&amp;nbsp; Otto&amp;nbsp;Roboter &amp;nbsp;näherbringen.&amp;nbsp; Der Düvelbot kann beim Fahren einer angebrachten Linie folgen sowie selbstständig Hindernissen ausweichen. Der Otto Roboter kann laufen, tanzen und ganze Choreografien lernen sowie über Lautsprecher mit einem kommunizieren. 
 Damit Spaß und Abwechslung im Unterricht auch nicht zu kurz kommen, können unterhaltsame Sets wie  Kaubonbon Spender  oder  Farbsortiermaschine  eingesetzt werden. Mit dem Kaubonbon-Spender können einzelne Kaubonbons ausgegeben und mit der Farbsortiermaschine Schokoladenlinsen (z. B. Smarties, M&amp;amp;Ms) mit einer Bonbonrutsche nach Farben sortiert werden. 
 Ebenfalls&amp;nbsp;bieten&amp;nbsp;wir&amp;nbsp;umfangreiche&amp;nbsp;Sets&amp;nbsp;wie&amp;nbsp;eine&amp;nbsp; Wetterstation &amp;nbsp;oder&amp;nbsp;ein&amp;nbsp; Smart&amp;nbsp;Home&amp;nbsp;Kit ,&amp;nbsp;welche ideal auch in Gruppenarbeiten eingesetzt werden können.&amp;nbsp; 
 &amp;nbsp; 
   Wie&amp;nbsp;programmiere&amp;nbsp;ich?   
 Die&amp;nbsp;Programmierung&amp;nbsp;von&amp;nbsp;Arduino&amp;nbsp;kompatiblen&amp;nbsp;Mikrocontrollern&amp;nbsp;geschieht&amp;nbsp;in&amp;nbsp;der&amp;nbsp;Software&amp;nbsp;„ Arduino&amp;nbsp;IDE &quot;&amp;nbsp;(Arduino Integrated Development Environment), die eine benutzerfreundliche Entwicklungsumgebung bietet. Die Programmierung erfolgt in einer Variante von C/C++, die speziell für Arduino angepasst wurde. Eine allgemeine Anleitung können Sie direkt auf unserer Seite finden:&amp;nbsp; https://funduino.de/programmieren  
   
 &amp;nbsp; 
  Blockbasierte&amp;nbsp;Alternative  
 Die Plattform OpenRoberta ermöglicht es Ihnen, blockbasiert zu programmieren. Der Programmcode muss also nicht als Syntax eingegeben werden, sondern es werden einfach Blöcke mit jeweiligen Funktionen verwendet. Einsteiger können so ideal ohne Vorkenntnisse schnell und einfach Erfolge erzielen. 
 Eine&amp;nbsp;Anleitung&amp;nbsp;zu&amp;nbsp;OpenRoberta&amp;nbsp;finden&amp;nbsp;Sie&amp;nbsp;hier:&amp;nbsp; https://funduino-aio.de/openroberta/  
   
   Warum&amp;nbsp;Arduino?   
 Die Arduino-Ideologie, die auf Open Source basiert, fördert die Zusammenarbeit und den Wissensaustausch zwischen Entwicklern weltweit. Abgesehen von der nutzerfreundlichen Entwicklungsumgebung für Einsteiger bietet Arduino als weiteren Vorteil eine riesige Community und die Fülle von verfügbaren Ressourcen. Es gibt zahlreiche Online-Foren, Tutorials und Bücher, die bei der Lösung von Problemen und der Inspiration für neue Projekte helfen. Auf unserer  Internetseite  findet ihr ebenfalls etliche Anleitungen. 
 Arduino hat in den letzten Jahren die Welt der Elektronik und der DIY-Projekte revolutioniert. Es bietet eine kostengünstige und zugängliche Möglichkeit, in die Welt der Mikrocontroller und Elektronik einzusteigen. (Die meisten Sensoren, die mit der Arduino Entwicklungsumgebung verwendet werden können, sind auch zu anderen Mikroelektronik-Systemen kompatibel. Häufig werden die Sensoren auch mit einem Raspberry Pi, dem ESP32 oder vergleichbaren Mikrocontrollern verwendet.) Obgleich Sie ein Anfänger oder ein erfahrener Elektronikbastler sind, Arduino bietet unendliche Möglichkeiten für kreative Projekte und ist eine Plattform, die die Neugier und den Erfindungsgeist bei Schülern und Studenten weckt.&amp;nbsp; 
 &amp;nbsp; 
   Als&amp;nbsp;Bildungseinrichtung&amp;nbsp;bei&amp;nbsp;uns&amp;nbsp;Vorteile&amp;nbsp;sichern   
 Wir unterstützen Bildungseinrichtungen mit günstigen Angeboten. Daher bekommen alle Bildungseinrichtungen, aber auch Lehrer, Schüler und Studenten einen Rabatt von bis zu 10 % auf alle Artikel, die direkt über unseren Shop bestellt werden. Wie das funktioniert erfahren Sie unter dem Link&amp;nbsp; https://funduinoshop.com/bildungsrabatt-kauf-auf-rechnung  
 Bildungseinrichtungen&amp;nbsp;können&amp;nbsp;auch&amp;nbsp;auf&amp;nbsp;Rechnung&amp;nbsp;bestellen.&amp;nbsp;Kostenvoranschläge,&amp;nbsp;schriftliche&amp;nbsp;Angebote&amp;nbsp;und&amp;nbsp;individuelle&amp;nbsp;Sets&amp;nbsp;erstellen&amp;nbsp;wir&amp;nbsp;ebenfalls&amp;nbsp;gerne&amp;nbsp;für&amp;nbsp;Sie. 
 Für Schulen bietet sich eine sortenreine Verpackung an (Eine Box mit LEDS, eine Box mit Mikrocontrollern, eine Box mit Sensoren etc.). Das hat sich als sinnvoll erwiesen, da man das Material dann besser in kleinen „Portionen“ ausgeben kann und einen Überblick hat, was zurückgebracht wird (oder eben nicht).&amp;nbsp;Wir&amp;nbsp;bieten&amp;nbsp;die&amp;nbsp;sortenreine Konfektionierung&amp;nbsp;ab&amp;nbsp;einer&amp;nbsp;Bestellmenge&amp;nbsp;von&amp;nbsp;20&amp;nbsp;Starter&amp;nbsp;Kits&amp;nbsp;an. 
 Wenden&amp;nbsp;Sie&amp;nbsp;sich&amp;nbsp;bei&amp;nbsp;Fragen&amp;nbsp;rund&amp;nbsp;um&amp;nbsp;das&amp;nbsp;Thema&amp;nbsp;Arduino&amp;nbsp;in&amp;nbsp;Bildungseinrichtungen&amp;nbsp;an&amp;nbsp; info@funduino.de . 
                ]]>
            </content>

                            <updated>2023-10-03T14:45:00+02:00</updated>
                    </entry>

    
    
        <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">RC Car für Arduino bauen: Autonomes Fahrzeug - Teil 3</title>
            <id>https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-3</id>
            <link href="https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-3"/>
            <summary type="html">
                <![CDATA[
                
                                            Willkommen zur dritten Folge unserer Blogreihe über Roboterautos. Im ersten Teil haben wir die Grundlagen für das Basisfahrzeug kennengelernt. Im zweiten Teil haben wir ein universelles Codesystem entwickelt, mit dem wir Fahrtstufen des Roboterautos festlegen...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Mit Roboterautos die Mobilität der Zukunft verstehen, Teil 3  
 Willkommen zur dritten Folge unserer Blogreihe über Roboterautos. Im   ersten Teil  &amp;nbsp;haben wir die Grundlagen für das Basisfahrzeug kennengelernt. Im   zweiten Teil  &amp;nbsp;haben wir ein universelles Codesystem entwickelt, mit dem wir Fahrtstufen des Roboterautos festlegen, und eine einfache Fernsteuerung mit einer Infrarot-Fernbedienung realisiert. Aufgrund der physikalischen Grenzen dieser Fernsteuerung möchte ich in dieser Folge die Übertragung der Fahrtanweisungen mit Bluetooth, z.B. von einem Smartphone an den BT-Empfänger HC-05, zeigen. Bluetooth ist ein 2,4GHz-Funksignal mit kurzer Reichweite. Sicher bis ca. 10m und störungsfrei bei Sonnenlicht. 
 Das Bluetooth-Modul HC-05 ist eigentlich ein Transceiver= Trans mitter + Re ceiver . Wir benutzen es allerdings nur als Empfänger, für das Senden der Fahrtanweisungen verwenden wir eine Bluetooth-APP am Android Smartphone (wegen des Sonderweges von Apple bei Bluetooth funktioniert es nicht mit einem iPhone). Es ist grundsätzlich möglich, auch eine Bluetooth-Fernbedienung mit dem HC-05 zu bauen; dafür werden jedoch ein zweiter HC-05, weiterer Micro Controller und ein Eingabegerät (Joystick-Controller) benötigt. 
 &amp;nbsp;  
  Von den sechs Pins des HC-05 Moduls werden nur vier benötigt: VCC (5V) und GND für die Spannungsversorgung des Moduls, sowie RXD und TXD zum Anschluss an zwei Pins des Mikrocontrollers, an denen SoftwareSerial eingerichtet wird. Allerdings kann man die Aufschrift LEVEL: 3.3V nicht ignorieren, um das Modul nicht zu beschädigen. An unserem Mikrocontroller mit 5V-Logik benötigen wir zumindest für den RXD Pin einen Spannungsteiler von 5V auf 3,3V, also z.B. Widerstände von 1 kOhm und 2,2 kOhm. 
 Der Schaltplan: HC-05 Modul am Mikrocontroller    
 Die AT-Befehle des HC-05 Moduls für Arduino Mikrocontroller 
 Links neben dem mit Key gekennzeichneten Anschluss befindet sich ein kleiner Taster (Button), der für die Konfiguration von Bedeutung ist. Wenn dieser Button beim Einschalten gedrückt wird, gelangen wir in den AT Kommando-Modus (die LED blinkt langsam im 2s-Rhythmus), in dem wir mit sogenannten AT-Befehlen (für Attention, Achtung) die Einstellungen vornehmen. Dazu benutzen wir ein modifiziertes Beispiel-Programm, bei dem die übliche serielle Schnittstelle mit dem Serial Monitor der Arduino IDE und der HC-05 über SoftwareSerial verbunden wird. 
  /*
  Software serial multiple serial test
 Receives from the hardware serial, sends to software serial.
 Receives from software serial, sends to hardware serial.
 The circuit:
 * RX is digital pin 10 (connect to TX of other device)
 * TX is digital pin 11 (connect to RX of other device)                           // voltage divider!
 created back in the mists of time
 modified 25 May 2012
 by Tom Igoe
 based on Mikal Hart&#039;s example
 This example code is in the public domain.
 */ 
 # include   &amp;lt;SoftwareSerial.h&amp;gt;  
 SoftwareSerial  BTSerial( 10 ,  11 );  // RX, TX                                              // mySerial changed to BTSerial 
 char  c= &#039; &#039; ;                                                                                                       // Declaration of variable for transmission 

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

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

 void   loop () {  // run over and over 
   if  (BTSerial. available ()) {
    c=BTSerial. read ();
     Serial . write (c);
  }
   if  ( Serial . available ()) {
    c= Serial . read ();
    BTSerial. write (c);
     Serial . write (c);                                                                                        // re-transmission of input in Serial Monitor 
  }
} 
 Die wesentlichen AT-Befehle werden im folgenden Bild verwendet. Die Gegenstelle, der HC-05, sendet ggf. eine Antwort und quittiert mit OK. 
 Uns interessieren vor allem der Name und die HEX-Adresse, um das Modul später auf dem Smartphone eindeutig zu identifizieren. Die AT-Befehle werden dabei in den seriellen Monitor des Mikrocontrollers eingegeben. Im nachfolgenden Bild sehr Ihr den seriellen Monitor der Arduino IDE. 
 Wer möchte, kann das Standard-Passwort 1234 ändern mit &quot; AT+PSWD=xxxx &quot;, wobei x für eine Ziffer von 0 bis 9 steht. Danach mit &quot; AT+PSWD? &quot; prüfen, ob die Eingabe erfolgreich war.    Nach Beendigung der Eingaben wird das Modul kurz vom Strom getrennt. Nach dem Wiedereinschalten ohne Knopfdruck befindet sich das HC-05-Modul im Standard-Modus. Die LED blinkt schnell (ca. 5-mal/s). 
 Modifikationen des RC-Cars: anderes Motorshield 
 Nun zum Robot Car. Nachdem wir beim letzten Mal den Motor Controller V2 verwendet haben, der für die Steuersignale nur die zwei I2C-Anschlüsse SDA=A4 und SCL=A5 benötigt, möchte ich dieses Mal den älteren Motor Controller V1 vorstellen, der zwar viele digitale Pins blockiert, aber häufig zum Schnäppchenpreis zu kaufen ist.     Auch dieses Motorshield habe ich ein wenig modifiziert, um Zugang für Sensoren und Funkempfänger zu erhalten. Auf der Seite der digitalen Pins gibt es nur einen Pin, der mit Hilfe eines gewinkelten Steckers zugänglich wird: Pin 2. Das ist gut für diejenigen, die hier den IR-Empfänger anschließen möchten. Mehr Möglichkeiten für Erweiterungen gibt es auf der anderen Seite, wo man mit Hilfe von Federleisten (auch Buchsenleisten genannt) Zugang zu sämtlichen analogen Eingängen sowie zur Spannungsversorgung erhält. 
 Da sämtliche analogen Eingänge auch als digitale Ein- oder Ausgänge genutzt werden können, haben wir hier die Möglichkeit, unsere Funkempfänger anzuschließen. Das klappt wunderbar mit dem 433 MHz Transceiver HC-12 (siehe nächste Folge), aber für den BT-Empfänger HC-05 nur mit Einschränkungen. Erstens können wir den RXD-Pin nicht direkt anschließen, wir benötigen den Spannungsteiler, und zweitens liefern die Pins nicht genügend Strom für die Energieversorgung des Moduls an diesen Pins. 
 Auf dem folgenden Bild ist ein kleiner, selbst gefertigter Adapter zu sehen, der den HC-05 mit 5V und Ground aus den entsprechenden Anschlüssen versorgt, TXD direkt mit RX der SoftwareSerial-Schnittstelle A1 =D15 und RXD über den Spannungsteiler mit A2 = D16 verbindet.   
 Der Schaltplan: HC-05 Modul mit L293D Motorshield am Arduino Mikrocontroller     
 Die Schaltung kann selbstverständlich auch auf einem Mini Breadboard mit Jumperkabeln realisiert werden. 
 Wie beim letzten Mal wird der Code für die Fahrtanweisungen auf Tastendruck erhöht oder vermindert; diesmal nur nicht mit IR-Fernbedienung, sondern mit der Touch-Funktion in der Smartphone-APP und der Bluetooth-Abfrage über SoftwareSerial. 
 Koppeln des HC-05 Bluetooth Moduls mit einer Android Applikation (APP) 
 Bevor sich die APP mit dem Robot Car verbinden kann, müssen wir in den Einstellungen das Pairing mit dem das Bluetooth-Modul durchführen. Das sollte ganz einfach sein, denn wir haben zuvor mit den AT-Befehlen den Namen und die HEX-Adresse des HC-05 abgefragt. 
 Wenn das Pairing geklappt hat und eine geeignete BT-App installiert wurde, kann diese gestartet und eingerichtet werden. Mit dem Tippen auf die Lupe im linken Bild werden geeignete Geräte angezeigt. Wir tippen auf das HC-05 und erhalten die Meldung „connected“. Die von mir verwendete App bietet mehrere Oberflächen für die Bedienung an (mittleres Bild). Ich habe mich für den Spiele-Controller entschieden. Auf dem mittleren Bild oben rechts sind zwei Pfeile, die eine kleinen Kreis bilden. Hier bitte antippen, wenn die Verbindung verloren gegangen ist. 
 Auf dem rechten Bild sind die Tasten eines Spiel-Controllers abgebildet. Vor der ersten Benutzung müssen den Schaltflächen die Zahlenwerte zugeordnet werden, die beim Tippen übertragen werden sollen. 
 Für die Cursortasten habe ich im Uhrzeigersinn die Zahlenwerte 1 bis 4 vorgegeben. Den weiteren Schaltflächen habe ich den Zahlenwert 5 zugeordnet. Diese Werte werden im Sketch an die Variable  blueToothVal &amp;nbsp;übergeben und führen in den &amp;nbsp;if -Verzeigungen der Funktion  loop()  zur Bestimmung des Codes für die Fahrtstufe.    
 Die Änderungen von Infrarot auf Bluetooth und Motor Controller V2 auf V1 verursachen einige Modifikationen im Hauptteil des Sketches. Hingegen ändert sich bei der Funktion motor() fast nichts. Nur bei der Schreibweise wird aufgrund der unterschiedlichen Programm-Bibliotheken (libraries) aus den Funktionen motor1-&amp;gt;setSpeed() nun motor1.setSpeed(). 
 Der Programmcode: RC Car für Arduino bauen 
 * Sample Code  for  Robot Car with Motor Shield V1 and BT receiver HC -05 , as of  20220515 
* based on Adafruit Motor shield V2 library, copyright Adafruit Industries LLC
*  this  code is  public  domain, enjoy!
* modified  for  Funduino
* Pins
* BT VCC to Arduino  5 V out.
* BT GND to GND
* Arduino A1= 15  (SS RX) - BT TX no need voltage divider
* Arduino A2= 16  (SS TX) - BT RX through a voltage divider ( 5 v to  3.3 v)
*/

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

 # include   &amp;lt;SoftwareSerial.h&amp;gt;  
 // initialize HC-05 
 SoftwareSerial  BTSerial( 15 ,  16 );  // RX, TX über Kreuz an TX, RX(voltage divider) 
 char  blueToothVal;
 int  x =  0 ;
 int  y =  0 ;
 int  left =  0 ;
 int  right =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correction for speedLevel 255/100 * 6V/VBatt 

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

 void   loop () {
   if (BTSerial. available ())  //wenn Daten empfangen werden...  
 Serial.print(&quot;available&quot;);      
{
    blueToothVal=BTSerial. read (); //..sollen diese ausgelesen werden 
 Serial.println(blueToothVal); 
  }
     if  (blueToothVal== &#039;1&#039; )  //wenn das Bluetooth Modul eine „1“ empfängt.. 
    {
       if  (code&amp;lt; 9000 )   code = code +  1000 ;      
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
     else   if  (blueToothVal== &#039;2&#039; )  //wenn das Bluetooth Modul eine „2“ empfängt.. 
    {
       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; )  //wenn das Bluetooth Modul eine „3“ empfängt.. 
    {
       if  (code&amp;gt; 2000 )   code = code -  1000 ;        
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);
    }
     else   if  (blueToothVal== &#039;4&#039; )  //wenn das Bluetooth Modul eine „4“ empfängt.. 
    {
     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; )  //wenn das Bluetooth Modul „5“ empfängt... 
    {           
      code =  5555 ;
       Serial . print ( &quot;Code = &quot; );
       Serial . println (code);    
    }
     delay ( 200 );    //little delay for better serial communication and to avoid bouncing 
    motor();
}    // end loop 

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

   //Korrektur der Fahrtstufen für Kurvenfahrt 
   if  (x== 1 ){
    right = speedL+ 20 ;
    left = speedL -20 ;
  }
   else   if  (x== 2 ){
    right = speedL+ 15 ;
    left = speedL -15 ;
  }
   else   if  (x== 3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
   else   if  (x== 4 ) {
    right = speedL+ 5 ;
    left = speedL -5 ;
  }
   else   if  (x== 6 ) {
    right = speedL  -5 ;
    left = speedL+ 5 ;
  }
   else   if  (x== 7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
   else   if  (x== 8 ) {
    right = speedL -15 ;
    left = speedL+ 15 ;
  }
   else   if  (x== 9 ) {
    right = speedL -20 ;
    left = speedL+ 20 ;
  }
   else  {
    right = speedL;
    left = speedL;
  }

   //Eingabe der Fahrtstufen für &quot;left&quot; und &quot;right&quot; 
   Serial . print ( &quot;left = &quot; );
   Serial . print (left);
   Serial . print ( &quot; right = &quot; );
   Serial . println (right);

   if  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1. run (RELEASE);
  }
   if  (right &amp;lt;  40  &amp;amp; right &amp;gt;  -40 ) {
    motor2. run (RELEASE);
  }
   if  (left&amp;gt;= 40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1. run (FORWARD);
      motor1. setSpeed (left * factor);
  }
   if  (right&amp;gt;= 40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2. run (FORWARD);
      motor2. setSpeed (right * factor);
  }
   if  (left&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1. run (BACKWARD);
      left = -left;
      motor1. setSpeed (left * factor);
  }
   if  (right&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2. run (BACKWARD);
      right = -right;
      motor2. setSpeed (right * factor);
  }
}    // end motor  
 Soweit die zweitgünstigste Lösung für ein Robot Car mit Fernsteuerung (vorausgesetzt, man hat ein Android Smartphone). Beim nächsten Mal möchte ich zeigen, wie einfach die Einbindung eines 433 MHz-Transceivers HC-12 funktioniert. Damit können sogar mehrere hundert Meter Reichweite erzielt werden. Allerdings steigen die Kosten, da nun zwei Transceiver und ein weiterer Mikro Controller benötigt werden. Bis dann. 
                ]]>
            </content>

                            <updated>2022-06-20T08: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">RC Car für Arduino bauen: Autonomes Fahrzeug - Teil 2</title>
            <id>https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-2</id>
            <link href="https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-2"/>
            <summary type="html">
                <![CDATA[
                
                                            Willkommen zur zweiten Folge unserer neuen Blogreihe über Roboterautos. Im ersten Teil haben wir die Grundlagen für das Basisfahrzeug kennengelernt. Diesmal wollen wir Möglichkeiten der Fernsteuerung thematisieren, dabei ein Codesystem entwickeln...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Mit Roboterautos die Mobilität der Zukunft verstehen, Teil 2  
 Willkommen zur zweiten Folge unserer neuen Blogreihe über Roboterautos. Im  ersten Teil  haben wir die Grundlagen für das Basisfahrzeug kennengelernt. Diesmal wollen wir Möglichkeiten der Fernsteuerung thematisieren, dabei ein Codesystem entwickeln, mit dem wir Fahrtstufen des Roboterautos bestimmen und schließlich eine einfache Fernsteuerung mit einer Infrarot-Fernbedienung realisieren. 
 Wofür benötige ich Fahrtstufen bei einem RC Car für Arduino Mikrocontroller? 
 1. Für die Steuerung der Motordrehzahlen von einem anderen Gerät aus gibt es grundsätzlich die Möglichkeit, mit einem Potentiometer (Poti) kontinuierlich Werte zu ermitteln und zu übertragen, oder auf Tastendruck den Wert der Fahrtstufe zu erhöhen bzw. zu vermindern. Auf den folgenden Bildern einige ausgewählte Beispiele, im ersten Bild Joystick-Steuerungen: 
 &amp;nbsp;  
 &amp;nbsp; 
 Auf dem zweiten Bild sehen wir Infrarot-Fernsteuerungen, eine Smartphone App mit Bluetooth-Empfänger sowie das LCD1602-Keypad-Shield, das u.a. mit einem 433 MHz Transceiver betrieben werden kann: 
 &amp;nbsp;  
 &amp;nbsp; 
 Um ein einheitliches Schema zu erreichen, macht es Sinn, die analogen Werte des Potis mit der map()-Funktion auf Werte zu reduzieren, die per Funk übertragen werden können. Der Analog-Digital-Konverter liefert 10-Bit-Zahlen, also Werte zwischen 0 und 1023. Die Mittelposition der Mini-Joysticks liegt bei ca. 511. Bei Division des Wertes durch 100 kann man mit einem Joystick zwei Werte (x- und y-Richtung) ermitteln, die zwischen 0 und 10 oder bei Anwendung der map()-Funktion zwischen 1 und 9 liegen. Das reicht allemal für die Eingabe der Geschwindigkeit und für Kurvenfahrten. Egal, ob wir 11 oder 9 Werte ermitteln, Stillstand bedeutet Wert 5 in y-Richtung und für Geradeausfahrt ebenfalls Wert 5. 
 Mit Blick auf den Controller mit den zwei Joysticks (Teil des Bausatzes  4DOF Mini Roboterarm Bausatz mit Joysticks und Servoantrieb ) entscheide ich mich bei der Vielfalt von verschiedenen Systemen für einen gut zu übertragenden Code zwischen 1111 und 9999, wobei die erste Stelle für die y-Richtung des linken Joysticks, die zweite Stelle für die x-Richtung des linken Joysticks, die dritte und vierte Stelle für einen optionalen zweiten Joystick oder bestimmte Tasten verwendet werden können. Dabei benötigen wir im ersten Beispiel mit der IR-Fernsteuerung nur die ersten beiden Stellen des vierstelligen Codes. 
 Die Drehzahlregelung beim RC Car für Arduino 
 Die Drehzahlregelung der Motoren erfolgt mit Pulsweitenmodulation (PWM). Der Wert für den sogenannten Duty Cycle ist eine 8-Bit-Zahl, also ein Wert zwischen 0 und 255 (=2 hoch 8 -1). Wer mit einem regelbaren Netzteil Spannungen zwischen 0 und 6V an den Motor anlegt, wird feststellen, dass bis ca. 1,5 V gar nichts zu bemerken ist. Dann fängt der Motor an zu brummen, bewegt sich aber nicht. Wer zugleich die Stromstärke misst, wird einen relativ hohen Wert feststellen. Die Energie wird in Wärme und Brummen umgesetzt – nicht wirklich gut. Ab 2,4 – 3 Volt fängt der Motor an zu drehen, die Stromstärke sinkt etwas, wenn der Motor unbelastet ist. Danach steigt die Drehzahl in Abhängigkeit von der angelegten Spannung. Beim Herunterregeln der Spannung dreht der Motor bis unter 2 Volt, aber wenn er z.B. durch erhöhten Reibungswiderstand oder ein Hindernis zum Stehen kommt, läuft er nicht wieder an. Fazit: Werte unterhalb von ca. 2,4 Volt sollten vermieden werden, die Eingabe sollte gleich 0 (null) gesetzt werden, um unnötigen Verschleiß und Stromverbrauch zu verhindern. Außer Stillstand (Code=5) benötigen wir Duty Cycle zwischen ca. 40% und 100% bei einer Versorgungsspannung von 6V für die Motoren. 
 Die Spannungsversorgung beim RC Car für Arduino 
 Wir haben im ersten Teil bereits mehrere Möglichkeiten der Spannungsversorgung thematisiert. Vier AA-Batterien je 1,5V ergeben 6V, die maximale Spannung der kleinen gelben Motoren. Vier AA-Akkus je 1,2 V reichen nicht als Spannungsversorgung. Man benötigt dann einen Batteriehalter für 6 Akkus und das ergibt 7,2 Volt. Und zwei Lithium-Ionen-Akkus (Nennspannung 3,7V) liefern im voll aufgeladenen Zustand über 8 Volt. Es macht also Sinn, im Programm einen Faktor festzulegen, der die Spannung der höchsten Fahrtstufe bei 6V limitiert. 
 Die Steuerung des RC Car für Arduino 
 Sofern die Fahrtanweisungen mit Tastern (engl. buttons), die sich ggf. sogar in einer Smartphone-App befinden können, erfolgen, wird zum Ausgangswert 55xx (Stillstand) jeweils der passende Wert erhöht oder vermindert, ohne dass das Maximum überschritten werden kann. 
 Den Code richtig auslesen 
 Die Zuordnung der ersten Stelle des Codes zu den erforderlichen Werten der Fahrtstufen erfolgt über den Index einer Liste mit den jeweiligen Zahlenwerten. 
 Fazit: Mit einem vierstelligen Code können wir mit den ersten beiden Stellen Geschwindigkeit und Kurvenfahrten steuern, die hinteren zwei Stellen dienen weiteren Funktionen (zunächst nicht benötigt). Also zum Beispiel Code95xx für schnellste Geradeausfahrt, 55xx für Stillstand, 77xx für Vorwärtsfahrt nach 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; 
 
 
  →  
 
 
 
 
 8 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↖  
 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 
  ↗  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 7 
 
 
  ←  
 
 
 &amp;nbsp; 
 
 
  ↖  
 
 
 &amp;nbsp; 
 
 
  ↑  
 
 
 &amp;nbsp; 
 
 
  ↗  
 
 
 &amp;nbsp; 
 
 
  →  
 
 
 
 
 6 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 
 ↖ 
 
 
 &amp;nbsp; 
 
 
 ↑ 
 
 
 &amp;nbsp; 
 
 
 ↗ 
 
 
 &amp;nbsp; 
 
 
 → 
 
 
 
 
 5 
 
 
 ← 
 
 
 &amp;nbsp; 
 
 
 ↖ 
 
 
 &amp;nbsp; 
 
 
  0  
 
 
 &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; 
 Nun wollen wir mit dem Kit, einem Mikrocontroller vom Typ ATmega328 (Bauform des UNO R3), einem MotorShield V2 und IR-Sender und -Empfänger unser erstes Smart Robot Car bauen. 
 Das Motor Shield V2 kann bis zu vier Motoren steuern, dabei werden für den Anschluss der Steuerleitungen der sogenannte I2C-Bus mit den Anschlüssen SDA (=Serial Data) am analogen Eingang A4 und SCL (=Serial Clock) an A5 benutzt. Auch hierfür hat Adafruit eine passende Programm-Bibliothek entwickelt und bereitgestellt. Achtung: Die Bibliotheken für die Motor Shields V1 und V2 sind nicht kompatibel. 
 &amp;nbsp;  
 Bild Motor Shield V2 mit Modifikation:  Eingelötete Buchsenleisten (Federleisten) für Anschluss von Zusatzausstattung 
 Egal, welches Motor Shield man benutzen möchte - V1 oder V2 -,&amp;nbsp; es macht Sinn, bei beiden Motor Shields zusätzliche Buchsenleisten einzulöten, um später Bluetooth- oder 433 MHz-Sender/Empfänger (engl. Transceiver=Transmitter + Receiver) oder Sensoren anzuschließen. Mehr dazu in den folgenden Blog-Beiträge. Der IR-Empfänger benötigt nur Spannungsversorgung aus Pin 3 und 4 sowie Pin2 für den IR Receiver. Der Lötkolben kann noch kalt bleiben. 
 Als Steuerung werden wir zunächst die kleine Infrarot-Fernbedienung von Funduino und einen IR-Empfänger benutzen. Obwohl der „nackte“ IR-Sensor genügt, empfehle ich das kleine Breakout-Board, da hier eine LED flackert, wenn IR-Signale empfangen werden; ein wertvolles Hilfsmittel, wenn ein Fehler gesucht wird. 
 Der Sketch ist zusammengesetzt aus zwei erprobten Teilen: Dem Beispiel-Sketch von Armin Joachimsmeyer, den er seiner tollen Programm-Bibliothek IRremote beigefügt hat und einem Robot Car-Sketch des Autors, das auf der Programm-Bibliothek von Adafruit beruht. 
 Der Programmcode für das RC Car für Arduino 
  /* Sample Code for Robot Car with Motor Shield V2 and IR receiver, as of 20220515
* based on Adafruit Motor shield V2 library, copyright Adafruit Industries LLC, 2009
* and SimpleReceiver.cpp, part of Arduino-IRremote https://github.com/Arduino-IRremote/Arduino-IRremote
* MIT License  Copyright (c) 2020-2022 Armin Joachimsmeyer
* modified for Funduino
* Motor Shield V2 utilizes I2C with SDA=A4 and SCL=A5
* IRreceiver utilizes Pin 2
 ************************************************************************************
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the &quot;Software&quot;), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is furnished
 * to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED &quot;AS IS&quot;, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
 * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
 * PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
 * CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE
 * OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *************************************************************************************/ 
 
 # include   &amp;lt;Adafruit_MotorShield.h&amp;gt;  
 // Create the motor shield object with the default I2C address 0x60 
Adafruit_MotorShield AFMS = Adafruit_MotorShield();
 // Select which &#039;port&#039; M1, M2, M3 or M4.  
Adafruit_DCMotor *motor1 = AFMS.getMotor( 2 );
Adafruit_DCMotor *motor2 = AFMS.getMotor( 3 );

 // define protocol for remote control, for more see samples code SimpleReceiver.cpp 
 # define  DECODE_NEC        // Includes Apple and Onkyo, also for tiny Funduino remote control  
 //#define INFO           // To see valuable informations from universal decoder for pulse width or pulse distance protocols 
 # define  IR_RECEIVE_PIN   2      // instead of   #include &quot;PinDefinitionsAndMore.h&quot;  
 # include   &amp;lt;Arduino.h&amp;gt;  
 # include   &amp;lt;IRremote.hpp&amp;gt;  

 // IR Receiver signal connected to Pin2, VCC to Pin3, GND to Pin4 
 int  IR_GND =  4 ;   
 int  IR_VCC =  3 ;

 int  x =  0 ;
 int  y =  0 ;
 int  left =  0 ;
 int  right =  0 ;
 int  code =  5555 ;
 int  speedL =  0 ;
 float  factor =  1.8 ;  // Correction for speedLevel 255/100 * 6V/VBatt 

 void   setup () {
   Serial . begin ( 9600 );
   Serial . println ( &quot;Motor test!&quot; );
   Serial . println ( &quot;Motorshield v2 - DC Motor test!&quot; );
   if  (!AFMS. begin ()) {          // create with the default frequency 1.6KHz 
     Serial . println ( &quot;Could not find Motor Shield. Check wiring.&quot; );
     while  ( 1 );
  }
   Serial . println ( &quot;Motor Shield found.&quot; );
   // Just to know which program is running on my Arduino 
   Serial . println (F( &quot;START &quot;  __FILE__  &quot; from &quot;  __DATE__  &quot;\r\nUsing library version &quot;  VERSION_IRREMOTE));
   // Start the receiver 
  IrReceiver. begin (IR_RECEIVE_PIN);       //, ENABLE_LED_FEEDBACK); 
   Serial . print (F( &quot;Ready to receive IR signals of protocols: &quot; ));
  printActiveIRProtocols(&amp;amp; Serial );
   Serial . print (F( &quot;at pin &quot; ));
   Serial . println (IR_RECEIVE_PIN);  
   // initialize digital pins as output for power supply 
   pinMode (IR_GND, OUTPUT );
   pinMode (IR_VCC, OUTPUT );
   digitalWrite (IR_GND, LOW );
   digitalWrite (IR_VCC, HIGH );    
}    // end setup 

 void   loop () {
   if  (IrReceiver.decode()) {
       // Print a short summary of received data 
      IrReceiver.printIRResultShort(&amp;amp; Serial );
       if  (IrReceiver.decodedIRData.protocol == UNKNOWN) {
           // We have an unknown protocol here, print more info 
          IrReceiver.printIRResultRawFormatted(&amp;amp; Serial , true);
      }
       Serial . println ();
       /*
       * !!!Important!!! Enable receiving of the next value,
       * since receiving has stopped after the end of the current received data packet.
       */ 
       delay ( 100 );    // Entprellen, keine schnelle Wiederholung      
      IrReceiver.resume();  // Enable receiving of the next value 
       /*
       * Finally, check the received data and perform actions according to the received command
       */ 
   if  (IrReceiver.decodedIRData.command ==  0x46 )   {
     if  (code&amp;lt; 9000 )   code = code +  1000 ;         
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
   else   if  (IrReceiver.decodedIRData.command ==  0x15 )   {
     if  (code&amp;gt; 2000 )   code = code -  1000 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }  
   else   if  (IrReceiver.decodedIRData.command ==  0x43 )   {
     if  ((code -1000 * int (code/ 1000 ))&amp;lt; 900 )  code = code +  100 ;      
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
   else   if  (IrReceiver.decodedIRData.command ==  0x44 )   {
     if  (code -1000 * int (code/ 1000 ) &amp;gt;  200 )   code = code -  100 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
   else   if  (IrReceiver.decodedIRData.command ==  0x40 )   {
    code =  5555 ;
     Serial . print ( &quot;Code = &quot; );
     Serial . println (code);
    }
   else   {
     Serial . print ( &quot;invalid code&quot; );
    }
  motor();
  }
}    // end loop 

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

   //Korrektur der Fahrtstufen für Kurvenfahrt 
   if  (x== 1 ){
    right = speedL+ 16 ;
    left = speedL -16 ;
  }
   else   if  (x== 2 ){
    right = speedL+ 13 ;
    left = speedL -13 ;
  }
   else   if  (x== 3 ) {
    right = speedL+ 10 ;
    left = speedL -10 ;
  }
   else   if  (x== 4 ) {
    right = speedL+ 7 ;
    left = speedL -7 ;
  }
   else   if  (x== 6 ) {
    right = speedL  -7 ;
    left = speedL+ 7 ;
  }
   else   if  (x== 7 ) {
    right = speedL -10 ;
    left = speedL+ 10 ;
  }
   else   if  (x== 8 ) {
    right = speedL -13 ;
    left = speedL+ 13 ;
  }
   else   if  (x== 9 ) {
    right = speedL -16 ;
    left = speedL+ 16 ;
  }
   else  {
    right = speedL;
    left = speedL;
  }

   //Eingabe der Fahrtstufen für &quot;left&quot; und &quot;right&quot; 
   Serial . print ( &quot;left = &quot; );
   Serial . print (left);
   Serial . print ( &quot; right = &quot; );
   Serial . println (right);

   if  (left &amp;lt;  40  &amp;amp; left &amp;gt;  -40 ) {
    motor1-&amp;gt; run (RELEASE);
  }
   if  (right &amp;lt;  40  &amp;amp; right &amp;gt;  -40 ) {
    motor2-&amp;gt; run (RELEASE);
  }
   if  (left&amp;gt;= 40 ) {
     if  (left&amp;gt; 100 ) left= 100 ;
      motor1-&amp;gt; run (FORWARD);
      motor1-&amp;gt; setSpeed (left * factor);
  }
   if  (right&amp;gt;= 40 ) {
     if  (right&amp;gt; 100 ) right= 100 ;
      motor2-&amp;gt; run (FORWARD);
      motor2-&amp;gt; setSpeed (right * factor);
  }
   if  (left&amp;lt;=  -40 ) {
     if  (left&amp;lt; -100 ) left= -100 ;
      motor1-&amp;gt; run (BACKWARD);
      motor1-&amp;gt; setSpeed (-left * factor);
  }
   if  (right&amp;lt;=  -40 ) {
     if  (right&amp;lt; -100 ) right= -100 ;
      motor2-&amp;gt; run (BACKWARD);
      motor2-&amp;gt; setSpeed (-right * factor);
  }
}    // end motor 
 
 Erklärungen des Programmcodes für das RC Car 
 Nach dem Inkludieren der Bibliotheken für das Motor Shield V2 und IRremote werden zwei Motoren instanziiert mit der Nummer am Terminal Block des Controllers sowie einige globale Variablen deklariert (Datentyp) und initialisiert (Anfangswert). 
 In der Funktion  setup()  werden die Serielle Schnittstelle und der IR Receiver initialisiert sowie die Pins für die Spannungsversorgung des IR Receivers als Ausgänge mit dem Zustand HIGH bzw. LOW eingerichtet. 
 In der Funktion  loop()  wird zunächst das Signal der IR-Fernbedienung empfangen, dann in Abhängigkeit der gedrückten Taste der Code für die Motorsteuerung verändert. Die Cursortasten up und down verändern die erste Stelle, left und right die zweite Stelle des Codes im Wertebereich 1 bis 9. Die Taste X führt zum Stillstand mit Code 5555. Die dritte und vierte Stelle des Codes sind zurzeit noch nicht von Bedeutung. Am Ende wird die selbst-definierte Funktion  motor()  ohne Argumente aufgerufen, da wir die Variablen global, d.h. in allen Funktionen gültig, definiert hatten. 
 In der selbst definierte Funktion  motor() , die wir auch in anderen Konfigurationen mit anderen Fernsteuerungen einsetzen werden, werden aus dem Code die Fahrtstufen für den linken und rechten Motor ermittelt. Der Prozentwert der Fahrtstufe wird schlussendlich mit dem eingangs definierten Faktor in den PWM-Wert für  setSpeed  umgerechnet. 
 &amp;nbsp;  
 Damit ist das Robot Car einsatzbereit. Funktioniert prima, solange man die optische Verbindung zwischen Fernbedienung und IR Receiver aufrechterhalten kann. Allerdings habe ich beim Fahren auf der Straße die Erfahrung gemacht, dass starke Sonneneinstrahlung den Empfang behindert. Deshalb steige ich auf Funkfernbedienung um. Bis demnächst. 
                ]]>
            </content>

                            <updated>2022-06-09T07:30: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">RC Car für Arduino bauen: Autonomes Fahrzeug - Teil 1</title>
            <id>https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-1</id>
            <link href="https://funduinoshop.com/rc-car-fuer-arduino-bauen-autonomes-fahrzeug-teil-1"/>
            <summary type="html">
                <![CDATA[
                
                                            Willkommen zu einer neuen Blogreihe über Roboterautos. Im ersten Teil werden wir die Grundlagen dafür kennenlernen, sozusagen als Entscheidungshilfe für die Kaufentscheidung, welches Chassis, welcher Mikrocontroller und welche Art der Fernsteuerung...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Mit Roboterautos die Mobilität der Zukunft verstehen  
 Willkommen zu einer neuen Blogreihe über Roboterautos. Im ersten Teil werden wir die Grundlagen dafür kennenlernen, sozusagen als Entscheidungshilfe für die Kaufentscheidung, welches Chassis, welcher Mikrocontroller und welche Art der Fernsteuerung am besten geeignet sind. 
 Zwei oder vier Räder - Abwägung der Vor- und Nachteile für den Bau von RC Cars für Arduino 
 Beginnen wir mit dem Chassis und betrachten wir die Vor- und Nachteile der preiswerten Kits mit zwei bzw. vier angetriebenen Rädern. Allen gemeinsam sind die Elektromotoren, sodass diese allein kein Auswahlkriterium sind. Die zweirädrigen Roboterautos sind zunächst preiswerter, weil die Kosten für zwei weitere Elektromotoren und Räder entfallen. Stattdessen haben sie ein oder zwei Stützräder, die den RC Cars eine hohe Wendigkeit verleihen. Wer also „auf dem Teller drehen“ möchte, ist damit bestens bedient. Allerdings kann man in dieser Preislage der Gleichstrom-Motoren nicht erwarten, dass sie mit hoher Präzision gleichmäßig laufen. Deshalb ist der Geradeauslauf nicht so gut wie bei der vierrädrigen Variante. Gerade beim Anlaufen der Motoren zeigen diese eine höhere Spurtreue, jedoch sind Kurvenfahrten nur mit deutlich größeren Radien möglich. Ein weiterer Vorteil der vierrädrigen Chassis ist mehr Platz für Batterien, Mikro Controller, ggf. DC/DC-Konverter und Sensoren. 
   
 Die Wahl des Mikrocontrollers für den Bau eines RC Cars 
 Die nächste Frage bezieht sich auf den Mikrocontroller und die Art der Programmierung. Die größte Rechenleistung auf dem kleinen Chassis hat zum Beispiel ein Mikro Computer vom Typ Raspberry Pi. Gerade im Hinblick auf die Fernsteuerung bieten die Typen mit eingebautem WiFi und Bluetooth Vorteile und man kann sogar Bilder einer Raspberry Pi-Kamera übertragen. Die Programmierung erfolgt in der weit verbreiteten Programmiersprache Python, jedoch dauert der Systemstart des Linux-basierten Betriebssystems Raspberry Pi OS rund eine Minute. Ein weiterer Nachteil der Raspis (kurz für Raspberry Pi) ist die Notwendigkeit einer guten Spannungsversorgung mit 5V. Dies erfordert einen guten DC/DC-Konverter. 
 Im Zusammenhang mit dem Thema Bluetooth-Fernsteuerung wird in einer späteren Folge ein Beispiel mit Raspberry Pi und der Android APP BlueDot von Martin O’Hanlon (Mitarbeiter der Raspberry Pi Foundation) gezeigt. 
 Viel schneller geht der Systemstart mit einem Micro Controller auf Basis des ATmega 328, z.B. dem  Funduino Uno  oder  Funduino&amp;nbsp;Nano . Rund eine Sekunde nach dem Einschalten kann man mit den Steuereingaben beginnen, kein Booten von MikroSD-Karte, das einmal hochgeladene Programm wird nicht vergessen. Die Eingangsspannung kann zwischen 5 und 9 Volt liegen. Programmiert wird in der  Arduino IDE , einer Entwicklungsumgebung in Anlehnung an C/C++ (Weitere Erklärung siehe  https://funduino.de/hardware-software ). Deshalb werden wir zunächst Beispiele mit dem Funduino Uno R3 betrachten, für die es perfekte Motor Controller als sogenannte Shields gibt. Diese werden einfach auf den Uno aufgesteckt und bei der Programmierung helfen uns sogenannte Bibliotheken (engl. libraries). 
 Exkurs: Was ist ein Motor Controller/Motortreiber? 
 Aufgrund der stark limitierten Stromstärke an den Ausgängen der Mikro Controller bedarf es bei größeren Verbrauchern – und dazu gehören alle Arten von Elektromotoren und Relais – einer externen Spannungsversorgung und einer elektronischen Schaltung, die das Steuersignal des Mikro Controllers umsetzt. Die Anforderungen an diesen Integrierten Schaltkreis (engl. IC=Integrated Circuit) sind jedoch noch höher: Er soll einerseits eine variable Drehzahl des Motors ermöglichen, andererseits wollen wir auch die Drehrichtung des Motors durch Umpolen ändern können. 
 Am Beispiel des ICs L293D wird nun die Funktionsweise erklärt. Grundsätzlich genügt dieser DIP-Baustein mit sechzehn „Beinchen“/Anschlüssen als Motor Controller für zwei Elektromotoren.     
 Die Spannungsversorgung des ICs erfolgt an den Anschlüssen VCC1 und Ground. Diese Spannung können wir am Mikro Controller abzapfen. Die Spannungsversorgung der Motoren erfolgt über VCC2 und Ground. Hier schließen wir die Batterie(n) an (z.B. 6 oder 9 Volt). Bei größeren Motoren muss der IC gekühlt werden, bei den kleinen gelben vom Kit nicht. 
 Den einen Motor schließen wir an 1Y und 2Y an, die dazugehörigen Steuerleitungen zur MCU (Micro Controller Unit) sind 1A, 2A und 1,2EN. 
 Das Umpolen der Motoren für die Änderung der Fahrtrichtung erfolgt grundsätzlich mit einer sogenannten H-Schaltung. Diese realisieren wir mit unserem Mikro Controller, indem wir zwei Ausgangspins (diese gehen an 1A und 1B) entweder auf HIGH oder LOW legen. 
 Die Geschwindigkeitsänderung erfolgt wie bei dem  Beispiel Nr. 04 – Pulsierende LED  mit Pulsweitenmodulation (PWM, engl. pulse width modulation), also dem sehr schnellen Ein- und Ausschalten der Spannung. Deshalb benötigen wir für den Anschluss 1,2EN („Enable“) einen PWM-fähigen Ausgang an der MCU (das sind die Pins mit der Tilde ~). 
 Für den zweiten Motor werden die Anschlüsse 3A, 4A und 3,4EN an Pins der MCU angeschlossen. 
 Das rechte Bild (Logic Diagram) erklärt die Funktionsweise des ICs. Wir sehen die vier Verstärker, die die Eingangssignale 1A bis 4A jeweils mit der Batteriespannung an die Ausgänge 1Y bis 4Y geben. Dies erfolgt jedoch nur, wenn zusätzlich die PWM-Eingänge 1,2EN und 3,4EN ebenfalls HIGH geschaltet sind. 
 Zwei von diesen ICs L293D sind auf dem Motor Shield V1 verbaut, so dass hier bis zu vier Motoren angeschlossen werden können. 
 Um nicht zu viele Pins zu verwenden, befindet sich in der Mitte auf dem Motor Shield V1 ein sogenanntes Schieberegister (engl. shift register, SN74HC595). Dessen Funktionsweise zu erklären, würde den Rahmen dieses Beitrags übersteigen. Zum Glück haben uns die Kollegen der New Yorker Fa. Adafruit die meiste Arbeit beim Programmieren abgenommen und eine Programm-Bibliothek (engl. library) bereitgestellt, um die Motoren einfach zu steuern.    
 Bild Motor Shield V1 mit Modifikation:   Eingelötete Buchsenleisten (Federleisten) für Anschluss von Zusatzausstattung 
 &amp;nbsp; 
 Das Motor Shield V2 kann ebenfalls bis zu vier Motoren steuern und benutzt dafür einen ähnlichen IC, jedoch für den Anschluss der Steuerleitungen den sogenannten I2C-Bus mit den Anschlüssen SDA (=Serial Data) am analogen Eingang A4 und SCL (=Serial Clock) an A5. Auch hierfür hat Adafruit eine passende Programm-Bibliothek entwickelt und bereitgestellt. 
   
 Bild Motor Shield V2 mit Modifikation:  Eingelötete Buchsenleisten (Federleisten) für Anschluss von Zusatzausstattung 
 Bei beiden Motor Shields sind hier zusätzliche Buchsenleisten eingelötet, um später Bluetooth- oder 433 MHz-Sender/Empfänger (engl. Transceiver=Transmitter + Receiver) oder Sensoren anzuschließen. Mehr dazu in einem der folgenden Blog-Beiträge. 
 Spannungsversorgung und Steuerung für ein RC Car für Arduino Mikrocontroller 
 Wenn unser Roboterauto eigenständig fahren soll, müssen wir es vom USB-Anschluss des PCs trennen. Damit geht auch die Stromversorgung verloren. Von nun an werden Kommandozentrale (MCU) und Elektromotoren mit Batterien oder Akkus versorgt. Dabei sind die Motoren die weitaus größeren Verbraucher. Der Batteriehalter, der den meisten Kits beiliegt, ist für vier Mignon (AA)-Batterien, also 6 Volt für MCU und Motoren. Wer Akkus verwenden möchte, sollte wegen der geringeren Spannung entweder sechs Mignon (AA)-Akkus oder zwei Lithium-Ionen-Akkus vom Typ 18650 verwenden. 
 Als Steuerung werden wir in den nächsten Folgen zunächst Fernsteuerungen mit Infrarot-Fernbedienung, Bluetooth-Transceiver mit Smartphone APP oder einem zweiten Mikro Controller ebenfalls mit dem BT-Transceiver HC-05 sowie Funkfernsteuerungen mit 433Mhz und 2,4 GHz kennenlernen. Den Abschluss der Blogreihe werden Aspekte des autonomen Fahrens, vornehmlich Hinderniserkennung, bilden. Bis demnächst. 
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Pegelwandler in der Mikroelektronik</title>
            <id>https://funduinoshop.com/pegelwandler-in-der-mikroelektronik</id>
            <link href="https://funduinoshop.com/pegelwandler-in-der-mikroelektronik"/>
            <summary type="html">
                <![CDATA[
                
                                            Häufig sollen in elektronischen Schaltungen zwei Geräte oder Module miteinander kommunizieren. Noch häufiger benötigen diese beiden Module einen unterschiedlichen Spannungspegel. In der Mikroelektronik...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Wo werden Pegelwandler in der Mikroelektronik eingesetzt? 
 Häufig sollen in elektronischen Schaltungen zwei Geräte oder Module miteinander kommunizieren. Noch häufiger benötigen diese beiden Module einen unterschiedlichen Spannungspegel. In der Mikroelektronik, beispielsweise bei einem Arduino Mikrocontroller, beträgt dieser Spannungspegel üblicherweise 3.3V oder 5V. Würde man ein Modul, welches mit 3.3V und ein Modul mit 5V direkt miteinander verbinden, würde das Modul mit einer maximalen Betriebsspannung von 3.3V bei einem anliegenden 5V Pegel zerstört werden.&amp;nbsp; 
 Damit genau dies vermieden wird, greift man auf sogenannte Pegelwandler zurück. Pegelwandler ermöglichen demnach die Kommunikation zwischen zwei Modulen mit unterschiedlichem Spannungspegel. Besonders interessant ist, dass Pegelwandler in zwei Richtungen funktionieren, ohne dass etwas am Anschluss geändert werden muss. Das Signal kann demnach von einem Modul Pegelwandler sind deshalb auch für I2C Leitungen geeignet. Weiter ist das Anheben oder Absenken des Spannungspegels von Schalteingängen oder Schaltausgängen möglich.&amp;nbsp; 
   
 Pegelwandler: Wie funktionieren Sie? 
 Auf dem obigen Bild wird besonders schön deutlich, wie die Signalübertragung innerhalb eines Pegelwandlers für 3.3 und 5V funktioniert. Auf der Platine liegen sich 5V Pegel (HV, &quot;High Voltage&quot;) und der 3.3V Pegel (LV, &quot;Low Voltage&quot;) direkt gegenüber. Es ist zu beachten, dass das in diesem Beispiel verwendete Modul (Artikel ist unten verlinkt) nur wenige Milliampere &quot;schalten&quot; kann. Das Modul ist beispielsweise nicht zum Schalten von Motoren oder Lampen geeignet. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Das MPU-6050 Modul: Gyroskop und Beschleunigungssensor</title>
            <id>https://funduinoshop.com/das-mpu-6050-modul-gyroskop-und-beschleunigungssensor</id>
            <link href="https://funduinoshop.com/das-mpu-6050-modul-gyroskop-und-beschleunigungssensor"/>
            <summary type="html">
                <![CDATA[
                
                                            Es gibt nur wenige Module auf dem Markt, die in den letzten Monaten so einen Hype ausgelöst haben wie das MPU-6050 Modul. Die zwei in eins Platine vereint dabei gleich zwei beliebte...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Es gibt nur wenige Module auf dem Markt, die in den letzten Monaten so einen Hype ausgelöst haben wie das MPU-6050 Modul. Die zwei in eins Platine vereint dabei gleich zwei beliebte Sensor-Eigenschaften: Das Modul kann gleichzeitig als Gyroskop, als auch als Beschleunigungssensor eingesetzt werden.  Wie das? Der Sensor umfasst ein 3-Achsen-Gyroskop und einen 3-Achsen-Beschleunigungssensor auf ein und demselben Chip. Dadurch können&amp;nbsp;alle (!) Sensorwerte zeitgleich abgerufen werden. So ist man als Bastler immer über die aktuelle Sensorposition bestens informiert. Diese Eigenschaft ist besonders für den Modellbau sehr interessant, vornehmlich bei balancierenden Chassis oder Drohnen. Zudem kann über einen weiteren Master I2C Bus auf externe Magnetometer oder andere Sensoren zurückgreifen, sodass auch diese Sensordaten vollumfänglich erfasst werden können.&amp;nbsp; 
 Die Sensordaten des MPU-6050 (GY-521) im Schnellüberblick: 
 
 Chipsatz: MPU-6050 (auch als GY-521 bekannt) 
 Spannungsversorgung: 3.3 - 5V DC 
 Freiheitsgerade: 6* 
 Schnittstelle: I2C 
 Pinabstand: 2.54 mm   
 
 Kommen wir nun zum spannenden Teil: der Praxis. Damit Ihr Euch einen schönen Überblick über die nützlichen Funktionen des MPU-6050 Moduls verschaffen könnt, haben wir für euch einen Beispiel-Schaltplan entwickelt. Dabei wird das MPU-6050 Modul von einem Funduino UNO R3 ausgelesen und die erfassten Daten ausgewertet.  Wir interessieren uns hierbei primär für die Sensordaten des Gyroskops. Dabei möchten wir die Werte der X-, Y- und Z-Achse auslesen und feststellen, ob eine Veränderung der Sensor-Lageposition stattgefunden hat. Die Veränderung der Lageposition soll uns mit farbigen LEDs dargestellt werden. 
   
 So weit, so gut: aber wie setzen wir das um? 
 Der Programmcode des MPU-6050 Moduls 
 Jetzt gehts ans Eingemachte: na ja, so halb. Denn erstmal müssen wir uns die passende Bibliothek für das MPU6050 Modul herunterladen und in unsere Arduino IDE einbinden. Die Bibliothek trägt den Namen &quot;&amp;lt;MPU6050_tockn.h&amp;gt;&quot; und kann direkt über die Bibliotheksverwaltung der Arduino IDE gefunden und installiert werden. 
 Nach diesem ersten Schritt beginnen wir mit dem eigentlichen Code. Zunächst legen wir die LED-Anschlüsse für unsere LEDs fest, die uns als Indikatoren für die Achspotition dienen sollen. Anschließend legen wir jeweils zwei Variablen für die Achspotition der drei Achsen fest.&amp;nbsp; 
 Sicherlich stellt Ihr Euch die Frage, warum wir gleich zwei Variablen pro Achse benötigen. Da wir feststellen möchten, ob sich die Position der jeweiligen Achse verändert hat, müssen wir zunächst einmal feststellen, welchen Wert der Sensor für die aktuelle Position erfasst hat. Diesen Sensorwert des MPU-6050 sichern wir uns für einen kurzen Zeitraum in der ersten Variable. In der zweiten Variablen wird der Wert der Achsposition wenig später erneut gespeichert. Wir können die beiden erfassten Messwerte nun miteinander vergleichen. Insofern eine Abweichnung der Position um ein zuvor definiertes Mindestmaß erfasst worden ist (in unserem Codebeispiel +-3), können davon ausgehen, dass der Sensor die Position verändert hat. In diesem Fall schalten wir die zugeordnete LED ein.&amp;nbsp; 
 Besonders schön: die erfassten Messdaten lassen sich gut im seriellen Plotter der Arduino IDE anzeigen.   
  // Dieser Sketch vergleicht die Winkel der X/Y/Z Achsen mit den vorangegangenen Werten. 
 // Sind sie um +/-3° unterschiedlich, schaltet der Sketch LEDs. (jew.1 für POS oder für NEG) 
 // Achtung: Es sind nicht die absoluten Werte sondern RELATIVE Werte gegenüber der vorherigen Messung 


 # include   &amp;lt;MPU6050_tockn.h&amp;gt;          // Bibliotheken einbinden  
 # include   &amp;lt;Wire.h&amp;gt;                   // &amp;lt;-  

MPU6050 mpu6050( Wire ,  0.1 ,  0.1 );   // Dämpfung der Werte. Je kleiner (Richtung&quot;0&quot;), um so nervöser die Werte- 
                                   // je größer (Richtung&quot;1&quot;) um so träger die Werte 

 const   int  ledXpos = 2 ;              //*** 
 const   int  ledXneg = 3 ;              //  * 
 const   int  ledYpos = 4 ;              //  *  Festlegen der LED-Anschlüsse 
 const   int  ledYneg = 5 ;              //  * 
 const   int  ledZpos = 6 ;              //  * 
 const   int  ledZneg = 7 ;              //*** 

 int  xJetztPos;                     // Variable AKTUELLE X-Pos 
 int  yJetztPos;                     // Variable AKTUELLE Y-Pos 
 int  zJetztPos;                     // Variable AKTUELLE Z-Pos 

 int  xVorPos;                       // Variable VORHERIGE X-Pos 
 int  yVorPos;                       // Variable VORHERIGE Y-Pos 
 int  zVorPos;                       // Variable VORHERIGE Z-Pos 

 int  unterschied =  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 () {                    // Anfang der Loop-Schleife 

  mpu6050.update();              // Erzeuge neuen Datensatz im Gyro 

xJetztPos=(mpu6050.getGyroAngleX());   // Fordere neuen Datensatz vom Gyro an, schreibe in X Variable 
yJetztPos=(mpu6050.getGyroAngleY());   // Fordere neuen Datensatz vom Gyro an, schreibe in Y Variable 
zJetztPos=(mpu6050.getGyroAngleZ());   // Fordere neuen Datensatz vom Gyro an, schreibe in Z Variable 

 if  (xJetztPos &amp;lt; xVorPos-(unterschied))             // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; -3 ? 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  HIGH );}   // Dann schalte LEDs entsprechend 
 else   if  (xJetztPos &amp;gt; xVorPos+(unterschied))        // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; +3 ? 
{ digitalWrite (ledXpos,  HIGH );  digitalWrite (ledXneg,  LOW );}   // Dann schalte LEDs entsprechend 
 else                                    // Oder eben alle X LEDs aus... 
{ digitalWrite (ledXpos,  LOW );  digitalWrite (ledXneg,  LOW );}   // Dann schalte LEDs entsprechend 

 if  (yJetztPos &amp;lt; yVorPos-(unterschied))             // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; -3 ? 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  HIGH );}   // Dann schalte LEDs entsprechend 
 else   if  (yJetztPos &amp;gt; yVorPos+(unterschied))        // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; +3 ? 
{ digitalWrite (ledYpos,  HIGH );  digitalWrite (ledYneg,  LOW );}   // Dann schalte LEDs entsprechend 
 else                                    // Oder eben alle Y LEDs aus... 
{ digitalWrite (ledYpos,  LOW );  digitalWrite (ledYneg,  LOW );}   // Dann schalte LEDs entsprechend 

 if  (zJetztPos &amp;lt; zVorPos-(unterschied))             // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; -3 ? 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  HIGH );}   // Dann schalte LEDs entsprechend 
 else   if  (zJetztPos &amp;gt; zVorPos+(unterschied))        // Vergleiche alten Datensatz mit neuem. Unterschied &amp;lt; +3 ? 
{ digitalWrite (ledZpos,  HIGH );  digitalWrite (ledZneg,  LOW );}   // Dann schalte LEDs entsprechend 
 else                                    // Oder eben alle Z LEDs aus... 
{ digitalWrite (ledZpos,  LOW );  digitalWrite (ledZneg,  LOW );}   // Dann schalte LEDs entsprechend 

xVorPos=xJetztPos;                    // Aktualisiere den (bisher) alten Datensatz 
yVorPos=yJetztPos;                    // Aktualisiere den (bisher) alten Datensatz 
zVorPos=zJetztPos;                    // Aktualisiere den (bisher) alten Datensatz 
                                      // Dann kann im nächsten Durchlauf wieder gegen &quot;vorher&quot; verglichen werden 

 Serial . print (xJetztPos);                       // &amp;gt;&amp;gt; serieller Plotter&amp;lt;&amp;lt; gerechte Schreibweise  [gib X aus] 
 Serial . print ( &quot; &quot; ); Serial . print (yJetztPos);     // (&quot; &quot;) = (\t) = Neue Farbe     [gib Y aus] 
 Serial . print ( &quot; &quot; ); Serial . println (zJetztPos);   // (&quot; &quot;) = (\t) = Neue Farbe     [gib Z aus] 
  delay ( 15 );                                    // (minimale Verzögerung beruhigt die serielle Ausgabe) 
}                                              // Ende der Loop-Schleife 


 // Experimentiere ruhig ein wenig mit der Dämpfung in der dritten Programmzeile 
 //-&amp;gt; MPU6050 mpu6050(Wire, 0.3, 0.3); 
 // oder mit dem delay() zum Schluss. Beobachte danach die Werte im &amp;gt;&amp;gt;seriellen PLOTTER &amp;lt;&amp;lt;  
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">PWM-Drehzahlregler in der Mikroelektronik</title>
            <id>https://funduinoshop.com/pwm-drehzahlregler-in-der-mikroelektronik</id>
            <link href="https://funduinoshop.com/pwm-drehzahlregler-in-der-mikroelektronik"/>
            <summary type="html">
                <![CDATA[
                
                                            Vor Entwicklung der Leistungselektronik wurde die Drehzahlregelung von (bürstenbehafteten) Gleichstrommotoren mit Linearreglern oder Vorwiderständen gelöst. Bildlich gesprochen hat...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Ursprung von PWM-Drehzahlreglern 
 Vor Entwicklung der Leistungselektronik wurde die Drehzahlregelung&amp;nbsp;von (bürsten behafteten) Gleichstrommotoren mit Linearreglern oder&amp;nbsp;Vorwiderständen gelöst. Bildlich gesprochen hat man die Spannung&amp;nbsp;(und dadurch auch den Strom) reduziert, um die Drehzahl zu ändern. 
 Das hat jedoch einige Nachteile, die vor allem im Batteriebetrieb&amp;nbsp;zutage treten. Spannung und Strom werden an der Regeleinheit (oder&amp;nbsp;dem Widerstand) in (ungenutzte) Wärmeenergie (&quot;verbraten&quot;) umgewandelt. 
 Der Gesamtverbrauch bleibt sehr hoch, während die nutzbare&amp;nbsp;Leistung weniger wird.&amp;nbsp;Da das Drehmoment vom Stromfluss abhängt, bricht auch dieses ein. 
 So funktionieren PWM-Drehzahlregler 
 Mit (Weiter)Entwicklung der Leistungselektronik ist man mit einer&amp;nbsp;anderen Idee an die Problematik herangegangen.&amp;nbsp;Durch (sehr) schnelles Ein- und Ausschalten der Versorgungsspannung&amp;nbsp;&quot;pulst&quot; man die Spannung (und damit den Strom).&amp;nbsp;Am (elektronischen) Schalter fällt in der &quot;AUS&quot;-Zeit keine Leistung ab.&amp;nbsp;Dadurch entstehen an der Regelung (fast) keine Verluste mehr. 
 In der &quot;EIN&quot;-Zeit liegt die VOLLE Spannung am Motor an. Dadurch ist&amp;nbsp;der Strom - und damit das Drehmoment entsprechend hoch.&amp;nbsp;Leider ist ein Motor mit seinen Spulen und dem Eisenkern kein idealer&amp;nbsp;ohmscher Verbraucher, weshalb diese Aussage physikalisch gesehen nicht&amp;nbsp;völlig richtig ist.&amp;nbsp; 
 Die Kombination aus Spuleninduktivität und Motorträgheit hilft&amp;nbsp;allerdings bei der Glättung der Drehzahl, sodass sich der Motor so&amp;nbsp;verhält, als würde&amp;nbsp;er mit kontinuierlicher Gleichspannung betrieben. 
 &amp;nbsp; 
   
 &amp;nbsp; 
 Damit sind wir auch schon bei den Nachteilen der PulsWeitenModulation.&amp;nbsp;Die Modulation mit einer Rechteckspannung führt zur Abstrahlung&amp;nbsp;multipler Radiofrequenzen. Es kommt zu EMV-Störungen, die gerade bei&amp;nbsp;Steuerungen zu tückischen Fehlern führen können. 
 Im niedrigen PWM-Frequenzbereich (1-2kHz) kommt es zu unangenehmen&amp;nbsp;Pfeifgeräuschen am Motor.&amp;nbsp;Man könnte die Schaltfrequenz jetzt einfach weiter erhöhen.&amp;nbsp;Dann hat der Strom aber nicht genügend Zeit, seinen maximalen Zustand&amp;nbsp;in der Spule/Wicklung zu erreichen.&amp;nbsp;Er oszilliert dann zwischen zwei nicht stabilen Zustandswerten, was zu&amp;nbsp;einer Stromwelligkeit führt. 
 Eine zu hohe Stromwelligkeit erhöht die Erwärmung im Wicklungspaket,&amp;nbsp;wodurch die Motorleistung abnimmt und die Lebensdauer des Motors&amp;nbsp;beeinträchtigt wird. 
 ... ganz schön viel Physik für ein kleines Bauteil. 
 Jetzt die gute Nachricht:&amp;nbsp;Bei Motoren in der Leistungsklasse sind diese Nachteile durchaus&amp;nbsp;hinnehmbar. Freuen wir uns über die vorher beschriebenen Vorteile. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Das PN532 NFC RFID Modul - Nahfeldkommunikation</title>
            <id>https://funduinoshop.com/das-pn532-nfc-rfid-modul-nahfeldkommunikation</id>
            <link href="https://funduinoshop.com/das-pn532-nfc-rfid-modul-nahfeldkommunikation"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Beitrag möchten wir euch das Auslesen von ID-Tags nahelegen. Im Zentrum des Beitrags steht dabei das PN532 NFC RFID Modul. Das Modul basiert auf dem NXP PN532 Chip. Dieser Chipsatz ist vor allem in Bereich des NFC (engl. für &quot;Near Field Communication&quot;)...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 RFID? NFC? Was ist das? 
 In diesem Beitrag möchten wir euch das Auslesen von ID-Tags nahelegen. Im Zentrum des Beitrags steht dabei das PN532 NFC RFID Modul.&amp;nbsp; 
 Das Modul basiert auf dem NXP PN532 Chip. Dieser Chipsatz ist vor allem in Bereich des NFC (engl. für &quot;Near Field Communication&quot;) weit verbreitet. Dabei wird ein NFC-fähiges Objekt, häufig z.B. eine Scheckkarte mit NFC-Chip, an einen NFC-Reader gehalten. Dadurch findet in sekundenbruchteilen ein Informationsaustausch statt.&amp;nbsp; 
 Das klingt abstrakt? Wenn Ihr über eine neuere EC-Karte und diese zum kontaktlosen Zahlen verwendet, dann kennt Ihr NFC sogar aus dem Alltag. Durch das Auflegen der Karte am Kartenterminal wird die Transaktion angestoßen - ganz schnell und unkompliziert. 
 Genau diese dahinterstehenden technischen Abläufe möchten wir uns genauer ansehen. Das PN532 Modul ist hierfür bestens geeignet, da es sowohl I2C als auch SPI fähig ist. Die gewünschte Art der Kommunikation kann direkt auf der Platine des PN532 durch Umlegen der darauf befindlichen Schalter ausgewählt werden. Die hierfür benötigte Schalterposition der jeweiligen Schnittstellen sehr Ihr rechts neben der Schaltskizze, welche sich etwas weiter unten auf der Seite befindet. 
 &amp;nbsp; 
 Der Schaltplan: 
   
 Tipp: Eine hochauflösende Version dieses Bildes findet Ihr  hier . Dort könnt Ihr die jeweilige Pinbelegung etwas besser erkennen.   
 Der Programmcode (I2C Version) 
  //******************************************************************************************************* 
 //**  Beispielsketch für das Auslesen von ID-Tags. Bei passender ID wird PIN 13 für 2 Sekunden         ** 
 //**  eingeschaltet (LED). Bei falscher ID wird an Pin 12 ein Ton erzeugt. (PASSIVEN Buzzer / Piezzo)  ** 
 //**  nutzen. Statt einer LED kann auch ein Türschloss geschaltet werden (über TIP120 Schaltverstärker ** 
 //******************************************************************************************************* 

 # include   &amp;lt;Wire.h&amp;gt;                              // Bibliothek fürs I2C Protokoll  
 # include   &amp;lt;Adafruit_PN532.h&amp;gt;                    // Bibliothek für das NFC/RFID Modul  !!! Bitte mittels Arduino IDE laden !!!  


 # define  PN532_IRQ   (2)                       // Definiere den IRQ Anschluss  
 # define  PN532_RESET (3)                       // Definiere den Reset Anschluss  

 const   int  AlarmPin  =   12 ;                    // Pin 12 Ausgang für Piezo Lautsprecher 
 const   int  OutputPin =   13 ;                    // Pin 13 Ausgang für LED oder über TIP120 zu einem Magnetschloss 
 unsigned   long  cardid;                         // Variable für die ausgelesene TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;            // Hier können zu akzeptierende IDs eingetragen werden 
 unsigned   long  TAGid2 =  4070796058 ;            // Sonst frei lassen. Die ID einzelner TAGs können mit 
 unsigned   long  TAGid3 ;                        // dem seriellen Monitor ausgelesen werden (115200 Baud einstellen) 

Adafruit_PN532 nfc(PN532_IRQ, PN532_RESET);   // Instanz erzeugen mit I2C Protokoll 


 void   setup () {                                            // Beginn Setup Funktion 
   pinMode (AlarmPin,  OUTPUT );                              // Definiere PIN als Ausgang 
    pinMode (OutputPin,  OUTPUT );                            // Definiere PIN als Ausgang 
   Serial . begin ( 115200 );                                   // Öffne serielle Übertragung mit 115200 Baud (ser Monitor gleiche Baud Einstellung!) 
   Serial . println ( &quot;Hallo!&quot; );                               // Schicke Text &quot;Hallo!&quot; auf seriellen Monitor 
  nfc. begin ();                                            // Beginne Kommunikation mit RFID Leser 
   unsigned   long  versiondata = nfc.getFirmwareVersion();   // Lese Versionsnummer der Firmware aus 
   if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

   Serial . print ( &quot;Chip PN5 gefunden&quot; );  Serial . println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Sende Text und Versionsinfos an seriellen 
   Serial . print ( &quot;Firmware ver. &quot; );  Serial . print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);       // Monitor, wenn Antwort vom Board kommt 
   Serial . print ( &#039;.&#039; );  Serial . println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);                   //  
  
  nfc.SAMConfig();                                          // Konfiguriere Board RFID Tags zu lesen 

   Serial . println ( &quot;Warte auf einen ISO14443A Chip ...&quot; );      // Sende Text dass gewartet wird an seriellen Monitor 
}


 void   loop () {                                               // Beginne Loop-Funktion 
  uint8_t success;                                          // Variable anlegen 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };                  // Puffer um die UID zu speichern 
  uint8_t uidLength;                                        // Länge der UID (4 or 7 bytes je nach ISO14443A Card/Chip Type) 

  // Warte auf einen ISO14443A Chip. Wird ein solcher entdeckt, wird die Variable 
  // mit der UID gefüllt. Abhängig von der Länge (4 bytes (Mifare Classic) oder 
  // 7 bytes (Mifare Ultralight) wird der Kartentyp erkannt. 
  
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

   if  (success) {                                            // Wenn erkannt wird, arbeite ab... 
     Serial . println ( &quot;Found an ISO14443A card&quot; );
     Serial . print ( &quot;  UID Length: &quot; );  Serial . print (uidLength, DEC);  Serial . println ( &quot; bytes&quot; );
     Serial . print ( &quot;  UID Value: &quot; );
    nfc.PrintHex(uid, uidLength);                           // gib Informationen auf seriellen Monitor aus 

     if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
       if   ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))   // Abfrage, ob die TAGs 1..2..3 mit der jeweiligen 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                  // Ein oder Aus 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }                                                       // Ende der IF Abfrage/Schleife 
}                                                         // Ende der Loop Schleife  
 Der Programmcode (SPI Version) 
  //******************************************************************************************************* 
 //**  Beispielsketch für das Auslesen von ID-Tags. Bei passender ID wird PIN 13 für 2 Sekunden         ** 
 //**  eingeschaltet (LED). Bei falscher ID wird an Pin 12 ein Ton erzeugt. (PASSIVEN Buzzer / Piezzo)  ** 
 //**  nutzen. Statt einer LED kann auch ein Türschloss geschaltet werden (über TIP120 Schaltverstärker ** 
 //******************************************************************************************************* 

 # include   &amp;lt;Wire.h&amp;gt;                              // Bibliothek fürs I2C Protokoll  
 # include   &amp;lt;SPI.h&amp;gt;                               // Bibliothek fürs SPI Protokoll  
 # include   &amp;lt;Adafruit_PN532.h&amp;gt;                    // Bibliothek für das NFC/RFID Modul !!! Bitte mittels Arduino IDE laden !!!  

 const   byte  PN532_SCK =  2 ;                     // 
 const   byte  PN532_MOSI = 3 ;                     // Definiere die Anschlüsse für  
 const   byte  PN532_SS  =  4 ;                     // die SPI Verbindung zum RFID  
 const   byte  PN532_MISO = 5 ;                     // Board 

 const   int  AlarmPin  =   12 ;                    // Definiere die Anschlüsse für  
 const   int  OutputPin =   13 ;                    // die (Schalt)Ausgänge 
 unsigned   long  cardid;                         // Variable für die ausgelesene TAG-ID 

 unsigned   long  TAGid1 =  1702536620 ;            // Hier können zu akzeptierende IDs eingetragen werden 
 unsigned   long  TAGid2 =  4070796058 ;            // Sonst frei lassen. Die ID einzelner TAGs können mit 
 unsigned   long  TAGid3 ;                        // dem seriellen Monitor ausgelesen werden (115200 Baud einstellen) 

Adafruit_PN532 nfc(PN532_SCK, PN532_MISO, PN532_MOSI, PN532_SS);    // Instanz erzeugen mit SPI Protokoll 

 void   setup () {                                // Beginn Setup Funktion 
   pinMode (AlarmPin,  OUTPUT );                  // Definiere PIN als Ausgang 
    pinMode (OutputPin,  OUTPUT );                // Definiere PIN als Ausgang 
   Serial . begin ( 115200 );                       // Öffne serielle Übertragung mit 115200 Baud (ser Monitor gleiche Baud Einstellung!) 
   Serial . println ( &quot;Hallo!&quot; );                   // Schicke Text &quot;Hallo!&quot; auf seriellen Monitor 
  nfc. begin ();                                // Beginne Kommunikation mit RFID Leser 
   unsigned   long  versiondata = nfc.getFirmwareVersion();   // Lese Versionsnummer der Firmware aus 
   if  (! versiondata) {                                    // Wenn keine Antwort kommt 
     Serial . print ( &quot;Kann kein Board finden !&quot; );             // Sende Text &quot;Kann kein...&quot; an seriellen Monitor 
     while  ( 1 );                                            // so lange Stopp 
  }

   Serial . print ( &quot;Found chip PN5&quot; );  Serial . println ((versiondata &amp;gt;&amp;gt;  24 ) &amp;amp;  0xFF , HEX);  // Sende Text und Versionsinfos an seriellen 
   Serial . print ( &quot;Firmware ver. &quot; );  Serial . print ((versiondata &amp;gt;&amp;gt;  16 ) &amp;amp;  0xFF , DEC);    // Monitor, wenn Antwort vom Board kommt 
   Serial . print ( &#039;.&#039; );  Serial . println ((versiondata &amp;gt;&amp;gt;  8 ) &amp;amp;  0xFF , DEC);                //  

  nfc.SAMConfig();                                              // Konfiguriere Board RFID Tags zu lesen 

   Serial . println ( &quot;Warte auf einen ISO14443A Chip ...&quot; );         // Sende Text dass gewartet wird an seriellen Monitor 
}


 void   loop () {                                                 // Beginne Loop-Funktion 
  uint8_t success;                                            // Variable anlegen 
  uint8_t uid[] = {  0 ,  0 ,  0 ,  0 ,  0 ,  0 ,  0  };                    // Puffer um die UID zu speichern 
  uint8_t uidLength;                                          // Länge der UID (4 or 7 bytes je nach ISO14443A Card/Chip Type) 

  // Warte auf einen ISO14443A Chip. Wird ein solcher entdeckt, wird die Variable 
  // mit der UID gefüllt. Abhängig von der Länge (4 bytes (Mifare Classic) oder 
  // 7 bytes (Mifare Ultralight) wird der Kartentyp erkannt. 
 
  success = nfc.readPassiveTargetID(PN532_MIFARE_ISO14443A, uid, &amp;amp;uidLength);

   if  (success) {                                                     // Wenn erkannt wird, arbeite ab... 
     Serial . println ( &quot;Found an ISO14443A card&quot; );
     Serial . print ( &quot;  UID Length: &quot; );  Serial . print (uidLength, DEC);  Serial . println ( &quot; bytes&quot; );
     Serial . print ( &quot;  UID Value: &quot; );
    nfc.PrintHex(uid, uidLength);                           // gib Informationen auf seriellen Monitor aus 

     if  (uidLength ==  4 ) {                                   // Hat die Karte/der Chip 4 byte Länge... 
                                                            // Mifare Classic Karte 
      cardid = uid[ 0 ];                                      // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // Setze die 4 byte Blöcke 
      cardid |= uid[ 1 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zu einem einzigen Block 
      cardid |= uid[ 2 ];                                     // 
      cardid &amp;lt;&amp;lt;=  8 ;                                         // zusammen 
      cardid |= uid[ 3 ];                                     // 
       Serial . print ( &quot;Scheint eine Mifare Classic zu sein #&quot; );   // 
       Serial . println (cardid);                                  // Gib die Informationen aus 
       Serial . println ( &quot;&quot; );                                      //  
       Serial . println ( &quot;&quot; );                                      //  
    }
       if   ((cardid) == (TAGid1)||(cardid) == (TAGid2)||(cardid) == (TAGid3))   // Abfrage, ob die TAGs 1..2..3 mit der jeweiligen 
{ digitalWrite (OutputPin, HIGH );                                                 // überein stimmt. Dann schalte je nach dem 
 delay ( 2000 );
 digitalWrite (OutputPin, LOW );}                                                  // Ein oder Aus 
 else 
{ tone (AlarmPin,  1000 );                                                         // Und gib ggf. einen Ton/Frequenz aus 
 delay ( 4000 );
 noTone (AlarmPin);}
    }                                                       // Ende der IF Abfrage/Schleife 
}                                                         // Ende der Loop Schleife  
 &amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Die richtige Druckbettbeschichtung für den 3D-Drucker auswählen</title>
            <id>https://funduinoshop.com/die-richtige-druckbettbeschichtung-fuer-den-3d-drucker-auswaehlen</id>
            <link href="https://funduinoshop.com/die-richtige-druckbettbeschichtung-fuer-den-3d-drucker-auswaehlen"/>
            <summary type="html">
                <![CDATA[
                
                                            Kennt ihr das auch? Das Filament haftet sehr schlecht auf dem Druckbett. Es entsteht Warping, der Druck wird unschön oder komplett unbrauchbar. Im folgenden Beitrag werde ich einen kurzen Überblick...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Die richtige Druckbettbeschichtung für 3D-Drucker wählen  
 Kennt ihr das auch? Das Filament haftet sehr schlecht auf dem Druckbett. Es entsteht Warping, der Druck wird unschön oder komplett unbrauchbar. Im folgenden Beitrag werde ich einen kurzen Überblick über verschiedene Druckbettbeschichtungen geben, die Preise und Anwendungsgebiete vergleichen und ein abschließendes Fazit ziehen. 
  Die beliebtesten Druckbettbeschichtungen im Überblick  
  Dauerdruckplatte mit magnetischer Grundplatte  
 Eine der einfachsten Lösungen für eine bessere Haftung der 3D-Druck-Objekte ist der Kauf einer Dauerdruckplatte. Diese gibt es als magnetische Version, wobei der Klebevorgang beim Tausch der Druckplatte wegfällt. 
 Bei der Entwicklung von magnetischen Dauerdruckplatten ist Creality aktuell einer der gefragtesten Hersteller. Die Kunststoffplatte mit einem magnetischen Sticker wird auf eine zuvor installierte, magnetische Folie auf dem Druckbett aufgelegt.&amp;nbsp; 
 Außerdem weisen gängige Materialen wie PLA oder PETG eine ausgezeichnete Haftung auf der Platte auf. Da das Druckbett auf maximal 80° C aufgeheizt werden kann, ist die Auflage für einen Druck mit &quot;anspruchsvollen&quot; Materialien, wie zum Beispiel ABS, eher weniger geeignet. 
 Nach dem Druck lässt sich die Kunststoffplatte gemeinsam mit dem gedruckten Objekt einfach vom Druckbett abziehen. Durch leichtes Biegen der Druckplatte löst sich das Bauteil fast von alleine - einfach und genial, gerade für Einsteiger! 
  Dauerdruckplatte ohne magnetische Grundplatte  
 Es gibt allerdings auch Druckplatten ohne magnetische Grundplatte. Hier zählt der Hersteller BuildTak zu den prominentesten Namen. Im Vergleich zu der magnetischen Version wird die Druckplatte direkt auf das Druckbett aufgeklebt, ist also &quot;fest&quot; mit dieser verbunden. Dieser Vorgang muss bei jedem Wechsel der Druckbettbeschichtung wiederholt werden, was einen höheren Arbeitsaufwand mit sich zieht. Allerdings ist die generelle Haftung, auch mit ABS als Druckmaterial, sehr gut.  Wichtige Anmerkung: wie es der Name schon sagt, sind Dauerdruckplatten nicht für eine einmalige Verwendung vorgesehen, sondern häufig wiederverwendbar und zeichnen sich daher durch einen sehr positives Preis-Leistungs-Verhältnis aus. 
  Blue Tape  
 Blue Tape, häufig auch Synonym zum&amp;nbsp; Malerkrepp bekannt, ist eine sehr preiswerte Möglichkeit, um die Haftung der gedruckten Objekte zu verbessern. 
 Die Applikation von Blue Tape ist im direkten Vergleich zu den Dauerdruckplatten vergleichsweise umständlich: Zunächst muss das Druckbett komplett gereinigt werden. Im Anschluss wird das Tape diagonal auf die Platte geklebt. Hierbei ist zu beachten, dass weder ein Spalt zwischen, noch eine Überlappung von den Klebekanten entsteht. Diese würde sich sonst auf das Druckbett übertragen. Im nächsten Schritt müssen eventuell auftretende Lufteinschlüsse entfernt werden. Zum Schluss wird das überschüssige Tape abgeschnitten, damit dieses den Bewegungsablauf der Druckplatte nicht stört. 
 Blue Tape muss nicht nach jedem Druckvorgang gewechselt werden. Wann eine Neubeschichtung notwendig wird, liegt zum größten Teil im Ermessen des Anwenders. 
 Was passiert nach dem Druck? Zunächst wird empfohlen, das Objekt händisch zu entfernen. Die Temperatur von dem Druckbett wird hierzu leicht erhöht. Anschließend wird versucht, das Teil seitlich zu &quot;hebeln&quot;. Sollte dies nicht möglich sein, kann ein Spachtel oder Messer verwendet werden, um das Objekt vorsichtig zu lösen.&amp;nbsp; 
 Sollte sich der fertige Druck nicht lösen lassen, kann das Tape inklusive Bauteil von der Platte abgezogen. Bei extrem harten Fällen, in denen das Material zu stark am Tape klebt und das Tape selber kaum vom Druckbett zu lösen ist, schaffen Lösemittel wie Isopropanol Abhilfe.&amp;nbsp;  Wir empfehlen Bluetape vor allem Einsteigern, die kostengünstig in die Themenwelt 3D-Druck starten möchten.&amp;nbsp; 
  Klebestifte oder Klebespray  
 Klebestifte und Klebespray erfüllen auch im 3D-Druck Ihren Zweck. Sie kleben. Bei der Anwendung gibt es allerdings einige Unterschiede zwischen Stift und Spray. 
 Der klassische Klebestift wird auf dem Druckbett verteilt. Falls der Klebstoff ungleichmäßig aufgetragen wird, wird das Objekt allerdings auf einer unebenen Oberfläche gedruckt. Dadurch können Unregelmäßigkeiten beim Druck entstehen, schlimmstenfalls kann die Nozzle beschädigt werden. 
 Die Haftung von Druckobjekten wird verbessert, allerdings ist die anschließende Reinigung von dem Druckbett sehr aufwendig.&amp;nbsp; 
 Klebespray kann gleichmäßiger aufgetragen und leichter entfernt werden, da dieser meist wasserlöslich ist. Leider ist bei dieser Methode die Gesamthaftung nicht so stark ausgeprägt wie, bei anderen Methoden. 
  Kapton-Band  
 Zum Abschluss stelle ich eine Option vor, die fast ausschließlich mit einem sehr schönen Druckergebnis überzeugen kann. 
 Kapton-Band wird ähnlich wie Blue Tape auf die Druckplatte geklebt. Die Montage kann sehr aufwendig sein und viel Fingerspitzengefühl fordern. Aufgrund der Materialbeschaffenheit von Kapton entstehen sehr schnell Blasen und Falten. Dies führt zu einer unebenen Druckbettbeschichtung und einem schlechten Druckergebnis. 
 Ist die Montage und Nivellierung des Druckbetts geschafft, können die Vorteile dieser Beschichtung genossen werden. Vor allem ABS haftet sehr gut auf Kapton. Dies führt, in Verbindung mit den richtigen Druckeinstellungen, zu einer insgesamt sehr guten Druckqualität. 
 Auch das Entfernen von fertig gedruckten Objekten funktioniert bei einer, mit Kapton beschichteten, Druckplatte ohne Probleme. Allerdings muss das Band regelmäßig gereinigt und gewechselt werden. Dies ist mit einem vergleichsweise hohen Arbeits- und Zeitaufwand verbunden. 
  Preis  
 Natürlich spielen Kosten ebenfalls eine tragende Rolle bei der Entscheidung für oder auch gegen den Einsatz von verschiedenen Druckbettbeschichtungen. Im Folgenden werde ich einen kurzen Überblick über die einzelnen Preise geben. 
 Beginnen werde ich mit den günstigeren Varianten. Herkömmliche Klebestifte gibt es überall günstig zu kaufen. Speziell für den 3D-Druck ausgelegte Klebestifte- und Spray gibt es für unter 10,00 € im Internet zu finden. Laut Aussage einiger Hersteller soll eine Kaufeinheit für ca. 100 Druckvorgänge ausreichen. Somit fällt der Preis pro Druck sehr gering aus. 
 Zu den günstigeren Möglichkeiten zählt auch Blue Tape. Diese gibt es in unserem Onlineshop in verschiedenen Ausführungen zu kaufen. Der Preis pro Druck ist auch hier ziemlich gering, da mit einer einzelnen Rolle mehrere Beschichungsvorgänge durchgeführt werden können. 
 Kapton-Band findet Ihr in unserem Onlineshop ebenfalls in verschiedenen Variationen. Im Vergleich zum Blue Tape ist das Kapton Band etwas teurer, jedoch aufgrund der hervorragenden Druckergebnisse definitiv ein sinnvolles Investment. 
 Dauerdurckplatten bestechen durch Ihr sehr gutes Preis-Leitungs-Verhältnis. Die Variante ohne magnetische Grundplatte ist bei uns mit rauer oder glatter Oberfläche erhältlich. Aufgrund Ihrer Beständigkeit ist Preis pro Druck vergleichsweise niedriger als bei den anderen Optionen. 
  Fazit   
 Welche Beschichtung ist denn nun die beste? Eine einfache Antwort gibt es leider nicht auf diese Frage. Das Zusammenspiel einiger Faktoren ist jedoch ausschlaggebend, um eine individuelle Empfehlung aussprechen zu können. Zu diesen Faktoren gehören der Kenntnisstand des Nutzers, der verfügbare finanzielle und zeitliche Rahmen sowie das Ziel, mit dem Objekte im 3D-Druck angefertigt werden. 
 Für Einsteiger im Bereich 3D-Druck und Leute, die schlichtweg nicht ausreichend Zeit habe,n sich mit dem ständigen Wechsel von Druckbettbeschichtungen auseinanderzusetzten, lässt sich ganz klar die (magnetische) Dauerdruckplatte empfehlen.&amp;nbsp;Besonders die magnetische Druckbettbeschichtung hat den Vorteil, dass die Magnetfolie lediglich einmal aufgetragen werden muss. Ist die Beschichtung zu erneuern, muss lediglich die alte Platte getauscht werden. Kein Kleben, kein Entfernen von Kleberückstanden. 
 Für Nutzer, die mehr Zeit in Druckprojekte investieren können und wollen, ist das Blue Tape oder Kapton-Band zu empfehlen. Der Zweck, die bessere Haftung von gedruckten Bauteilen, wird bei beiden Möglichkeiten vollumfänglich erfüllt. Die erhöhte Zeit- und Aufwandsinvestition wird durch den geringeren Beschaffungspreis ausgeglichen. 
 Von dem Gebrauch herkömmlichen Klebestiften oder Haarspray kann ich persönlich nur abraten. Die Klebereste sind äußerst schwer zu entfernen und die enthaltenden Materialien können Schäden beim Auftragen verursachen, wenn sie außerhalb der Druckplatte auf das Gerät gelangen. Speziell für den 3D-Druck entwickelte Klebestifte und Klebespray haben im Internet gute Rezensionen bekommen. Allerdings bleibt der Wechsel der Klebeschicht nach jedem Druck bestehen, wodurch der Abreitsaufwand erhöht wird - häufig eine zu klebrige Angelegenheit. 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Luftkissenlandungsboot der WISENT-Klasse</title>
            <id>https://funduinoshop.com/luftkissenlandungsboot-der-wisent-klasse</id>
            <link href="https://funduinoshop.com/luftkissenlandungsboot-der-wisent-klasse"/>
            <summary type="html">
                <![CDATA[
                
                                            Auf vielen Modellschiff-Schaufahren sind die meisten Schiffe bis ins letzte Detail und in sehr hoher Qualität gebaut. Schade, dass das von den Zuschauern oft übersehen wird. Spektakuläre und nicht alltägliche Modelle...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Modellbau: Luftkissenlandungsboot der WISENT-Klasse &quot;LCAC – Landing Craft Air Cushion&quot; 
 Auf vielen Modellschiffschaufahren sind die meisten Schiffe bis ins letzte&amp;nbsp;Detail und in sehr hoher Qualität gebaut. Schade, dass das von&amp;nbsp;den Zuschauern oft übersehen wird. Spektakuläre und nicht alltägliche&amp;nbsp;Modelle ziehen schon eher die Aufmerksamkeit auf sich. Dazu gehören ohne&amp;nbsp;Zweifel die Luftkissenboote (Hovercraft).&amp;nbsp;Warum nicht mal das Größte seiner Art auch als Modell bauen?&amp;nbsp;Mit 550 Tonnen Verdrängung ist die Zubr-Klasse (Wisent-Klasse) ein Gigant.&amp;nbsp;Ein Plastikmodell gibt es in 1:110. Das war mir zu klein. 1:75 fand ich gerade&amp;nbsp;richtig. Also Eigenbau! 
 Luftkissenboot selber bauen: Aber wie? 
 Um sich in diese Materie einzulesen, war das Buch „RC Luftkissenboote“ von&amp;nbsp;K.Jackson &amp;amp; M.Porter vom VTH-Verlag eine wertvolle Hilfe. Welche technischen&amp;nbsp;Komponenten das Modell zum Schweben bringen sollte, musste ausprobiert&amp;nbsp;werden. Berechnungen waren hier wenig zielführend. Am Ende des Textes eine&amp;nbsp;Aufstellung der verwendeten Akku- und Antriebstechnik. Einen Bauplan zu&amp;nbsp;diesem Typ gibt es nicht, also mussten Fotos herhalten und es wurde viel&amp;nbsp;gerechnet. 
 Der Rohbau wurde mit einer PU-Schaum-Platte und einem Power-Kleber&amp;nbsp;aus dem Baumarkt bewerkstelligt. Das ging recht zügig voran. Ein 70 mm Impeller, der oft für Styropor-Modellflieger eingesetzt wird, soll den Wisent&amp;nbsp;zum „Hovern“ bringen. Die Luftschürze wird mit Rip-Nylon ausgeführt.&amp;nbsp;Ein Material, das bei Zeltplanen und bei Fallschirmspringern Verwendung&amp;nbsp;findet. 
 Die Stromversorgung des Luftkissenlandungsbootes 
 Bei der geplanten Größe von 900 x 400 mm war von vornherein klar, dass es kein Energiespar-Modell wird. Ein 18 V Akku mit 2,5 Ah aus dem&amp;nbsp;Werkzeugprogramm – kombiniert mit einem Spannungswandler – soll die gewünschte Spannung von gleichmäßig 12 V bereitstellen.&amp;nbsp;Ein zweiter Spannungswandler regelt die 12 V nochmal auf 9 V herunter&amp;nbsp;und liefert damit den Propeller und der nautischen Beleuchtung eine&amp;nbsp;gleichmäßige Spannung.&amp;nbsp;Somit erfolgt die gesamte Stromversorgung aus einem Akku.&amp;nbsp;Zwei der äußeren Propeller sind für den Vortrieb ausgelegt, der mittlere&amp;nbsp;Motor wurde umgepolt und dieser Propeller „verkehrt herum“ auf die  Antriebswelle gesteckt. Rückwärtsfahrten sind somit problemlos möglich.&amp;nbsp;Die drei Antriebsgondeln hat mir die Firma – Ray Haller aus Eibenstock – auf&amp;nbsp;dem 3D-Drucker gedruckt. Sie werden synchron von einem Servo angesteuert.&amp;nbsp;Dieses Antriebskonzept hat sich bewährt.&amp;nbsp;Die 3,5 Zoll (ca. 9 cm) Propeller stammen aus dem Ersatzteilsortiment für Quadcopter.&amp;nbsp;Trotz konsequenter Leichtbauweise bringt das Modell mit allen Einbauten&amp;nbsp;4,7 kg auf die Waage. Das macht ein Anlanden zwar möglich, aber für Fahrten&amp;nbsp;an Land ist es nicht geeignet. Auch das Original ist ja zu 99 % auf dem&amp;nbsp;Wasser unterwegs. Von diesem „Riesen-Wisent“ wurden 18 Stück gebaut.&amp;nbsp;Die Ukraine, Korea, Russland, China und Griechenland nutzten sie. 
 Verwendete Bauteile von 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 Regler wird zu heiß)  3x R5-E-4-3:  Ready ToSky 1306 KV3100 für 150er Quadcopter  3x R6-E-1-4:  Hobbywing SkyWalker 12AE Brushless ESC  2x R12-B-8-2:  DC-DC Step Down Modul 300W 20A 6-40V auf 1,2-36V  
 1x Akku 2,5 Ah 18 V von Einhell (Fahrzeit ca. 15 min) Gesteuert wird das Modell mit einer Carson 6-Kanal Fernsteuerung 2,4 GHz. 
                ]]>
            </content>

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

    
</feed>
