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

    
</feed>
