<?xml version="1.0" encoding="UTF-8" ?>
<feed xmlns="http://www.w3.org/2005/Atom">
    <link href="https://www.roboter-bausatz.de/c/projekte/?sAtom=1" rel="self" type="application/atom+xml" />
    <author>
        <name>Roboter-Bausatz.de</name>
    </author>
    <title>Blog / Atom Feed</title>
    <id>https://www.roboter-bausatz.de/c/projekte/?sRss=1</id>
    <updated>2026-05-26T10:00:19+02:00</updated>
    
        <entry>
            <title type="text">3D-gedrucktes Shadowbox LED-Herz für Valentinstag</title>
            <id>https://www.roboter-bausatz.de/projekte/3d-gedrucktes-shadowbox-led-herz-fuer-valentinstag</id>
            <link href="https://www.roboter-bausatz.de/projekte/3d-gedrucktes-shadowbox-led-herz-fuer-valentinstag"/>
            <summary type="html">
                <![CDATA[
                
                                            3D-gedrucktes LED-Herz als modulare Shadowbox für den Valentinstag. Mit wechselbaren Einsätzen, WS2812B LEDs und WLED steuerbar per Smartphone – ideal auch als Last-Minute-Geschenk.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Valentinstag gerettet: 3D-gedruckte Shadowbox in Herzform 
 Du brauchst  noch schnell ein besonderes Valentinstagsgeschenk , das nicht nach Tankstelle aussieht? Dieses  3D-gedruckte Shadowbox LED-Herz  ist ein echter Hingucker: modern, persönlich und mit ganz viel Liebe zum Detail. ❤️ 
 
 Verschiedene Motive zur Auswahl 
 Frei wählbare Farben 
 Sanfte Animationen 
 Steuerung per Smartphone oder Browser 
 Anpassbar ohne alles neu zu drucken 
 
 &amp;nbsp; 
 Das Herz besteht aus passgenau  3D-gedruckten Elementen  und wird von einem  WS2812B LED-Strip  zum Leuchten gebracht. Gesteuert wird alles über einen  D1 mini  mit der beliebten  WLED-Software , damit lassen sich Farben, Animationen und Stimmungen ganz einfach per Smartphone anpassen. Ob romantisches Rot, sanfter Farbverlauf oder individuelles Preset: Dein Herz leuchtet genau so, wie eure Liebe sich anfühlt. ✨ 
 Perfekt als  Last-Minute-Valentinstagsgeschenk , persönliches Deko-Highlight oder selbstgemachtes Präsent mit Wow-Effekt. 
 &amp;nbsp;  
 Individuell anpassbar – Bestimme dein persönliches Kitschlevel 
 Das Highlight dieser Shadowbox ist ihr  modulares Design . Der innere Einsatz lässt sich austauschen und damit auch der komplette Look. 
 Mögliche Einsätze sind zum Beispiel: 
 
  Skyline-Motive  für einen modernen, urbanen Stil 
   Schloss Neuschwanstein   für maximale Romantik 
   Halloween-Einsatz  , wenn es bewusst verspielt oder schräg sein darf 
 
 So wird aus dem klassischen Valentinstag Geschenk eine  Ganzjahres-Deko , die sich jederzeit an Anlass, Jahreszeit oder Geschmack anpassen lässt. 
 Bauanleitung &amp;amp; Druckdetails 
 Link zum Modell:  https://makerworld.com/en/models/156728-lovers-valentine-day-shadowbox#profileId-171742  
 
 Druckzeit ca. 8h 22m 
 Drucker: Bambu Lab X1C 
 Filament: 380g  yourDroid PLA Weiss , 22g  yourDroid PLA Rot  
 
 Benötigte Bauteile: 
 
  Warenkorb  
 D1 Mini ESP32 Board 
 Micro-USB Kabel mit An/Ausschalter 
 1 Paar 4 Pin JST-Kabel für LED-Streifen 
 Ca. 1m WS2812B LED Strip 
 Optional:&amp;nbsp; USB Netzteil  
 
 &amp;nbsp;Anschlussplan 
   
 Pinbelegung D1 Mini: 
 
 IO16 -&amp;gt; DIN 
 GND -&amp;gt; GND 
 5V -&amp;gt; 5V 
 
 Software 
 
 ESP32 Board per USB am PC anschließen 
  https://install.wled.me/ &amp;nbsp;aufrufen und auf  Install  drücken und dem Installationsprozess folgen. 
 ? Eine  Schritt-für-Schritt-Anleitung für WLED  findet Ihr  hier in unserem Blog , sodass auch Einsteiger problemlos starten können. 
 Wichtig: Zuerst testen und dann erst einbauen! 
 
 Aufbau 
 D1 Mini Board und LEDs mit doppelseitigem Klebeband auf die Backplate kleben und Kabel nach hinten ausführen. Einen roten Rahmen ans äußere Gehäuse anbringen und anschließend die Backplate einlegen. 
   
 Die restlichen Einsätze nacheinander einlegen und mit dem zweiten roten Rahmen verschließen 
   
 Einstecken und mit dem Smartphone steuern 
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">TM1637 mit Arduino ansteuern</title>
            <id>https://www.roboter-bausatz.de/projekte/tm1637-mit-arduino-ansteuern</id>
            <link href="https://www.roboter-bausatz.de/projekte/tm1637-mit-arduino-ansteuern"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Tutorial zeigen wir, wie Sie ein TM1637 4-Digit-Display einfach an einen Arduino anschließt und mit Beispielcode ansteuern.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 TM1637 4-Digit-Display am Arduino anschließen und ansteuern – Schritt für Schritt 
 Inhaltsverzeichnis 
 
  Benötigte Komponenten  
  Beschreibung  
  Funktionsweise  
  Pinbelegung  
  Anschlussplan  
  Ansteuerung mit Arduino 
 
  Benötigte Bibliothek  
  Grundfunktionen  
  Buchstaben und Symbole  
  Beispiel-Sketch „Nervöser Zähler“  
 
 
  Fehlerdiagnose  
 
 Benötigte Komponenten 
 
  Arduino UNO R3 kompatibles Board  
  TM1637 Modul &amp;nbsp; (Weiss, Blau   , Rot, Grün, Gelb)  
 4x  Buchse-Stecker Jumperkabel  
 
 Beschreibung 
 Das TM1637-Modul ist ein kompaktes 4-stelliges 7-Segment-LED-Display, das häufig in Arduino-Projekten zur Anzeige von Zahlen, Zeiten oder Zählerständen eingesetzt wird. Durch den integrierten TM1637-Treiberchip entfällt die direkte Ansteuerung der einzelnen Segmente, was den Hardware- und Programmieraufwand deutlich reduziert. 
 Das Modul benötigt nur  vier Anschlüsse : Versorgungsspannung ( 5V ),  GND  sowie die beiden Datenleitungen  CLK  (Clock) und  DIO  (Data). Dadurch ist es besonders übersichtlich zu verdrahten und eignet sich hervorragend für Einsteiger. 
 Funktionsweise 
 Die Kommunikation zwischen Arduino und TM1637 erfolgt über ein zweidrahtiges serielles Protokoll, das dem I²C-Prinzip ähnelt, jedoch herstellerspezifisch ist. Über die CLK-Leitung gibt der Arduino den Takt vor, während über DIO die Daten übertragen werden. 
 Der TM1637-Chip übernimmt intern die Multiplex-Ansteuerung der Segmente sowie die Helligkeitssteuerung des Displays. Der Arduino sendet lediglich die darzustellenden Zahlen oder Symbole, wodurch der benötigte Code sehr kompakt bleibt. 
 Dank passender Bibliotheken lässt sich das Display schnell initialisieren und mit wenigen Befehlen steuern – ideal für einfache Anzeigen in Mikrocontroller-Projekten. 
 &amp;nbsp; 
 Pinbelegung 
 
 
 
 
  Display  
 
 
  Arduino  
 
 
  Funktion  
 
 
 
 
  VCC  
 
 
 5V 
 
 
 3,3V-5V DC 
 
 
 
 
  GND  
 
 
 GND 
 
 
 Masse 
 
 
 
 
  CLK  
 
 
 Digital Pin 3 
 
 
 Taktsignal 
 
 
 
 
  DIO  
 
 
 Digital Pin 2 
 
 
 Bidirektionale Datenleitung 
 
 
 
 
 Anschlussplan 
   
 &amp;nbsp; 
 Ansteuerung mit Arduino 
 &amp;nbsp; 
 Benötigte Bibliothek 
 Arduino-IDE → Bibliotheksverwalter → suchen nach: 
 „TM1637Display“ von Avishay Orpaz 
 Grundfunktionen 
 Helligkeit einstellen (stufenweise von 0 bis 7) 
  display.setBrightness(7); &amp;nbsp; &amp;nbsp; // Helligkeit (0–7)  
 Ganze Zahl anzeigen 
  display.showNumberDec(1234); // Zahl anzeigen  
 Führende Nullen werden angezeigt, 42 -&amp;gt; 0042 
  display.showNumberDec(42, true); // → 0042  
 Anzeige löschen, schaltet alle Segmente aus 
  display.clear(); &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Anzeige löschen  
 Doppelpunkte ansteuern 
  display.showNumberDecEx(1234, 0b01000000, true); // Doppelpunkt EIN  
 Doppelpunkt blinken lassen 
  display.showNumberDecEx(1234, 0, true); &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp;// aus  
  display.showNumberDecEx(1234, 0b01000000, true); // an  
 Buchstaben und Symbole 
 
 Einige Symbole und Buchstaben lassen sich darstellen 
 Typische Beispiele: HELP, COOL, FAIL, ---- (Ladeanzeige) 
 
  uint8_t data[] = {  
  &amp;nbsp; SEG_H, SEG_E, SEG_L, SEG_L  
  };  
  display.setSegments(data);  
 &amp;nbsp;&amp;nbsp; 
 Beispiel-Sketch „Nervöser Zähler“ 
 
 zählt von 0000 bis 9999 
 der Doppelpunkt blinkt wie ein Herzschlag 
 bei  1337  bleibt er kurz stehen 
 
 &amp;nbsp; 
 #include &amp;lt;TM1637Display.h&amp;gt; &amp;nbsp; #define CLK 3 #define DIO 2 &amp;nbsp; TM1637Display display(CLK, DIO); &amp;nbsp; int counter = 0; bool colonOn = false; &amp;nbsp; void setup() { &amp;nbsp; display.setBrightness(7); } &amp;nbsp; void loop() { &amp;nbsp; // Doppelpunkt blinken lassen &amp;nbsp; colonOn = !colonOn; &amp;nbsp; &amp;nbsp; display.showNumberDecEx( &amp;nbsp; &amp;nbsp; counter, &amp;nbsp; &amp;nbsp; colonOn ? 0b01000000 : 0, // Doppelpunkt AN/AUS &amp;nbsp; &amp;nbsp; true &amp;nbsp; ); &amp;nbsp; &amp;nbsp; // Easter Egg ? &amp;nbsp; if (counter == 1337) { &amp;nbsp; &amp;nbsp; delay(2000); // kurz feiern &amp;nbsp; } &amp;nbsp; &amp;nbsp; counter++; &amp;nbsp; if (counter &amp;gt; 9999) counter = 0; &amp;nbsp; &amp;nbsp; delay(300); } 
 Fehlerdiagnose 
 ❌  Dezimalpunkt geht nicht   ➡️ normal, dieses Modul hat die DP-LEDs nicht angeschlossen 
 ❌  Anzeige bleibt dunkel   ➡️ VCC/GND vertauscht oder falsche Pins 
 ❌  Flackert   ➡️ zu lange Kabel → kürzer halten 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2026-02-03T00:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Anleitung ESP32 in Arduino IDE einrichten</title>
            <id>https://www.roboter-bausatz.de/projekte/anleitung-esp32-in-arduino-ide-einrichten</id>
            <link href="https://www.roboter-bausatz.de/projekte/anleitung-esp32-in-arduino-ide-einrichten"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitungen zeigen wir die Einrichtung und Programmierung eines ESP32 Entwicklungsboards in der Arduino IDE.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 ESP32 in der Arduino IDE einrichten 
 Voraussetzungen 
 
 Arduino IDE (Arduino IDE 2.x) 
 USB-Kabel zum Anschluss des ESP32 
 Ein ESP32-Board (z. B. ESP32 DevKit v1) 
 
 &amp;nbsp; 
 Schritt 1: Boardverwalter-URL hinzufügen 
 
 Öffne die Arduino IDE. 
 Gehe zu  Datei &amp;gt; Einstellungen .   
 Füge unter  Zusätzliche Boardverwalter-URLs  Folgendes ein:   https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json      Mehrere URLS können einfach mit Komma getrennt werden. 
 Klicke auf  OK . 
 
 Schritt 2: ESP32-Board installieren 
 
 Gehe zu  Werkzeuge &amp;gt; Board &amp;gt; Board-Verwaltung…     
 Suche nach  esp32 .   
 Wähle  &quot;esp32 by Espressif Systems&quot;  aus und klicke auf  Installieren . 
 
 Schritt 3: &amp;nbsp;ESP32 anschließen 
 
 Schließe deinen ESP32 per USB an den PC an. 
 Warte, bis er erkannt wird (ggf. Treiber installieren, z. B. CP210x oder CH340). 
 In der IDE: Gehe zu  Werkzeuge &amp;gt; Port  und wähle den passenden COM-Port aus. 
 
 Schritt 4: Board und Port wählen 
 
 Gehe zu  Werkzeuge &amp;gt; Board  und wähle das passende Board aus  z. B.  &quot;ESP32 Dev Module&quot; . 
 Wähle den  richtigen Port  aus (z. B. COM3 oder /dev/ttyUSB0). 
 
 Schritt 5:. Erstes Programm hochladen 
 
 Öffne das Beispiel:  Datei &amp;gt; Beispiele &amp;gt; 01.Basics &amp;gt; Blink  
 Passe ggf. die LED-Pin-Nummer an (LED_BUILTIN → meist GPIO 2 bei ESP32): 
 
 void setup() { 
 &amp;nbsp; pinMode(2, OUTPUT); // GPIO 2 
 } 
 &amp;nbsp; 
 void loop() { 
 &amp;nbsp; digitalWrite(2, HIGH); 
 &amp;nbsp; delay(1000); 
 &amp;nbsp; digitalWrite(2, LOW); 
 &amp;nbsp; delay(1000); 
 } 
 3. Klicke auf den  Haken  (Überprüfen) und dann auf den  Pfeil  (Hochladen). 
 &amp;nbsp; 
  Hinweis:   Wenn der Upload hängt, drücke während des &quot;Connecting...&quot; den Boot-Knopf am ESP32, bis der Upload startet.  
 Fertig! 
 Die LED auf dem ESP32 sollte jetzt im Sekundentakt blinken – dein ESP32 läuft! 
 ESP32 ins WLAN einbinden 
 Voraussetzungen 
 
 WLAN-Name (SSID) 
 WLAN-Passwort 
 
 Beispielcode um WLAN-Verbindung herzustellen: 
 #include &amp;lt;WiFi.h&amp;gt; &amp;nbsp;// Bibliothek für ESP32 WLAN 
 &amp;nbsp; 
 const char* ssid = &quot;DEIN_SSID&quot;; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // &amp;lt;-- Dein WLAN-Name 
 const char* password = &quot;DEIN_PASSWORT&quot;; // &amp;lt;-- Dein WLAN-Passwort 
 &amp;nbsp; 
 void setup() { 
 &amp;nbsp; Serial.begin(115200); 
 &amp;nbsp; delay(1000); 
 &amp;nbsp; 
 &amp;nbsp; Serial.println(&quot;Verbinde mit WLAN...&quot;); 
 &amp;nbsp; WiFi.begin(ssid, password); 
 &amp;nbsp; 
 &amp;nbsp; while (WiFi.status() != WL_CONNECTED) { 
 &amp;nbsp; &amp;nbsp; delay(500); 
 &amp;nbsp; &amp;nbsp; Serial.print(&quot;.&quot;); 
 &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; Serial.println(&quot;&quot;); 
 &amp;nbsp; Serial.println(&quot;WLAN verbunden!&quot;); 
 &amp;nbsp; Serial.print(&quot;IP-Adresse: &quot;); 
 &amp;nbsp; Serial.println(WiFi.localIP()); 
 } 
 &amp;nbsp; 
 void loop() { 
 &amp;nbsp; // Hier kannst du z. B. Sensorwerte senden oder einen Webserver starten 
 } 
 &amp;nbsp; 
 &amp;nbsp; 
 So verwendest du den Code 
 
 Öffne die Arduino IDE. 
 Ersetze DEIN_SSID und DEIN_PASSWORT im Sketch mit deinen WLAN-Daten. 
 Hochladen auf den ESP32. 
 Öffne den  seriellen Monitor  (Baudrate 115200), um den Verbindungsstatus und die IP-Adresse zu sehen. 
 
 Was kannst du mit dem Code machen? 
 
 Einen  Webserver  auf dem ESP32 starten 
 Daten an einen  MQTT-Broker  senden 
 Einen  IoT-Sensor  ins Heimnetz einbinden 
 
 &amp;nbsp; 
 Weitere Beispielcodes 
 Wenn das Board ESP32 eingestellt ist, findest du unter „Datei – Beispiele „ jede Menge praktische Codes zum Ausprobieren. 
 Besonders praktisch sind die Codes unter „Datei – Beispiele - WIFI“ wie z. B. der Wifiscan. Der WIFI-Scanner startet das ESP32 Modul im Scan-Modus und sucht nach verfügbaren WLANs, zeigt deren Name, Signalstärke und Verschlüsselung an. 
 &amp;nbsp;  
 In der Liste ganz runter bis WiFi scrollen 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">3D-gedruckte Löthilfe</title>
            <id>https://www.roboter-bausatz.de/projekte/3d-gedruckte-loethilfe</id>
            <link href="https://www.roboter-bausatz.de/projekte/3d-gedruckte-loethilfe"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Blogbeitrag zeigen wir dir, wie du mit einer 3D-gedruckten Löthilfe Y-Kabel aus Dupont-Kabeln für dein nächstes Arduino-Projekt selbst baust.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Auf  Makerworld  entdeckt und sofort gedacht: „Das muss ich mir mal genauer anschauen!“ Besonders für Arduino-Projekte ist dieses 3D-gedruckte Modell eine super Hilfe. Mit dieser Löthilfe gelingt dir der Bau von Y-Kabeln aus Dupont-Kabeln im Handumdrehen.&amp;nbsp;Aber das ist noch nicht alles: Diese Löthilfe eignet sich auch perfekt als „dritte Hand“ für alle anderen Lötarbeiten, bei denen du präzise und stabile Verbindungen herstellen möchtest. 
 Was ist ein Y-Kabel und wofür brauchst du es? 
 Ein Y-Kabel kommt immer dann zum Einsatz, wenn du mehrere Bauteile an dein Arduino anschließen möchtest. Typischerweise hat ein Arduino nur einen Stromversorgungspin (VCC) und einen GND-Pin. Wenn du allerdings ein Display und einen Drehencoder an dein Arduino anschließen möchtest, benötigst du ein Y-Kabel, um beide Komponenten gleichzeitig zu verbinden. 
  Hier findest du unsere Videoanleitung, wie du ein Y-Kabel baust:     
 Schritt-für-Schritt-Anleitung zum Bau eines Y-Kabels: 
  Schritt 1: Planung der Verbindungen  Zuerst musst du sicherstellen, welche Bauteile du miteinander verbinden willst. In meinem Fall möchte ich ein Display und einen Drehencoder mit dem Arduino verbinden. Dafür brauchst du einen Stecker, um diesen an die Pinleiste des Arduinos anzuschließen, sowie zwei Female-Buchsen. 
  Schritt 2: Vorbereitung der Kabel  Jetzt besorgst du dir die nötigen Kabel und schneidest ein Female-to-Female-Kabel in der Mitte durch. Dann crimpe die Enden der Kabel. Wenn alle Kabel richtig vorbereitet sind, verdrille die Drähte der Female-Kabel. 
  Schritt 3: Schrumpfschlauch anbringen (optional)  Nun kannst du einen Schrumpfschlauch über das Kabel ziehen, um später eine saubere Isolierung zu erreichen. Das ist nicht zwingend notwendig, aber es sorgt dafür, dass alles ordentlich aussieht und besser geschützt ist. 
  Schritt 4: Die 3D-gedruckte Löthilfe einsetzen  Nun kommt die 3D-gedruckte Löthilfe ins Spiel. Stecke die Kabel in die vorgesehenen Halterungen – so hält die Löthilfe das Kabel fest, als wäre sie eine dritte Hand. Heize deinen Lötkolben auf 350 bis 400 Grad Celsius vor und halte ihn unter das Kabel. Leg das Lötzinn (ich benutze 0,5 mm Lötzinn, aber 1 mm funktioniert auch) oben auf die Kabel. Der Lötkolben schmilzt das Lötzinn und verbindet die Drähte miteinander. 
  Schritt 5: Schrumpfschlauch verwenden  Sobald die Kabel miteinander verbunden sind und die Lötstelle abgekühlt ist, kannst du das gelötete Kabel vorsichtig aus der Halterung nehmen. Jetzt schiebe den Schrumpfschlauch über die gelötete Stelle und erhitze ihn mit einem Feuerzeug. Falls du kein Feuerzeug zur Hand hast, kannst du auch den Lötkolben dafür verwenden. Der Schrumpfschlauch wird so fixiert und schützt deine Lötstellen. 
 Fazit: 
 Mit dieser einfachen Methode und der Unterstützung der 3D-gedruckten Löthilfe kannst du ganz leicht ein Y-Kabel für dein Arduino-Projekt bauen.&amp;nbsp;Aber auch wenn du keine Y-Kabel erstellst, ist die Löthilfe eine geniale Unterstützung für alle anderen Lötarbeiten. 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2025-04-01T12:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">DIY Arduino Lautstärkemixer</title>
            <id>https://www.roboter-bausatz.de/projekte/diy-arduino-lautstaerkemixer</id>
            <link href="https://www.roboter-bausatz.de/projekte/diy-arduino-lautstaerkemixer"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Blogbeitrag stellen wir euch den Open-Source Arduino Läutstärkemixer DEEJ vor.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 DEEJ - Der&amp;nbsp;DIY Arduino Lautstärkemixer für Gaming, Streaming &amp;amp; Office 
 Wer kennt es nicht; man ist am Zocken, Musikhören oder Streamen und will den Lautstärke-Pegel einer oder mehrerer Apps anpassen... Mit diesem  Open-Source-Projek t gehört dieses Problem bald deiner Vergangenheit an! Wir zeigen dir, wie du mit einem Arduino und mehreren Reglern die Lautstärke verschiedener Anwendungen auf deinem Windows- oder Linux-PC steuern kannst. 
 Was ist DEEJ? 
 DEEJ ist ein hardware Lautstärkemixer, der aus einem Arduino-basierten Controller und einer Anwendung besteht.&amp;nbsp; Mit DEEJ kannst du eine mehrere Regler an deinem PC anschließen, um die Lautstärke einzelner Anwendungen intuitiv und präzise zu steuern. Dadurch hast du jederzeit die Kontrolle über deine Audioumgebung, ohne aus deiner aktuellen Anwendung tabben zu müssen.  
  Wie funktioniert DEEJ?  
  Die Funktionsweise ist recht einfach: Der Arduino wird mit den Reglern und deinem PC verbunden, laden den Sketch auf deinen Arduino, starte die DEEJ-Anwendung und ordne deine Progrmame den einzelnen Reglern zu. Schon kannst du die Lautstärke deiner Anwendungen mit den Reglern steuern wie ein DJ!  
  Was wird benötigt?  
 
  Nano V3 Board kompatibel mit Arduino  
 5  Schiebepotentiometer  
 1x&amp;nbsp;  Anschlusskabel   
 1x&amp;nbsp; Aderleitungen  
 5x M3x10 Schrauben 
 7x M3x20 Schrauben 
 Gehäuse aus dem 3D-Drucker -&amp;gt;  STL  
  (Ein Gehäuse aus Karton oder Holz geht auch!)  
   DEEJ Software   
 
  Anschlussplan  
 &amp;nbsp;  
       
 
 
 Potentiometer 
 Nano Board 
 
 
 OTA1 
 A0 
 
 
 OTA2 
 A1 
 
 
 OTA3 
 A2 
 
 
 OTA4 
 A3 
 
 
 OTA5 
 A4 
 
 
 GND 
 GND 
 
 
 VCC 
 5V 
 
 
 
  Aufbauanleitung  
 
  Duponkabel an OTA (Abgriff A) aller Potentiometer anstecken und ins Gehäuse montieren.  
  VCC und GND aller Potentiometer verbinden. Das Kabel an den ersten Poti löten und für die nächsten immer ein Stück abisoliert und auflöten.&amp;nbsp;Ich habe hierfür Aderleitungen mit Silikonmantel genommen, da man diese gut abisolieren kann und sie beim Löten nicht schmoren.  
  Kabel der Potentiometer an das Nano Board anlöten.       
  Nano Board mit dem PC verbinden und den DEEJ Sketch hochladen.   
 
  Konfiguration  
     
  Öffne die config.yaml mit einem Texteditor und schreibe beim Slider Mapping  deine gewünschten Programme  herein. Es können auch Systemlautstärke (Master) oder der ganze Name eines Geräts angegeben werden (z.B. Lautsprecher oder Mikrofon).  
  Anschließend  COM-Port des Nano  Boards (kannst du im Gerätemanager oder in der Arduino IDE nachschauen) hinterlegen und das Programm starten. Schon kannst du stressfrei die Lautstärke deiner Anwendungen steuern!  
     
                ]]>
            </content>

                            <updated>2024-06-07T00:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Digitale Zeiterfassung mit Arduino</title>
            <id>https://www.roboter-bausatz.de/projekte/digitale-zeiterfassung-mit-arduino</id>
            <link href="https://www.roboter-bausatz.de/projekte/digitale-zeiterfassung-mit-arduino"/>
            <summary type="html">
                <![CDATA[
                
                                            Ein Arduino-basiertes Zeiterfassungssystem ist eine kostengünstige und einfache Lösung zur Erfassung und Verwaltung von Arbeitszeiten. Dieses DIY-Projekt nutzt ein Arduino-Board, ein RFID-Modul und eine Echtzeituhr (RTC), um die An- und Abwesenheit von Mitarbeitern zu registri...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 DIY-Projekt zur digitalen Zeiterfassung mit Arduino 
   
 Einleitung 
 In diesem DIY-Projekt werden wir ein digitales Zeiterfassungssystem bauen. Mit Hilfe eines Arduino-Boards und verschiedenen Komponenten wie einem RFID-Leser, einem OLED-Display und einem Datalogger-Shield mit RTC (Echtzeituhr) können wir die An- und Abwesenheitszeiten von Mitarbeitern erfassen und speichern. 
 Verwendete Bauteile 
 
  yourDroid UNO R3 Entwicklungsboard ATMEGA328P-PU arduino kompatibel  
  Datalogger Shield für Arduino mit RTC  
  RFID Set MFRC522 - Kartenleser + Mifare Transponder/Karte  
  1.3&quot; OLED Display I2C/IIC/TWI 128x64 Pixel für Arduino  
  Aktiver Buzzer 3,3V-5V  
  Drucktaster Button Schalter Rot 12mm 250V 1A  
  Drucktaster Button Schalter Grün 12mm 250V 1A  
  40 Pin Dupont / Jumper Kabel Buchse-Stecker 10 cm  
 Ein 3D-gedrucktes Gehäuse (die .stl-Datei wird bereitgestellt) 
 Eine SD Karte 
 
 Aufbau 
 Verkabelung 
 
  Arduino UNO R3 : Verbinden Sie das Arduino-Board mit Ihrem Computer über ein USB-Kabel. 
  Datalogger Shield : Stecken Sie das Datalogger Shield auf das Arduino-Board. 
  RFID-Leser :
 
 SDA -&amp;gt; Pin 7 
 SCK -&amp;gt; Pin 13 
 MOSI -&amp;gt; Pin 11 
 MISO -&amp;gt; Pin 12 
 IRQ -&amp;gt; Nicht verbunden 
 GND -&amp;gt; GND 
 RST -&amp;gt; Pin 9 
 3.3V -&amp;gt; 3.3V 
 
 
  OLED Display :
 
 VCC -&amp;gt; 5V 
 GND -&amp;gt; GND 
 SDA -&amp;gt; A4 
 SCL -&amp;gt; A5 
 
 
  Buzzer :
 
 VCC -&amp;gt; Pin 4 
 GND -&amp;gt; GND 
 
 
  Drucktaster :
 
 Roter Taster (gehen) -&amp;gt; Pin 3 und GND 
 Grüner Taster (kommen) -&amp;gt; Pin 2 und GND 
 
 
 
   
 Gehäuse 
 Drucken Sie das Gehäuse mit einem 3D-Drucker. Die .stl-Datei können Sie hier herunterladen:  TIMETRACKERPQQMQh97MkH7l  
 Programmierung 
 Laden Sie den folgenden Code auf Ihr Arduino-Board:&amp;nbsp; TIMETRACKER.ino     
 
 
 
 
 /#include &quot;MFRC522.h&quot; 
 #include &quot;SPI.h&quot; 
 #include &quot;SdFat.h&quot; 
 #include &quot;RTClib.h&quot; 
 #include &quot;SSD1306Ascii.h&quot; 
 #include &quot;SSD1306AsciiWire.h&quot; 
 &amp;nbsp; 
 // Name des RTC-Moduls 
 RTC_DS3231 rtc; 
 &amp;nbsp; 
 // Adressierung des OLED-Displays 
 #define I2C_ADDRESS 0x3C 
 &amp;nbsp; 
 // Buttons definieren 
 #define greenButton 2 
 #define redButton 3 
 &amp;nbsp; 
 // RFID Anschlüsse definieren 
 #define SDA 7 
 #define RST 9 
 &amp;nbsp; 
 // Name des OLED-Displays 
 SSD1306AsciiWire oled; 
 &amp;nbsp; 
 // Bezeichnung der SD-Karte 
 SdFat SD; 
 &amp;nbsp; 
 // Bezeichnung der CSV-Datei 
 File Zeiterfassung; 
 &amp;nbsp; 
 // RFID-Empfänger benennen und Pins zuordnen 
 MFRC522 mfrc522(SDA, RST); 
 &amp;nbsp; 
 // Pin der SD-Karte 
 int DatenPin = 10; 
 &amp;nbsp; 
 // Pin des Buzzer 
 int buzzer = 4; 
 &amp;nbsp; 
 // Wert zum Auslesen der Aktivität 
 int ButtonValue = 0; 
 &amp;nbsp; 
 // Variable zum Verfolgen der RFID-Aktivität 
 bool rfidGelesen = false; 
 &amp;nbsp; 
 // Trennzeichen für die CSV-Datei 
 const String TrennZeichen = &quot;,&quot;; 
 &amp;nbsp; 
 String Mitarbeiter; 
 &amp;nbsp; 
 void setup() { 
 &amp;nbsp; &amp;nbsp; Serial.begin(9600); 
 &amp;nbsp; &amp;nbsp; SPI.begin(); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // OLED mit 128x64 Pixeln starten 
 &amp;nbsp; &amp;nbsp; Wire.begin(); 
 &amp;nbsp; &amp;nbsp; oled.begin(&amp;amp;Adafruit128x64, I2C_ADDRESS); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Schriftart festlegen 
 &amp;nbsp; &amp;nbsp; oled.setFont(Arial14); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; kommen gehen&quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; &quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Zur Zeiterfassung&quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Taste druecken!&quot;)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Initialisierung des RFID-Empfängers 
 &amp;nbsp; &amp;nbsp; mfrc522.PCD_Init(); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Buttons als Input deklarieren 
 &amp;nbsp; &amp;nbsp; pinMode(greenButton, INPUT_PULLUP); 
 &amp;nbsp; &amp;nbsp; pinMode(redButton, INPUT_PULLUP); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Buzzer als Output deklarieren 
 &amp;nbsp; &amp;nbsp; pinMode(buzzer, OUTPUT); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // RTC-Modul starten 
 &amp;nbsp; &amp;nbsp; if (!rtc.begin()) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;RTC Initialisierung fehlgeschlagen!&quot;)); 
 &amp;nbsp; &amp;nbsp; } else if (rtc.lostPower()) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Setze die Uhrzeit nur, wenn die RTC ihre Zeit verloren hat 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; rtc.adjust(DateTime(F(__DATE__), F(__TIME__))); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;RTC Uhrzeit eingestellt!&quot;)); 
 &amp;nbsp; &amp;nbsp; } else { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;RTC bereit und Uhrzeit korrekt!&quot;)); 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // SD-Karte starten 
 &amp;nbsp; &amp;nbsp; if (!SD.begin(DatenPin)) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;Initialisierung fehlgeschlagen!&quot;)); 
 &amp;nbsp; &amp;nbsp; } else { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;SD-Karte gestartet!&quot;)); 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // rtc.now() -&amp;gt; aktuelle Zeit holen 
 &amp;nbsp; &amp;nbsp; DateTime aktuell = rtc.now(); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Format des Datums festlegen 
 &amp;nbsp; &amp;nbsp; char Datum[] = &quot;DD.MM.YYYY&quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Datum in String umwandeln und anzeigen 
 &amp;nbsp; &amp;nbsp; Serial.print(aktuell.toString(Datum)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Format der Zeitangabe festlegen 
 &amp;nbsp; &amp;nbsp; char Zeit[] = &quot;hh:mm:ss&quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Zeitangabe in String umwandeln und anzeigen 
 &amp;nbsp; &amp;nbsp; Serial.print(aktuell.toString(Zeit)); 
 } 
 &amp;nbsp; 
 void loop() { 
 &amp;nbsp; &amp;nbsp; // Wenn grüner Button gedrückt wird 
 &amp;nbsp; &amp;nbsp; if (digitalRead(greenButton) == LOW) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; kommen&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; &quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Karte an das&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Lesegeraet halten!&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; ButtonValue = 1; // Setze ButtonValue auf 1 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, HIGH); // Ton an 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; delay(100); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, LOW); // Ton aus 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; delay(1000); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; rfidGelesen = true; // Erlaube das Lesen des RFID-Chips 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Wenn roter Button gedrückt wird 
 &amp;nbsp; &amp;nbsp; if (digitalRead(redButton) == LOW) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; gehen&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; &quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Karte an das&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Lesegeraet halten!&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; ButtonValue = 2; // Setze ButtonValue auf 2 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, HIGH); // Ton an 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; delay(100); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, LOW); // Ton aus 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; delay(1000); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; rfidGelesen = true; // Erlaube das Lesen des RFID-Chips 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Wenn RFID-Chip noch nicht gelesen wurde und einer der Buttons gedrückt wurde 
 &amp;nbsp; &amp;nbsp; if (rfidGelesen == false) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; return; // Warte auf Button-Druck 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // vom RFID ermittelter Wert der Karte als Folge von Dezimalzahlen 
 &amp;nbsp; &amp;nbsp; String WertDEZ; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // String Mitarbeiter löschen, damit falsche Karte erkannt wird 
 &amp;nbsp; &amp;nbsp; Mitarbeiter = &quot;&quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Wenn keine Karte in Reichweite ist 
 &amp;nbsp; &amp;nbsp; if (!mfrc522.PICC_IsNewCardPresent()) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // wird die Abfrage wiederholt. 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; return; 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Wenn kein RFID-Sender ausgewählt wurde 
 &amp;nbsp; &amp;nbsp; if (!mfrc522.PICC_ReadCardSerial()) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // wird die Abfrage wiederholt. 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; return; 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;Karte entdeckt!&quot;)); 
 &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, HIGH); // Ton an 
 &amp;nbsp; &amp;nbsp; delay(100); 
 &amp;nbsp; &amp;nbsp; digitalWrite(buzzer, LOW); // Ton aus 
 &amp;nbsp; &amp;nbsp; delay(1000); 
 &amp;nbsp; &amp;nbsp; // Dezimal-Werte in String WertDEZ schreiben 
 &amp;nbsp; &amp;nbsp; for (byte i = 0; i &amp;lt; mfrc522.uid.size; i++) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; WertDEZ = WertDEZ + String(mfrc522.uid.uidByte[i], DEC) + &quot; &quot;; 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // dezimalen Wert anzeigen 
 &amp;nbsp; &amp;nbsp; Serial.println(&quot;Wert in dezimal: &quot; + WertDEZ); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Leerzeichen am Ende entfernen 
 &amp;nbsp; &amp;nbsp; WertDEZ.trim(); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; /* 
 &amp;nbsp; &amp;nbsp; Karten abfragen und Namen der Mitarbeiter*innen zuordnen 
 &amp;nbsp; &amp;nbsp; Dezimal-Werte durch Namen 
 &amp;nbsp; &amp;nbsp; */ 
 &amp;nbsp; &amp;nbsp; if (WertDEZ == &quot;227 211 219 29&quot;) Mitarbeiter = &quot; Max Mustermann&quot;; 
 &amp;nbsp; &amp;nbsp; if (WertDEZ == &quot;147 50 48 28&quot;) Mitarbeiter = &quot; Maxi Musterfrau&quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Namen abfragen 
 &amp;nbsp; &amp;nbsp; if (Mitarbeiter == &quot; Max Mustermann&quot; || Mitarbeiter == &quot; Maxi Musterfrau&quot;) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Daten in die Datei schreiben 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; DatenSchreiben(); 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // bei falscher Karte 
 &amp;nbsp; &amp;nbsp; else { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;Falsche Karte!&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.print(F(&quot; Falsche Karte!&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; delay(2000); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; kommen gehen&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; &quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Zur Zeiterfassung&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Taste druecken!&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; ButtonValue = 0; 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; rfidGelesen = false; 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Pause, damit die Daten nicht mehrfach geschrieben werden 
 &amp;nbsp; &amp;nbsp; delay(2000); 
 } 
 &amp;nbsp; 
 void DatenSchreiben() { 
 &amp;nbsp; &amp;nbsp; // Meldungen im Seriellen Monitor 
 &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;Schreibe Daten in Zeiterfassung.csv ... &quot;)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Name der Mitarbeiter*in 
 &amp;nbsp; &amp;nbsp; Serial.println(&quot;Mitarbeiter*in: &quot; + Mitarbeiter); 
 &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;-----------------------------&quot;)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // rtc.now() -&amp;gt; aktuelle Zeit holen 
 &amp;nbsp; &amp;nbsp; DateTime aktuell = rtc.now(); 
 &amp;nbsp; &amp;nbsp; char Datum[] = &quot;DD.MM.YYYY &quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Datum in String umwandeln und anzeigen 
 &amp;nbsp; &amp;nbsp; Serial.print(aktuell.toString(Datum)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Format der Zeitangabe festlegen 
 &amp;nbsp; &amp;nbsp; char Zeit[] = &quot;hh:mm:ss&quot;; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Zeitangabe in String umwandeln und anzeigen 
 &amp;nbsp; &amp;nbsp; Serial.println(aktuell.toString(Zeit)); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Ausgabe OLED 
 &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; oled.println(Mitarbeiter); 
 &amp;nbsp; &amp;nbsp; oled.println(aktuell.toString(Datum)); 
 &amp;nbsp; &amp;nbsp; oled.println(aktuell.toString(Zeit)); 
 &amp;nbsp; &amp;nbsp; delay(2000); 
 &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; oled.print(F(&quot; Gespeichert!&quot;)); 
 &amp;nbsp; &amp;nbsp; delay(2000); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Reset für den nächsten Durchlauf 
 &amp;nbsp; &amp;nbsp; rfidGelesen = false; 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; /* 
 &amp;nbsp; &amp;nbsp; FILE_WRITE - Datei zum Schreiben öffnen 
 &amp;nbsp; &amp;nbsp; wenn die Datei noch nicht existiert, wird sie neu erstellt 
 &amp;nbsp; &amp;nbsp; ansonsten werden neuen Daten ans Ende angehängt 
 &amp;nbsp; &amp;nbsp; */ 
 &amp;nbsp; &amp;nbsp; Zeiterfassung = SD.open(&quot;Zeiterfassung.csv&quot;, FILE_WRITE); 
 &amp;nbsp; &amp;nbsp; if (Zeiterfassung) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Überschrift nach jedem Datensatz wiederholen 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;Mitarbeiter*in:&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;Datum:&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;Zeit&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;Aktion&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.println(); 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Daten in die Datei schreiben: Mitarbeiter*in, Datum, Zeit und Aktion 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; // Werte durch Trennzeichen (,) trennen 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(Mitarbeiter); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(Datum); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(Zeit); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(TrennZeichen); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; if (ButtonValue == 1) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;kommen&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; } else if (ButtonValue == 2) { 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.print(F(&quot;gehen&quot;)); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.println(); 
 &amp;nbsp; &amp;nbsp; &amp;nbsp; &amp;nbsp; Zeiterfassung.println(); 
 &amp;nbsp; &amp;nbsp; } 
 &amp;nbsp; 
 &amp;nbsp; &amp;nbsp; // Datei schließen 
 &amp;nbsp; &amp;nbsp; Zeiterfassung.close(); 
 &amp;nbsp; &amp;nbsp; Serial.println(F(&quot;Speichern abgeschlossen.&quot;)); 
 &amp;nbsp; &amp;nbsp; Serial.println(); 
 &amp;nbsp; &amp;nbsp; delay(200); 
 &amp;nbsp; &amp;nbsp; // Reset für den nächsten Durchlauf 
 &amp;nbsp; &amp;nbsp; ButtonValue = 0; 
 &amp;nbsp; &amp;nbsp; oled.clear(); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; kommen gehen&quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; &quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Zur Zeiterfassung&quot;)); 
 &amp;nbsp; &amp;nbsp; oled.println(F(&quot; Taste druecken!&quot;)); 
 } 
 &amp;nbsp; 
 
 
 
 
 Anleitungsvideo mit Funktion 
    
 #include &amp;lt;Wire.h&amp;gt;#include &amp;lt;RTClib.h&amp;gt; RTC_DS3231 rtc; void setup() {&amp;nbsp; Serial.begin(9600);&amp;nbsp; Wire.begin();&amp;nbsp;&amp;nbsp;&amp;nbsp; if (!rtc.begin()) {&amp;nbsp; &amp;nbsp; Serial.println(&quot;RTC konnte nicht gefunden werden!&quot;);&amp;nbsp; &amp;nbsp; while (1);&amp;nbsp; } &amp;nbsp; // RTC auf das Kompilierdatum und -zeit einstellen&amp;nbsp; rtc.adjust(DateTime(F(__DATE__), F(__TIME__)));&amp;nbsp; Serial.println(&quot;RTC erfolgreich auf das Kompilierdatum und -zeit eingestellt!&quot;);} void loop() {&amp;nbsp; // Hier können weitere Anweisungen eingefügt werden} 
 &amp;nbsp; 
                ]]>
            </content>

                            <updated>2024-05-29T15:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">DIY-Elektronik Set für automatische Pflanzenbewässerung</title>
            <id>https://www.roboter-bausatz.de/projekte/diy-elektronik-set-fuer-automatische-pflanzenbewaesserung</id>
            <link href="https://www.roboter-bausatz.de/projekte/diy-elektronik-set-fuer-automatische-pflanzenbewaesserung"/>
            <summary type="html">
                <![CDATA[
                
                                            Möchten Sie Ihre Pflanzen optimal pflegen, selbst wenn Sie mal nicht zu Hause sind? Wir stellen euch eine Lösung mit DIY-Elektronik vor!
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Möchten Sie Ihre Pflanzen optimal pflegen, selbst wenn Sie mal nicht zu Hause sind? Unser DIY-Elektronik Set für Automatische Pflanzenbewässerung ist die perfekte Lösung für grüne Daumen und Hobby-Maker, die ihre Pflanzen liebevoll pflegen möchten, ohne sich ständig Sorgen machen zu müssen.  
  Dieses Set ermöglicht es Ihnen, eine intelligente Bewässerungslösung zu erstellen, die die Feuchtigkeit Ihrer Pflanzen überwacht und automatisch bewässert, sobald es nötig ist.  
  Benötigte Komponenten  
 1x DIY-Elektronik Set für automatische Pflanzenbewässerung bestehend aus: 
 
 Feuchtigkeitssensor + Anschlussplatine 
 DC-USB Kabel 
 1m PVC-Schlauch 
 1 Kanal Relais 
 Dupontkabel 
 DC-Pumpe 
 Batteriegehäuse 
 
 Pinbelegung 1 Kanal Relais 5V 
   
 
  NO (Normally Open): &amp;nbsp;Bei der NO-Konfiguration ist das Relais immer offen. Es fließt kein Strom, bis ein Signal den Stromkreis schließt. 
  COM: &amp;nbsp;Gemeinsamer Pin 
  NC (Normally Closed): &amp;nbsp;Bei der NC-Konfiguration, ist das Relais standardmäßig geschlossen. Es fließt Strom, bis ein Signal den Stromkreis öffnet. 
 
 Pinbelegung Sensorplatine 
   
 
 VCC -&amp;gt; Stromversorgung mit 3,3 – 5V 
 GND -&amp;gt; GND (Masse) 
 DO -&amp;gt; Digital Output (Digitaler Signal-Ausgang) 
 AO -&amp;gt; Analog Output (Analoger Signal-Ausgang –  Wird bei diesem Set nicht angeschlossen ) 
 
 Anschlussplan 
   
 Anleitung 
 
 Relais und Anschlussplatine des Sensors mit 5V und GND verbinden 
 Schwarzes Kabel der Pumpe (GND) ans schwarze Kabel der 5V Stromversorgung anschließen 
 Rotes Kabel der Pumpe an NO des Relais anschließen 
 Anschlussplatine D0 an den IN-Pin des Relais anschließen 
 Anschlussplatine mit dem Sensor verbinden 
 
 Mit dem Potentiometer an der Platine kann die Empfindlichkeit eingestellt werden, ab wann das Relais die Pumpe einschalten soll. 
                ]]>
            </content>

                            <updated>2024-02-23T09:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">WS2812B LEDs mit ESP32 WLED steuern</title>
            <id>https://www.roboter-bausatz.de/projekte/ws2812b-leds-mit-esp32-wled-steuern</id>
            <link href="https://www.roboter-bausatz.de/projekte/ws2812b-leds-mit-esp32-wled-steuern"/>
            <summary type="html">
                <![CDATA[
                
                                            Heute tauchen wir ein in die faszinierende Welt der adressierbaren WS2812B RGB-LEDs und zeigen dir, wie du sie mit Leichtigkeit mithilfe eines ESP32 und der beeindruckenden WLED-Software steuern kannst. Erfahre, wie du mit nur wenigen Schritten atemberaubende Lichteffekte per ...
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                    
 Die adressierbaren&amp;nbsp;   WS2812B bzw. „Neopixel  “ werden häufig in blinkenden und leuchtenden Arduino oder Raspberry Pi Projekten verwendet. Sie können mit Bibliotheken programmiert werden oder mit Fernbedienungen gesteuert werden – aber was, wenn man seine Ambientebeleuchtung gemütlich von der Couch mit dem Smartphone einstellen möchte?&amp;nbsp;Hier kommt die WLED-App ins Spiel: Eine kostenlose Open Source Lösung zur Steuerung von RGB LEDs mit unendlich vielen vorprogrammierten Abläufen und Konfigurationsmöglichkeiten. 
 WLED Features 
 
 Sehr einfach zu installieren &amp;amp; bedienen 
 WS2812FX Bibliothek mit über 100 Effekten 
 FastLED noise Effekte und 50 Paletten 
 Modernes UI mit Smartphone Apps 
 Konfiguration &amp;amp; Steuerung über WLAN 
  Home-Assistant Integration  
 Bis zu 10 LED Outputs pro ESP32 
 
 Benötigte Komponenten 
 Alles, was wir dafür brauchen, ist ein beliebiges ESP32 Board und WS2812B LED-Strips. 
 Falls Sie mehr als ca. 1m LEDs anschließen möchten, wird noch eine Externe Stromversorgung benötigt. Hier die Übersicht der Teile: 
 
  ESP32  
 WS2812B LED-Strip  1m  /  5m  
  5V Netzteil &amp;nbsp;(3A oder mehr empfohlen) 
  Hohlstecker Adapter  
  Dupontkabel Buchse-Stecker  
 
 WLED auf dem ESP32 installieren 
 Für die Installation der WLED Firmware gibt es eine tolle Webseite, die die komplette Installation auf dem ESP32 für uns übernimmt. 
 
 ESP32 Board per USB am PC anschließen 
  https://install.wled.me/  aufrufen und auf Install drücken.   
 COM-Port auswählen   
 WLED Installation durchführen lassen.   
 Netzwerkverbindung herstellen.   
 Visit device anklicken   
 Am besten Sie speichern sich die Adresse im Browser, bis wir die Lokale Adresse eingestellt haben.   
 Config aufrufen -&amp;gt; LED Preferences.     Dort können Sie bei  max. current  die Stromaufnahme begrenzen, bei einem&amp;nbsp; 3A Netzteil z.B. 2.8A eingeben, um einen Puffer zu haben. Bei  length &amp;nbsp;geben Sie die Anzahl der LEDs ein, die Anzahl der LEDs erscheint nochmal ganz oben. 
 Als nächstes zurück zur Config und Wifi Setup auswählen.   Hier können Sie bei&amp;nbsp;  mDNS address  eine Adresse vergeben, die Sie im Browser aufrufen können, solange Sie sich im selben Netzwerk befinden. Wenn Sie &quot; WLED-Wohnzimmer &quot; eingeben können Sie Ihre WLED App unter &quot;http:// WLED-Wohnzimmer .local&quot; aufrufen, das macht es Ihnen einfacher als die IP-Adresse abzutippen.  
 Nun können Sie mit Geräten im selben Netzwerk die IP Adresse oder mDNS Adresse des ESP32 im Browser eingeben und WLED Oberfläche aufrufen. 
 
 WLED Smartphone Apps 
 Für Android- und iOS-Geräte finden Sie hier die passenden Apps: 
 
  WLED Native (iOS AppStore)  
  WLED (Android Playstore)  
 
 Die Installation geht sehr einfach von der Hand. Hier das Beispiel unter Android: 
   
   
   
   
 Anschlussplan 
 In unserem Beispiel verwenden wir GPIO 02 zum Ansteuern der LEDs, den Pin können Sie aber jeder Zeit in den Einstellungen ändern. Wenn Sie nur 1m (60 LEDs) anschließen und die Strombegrenzung auf 850mA lassen, benötigen Sie kein Netzteil als externe Stromversorgung und können das Board einfach per USB betreiben. 
   
 &amp;nbsp; 
 Für mehr LEDs (&amp;gt;1A) benötigen Sie ein Netzteil als externe Stromversorgung. Um die Schaltung sorgen- und störungsfrei zu betreiben, empfehlen wir noch einen 470 Ohm Widerstand und einen kleinen Elektrolyt-Kondensator für die Schaltung. Der 470 Ohm Widerstand kommt an die Datenleitung zwischen GPIO und DIN, dies dient dazu den GPIO zu schonen. Der Kondensator z.B. 1000uF kommt zwischen + und - der Stromversorgung und dient als Puffer für Stromschwankungen. Der genaue Wert des Kondensators ist nicht so wichtig, ein etwas kleinerer oder größerer Wert funktioniert genauso gut. 
   
                ]]>
            </content>

                            <updated>2024-01-31T08:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Die besten Seiten für 3D-Druck Modelle 2026</title>
            <id>https://www.roboter-bausatz.de/projekte/die-besten-seiten-fuer-3d-druck-modelle-2026</id>
            <link href="https://www.roboter-bausatz.de/projekte/die-besten-seiten-fuer-3d-druck-modelle-2026"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Beitrag stellen wir Ihnen die besten Webseiten und Alternativen zu Thingiverse vor, um 3D-Druck Modelle zu Downloaden.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Kostenlose 3D-Druck-Modelle 2026 - Wo findet man STL &amp;amp; 3MF Dateien? 
 Wer  3D-Modelle zum Drucken  sucht, hat 2026 mehr Auswahl denn je. Neben bekannten Plattformen wie Thingiverse gibt es zahlreiche  Webseiten für kostenlose STL- und 3MF-Dateien , aber auch professionelle Marktplätze für hochwertige Premium-Modelle. 
 In diesem Artikel zeigen wir dir  die besten Seiten für 3D-Druck-Dateien , praktische Suchmaschinen und Tipps, worauf du beim Download achten solltest. 
 STL Suchmaschinen - Wer suchet, der findet! 
 Yeggi – Die Suchmaschine für 3D-Druck-Modelle 
  https://www.yeggi.com &amp;nbsp;Yeggi durchsucht zahlreiche Webseiten gleichzeitig und ist ideal, um  kostenlose STL-Dateien  oder  3MF-Modelle  schnell zu vergleichen. 
 H3: STL Finder 
  https://www.stlfinder.com &amp;nbsp;STL Finder ist eine spezialisierte Suchmaschine für  druckbare 3D-Modelle  und besonders hilfreich bei funktionalen Teilen. 
 Vorgestellte Webseiten 
 Printables (ehemals Prusaprinters.org) 
  https://www.printables.com/de  ist die Community Seite und 3D-Modell Datenbank von&amp;nbsp; Prusa , dem original Hersteller vom Prusa i3 3D-Drucker. Hier tummelt sich eine aktive Community rund um das Thema 3D-Druck. Erwähnenswert sind die regelmäßigen Design Wettbewerbe, bei denen tolle Modelle entstehen, die von einer Jury bewertet werden. Die Sieger erhalten Goodies und Gutscheine für den Prusa Shop und alle Nutzer können die Modelldateien kostenlos herunterladen. 
 Makerworld von Bambu Lab 
  https://makerworld.com/ &amp;nbsp;ist die 3D-Modelldatenbank von Bambu Lab. Die Seite lockt mit fertigen  .3mf Dateien für die Bambu Lab Drucker  inkl. Integration des hauseigenen  Bambu Studios . Interessant für jeden sind aber die tollen,  oft mehrfarbigen Modelle , die Creators hochladen. Durch ein ausgeklügeltes Belohnungsprogramm sind Designer besonders Motiviert Ratings zu sammeln, um sich von den angesammelten Punkten Rabatte im Bambu Store zu ergattern. Neben dem Punkte sammeln gibt es auch ständig  Wettbewerbe mit Preisen , die dazu beitragen, dass das Repertoire der Seite stetig mit qualitiv hochwertigen Modellen wächst.&amp;nbsp; 
 Thangs3D 
  https://thangs.com/ &amp;nbsp;ist die am schnellsten wachsende Seite rund um das Thema 3D-Druck Dateien. Hier finden Sie kostenlose Modelle aller Kategorien. Eine großer Pluspunkt ist die sehr gut funktionierende&amp;nbsp; 3D-Ansicht von Modellen , so kann man vor dem Herunterladen schauen, ob das Modell den Erwartungen entspricht. 
 Thingiverse 
  https://www.thingiverse.com &amp;nbsp;besitzt die meisten Modelle online und ist die allererste Anlaufstelle für 3D-Druck Dateien. Alle Dateien sind kostenlos verfügbar und manche Designer lassen sich durch Spenden finanzieren. 
 Die besten Alternativen zu Thingiverse 
  Thangs&amp;nbsp; und&amp;nbsp; Printables &amp;nbsp;sind zur Zeit die besten Alternativen zu Thingiverse. Seit 2020 wird Thingiverse von technischen Problemen geplagt und ist immer wieder nicht erreichbar. Die aggressive Werbestrategie und das blockieren von Adblockern hat ebenfalls viele Nutzer vergrault. Zum Umgehen der Pop-Up Blocker Sperre, können sie einfach &quot;/zip&quot; hinter die URL eingeben und die Dateien wie gewohnt herunterladen. 
 MyMiniFactory 
  https://www.myminifactory.com/ &amp;nbsp;bietet kostenlose und bezahlte Modelle an. Es ist die  Anlaufstelle für Brettspiele und Miniaturen  für z.B. DnD, Warhammer (40K) und andere Tabletops. Ein großer Vorteil an dieser Seite ist die aktive Community und Design Competitions.&amp;nbsp; 
 YouMagine 
  https://www.youmagine.com/ &amp;nbsp;ist eine Seite für Open Source Modelle. Hier finden sich viele Community Designs und tolle Projekte. 
 Cult3D 
  https://cults3d.com &amp;nbsp;wird immer bekannter für die großartige Qualität und künstlerische Vielfalt von 3D-Modellen. Auf dieser Plattform werden vor Allem Freunde der Kunst, Dekoration und Cosplay fündig.  Neben vielen kostenlosen Modellen, gibt es auch extrem detaillierte, hochwertige Modelle zum Kaufen. Die Preise variieren hier stark und hängen oft vom Detailgrad der Modelle ab. 
 GRABCAD 
  https://grabcad.com &amp;nbsp;ist eine Community für Ingenieure, die CAD-Dateien benötigen. Gegen eine kostenlose Registrierung können Sie hier alle Möglichen technischen Teile als CAD-Datei herunterladen und für Ihre 3D-Modelle verwenden. 
  Die CAD-Dateien lassen sich nicht 3D-drucken und sind zum Designen gedacht!  
 Smithsonian 
  https://3d.si.edu/ &amp;nbsp;ist auf Kunst und Bildung spezialisiert. Die Seite hat sich zur Aufgabe gemacht, Artefakte und andere historische Gegenstände aus Museen aus aller Welt zu 3D-scannen und als druckbares 3D-Modell anzubieten. 
 NIH 3D Print Exchange 
  https://3dprint.nih.gov/ &amp;nbsp;ist eine Seite von Bildungsinstituten für medizinische und wissenschaftliche 3D-Modelle. Sehr speziell, aber interessant. 
 traceparts 
  https://www.traceparts.com/de &amp;nbsp;ist eine riesige Ansammlung an mechanischen Komponenten zum herunterladen als CAD, STEP oder STL-Datei. Die STL-Dateien auf dieser Seite können Sie direkt ausdrucken, die zahlreiche andere Formate sind zum Designen von eigenen Modellen. 
 Shapeways 
  https://www.shapeways.com &amp;nbsp;Eigentlich ein Marktplatz zum kaufen gedruckter Modelle (als Druckaufträge), jedoch lassen sich viele Modelle nach einer kostenlosen Registrierung ebenfalls kostenlos herunterladen. Besonderes Highlight ist hier der  DM-Workshop  für Tabletop &amp;amp; Wargaming Modelle wie Dungeons &amp;amp; Dragons. 
 Lizensierte und kostenpflichtige Modelle 
 Desweiteren gibt es noch viele kostenpflichtige Anlaufstellen hochwertiger 3D-Modell für Figuren aus Spielen, Filmen, Comics und Animes. 
 Kurz und knapp unsere Favoriten:&amp;nbsp;https://www.sanix3d.com/&amp;nbsp;und&amp;nbsp; https://www.gambody.com/  
                ]]>
            </content>

                            <updated>2024-01-29T00:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Print yourDroid</title>
            <id>https://www.roboter-bausatz.de/projekte/print-yourdroid</id>
            <link href="https://www.roboter-bausatz.de/projekte/print-yourdroid"/>
            <summary type="html">
                <![CDATA[
                
                                            Druck dir unser Maskottchen
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Die Druckdateien für unseren Droiden (Marvin) 
  MARVIN.stl  
  MARVIN.3mf     
  &amp;nbsp;  
  &amp;nbsp;  
  &amp;nbsp;  
                ]]>
            </content>

                            <updated>2023-11-23T00:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Halloween SPECIALS zum Drucken</title>
            <id>https://www.roboter-bausatz.de/projekte/halloween-specials-zum-drucken</id>
            <link href="https://www.roboter-bausatz.de/projekte/halloween-specials-zum-drucken"/>
            <summary type="html">
                <![CDATA[
                
                                            Drucke deinen Hexenkessel, Krähe oder Horrorhände
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                   Du weißt nicht, was du drucken sollst? Wir wärs mit dem schaurig schönen Hexenkessel mit Beleuchtung? Schnell gebaut, toller Effekt!    
 Alles was du dazu brauchst sind 
 
  Schwarzes PLA Filament  
  Grünes PLA Filament  
  Kupfer-Filament  
  LED Modul  
  Arduino Board  
 
 Danach losdrucken, Licht einbauen und Halloween kann kommen! 
   Oder doch lieber die gruselige  Krähe ? Hier benötigst du lediglich  LED´S  für die Augen und einen  Batteriehalter  - und schon hast du die perfekte Dekoration.    
 Einfach nur drucken?&amp;nbsp; Die  Horrorhände  sind schnell gemacht und ein Hingucker für jede Halloweenparty. 
                ]]>
            </content>

                            <updated>2023-10-20T15:45:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Arduino HC-SR501 Bewegungsmelder mit Sound</title>
            <id>https://www.roboter-bausatz.de/projekte/arduino-hc-sr501-bewegungsmelder-mit-sound</id>
            <link href="https://www.roboter-bausatz.de/projekte/arduino-hc-sr501-bewegungsmelder-mit-sound"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung erstellen wir einen interaktiven Bewegungsmelder mit HC-SR501 Sensor, der bei erkannter Bewegung einen Sound abspielt. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  Interaktiver Arduino Bewegungsmelder mit Sound  
 Schwierigkeitsgrad: Einfach 
 Benötigte Komponenten: 
 
  Arduino Uno kompatibles Board  
  HC-SR501 Bewegungssensor  
  DFPlayer Mini Mp3 Modul  
  Lautsprecher  
  Jumperkabel  
 1k Widerstand (oder kleiner) 
 USB-Kabel zum Anschließen des Arduinos an den Computer 
 Computer mit Arduino IDE 
 Stromversorgung: 5-12V Batteriehalter oder&amp;nbsp; DC-Netzteil  
 
 Benötigtes Werkzeug: 
 
 Lötkolben 
 
 Der Lötkolben wird nur benötigt, falls ein Kabel an den Lautsprecher gelötet werden muss. 
 Übersicht 
 In dieser Anleitung erstellen wir einen interaktiven Bewegungsmelder, der bei erkannter Bewegung einen Sound abspielt.  Wenn jemand sich nähert, wird der Bewegungsmelder aufgeweckt und ertappt den Eindringling in flagranti!&amp;nbsp; Der Bewegungsmelder nutzt einen Arduino Uno R3 als Hauptsteuereinheit, einen HC-SR501 Bewegungssensor zur Bewegungserkennung, ein DFPlayer Mini Audio Modul zur Soundwiedergabe und einen Lautsprecher, um den Sound wiederzugeben. Wir werden Dupont-Kabel und ein Breadboard verwenden, um die Komponenten zu verbinden und die Schaltung zu erstellen. 
  Das Konzept ist einfach: Sobald jemand den Raum betritt oder sich darin bewegt, erfasst der HC-SR501 Bewegungssensor die Aktivität und sendet ein Signal an den Arduino Uno. Aber hier kommt der spaßige Teil - mit dem DFPlayer Mini Audio Modul wird über die Lautsprecher eine Sounddatei ausgegeben. Dadurch ist dieses Projekt vielseitig einsetzbar z.B. als Kühlschrank-Alarm, Eintrittshymne für&#039;s Büro, Eingangsbereich-Empfang, uvm.  
 Als Lautsprecher können Sie auch einen beliebigen Lautsprecher aus alten Geräten verwenden, wir haben uns für einen kleinen  0,5W 8 Ohm Lautsprecher  entschieden. 
  Verkabelung  
   Verbinde den HC-SR501 Bewegungssensor und das DFPlayer Mini Audio Modul mithilfe der Dupont-Kabel mit dem Arduino Uno R3 auf dem Breadboard. Achte darauf, die Verbindungen richtig herzustellen und die Pins der verschiedenen Komponenten korrekt anzuschließen.   
  HC-SR501  
 
  VCC -&amp;gt; 5V  
  Signal (mittlerer Pin) -&amp;gt;Arduino D2  
  GND -&amp;gt; GND  
 
  Mit den beiden Potis kannst du die Haltedauer und die Reichweite des Bewegungsmelders einstellen. Tipp: Jumper gesetzt lassen.Haltedauer komplett gegen den Uhrzeigersinn drehen und Reichweite komplett im Uhrzeigersinn schrauben.  
  DFPlayer Mini  
     
 
  TX -&amp;gt; Arduino D10  
 RX -&amp;gt; Arduino D11 
 SPK 1 -&amp;gt; Lautsprecher + 
 SPK 2- -&amp;gt; Lautsprecher - 
 GND -&amp;gt; GND 
 VCC -&amp;gt; 5V 
 
 Anschlussplan 
   
 Programmierung 
  Öffne den  Bewegungsmelder Sketch   &amp;nbsp;mit der Arduino IDE&amp;nbsp;und lade ihn auf dein Arduino Board hoch. Für den Sketch wird die&amp;nbsp;DFPlayerMini_Fast.h Bibliothek benötigt.  
 Lade deine .MP3 oder .WAV Dateien auf eine MicroSD-Karte (max. 32GB). 
 Ergebnis 
  Mit diesem DIY-Bewegungsmelder mit Sound hast du eine interaktive und unterhaltsame Möglichkeit geschaffen, auf Bewegungen in einem Raum oder an einem bestimmten Ort aufmerksam zu machen. Es bietet auch die Möglichkeit, kreative Soundeffekte oder Musik im Wohnraum oder deinen DIY-Projekten zu integrieren. Lasse deiner Fantasie freien Lauf und experimentiere mit verschiedenen Sounds und Konfigurationen, um das Projekt deinen Vorlieben anzupassen.  
  Fehlerbehebung  
  Sollte es mal nicht auf Anhieb funktionieren, hier einige hilfreiche Tipps zur Fehlersuche.  
  HC-SR501 löst nicht aus&amp;nbsp;  
 
 
 
 Den Jumper des Moduls können Sie zwischen H und L setzen,&amp;nbsp; im &quot;H&quot;-Modus bleibt das Signal so lange aktiv, wie eine Bewegung erkannt wird, während im &quot;L&quot;-Modus das Signal nur einmal gesendet wird, auch wenn weiterhin Bewegung erkannt wird.&amp;nbsp; 
 Die Potentiometer auf dem HC-SR501-Modul regeln die Empfindlichkeit und die Zeit, wie lange das Signal am Ausgang bleibt. Drehen Sie die Potentiometer mal auf beide Extreme, um zu sehen, ob sich das Verhalten ändert.&amp;nbsp;&amp;nbsp; 
 
 
 DFPlayer spielt nichts ab 
 
 
  Formatieren Sie die SD-Karte erneut im FAT32 Format.  
  Die SD-Karte darf nicht mehr als 32GB Kapazität haben.  
 Testen Sie eine kleinere MP3 Datei mit gängiger Bitrate wie z.B. 128 kbps, um Codec-Probleme auszuschließen. 
 Testen Sie einen anderen Lautsprecher, um einen defekten Lautsprecher auszuschließen. 
 Überprüfen Sie den verwendeten Widerstand.&amp;nbsp;Der RX-Pin des DFPlayer Mini ist für 3,3V TTL-Pegel ausgelegt, während der Arduino 5V TTL verwendet, ohne einen Widerstand mit ~1K Ohm funktioniert die Kommunikation nicht. 
 Stellen Sie sicher, dass keine lockeren Verbindungen bestehen, insbesondere bei Steckverbindungen. 
 
 
 
                ]]>
            </content>

                            <updated>2023-07-20T08:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Unser neues Metalldetektor-Bundle!</title>
            <id>https://www.roboter-bausatz.de/projekte/unser-neues-metalldetektor-bundle</id>
            <link href="https://www.roboter-bausatz.de/projekte/unser-neues-metalldetektor-bundle"/>
            <summary type="html">
                <![CDATA[
                
                                            Entdecken Sie mit diesem Bundle die aufregende Welt des Metalldetektors und genießen Sie stundenlanges Suchvergnügen! 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                   Unser neues Metalldetektor-Bundle!   
 Entdecken Sie mit diesem Bundle die aufregende Welt des Metalldetektors und genießen Sie stundenlanges Suchvergnügen!&amp;nbsp; 
 Das Bundle besteht aus: 
 
  1x Bausatz Metalldetektor zum Löten &amp;nbsp; 
  1x Batteriehalter für 3x AA Batterien 4.5V mit An/Aus-Schalter &amp;nbsp; 
  1x Batteriebox für 10 AA Batterien  
 
  Zusammengesetzt ist das Bundle aus dem Metalldetektor Bausatz. Dieser Bausatz lässt sich ganz leicht zusammenbauen und Löten. Die entsprechenden Markierungen auf der Platine zeigen auf, an welche Stelle die Bauteile kommen. Der Metalldetektor ist mit einem Buzzer ausgestattet, welcher ausschlägt, wenn sich möglicherweise ein Schatz in der Nähe befindet.&amp;nbsp;&amp;nbsp; 
 Wenn Sie noch keine Lötstation besitzen, empfehlen wir Ihnen unsere Lötstation  1x yourDroid regelbare Lötstation 48W ZD-99 mit Zubehör . Damit haben Sie alles, was Sie zum Löten benötigen.&amp;nbsp; 
 Um die Stromversorgung zu gewährleisten, ist bei dem Bundle ein Batteriehalter für 3x AA-Batterien enthalten. Das Gehäuse ist mit einem An/Aus-Schalter ausgestattet, damit Sie den Detektor auch ausschalten können, wenn die Schätzjagd vorbei ist oder Sie eine kleine Trinkpause einlegen möchten. &amp;nbsp; 
 Falls auf der Strecke mal der Saft der Batterien ausgeht, gibt es bei dem Bundle eine Batteriebox für 10 weitere Batterien dazu. So ist die Stromversorgung auch für längere Ausflüge gesichert&amp;nbsp; 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Parksensor mit Arduino Uno, HC-SR04 und LED-Ring</title>
            <id>https://www.roboter-bausatz.de/projekte/parksensor-mit-arduino-uno-hc-sr04-und-led-ring</id>
            <link href="https://www.roboter-bausatz.de/projekte/parksensor-mit-arduino-uno-hc-sr04-und-led-ring"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung bauen wir eine Einparkhilfe mit einem Arduino Uno, HC-SR04 Ultraschallsensor und einem 24-Bit LED Ring als Anzeige.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                  DIY-Anleitung -&amp;nbsp; Parksensor mit Arduino, HC-SR04 und WS2812B Neopixel Ring  
 Schwierigkeitsgrad: Einfach 
 Benötigte Komponenten: 
 
  Arduino Uno kompatibles Board  
  HC-SR04 Ultraschallsensor  
  WS2812B (Neopixel) Ring (24 LEDs)  
  Jumperkabel  
 USB-Kabel zum Anschließen des Arduinos an den Computer 
 Computer mit Arduino IDE 
 Stromversorgung: 5-12V Batteriehalter oder  DC-Netzteil  
 
 Benötigtes Werkzeug: 
 
 Lötkolben 
  Optional : 3D-Drucker (für HC-SR04 Gehäuse) 
 
 Übersicht 
  In dieser Anleitung zeigen wir dir, wie du einen Parksensor mit einem Arduino, einem HC-SR04 Ultraschall-Abstandssensor und einem WS2812B Neopixel Ring baust. Mit diesem Projekt kannst du eine visuelle Anzeige erstellen, die sich von Grün nach Rot füllt und rot blinkt, wenn der Abstand zu einem Objekt zu gering wird. Der Parksensor hilft dir dabei, Objekte in deiner Nähe zu erkennen und bietet eine praktische Lösung zum Einparken oder zur Vermeidung von Kollisionen.  
    Verkabelung &amp;amp; Anschlussplan    
 
 
 Schließe den HC-SR04 an den Arduino an: 
 
 Verbinde den VCC-Pin des HC-SR04 mit dem 5V-Pin des Arduino. 
 Verbinde den GND-Pin des HC-SR04 mit dem GND-Pin des Arduino. 
 Verbinde den Trig-Pin des HC-SR04 mit dem digitalen Pin 6 des Arduino. 
 Verbinde den Echo-Pin des HC-SR04 mit dem digitalen Pin 5 des Arduino. 
 
 
 
 Schließe den Neopixel Ring an den Arduino an: 
 
 
 Verbinde den VCC-Pin des Neopixel Rings mit dem 5V-Pin des Arduino. 
 Verbinde den GND-Pin des Neopixel Rings mit dem GND-Pin des Arduino. 
 Verbinde den DIN-Pin (Data Input) des Neopixel Rings mit Pin 4 des Arduino. 
 
 
   
 Arduino Code hochladen 
 Öffne den&amp;nbsp; parksensor Sketch &amp;nbsp;mit der Arduino IDE&amp;nbsp;und lade ihn auf dein Arduino Board hoch. Für den Sketch werden die beiden  Bibliotheken  &quot; NewPing &quot; und &quot; Adafruit Neopixel &quot; benötigt, Sie finden die beiden Bibliotheken in der Arduino IDE zur Installation unter &quot;Sketch - Bibliothek einbinden -&amp;gt; Bibliotheken verwalten...&quot; 
 Funktionsweise 
 Der HC-SR04 Ultraschallsensor misst kontinuerlich den Abstand, der Arduino UNO wertet die Daten des Sensors aus und lässt den LED-Ring entsprechend aufleuchten. Ist das Objekt weit genug weg, leuchten die WS2812B LEDs im Neopixel Ring grün auf.&amp;nbsp;Je näher das Objekt kommt, desto mehr werden die LEDs rot aufleuchten. Sobald der Abstand zu gering wird, beginnt der Neopixel Ring rot zu blinken, um anzuzeigen, dass ein Hindernis in der Nähe ist und Vorsicht geboten ist.&amp;nbsp;Das ermöglicht es uns, den Parksensor effektiv als visuelle Hilfestellung beim Einparken oder zur Vermeidung von Kollisionen zu verwenden. 
   
   
                ]]>
            </content>

                            <updated>2023-07-03T00:00:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Entdecke den ultimativen DIY-MP3-Player!</title>
            <id>https://www.roboter-bausatz.de/projekte/entdecke-den-ultimativen-diy-mp3-player</id>
            <link href="https://www.roboter-bausatz.de/projekte/entdecke-den-ultimativen-diy-mp3-player"/>
            <summary type="html">
                <![CDATA[
                
                                            Mit diesem DIY-MP3-Player-Bundle ganz einfach eigene kleine wunderbare Soundanlage zusammenbauen
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 
 
 Entdecke den ultimativen DIY-MP3-Player! 
 mit unserem DIY-MP3-Player-Bundle kannst du deine eigene kleine wunderbare Soundanlage zusammenbauen. Perfekt für jung und alt! 
 Das Bundle besteht aus:&amp;nbsp; 
 
 1x  MP3 Audiomodul  
 1x  yourDroid Netzteil für Raspberry Pi DC 5V 2.5A Micro-USB &amp;nbsp; 
 1x  Mini Lautsprecher 40mm 4 Ohm 3W &amp;nbsp; 
 1x  1 Meter Silikonkabel 22 AWG flexibel Schwarz+Rot &amp;nbsp; 
 
 &amp;nbsp; 
 Dieses tolle Bundle besteht einmal aus dem MP3 Audiomodul, welches Ihnen eine reibungslose und kristallklare Musikwiedergabe ermöglicht. Schließen Sie einfach Ihre Playlist per USB oder MicroSD-Karte an das Modul an. Zusätzlich erhält man in dem Bundle das yourDroid Netzteil für Raspberry Pi DC 5V 2.5A Micro-USB, mit dem eine zuverlässige Stromversorgung zu dem MP3-Player sichergestellt ist. Um den Sound deines Players zu verbessern, enthält das Bundle auch einen Mini-Lautsprecher, für deutlich besseren und satten Klang zu bekommen. Um mit dem Basteln direkt anfangen zu können, wird das Bundle von dem Silikonkabel komplementiert. So kann man ganz leicht das Modul mit den Lautsprechern verbinden&amp;nbsp; 
 So verbindest du die Artikel miteinander:&amp;nbsp; 
 
 Verwende das Silikonkabel, um den Audioeingang des Lautsprechers mit dem entsprechenden Anschluss des Audiomoduls zu verbinden. Achte darauf, die richtigen Kanäle zu verbinden (Schwarz für GND, Rot für den Audioeingang).&amp;nbsp; 
 Schließe das yourDroid Netzteil an eine geeignete Stromquelle an und verbinde es mit dem Micro-USB-Anschluss des MP3-Audiomoduls.&amp;nbsp; 
 Sobald alles korrekt verbunden ist, kannst du deine Lieblings-MP3-Dateien auf einer Micro-SD-Karte/Micro-USB speichern und in den entsprechenden Steckplatz des MP3-Audiomoduls einlegen.&amp;nbsp; 
 Schalte das System ein, und schon kannst du den Klang deines selbstgebauten MP3-Players genießen. Steuere die Wiedergabe über die entsprechenden Tasten oder Knöpfe des MP3-Audiomoduls.&amp;nbsp; 
  
 
                ]]>
            </content>

                            <updated>2023-06-29T15:30:00+02:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">Arduino Drehteller mit gedruckten Teilen</title>
            <id>https://www.roboter-bausatz.de/projekte/arduino-drehteller-mit-gedruckten-teilen</id>
            <link href="https://www.roboter-bausatz.de/projekte/arduino-drehteller-mit-gedruckten-teilen"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung bauen wir einen arduino-gesteuerten Drehteller mit Teilen aus dem 3D-Drucker.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Gedruckte Teile (STL Download  Drehteller &amp;nbsp; Base mit DC-Buchse  ) 
 Arduino Nano kompatibles Board + USB-Kabel 
 28BYJ-48 Schrittmotor 
 ULN2003 Treiber 
 5V Netzteil 
 Ein-/Ausschalter 
 DC-Einbaubuchse 
 2 M3 Schrauben 
 4x 608zz Kugellager (8x22x7mm) 
 
 Benötigtes Werkzeug 
 
 Optional: Doppelseitiges Klebeband oder Heißkleber 
 3D-Drucker 
 Lötkolben 
 Schraubendreher 
 Abisolierzange 
 
 Beschreibung 
 Dieses Projekt basiert auf  diesem Design , welches auf Thingiverse zum Download verfügbar ist. Wir haben das Projekt herausgesucht und gedruckt, weil wir ansprechende Aufnahmen für kleine Bausätze und Artikel erstellen wollten. Hierfür war dieser Drehteller perfekt geeignet und die Dateien wanderten fix an den 3D-Drucker. 
 Das Design setzt auf einen  Arduino Nano  mit einem günstigen  28BYJ-48 Schrittmotor , der sich für diesen Zweck perfekt eignet. Durch die ULN2003  Treiberplatine  lässt sich der Schrittmotor, wie in diesem Beitrag beschrieben, super einfach ansteuern und programmieren. 
   
 Die Bodenplatte haben wir angepasst und eine Bohrung für eine  DC-Einbaubuchse  hinzugefügt, damit man sein Netzteil auch für andere Zwecke verwenden kann. Ohne diese Bohrung für die Buchse, müsste man den Stecker vom Netzteil opfern. 
   
 Druckparameter 
 
 3D-Drucker: Ender-5 Plus 
 Filament: yourDroid PLA+ (Weiss) 
 Düsentemperatur: 210°C / 200°C 
 Heizbetttemperatur: 60°C 
 Layerhöhe: 0,24 mm 
 Infill: 15% 
 
 Anschlussplan 
 &amp;nbsp;  
 
 
 
 
   ULN2003 Platine   
 
 
   Arduino   
 
 
 
 
   IN1   
 
 
  Pin 8  
 
 
 
 
   IN2   
 
 
  Pin 9  
 
 
 
 
   IN3   
 
 
  Pin 10  
 
 
 
 
   IN4   
 
 
  Pin 11  
 
 
 
 
   +   
 
 
  VIN  
 
 
 
 
   -   
 
 
  GND  
 
 
 
 
 &amp;nbsp; 
 Code 
 &amp;nbsp;Mit diesem Code dreht sich der Drehteller in moderater Geschwindigkeit und nur in eine Richtung. 
 
 
 
 
 &amp;nbsp;// Quelle: https://github.com/NikodemBartnik/ArduinoTutorials/tree/master/28BYJ-48 
 &amp;nbsp; 
 #define STEPPER_PIN_1 9 
 #define STEPPER_PIN_2 10 
 #define STEPPER_PIN_3 11 
 #define STEPPER_PIN_4 12 
 int step_number = 0; 
 void setup() { 
 pinMode(STEPPER_PIN_1, OUTPUT); 
 pinMode(STEPPER_PIN_2, OUTPUT); 
 pinMode(STEPPER_PIN_3, OUTPUT); 
 pinMode(STEPPER_PIN_4, OUTPUT); 
 &amp;nbsp; 
 } 
 &amp;nbsp; 
 void loop() { 
 &amp;nbsp; 
 &amp;nbsp; OneStep(false); 
 &amp;nbsp; delay(2); 
 &amp;nbsp;&amp;nbsp; 
 &amp;nbsp; 
 } 
 &amp;nbsp; 
 &amp;nbsp; 
 void OneStep(bool dir){ 
 &amp;nbsp; &amp;nbsp; if(dir){ 
 switch(step_number){ 
 &amp;nbsp; case 0: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; break; 
 &amp;nbsp; case 1: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; break; 
 &amp;nbsp; case 2: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; break; 
 &amp;nbsp; case 3: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, HIGH); 
 &amp;nbsp; break; 
 }&amp;nbsp; 
 &amp;nbsp; }else{ 
 &amp;nbsp; &amp;nbsp; switch(step_number){ 
 &amp;nbsp; case 0: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, HIGH); 
 &amp;nbsp; break; 
 &amp;nbsp; case 1: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; break; 
 &amp;nbsp; case 2: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; break; 
 &amp;nbsp; case 3: 
 &amp;nbsp; digitalWrite(STEPPER_PIN_1, HIGH); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_2, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_3, LOW); 
 &amp;nbsp; digitalWrite(STEPPER_PIN_4, LOW); 
 &amp;nbsp; 
 &amp;nbsp;&amp;nbsp; 
 }&amp;nbsp; 
 &amp;nbsp; } 
 step_number++; 
 &amp;nbsp; if(step_number &amp;gt; 3){ 
 &amp;nbsp; &amp;nbsp; step_number = 0; 
 &amp;nbsp; } 
 } 
 
 
 
 
                ]]>
            </content>

                            <updated>2022-12-07T00:00:00+01:00</updated>
                    </entry>

    
    
        <entry>
            <title type="text">L298N Motortreiber mit Arduino ansteuern</title>
            <id>https://www.roboter-bausatz.de/projekte/l298n-motortreiber-mit-arduino-ansteuern</id>
            <link href="https://www.roboter-bausatz.de/projekte/l298n-motortreiber-mit-arduino-ansteuern"/>
            <summary type="html">
                <![CDATA[
                
                                            In diesem Beitrag zeigen wir, wie Sie mit dem Arduino und L298N Motortreiber zwei DC-Motoren steuern können. Das L298N Modul ist die einfachste Möglichkeit zwei Motoren für einen fahrenden Arduino Roboter zu steuern.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO kompatibles Board + USB-Kabel 
 2 DC-Motoren 
 Mind. 4 Dupontkabel Buchse-Stecker 
 DC 5-12V Stromversorgung 
 
 Übersicht L298N Modul 
 Mit dem L298N Modul lassen sich zwei DC-Motoren unabhängig voneinander und in beide Richtungen steuern. Sie können auch vier Motoren gleichzeitig anschließen und paarweise ansteuern. Das L298N Modul besteht aus einer doppelten H-Brücke und eignet sich ideal für Robotik-Projekte und ferngesteuerte Autos. Mit dem L298N Modul können Sie auch einen Schrittmotor steuern, darauf gehen wir in dieser Anleitung aber nicht ein. 
 Pinbelegung 
 &amp;nbsp;  
   
 Funktionsweise 
 Ansteuerung des L298N Moduls 
 Den ersten Motor Schließen Sie an OUT1 und OUT2 an, den zweiten an OUT3 und OUT4. Wenn der erste Motor in eine Richtung drehen soll, legen Sie ein High Signal an IN1 und LOW an IN2, diese Pins entsprechen OUT1 und OUT2 am Ausgang. Um die Richtung umzudrehen, drehen Sie die Signale um. Dasselbe Funktioniert auch beim zweiten Motor. 
 Hier ist die Steuerung von zwei Motoren aufgeschlüsselt: 
 
 
 
 
  IN1  
 
 
  IN2  
 
 
  IN3  
 
 
  IN4  
 
 
  Richtung  
 
 
 
 
  0  
 
 
 0 
 
 
 0 
 
 
 0 
 
 
 Stop 
 
 
 
 
  1  
 
 
 0 
 
 
 1 
 
 
 0 
 
 
 Vorwärts 
 
 
 
 
  0  
 
 
 1 
 
 
 0 
 
 
 1 
 
 
 Rückwärts 
 
 
 
 
  1  
 
 
 0 
 
 
 0 
 
 
 1 
 
 
 Links 
 
 
 
 
  0  
 
 
 1 
 
 
 1 
 
 
 0 
 
 
 Rechts 
 
 
 
 
 &amp;nbsp; 
 Geschwindigkeit steuern 
 Um die Geschwindigkeit zu regulieren, besitzt das Modul die Pins ENA und ENB. Diese Pins werden mit PWM angesteuert und passen je nach Pulslänge die Rotation der Motoren an. Je weiter das Pulssignal, desto schneller dreht sich der Motor. Die exakte Pulsweite ist je nach Motor verschieden, selbst bei Baugleichen Modellen – da ist Experimentieren gefragt. 
 Stromversorgung 
 Zur Stromversorgung von Microcontrollern besitzt das Modul den  5V Ausgang , der versorgt wird, solange der 12V Jumper gesetzt ist. Bei einer Eingangsspannung über 12V, müssen Sie den 12V Jumper entfernen. Damit aktivieren Sie die Stromversorgung zum integrierten 5V Spannungswandler. An den 12V Anschluss können Sie eine  Eingangsspannung von DC 7V bis 35V  anlegen. 
 Anschlussplan 
 &amp;nbsp; 
 
 
 
 
 
   L298N   
 
 
   Arduino   
 
 
 
 
   ENA   
 
 
  10  
 
 
 
 
   ENB   
 
 
  5  
 
 
 
 
   IN1   
 
 
  9  
 
 
 
 
   IN2   
 
 
  8  
 
 
 
 
   IN3   
 
 
  7  
 
 
 
 
   IN4   
 
 
  6  
 
 
 
 
 
 Der Anschluss der Stromversorgung kann je nach Situation angepasst werden. Sie können das Modul entweder mit dem Arduino, getrennt oder an einer Stromversorgung anschließen. 
 Anschluss mit gemeinsamer Stromversorgung 
   
 Anschluss mit getrennter Stromversorgung 
   
 &amp;nbsp; 
 Code für Arduino 
 &amp;nbsp; 
 //Motoranschluesse 
 // Sie können hier die Pinbelegung beliebig aendern 
 #define EnA 10 
 #define EnB 5 
 #define In1 9 
 #define In2 8 
 #define In3 7 
 #define In4 6 
 &amp;nbsp; 
 &amp;nbsp; 
 void setup() 
 { 
  &amp;nbsp;// Pins als Output deklarieren 
  &amp;nbsp;pinMode(EnA, OUTPUT); 
  &amp;nbsp;pinMode(EnB, OUTPUT); 
  &amp;nbsp;pinMode(In1, OUTPUT); 
  &amp;nbsp;pinMode(In2, OUTPUT); 
  &amp;nbsp;pinMode(In3, OUTPUT); 
  &amp;nbsp;pinMode(In4, OUTPUT); 
 } 
 void vorwaerts() &amp;nbsp;&amp;nbsp;//beide Motoren vorwärts drehen lassen 
 { 
  &amp;nbsp;// Motor A einschalten 
  &amp;nbsp;digitalWrite(In1, HIGH); 
  &amp;nbsp;digitalWrite(In2, LOW); 
  &amp;nbsp;// Geschwindigkeit 150 von max. 255 
  &amp;nbsp;analogWrite(EnA, 200); 
  &amp;nbsp;// Motor A einschalten 
  &amp;nbsp;digitalWrite(In3, HIGH); 
  &amp;nbsp;digitalWrite(In4, LOW); 
  &amp;nbsp;// Geschwindigkeit 150 von max. 255 
  &amp;nbsp;analogWrite(EnB, 200); 
  &amp;nbsp;delay(2000); 
  &amp;nbsp;// alle Motoren ausschalten 
  &amp;nbsp;digitalWrite(In1, LOW); 
  &amp;nbsp;digitalWrite(In2, LOW); &amp;nbsp; 
  &amp;nbsp;digitalWrite(In3, LOW); 
  &amp;nbsp;digitalWrite(In4, LOW); 
 } 
 void loop() 
 { 
  &amp;nbsp;vorwaerts(); 
  &amp;nbsp;delay(1000); 
 } 
 &amp;nbsp; 
 Beispiel mit Potentiometer 
 Mit diesem Aufbau können Sie die Geschwindigkeit des Motors mit einem Potentiometer steuern.&amp;nbsp; Hier der Arduino Code mit Potentiometer  
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Acht LEDs mit 74HC595 steuern</title>
            <id>https://www.roboter-bausatz.de/projekte/acht-leds-mit-74hc595-steuern</id>
            <link href="https://www.roboter-bausatz.de/projekte/acht-leds-mit-74hc595-steuern"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir Ihnen, wie Sie mit Hilfe des 74HC595 Schieberegisters acht LEDs mit weniger Arduino-Pins steuern können. 
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO R3 kompatibles Board 
 Breadboard 
 14 Jumperkabel 
 74HC595 IC 
 8x 220 Ohm Widerstand 
 8x LED 
 
 Übersicht 
 In dieser Anleitung zeigen wir Ihnen, wie Sie mit Hilfe des 74HC595 acht LEDs mit weniger Pins steuern können. Während Sie die LEDs auch einzeln an den Arduino UNO anschließen könnten, würden Ihnen schnell die Pins für andere Komponenten wie Sensoren und Motoren ausgehen. Um dieses Problem zu umgehen, nutzen wir den 74HC595 Chip, einen Seriell-zu-Parallel-Logik-Wandler. Dieser Chip besitzt 8 Ausgänge, die Sie mit nur 3 Eingängen Bit für Bit ansteuern können. Das Ansteuern der LEDs mit dem 74HC595 IC geschieht etwas langsamer, ist aber mit über 500.000 Befehlen pro Sekunde statt 8.000.000 immer noch sehr schnell – schneller als das menschliche Auge eine Veränderung erkennen kann. 
 Funktionsweise 
 Der 74HC595 Chip arbeitet mit einem Schieberegister (shift register), welches 8 Speicherplätze mit entweder 0 oder 1 füllen kann. Um jeden dieser Werte ein- oder auszuschalten, werden die Daten über die Pins &quot;Data&quot; und &quot;Clock&quot; des Chips eingespeist. 
   
 Der Clock-Pin muss acht Impulse empfangen. Bei jedem Impuls wird, wenn der Daten-Pin „high“ ist, eine 1 in das Schieberegister geschoben, andernfalls eine 0 („low“). Wenn alle acht Impulse empfangen wurden, kopiert das Aktivieren des &#039;Latch&#039;-Pins diese acht Werte in das Latch-Register. Dies ist notwendig, da sonst die falschen LEDs flackern würden, während die Daten in das Schieberegister geladen werden. 
 Der Chip verfügt auch über einen Output-Enable-Pin (OE), mit dem die Ausgänge auf einmal aktiviert oder deaktiviert werden können. Man könnte diesen Pin mit einem PWM-fähigen UNO-Pin verbinden und &#039;analogWrite&#039; verwenden, um die Helligkeit der LEDs zu steuern. Dieser Pin ist active low, also verbinden wir ihn mit GND. 
 Schaltplan 
   
 Anschlussplan 
   
 Da wir acht LEDs und acht Widerstände anschließen müssen, gibt es tatsächlich eine ganze Reihe von Verbindungen herzustellen. 
 Es ist am einfachsten, den 74HC595-Chip zuerst anzuschließen, da so ziemlich alles andere mit ihm verbunden ist. Setzen Sie ihn so ein, dass die kleine U-förmige Kerbe oben auf dem Breadboard liegt. Der Pin 1 des Chips befindet sich links von dieser Aussparung. 
 
 Digital 12 von der UNO geht an Pin #14 des Schieberegisters 
 Digital 11 von der UNO geht an Pin #12 des Schieberegisters 
 Digital 9 vom UNO geht an Pin #11 des Schieberegisters 
 
 Alle Ausgänge des ICs bis auf einen befinden sich auf der linken Seite des Chips. Der Einfachheit halber befinden sich daher auch die LEDs dort. 
 Setzen Sie anschließend die Widerstände ein. Sie müssen darauf achten, dass sich die Leitungen der Widerstände nicht berühren. Das sollten Sie noch einmal überprüfen, bevor Sie den Strom an den Arduino UNO anschließen. Wenn Sie Schwierigkeiten haben, die Widerstände so anzuordnen, dass sich ihre Leitungen nicht berühren, können Sie die Drähte kürzen. Dadurch liegen Sie näher an der Oberfläche vom Breadboard. 
 Als Nächstes platzieren Sie die LEDs auf dem Breadboard. Die langen Beinchen der LEDs (positiv) müssen alle in Richtung des Chips zeigen, unabhängig davon auf welcher Seite des Breadboards sie sich befinden. 
 Bringen Sie die Jumperkabel wie oben gezeigt an. Vergessen Sie nicht die Brücke, die von Pin 8 des ICs zur GND-Spalte des Breadboards führt. 
 Laden Sie den Sketch hoch und probieren Sie ihn aus. Jede LED sollte der Reihe nach aufleuchten, bis alle LEDs an sind. Anschließend sollten sie alle wieder ausgehen und den Zyklus wiederholen. 
 Code 
  int   tDelay   =   100;  
  int   latchPin   =   11; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;  // (11) ST_CP [RCK] on 74HC595  
  int   clockPin   =   9; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;  // (9) SH_CP [SCK] on 74HC595  
  int   dataPin   =   12; &amp;nbsp;&amp;nbsp;&amp;nbsp;&amp;nbsp;  // (12) DS [S1] on 74HC595  
  &amp;nbsp;  
  byte   leds   =   0;  
  &amp;nbsp;  
  void   updateShiftRegister()  
  {  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;  digitalWrite  (latchPin  ,  LOW  );  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;  shiftOut  (dataPin  ,   clockPin  ,  LSBFIRST  ,   leds);  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;  digitalWrite  (latchPin  ,  HIGH  );  
  }  
  &amp;nbsp;  
  void  setup  ()   
  {  
   &amp;nbsp; &amp;nbsp;  pinMode  (latchPin  ,  OUTPUT  );  
   &amp;nbsp; &amp;nbsp;  pinMode  (dataPin  ,  OUTPUT  ); &amp;nbsp;  
   &amp;nbsp; &amp;nbsp;  pinMode  (clockPin  ,  OUTPUT  );  
  }  
  &amp;nbsp;  
  void  loop  ()   
  {  
   &amp;nbsp; &amp;nbsp;leds   =   0;  
   &amp;nbsp; &amp;nbsp;updateShiftRegister();  
   &amp;nbsp; &amp;nbsp;  delay  (tDelay);  
   &amp;nbsp; &amp;nbsp;  for   (  int   i   =   0; i   &amp;lt;   8; i  ++  )  
   &amp;nbsp; &amp;nbsp;{  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;&amp;nbsp;  bitSet  (leds  ,   i);  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;&amp;nbsp;updateShiftRegister();  
   &amp;nbsp; &amp;nbsp;&amp;nbsp;&amp;nbsp;  delay  (tDelay);  
   &amp;nbsp; &amp;nbsp;  }  
  }  
 Als erstes definieren wir die drei Pins, die wir verwenden werden. Dies sind die digitalen UNO-Ausgänge, die mit den Latch-, Clock- und Daten-Pins des 74HC595 verbunden werden. 
   int latchPin = 11;   
   int clockPin = 9;   
   int dataPin = 12;   
 Als nächstes wird eine Variable namens &quot;leds&quot; definiert. Diese wird verwendet, um das Muster der LEDs zu speichern, die gerade ein- oder ausgeschaltet sind. Daten des Typs &quot;Byte&quot; stellen Zahlen mit acht Bits dar. Jedes Bit kann entweder ein- oder ausgeschaltet sein, so dass diese Variable perfekt geeignet ist, um folgende Werte zu speichern welche unserer acht LEDs ein- oder ausgeschaltet sind. 
  byte leds = 0;  
 Die Setup-Funktion deklariert die drei Pins als digitale Ausgänge. 
   void setup()   
   {   
   pinMode(latchPin, OUTPUT);   
   pinMode(dataPin, OUTPUT);   
   pinMode(clockPin, OUTPUT);   
  }  
 Die Funktion &quot;loop&quot; schaltet zunächst alle LEDs aus, indem sie der Variable &quot;leds&quot; den Wert 0 gibt. Dann ruft sie &#039;updateShiftRegister&#039; auf, dass das &#039;leds&#039;-Muster an das Schieberegister sendet, so dass alle LEDs ausgeschaltet werden. Wie &#039;updateShiftRegister&#039; funktioniert, wird im Anschluss erklärt. 
 Die Schleifenfunktion hält eine halbe Sekunde lang an und beginnt dann, mit Hilfe der &#039;for&#039;-Schleife und der Variablen &#039;i&#039; von 0 bis 7 zu zählen. Jedes Mal wird die Arduino-Funktion &#039;bitSet&#039; verwendet, um das Bit zu setzen, das die LED in der Variablen &#039;leds&#039; steuert. 
 Anschließend wird die Funktion &quot;updateShiftRegister&quot; aufgerufen, damit die LEDs aktualisiert werden, um den Wert in der Variablen &quot;leds&quot; wiederzugeben. Es gibt dann eine halbe Sekunde Verzögerung, bevor &#039;i&#039; inkrementiert wird und die nächste LED aufleuchtet. 
   loop()   
   {   
   leds = 0;   
   updateShiftRegister();   
   delay(500);   
   for (int i = 0; i &amp;lt; 8; i++)   
   {   
   bitSet(leds, i);   
   updateShiftRegister();   
   delay(500);   
  }  
  }  
  Erklärung  
 Die Funktion &#039;updateShiftRegister&#039; setzt zunächst den latchPin auf low und ruft dann die UNO-Funktion &#039;shiftOut&#039; auf, bevor sie den &#039;latchPin&#039; wieder auf high setzt. 
 Diese Funktion benötigt vier Parameter, die ersten beiden sind die Pins, die für Data bzw. Clock verwendet werden sollen. 
 Der dritte Parameter gibt an, an welchem Ende der Daten man beginnen möchte. Wir beginnen mit dem rechten Bit, das als &#039;Least Significant Bit&#039; (LSB) bezeichnet wird. 
 Der letzte Parameter sind die eigentlichen Daten, die in das Schieberegister geschoben werden sollen, in diesem Fall also &#039;leds&#039;. 
   void updateShiftRegister()   
   {   
   digitalWrite(latchPin, LOW);   
   shiftOut(dataPin, clockPin, LSBFIRST, leds);   
   digitalWrite(latchPin, HIGH);   
 &amp;nbsp; 
 Wenn Sie eine der LEDs nicht ein-, sondern ausschalten wollten, würden Sie eine ähnliche Arduino-Funktion (bitClear) mit der Variablen &quot;leds&quot; aufrufen. Dadurch wird das Bit von &quot;leds&quot; auf 0 gesetzt und Sie müssten dann nur noch einen Aufruf von &quot;updateShiftRegister&quot; folgen lassen, um die tatsächlichen LEDs zu aktualisieren. 
 Ergebnis 
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Infrarot Fernbedienung mit Arduino verwenden</title>
            <id>https://www.roboter-bausatz.de/projekte/infrarot-fernbedienung-mit-arduino-verwenden</id>
            <link href="https://www.roboter-bausatz.de/projekte/infrarot-fernbedienung-mit-arduino-verwenden"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir, wie Sie eine Infrarot-Fernbedienung mit empfänger an einem Arduino UNO kompatiblen Board verwenden.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
  Arduino UNO R3 kompatibles Board  
  Breadboard  
  11 Jumperkabel  
  1x IR Fernbedienung  
  1x IR Empfänger  
  6x 220 Ohm Widerstand  
  6x LED  
 
 Übersicht 
 In Dieser Anleitung zeigen wir Ihnen, wie sie den Infrarotempfänger und die Infrarotfernbedienung mit Ihrem Arduino UNO kompatiblen Board verwenden. 
 IR-Fernbedienungen senden binäre Impulse als Signal im unsichtbaren Infrarotbereich aus. Um Störsignale von anderen Quellen zu vermeiden, werden die Signale vormoduliert und erst dann mit Hilfe einer IR-LED in einer bestimmten Frequenz gesendet. 
 Der IR-Empfänger besitzt in der Regel eine IR-Fotodiode, die Signale auf einer bestimmten Frequenz empfängt und Störungen von anderen Lichtquellen filtert. Hinter der IR-Fotodiode befindet sich dann meistens ein Signalverstärker und Demodulator, um das Signal weiterverarbeiten zu können. 
 Funktionsweise 
 Der IR-Empfänger wandelt das Lichtsignal, welches von der IR-LED gesendet wird, in ein schwaches, elektronisches Signal um. Dieses Signal wird dann durch einen IC verstärkt, automatisch gefiltert, geglättet und demoduliert, bis das ursprüngliche Signal der Fernbedienung wiederhergestellt ist. Dieses Signal wird dann an den Output-Pin des IR-Empfängers gesendet. 
   
 Verschlüsselung mit NEC-Protokoll 
 Wenn Sie die Signale einer IR-Fernbedienung auslesen wollen, müssen Sie zuerst wissen, wie sie verschlüsselt sind. Die Verschlüsselung in unserem Beispiel ist das NEC-Protokoll. 
 Technische Daten des NEC-Protokolls 
 
 8-bit Adressen und 8-bit Befehlslängen. 
 Adresse und Befehl werden zur Verlässlichkeit immer wiederholt. 
 Puls Distance Modulation (PDM) 
 Frequenz von 38 Khz 
 Bit time von 1.125 ms oder 2.25 ms 
 
 Definition von 0 und 1 im NEC-Protokoll 
   
 Signalübertragung bei Knopfdruck auf der Fernbedienung 
 &amp;nbsp;  
 Diese Abbildung zeigt eine typische  Impulsfolge des NEC-Protokolls.  Bei diesem Protokoll wird das  LSB  (Least Significant Bit) zuerst übertragen. In diesem Fall wird die Adresse $59 und der Befehl $16 übertragen. Eine Nachricht wird durch einen 9 ms AGC-Burst eingeleitet, der bei den früheren IR-Empfängern zur Einstellung der Verstärkung verwendet wurde. AGC steht kurz für engl. „automatic gain control“ und dient dazu, den Ausgangspegel eines Verstärkers konstant zu halten. 
 Auf diesen AGC-Burst folgt ein 4,5 ms langes Leerzeichen, auf das die Adresse und der Befehl folgen.  Adresse und Befehl werden zwei Mal übertragen , um die Fehlerquote zu verringern. Beim zweiten Übertragen sind alle Bits invertiert und können zur Überprüfung der empfangenen Nachricht verwendet werden. Die Gesamtübertragungszeit ist konstant, da jedes Bit mit seiner invertierten Länge wiederholt wird. Wenn Sie an diese Zuverlässigkeit nicht benötigen, können Sie die invertierten Werte auch ignorieren, oder die Adresse und den Befehl auf jeweils 16 Bit erweitern! 
 Ein Impuls wird gesendet, wenn eine Taste gedrückt und nach einer bestimmten Zeit losgelassen wird. 
   
 Ein Befehl wird nur einmal übertragen, auch wenn die Taste der Fernbedienung gedrückt bleibt. Alle 110ms wird ein Wiederholungscode gesendet, solange die Taste gedrückt bleibt. Dieser Wiederholungscode ist einfach ein 9ms AGC-Burst, gefolgt von einer 2,25ms Pause und einem 560µs Burst. 
   
 Wenn der Impuls im Empfänger eintrifft, findet eine Dekodierung, Signalverstärkung und Wellenglättung statt. Sie müssen als sicherstellen, dass der Ausgangspegel genau das Gegenteil von dem des sendenden Signals ist. Das heißt, wenn kein Infrarotsignal vorhanden ist, ist der Ausgangspegel hoch; Wenn ein Infrarotsignal vorhanden ist, ist der Ausgangspegel low. Sie können das Signal des Empfängers mit einem Oszilloskop untersuchen, um das Signal besser zu verstehen. 
 Anschlussplan 
   
 Den VOUT-Pin vom IR-Empfänger schließen wir auf Pin 11 an. Die LEDs mit den Widerständen kommen an die Pins 2, 3, 4, 5, 6, 7. Die Spannungsversorgung erfolgt über den BUS des Breadboards, verbunden mit GND und 5V vom Arduino. 
 Code 
 Für den Code wird die  IRremote Bibliothek  verwendet. Das Programm dekodiert das verschlüsselte Signal der IR-Fernbedienung. So können Sie im seriellen Monitor der Arduino IDE die Signale der Fernbedienung auslesen. Mit diesen Signalen können wir dann unsere Anwendung steuern, in diesem Beispiel die 6 LEDs. 
   
  Die Codes können je nach Fernbedienung und Charge variieren.  Wenn Sie z. B. die Tastenbelegung zum Einschalten der ersten LED ändern möchten, müssen Sie folgende Zeile anpassen: 
  long on1&amp;nbsp; = 0x00FFA25D;   
 Diese Zeile passen wir an, um die erste LED einzuschalten. Wie wir im seriellen Monitor erkennen können, entspricht  FFA25D  unserer ersten Taste der Fernbedienung. 
 Nun können Sie den angepassten Sketch erneut hochladen und die LEDs mit Hilfe der Taste anschalten. So können Sie nach der Reihe alle LEDs den Tasten zuweisen. 
 #include &amp;lt;IRremote.h&amp;gt; int RECV_PIN = 11; // Pin vom IR-Empfänger int LED1 = 2; // LED Pin int LED2 = 3; // LED Pin int LED3 = 4; // LED Pin int LED4 = 5; // LED Pin int LED5 = 6; // LED Pin int LED6 = 7; // LED Pin // Ab hier können Sie die Tastenbelegung anpassen long on1 = 0x00FFA25D;  long off1 = 0x00FFE01F; long on2 = 0x00FF629D; long off2 = 0x00FFA857; long on3 = 0x00FFE21D; long off3 = 0x00FF906F; long on4 = 0x00FF22DD; long off4 = 0x00FF6897; long on5 = 0x00FF02FD; long off5 = 0x00FF9867; long on6 = 0x00FFC23D; long off6 = 0x00FFB04F; 
 IRrecv irrecv(RECV_PIN); decode_results results; // Dumps out the decode_results structure. // Call this after IRrecv::decode() // void * to work around compiler issue //void dump(void *v) { // decode_results *results = (decode_results *)v void dump(decode_results *results) {  int count = results-&amp;gt;rawlen;  if (results-&amp;gt;decode_type == UNKNOWN)   {  Serial.println(&quot;Could not decode message&quot;);  }   else   {  if (results-&amp;gt;decode_type == NEC)   {  Serial.print(&quot;Decoded NEC: &quot;);  }   else if (results-&amp;gt;decode_type == SONY)   {  Serial.print(&quot;Decoded SONY: &quot;);  }   else if (results-&amp;gt;decode_type == RC5)   {  Serial.print(&quot;Decoded RC5: &quot;);  }   else if (results-&amp;gt;decode_type == RC6)   {  Serial.print(&quot;Decoded RC6: &quot;);  }  Serial.print(results-&amp;gt;value, HEX);  Serial.print(&quot; (&quot;);  Serial.print(results-&amp;gt;bits, DEC);  Serial.println(&quot; bits)&quot;);  }  Serial.print(&quot;Raw (&quot;);  Serial.print(count, DEC);  Serial.print(&quot;): &quot;); 
 for (int i = 0; i &amp;lt; count; i++)   {  if ((i % 2) == 1) {  Serial.print(results-&amp;gt;rawbuf[i]*USECPERTICK, DEC);  }   else   {  Serial.print(-(int)results-&amp;gt;rawbuf[i]*USECPERTICK, DEC);  }  Serial.print(&quot; &quot;);  }  Serial.println(&quot;&quot;);  } 
 void setup()  {  pinMode(RECV_PIN, INPUT);   pinMode(LED1, OUTPUT);  pinMode(LED2, OUTPUT);  pinMode(LED3, OUTPUT);  pinMode(LED4, OUTPUT);  pinMode(LED5, OUTPUT);  pinMode(LED6, OUTPUT);   pinMode(13, OUTPUT);  Serial.begin(9600);    irrecv.enableIRIn(); // Start the receiver  } 
 int on = 0; unsigned long last = millis(); 
 void loop()  {  if (irrecv.decode(&amp;amp;results))   {  // If it&#039;s been at least 1/4 second since the last  // IR received, toggle the relay  if (millis() - last &amp;gt; 250)   {  on = !on; // digitalWrite(8, on ? HIGH : LOW);  digitalWrite(13, on ? HIGH : LOW);  dump(&amp;amp;results);  }  if (results.value == on1 )  digitalWrite(LED1, HIGH);  if (results.value == off1 )  digitalWrite(LED1, LOW);   if (results.value == on2 )  digitalWrite(LED2, HIGH);  if (results.value == off2 )  digitalWrite(LED2, LOW);   if (results.value == on3 )  digitalWrite(LED3, HIGH);  if (results.value == off3 )  digitalWrite(LED3, LOW);  if (results.value == on4 )  digitalWrite(LED4, HIGH);  if (results.value == off4 )  digitalWrite(LED4, LOW);   if (results.value == on5 )  digitalWrite(LED5, HIGH);  if (results.value == off5 )  digitalWrite(LED5, LOW);   if (results.value == on6 )  digitalWrite(LED6, HIGH);  if (results.value == off6 )  digitalWrite(LED6, LOW);   last = millis();   irrecv.resume(); // Receive the next value  } } 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">DIY RGB Leuchtschrift mit Arduino</title>
            <id>https://www.roboter-bausatz.de/projekte/diy-rgb-leuchtschrift-mit-arduino</id>
            <link href="https://www.roboter-bausatz.de/projekte/diy-rgb-leuchtschrift-mit-arduino"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir, wie Sie eine dekorative RGB Leuchtschrift selbst herstellen und mit einem Arduino steuern können.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 DIY RGB Leuchtschrift mit Arduino 
 Dieses kleine DIY-Projekt ist ein echter Hingucker, egal ob für die eigene Wohnung, als Geschenk oder als Dekoration in Geschäftsräumen – Leuchtbuchstaben sind der Hit. 
 Über einen Arduino oder anderen einen anderen Microcontroller lassen sich die adressierbaren LED einzeln ansteuern und können so tolle Lichteffekte erzeugen. 
 Je nach verwendetem Microcontroller und anderen Erweiterungen lassen sich die Leuchtbuchstaben auch per App ansteuern oder können beispielsweise über einen Bewegungsmelder ausgelöst werden. 
 Benötigte Komponenten 
 
  Filament in beliebigen Farben  
  Lötzinn  
  WS2812B LED Streifen  
  yourDroid UNO R3 Entwicklungsboard  
  Dupont / Jumper Kabel Buchse Stecker  
  Kabel  
  Netzteil  
  USB Kabel  
 
 Benötigtes Werkzeug 
 
 3D-Drucker 
 Heißkleber 
  Lötstation  
  S  eitenschneider  
  Abisolierzange  
  Dritte Hand / Löthilfe  
 
 &amp;nbsp;Bauanleitung 
 Schritt 1 
 Zunächst muss man die Buchstaben auf dem 3D-Drucker in beliebiger Größe ausdrucken. Hierfür haben wir  diese kostenlose Vorlage von Thingiverse  verwendet.  Zwingend benötigt werden dabei die einzelnen Buchstaben sowie die dazugehörigen Abdeckungen, also zum Beispiel die Dateien  Letter_R.stl  und  Letter_R_lens.stl  für den Buchstaben R 
   
 &amp;nbsp; 
 Schritt 2 
 Der LED Streifen wird, je nach für den einzelnen Buchstaben benötigter Länge, entlang des Lötpads in Stücke geschnitten. An die Lötpads des ersten Streifens werden drei Dupontkabel mit Stecker angelötet, die später an den Arduino angeschlossen werden. An die andere Seite, die später zum nächsten Buchstaben führt kommt ein normales Kabel, dass dann wieder an den LED-Streifen angelötet wird. 
   
 &amp;nbsp;Dabei ist es hilfreich zunächst die abisolierten Kabelenden zu verdrillen und mit etwas Lötzinn zu benetzen. 
   
 Auch auf die Lötpads des LED-Streifens kann man vorab etwas Lötzinn geben. So muss man nur kurz das bereits aufgetragene Zinn wieder erhitzen und die Kabel und der LED-Streifen verbinden sich leichter.&amp;nbsp; 
   
 Extrem wichtig ist, dass man auf die durch Pfeile gekennzeichnete Richtung der LED-Streifen achtet.&amp;nbsp; 
   
 &amp;nbsp; 
 Schritt 3 
 Der LED-Streifen wird nun mit etwas Heißkleber seitlich im Buchstaben fixiert, die LED nach innen gerichtet und die Kabel durch die vorhandenen Löcher geführt. Beim nächsten Buchstaben wird das oben beschriebene Wiederholt, bis alle Buchstaben mit LED-Streifen bestückt sind. 
   
   
 &amp;nbsp; 
 Schritt 4 
 &amp;nbsp;Nun werden die Abdeckkappen auf in die Buchstaben gesteckt. 
   
 &amp;nbsp; 
 Schritt 5 
 &amp;nbsp;Die an den ersten Buchstaben angelöteten Dupontkabel werden nun mit dem Arduino verbunden. 
 “5V“ vom LED-Streifen kommt an den 5 Volt Anschluss des Arduino. 
 “G“ wird an GND angeschlossen und “D“ stecken wir an Pin 6 des Arduino. 
   
 &amp;nbsp; 
 Den Arduino Programmieren 
 Der Arduino wird an den USB-Anschluss des Computers angeschlossen und wir starten die Programmierumgebung “ Arduino IDE “ 
 Für unser Besipiel benötigen wir zunächst die Bibliothek “Adafruit Neopixel“, die wir über “Werkzeuge“ &amp;gt; “Bibliotheken verwalten...“ hinzufügen 
   
   
 &amp;nbsp;Anschließend fügen wir folgenden Code in den Sketch ein und editieren noch den Wert hinter “#define LED_COUNT“. Dort wird die Anzahl der in der Leuchtschrift verbauten LED eingetragen. Anschließend laden wir den Code auf den Arduino: 
 &amp;nbsp; 
 #include &amp;lt;Adafruit_NeoPixel.h&amp;gt; 
 #ifdef __AVR__ 
 #include &amp;lt;avr/power.h&amp;gt; 
 #endif 
 &amp;nbsp; 
 #define LED_PIN 6 // Der Pin an den &quot;D&quot; vom LED Streifen angeschlossen ist 
 &amp;nbsp; 
 #define LED_COUNT 80 // Anzahl der in der Leuchtschrift verbauten LED 
 &amp;nbsp; 
 Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800); 
 &amp;nbsp; 
 void setup() { 
 #if defined(__AVR_ATtiny85__) &amp;amp;&amp;amp; (F_CPU == 16000000) 
 clock_prescale_set(clock_div_1); 
 #endif 
 &amp;nbsp; 
 strip.begin(); 
 strip.show(); 
 strip.setBrightness(80); // Helligkeit 0 - 100 
 } 
 &amp;nbsp; 
 void loop() { 
 rainbow(10); 
 theaterChaseRainbow(50); 
 } 
 &amp;nbsp; 
 void colorWipe(uint32_t color, int wait) { 
 for(int i=0; i&amp;lt;strip.numPixels(); i++) { 
 strip.setPixelColor(i, color); 
 strip.show(); 
 delay(wait); 
 } 
 } 
 &amp;nbsp; 
 void theaterChase(uint32_t color, int wait) { 
 for(int a=0; a&amp;lt;10; a++) { 
 for(int b=0; b&amp;lt;3; b++) { 
 strip.clear(); 
 for(int c=b; c&amp;lt;strip.numPixels(); c += 3) { 
 strip.setPixelColor(c, color); 
 } 
 strip.show(); 
 delay(wait); 
 } 
 } 
 } 
 &amp;nbsp; 
 void rainbow(int wait) { 
 for(long firstPixelHue = 0; firstPixelHue &amp;lt; 5*65536; firstPixelHue += 256) { 
 for(int i=0; i&amp;lt;strip.numPixels(); i++) { 
 int pixelHue = firstPixelHue + (i * 65536L / strip.numPixels()); 
 strip.setPixelColor(i, strip.gamma32(strip.ColorHSV(pixelHue))); 
 } 
 strip.show(); 
 delay(wait); 
 } 
 } 
 &amp;nbsp; 
 void theaterChaseRainbow(int wait) { 
 int firstPixelHue = 0; 
 for(int a=0; a&amp;lt;30; a++) { 
 for(int b=0; b&amp;lt;3; b++) { 
 strip.clear(); 
 for(int c=b; c&amp;lt;strip.numPixels(); c += 3) { 
 int hue = firstPixelHue + c * 65536L / strip.numPixels(); 
 uint32_t color = strip.gamma32(strip.ColorHSV(hue)); 
 strip.setPixelColor(c, color); 
 } 
 } 
 } 
 } 
 &amp;nbsp; 
 Fertig! 
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Soundmodul mit Arduino auslesen</title>
            <id>https://www.roboter-bausatz.de/projekte/soundmodul-mit-arduino-auslesen</id>
            <link href="https://www.roboter-bausatz.de/projekte/soundmodul-mit-arduino-auslesen"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir, wie Sie ein Soundmodul mit Mikrofon mit einem Arduino UNO kompatiblen Board auslesen können.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO R3 kompatibles Board 
 Soundmodul 
 4 Buchse-Stecker Kabel 
 
 Beschreibung 
 In dieser Anleitung zeigen wir Ihnen, wie Sie mit dem Soundmodul Töne erkennen können. Das Modul reagiert super auf Händeklatschen, Schnipsen, Klopfen oder andere akustische Signale. Es besteht aus einer Schaltung mit einem Mikrofon, dessen Empfindlichkeit über das Potentiometer eingestellt werden kann. Einfach erklärt ist ein Mikrofon ein Schallwandler, der akustische Signale in elektrische Signale umwandelt. Mikrofone funktionieren im genauen Gegensatz zu Lautsprechern, die aus elektrischen Signalen Töne erzeugen. 
 Funktionsweise 
 Mikrofone gibt es mit verschiedenen Formen, Größen und Technologien. Auf unserem Modul ist ein Kondensator-Mikrofon verbaut, mit dem wir uns etwas genauer beschäftigen. Kondensatormikrofone werden oft in Mobiltelefonen, Laptops ect. Verbaut. Sie arbeiten wie ein Plattenkondensator, der seine Kapazität ändern kann. Im Inneren ist eine hauchdünne, elektrisch leitende Membran dicht an einer elektrisch geladenen Metallplatte angebracht. 
   
 Wenn Schall auf die Membran trifft, fängt sie an zu schwingen, wodurch sich die Kapazität des Kondensators verändert. Diese Veränderung der Kapazität resultiert in einer variablen Spannung. 
 Der Pin DO ist ein Digitaler Ausgang, der „High“ ausgibt, wenn der Schwellenwert überschritten wird. Den Schwellenwert können Sie mit dem Potentiometer einstellen. Mit diesem Anschluss können Sie nur erkennen, ob eine bestimmte Lautstärke überschritten wird. 
 Während der digitale Ausgang nur 1 oder 0 ausgibt, können Sie mit dem analogen Ausgang AO nicht nur Geräusche erkennen, sondern auch die Lautstärke als analoges Signal verarbeiten. 
 Schaltplan 
 &amp;nbsp; 
   
 Anschlussplan 
   
 
 
 
 
  Soundmodul  
 
 
  Arduino  
 
 
 
 
  -  
 
 
  GND  
 
 
 
 
  +  
 
 
  5V  
 
 
 
 
  AO (analoger Ausgang)  
 
 
  A0  
 
 
 
 
  DO (digitaler Ausgang)  
 
 
  3  
 
 
 
 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 Code für Arduino 
 Analoges Signal 
 Mit dem Code für den analogen Ausgang können Sie die Lautstärke direkt im seriellen Monitor der Arduino IDE auslesen. 
 &amp;nbsp; 
 int sensorPin = A0; // Pin vom Soundmodul int ledPin = 13; // Pin der LED, 13 ist die integrierte LED des Arduino UNO int sensorValue = 0; // Variable um den Messwert zwischenzuspeichern 
 void setup() { pinMode(ledPin,OUTPUT); Serial.begin(9600); } void loop(){ sensorValue = analogRead(sensorPin); digitalWrite(ledPin, HIGH);  delay(sensorValue);  digitalWrite(ledPin, LOW); delay(sensorValue); Serial.println(sensorValue, DEC); } 
 &amp;nbsp; 
 &amp;nbsp; 
 Digitales Signal 
 Mit dem digitalen Ausgang können Sie erkennen, ob eine gewisse Lautstärke überschritten wird. Den Schwellenwert können Sie am Potentiometer vom Modul einstellen. Wenn ein Geräusch den Schwellenwert überschreitet, liegt am Pin 3 vom Arduino ein „High“-Signal an und die LED „L“ auf dem Arduino leuchtet auf. 
 &amp;nbsp; 
 int ledPin=13;// Pin der LED, 13 ist die integrierte ledPin des Arduino UNO int sensorPin=3; //define switch port ;int val;//define digital variable val void setup() { pinMode(ledPin,OUTPUT); pinMode(sensorPin,INPUT); } void loop() 
 { val=digitalRead(sensorPin); if(val==HIGH)// Wenn an Pin 3 ein Signal anliegt, soll die LED aufleuchten { digitalWrite(ledPin,HIGH); } else { digitalWrite(ledPin,LOW); // ansonsten soll die LED aus sein } } 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Wasserstandsensor mit Arduino auslesen</title>
            <id>https://www.roboter-bausatz.de/projekte/wasserstandsensor-mit-arduino-auslesen</id>
            <link href="https://www.roboter-bausatz.de/projekte/wasserstandsensor-mit-arduino-auslesen"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir, wie Sie einen Wasserstand bzw. Regensensor mit einem Arduino UNO kompatiblen Board auslesen.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO R3 kompatibles Board 
 Wasserstandsensor 
 3 Buchse-Stecker Kabel 
 
 Beschreibung 
 In dieser Anleitung zeigen wir Ihnen, wie Sie den Wasserstandsensor auslesen können. Dieser Sensor erkennt die Tiefe von Wasser mit Hilfe einer Verstärkerschaltung und mehreren Leiterbahnen auf der Platine. Beim Eintauchen des Moduls verändert sich der Widerstand der Leiterbahnen je nach Tiefe des Wassers. Das Signal der Wassertiefe lässt sich dann am analogen Eingang des Arduinos umwandeln und auslesen. 
 Mit dem Wasserstandsensor können Sie Regen und Wassertief messen oder erkennen, ob ein Leck vorhanden ist. Der Sensor besteht hauptsächlich aus einem Transistor, einem 1M Ohm Widerstand und mehreren offenen Leiterbahnen. 
 Der Sensor besitzt einen 1M Ohm Pullup-Widerstand, um den Sensor auf „High“ zu ziehen, bis Wassertropfen die Leiterbahnen des Sensors kurzschließen. Somit funktioniert der Sensor sogar am digitalen Eingang des Arduinos. Am analogen Eingang kann allerdings die Menge an Wasser zwischen den Kontakten der Leiterbahnen gemessen werden. 
 Der Wasserstand wird durch eine Reihe von freiliegenden parallelen Leiterbahnen ermittelt. Je nach Wassermenge verändert sich der analoge Wert. Dieser analoge Wert kann ausgelesen und in einem Programm verwendet werden, um die Funktion des Wasserstands-Sensors zu erreichen. 
 Schaltplan 
   
 &amp;nbsp;Anschlussplan 
   
 
 
 
 
  Wasserstandsensor  
 
 
  Arduino  
 
 
 
 
  -  
 
 
  GND  
 
 
 
 
  +  
 
 
  5V  
 
 
 
 
  S  
 
 
  A0  
 
 
 
 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 Code für Arduino 
 int Sensor = A0; int alterMesswert = 0; // Variable, um den vorherigen Messwert zu vergleichen char printBuffer[128]; 
 void setup() {  Serial.begin(9600); } 
 void loop() {  int messwert = analogRead(Sensor); // Sensor auslesen und in der Variable Messwert speichern 
 if(((alterMesswert&amp;gt;=messwert) &amp;amp;&amp;amp; ((alterMesswert - messwert) &amp;gt; 10)) || ((alterMesswert&amp;lt;messwert) &amp;amp;&amp;amp; ((messwert - alterMesswert) &amp;gt; 10)))  {  sprintf(printBuffer,&quot;Messwert ist %d\n&quot;,Sensor, messwert);  Serial.print(printBuffer);  alterMesswert = messwert;  } } 
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">Joystick Modul mit Arduino auslesen</title>
            <id>https://www.roboter-bausatz.de/projekte/joystick-modul-mit-arduino-auslesen</id>
            <link href="https://www.roboter-bausatz.de/projekte/joystick-modul-mit-arduino-auslesen"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir Ihnen, wie Sie einen Joystick mit einem Arduino UNO kompatiblen Board auslesen können.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO R3 kompatibles Board 
 Joystick Modul 
 5 Buchse-Stecker Kabel 
 
 Beschreibung 
 Mit Joysticks bringen Sie Ihre Projekte unter analoge Kontrolle! Dieses Joystick Modul eignet sich perfekt für eine 2-Achsen-Steuerung wie Sie häufig in Roboterarmen verwendet wird. Das Modul macht sich ebenfalls super als Eingabemethode für Spiele und Menüs. 
 Dieses Joystick Modul besitzt 5 Pins: GND, 5V, VRx, VRy und SW. Die Beschriftung kann je nach Charge variieren, die Belegung und Funktion bleibt aber die gleiche. Der Joystick arbeitet analog und liefert genauere Werte als digitale Joysticks. Er verfügt über einen integrierten Taster, der durch Drücken ausgelöst werden kann. Dadurch lassen sich z.B. Umschaltfunktionen (Toggle) oder Auswahlfunktionen (Select) programmieren. 
 Funktionsweise 
 Am Arduino werden die Daten der X- und Y-Pins über analoge Eingänge gelesen. Das Joystick Modul besitzt jeweils ein Potentiometer für die X- und Y-Achse. Je nach Position des Joysticks wird eine andere Ausgangsspannung an unseren Arduino gegeben. Das Arduino Board wandelt die analoge Spannung zwischen 0 bis 5V in Werte von 0 bis 1023 um. Der Taster liefert permanent 2V, bei Betätigung wird er mit GND verbunden. Im seriellen Monitor lesen wir 1 im Ruhezustand und 0 beim Auslösen. 
 Schaltplan 
   
 Anschlussplan 
   
 &amp;nbsp; 
 
 
 
 
  Joystick  
 
 
  Arduino  
 
 
 
 
  GND  
 
 
  Ground  
 
 
 
 
  +5V  
 
 
  5V  
 
 
 
 
  VRx  
 
 
  Analoger Pin A0  
 
 
 
 
  VRy  
 
 
  Analoger Pin A1  
 
 
 
 
  SW  
 
 
  Digitaler Pin 2  
 
 
 
 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 Code für Arduino 
 const int SW_pin = 2; // Taster-Pin const int X_pin = A0; // X-Ausgang const int Y_pin = A1; // Y-Ausgang 
 void setup() {  pinMode(SW_pin, INPUT);  digitalWrite(SW_pin, HIGH);  Serial.begin(9600); } 
 void loop() {  Serial.print(&quot;Taster: &quot;);  Serial.print(digitalRead(SW_pin));  Serial.print(&quot;\n&quot;);  Serial.print(&quot;X-Achse: &quot;);  Serial.print(analogRead(X_pin));  Serial.print(&quot;\n&quot;);  Serial.print(&quot;Y-Achse: &quot;);  Serial.println(analogRead(Y_pin));  Serial.print(&quot;\n\n&quot;);  delay(500); } 
 &amp;nbsp; 
 Mit dem seriellen Monitor können Sie die aktuellen Werte auslesen. Wenn der Joystick im Mittelpunkt (Ruheposition) steht, sollte er einen Wert von ca. 512 ausgeben. Wenn Sie eine Achse bewegen, ändert sich der Wert von 0 bis 1023 
   
                ]]>
            </content>

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

    
    
        <entry>
            <title type="text">4x4 Keypad Modul mit Arduino UNO ansteuern</title>
            <id>https://www.roboter-bausatz.de/projekte/4x4-keypad-modul-mit-arduino-uno-ansteuern</id>
            <link href="https://www.roboter-bausatz.de/projekte/4x4-keypad-modul-mit-arduino-uno-ansteuern"/>
            <summary type="html">
                <![CDATA[
                
                                            In dieser Anleitung zeigen wir die Funktionsweise eines 4x4 Keypad Modul mit einem Arduino UNO kompatiblen Board.
                                        ]]>
            </summary>
            <content type="html">
                <![CDATA[
                 Benötigte Komponenten 
 
 Arduino UNO R3 kompatibles Board 
 4x4 Keypad Modul 
 Buzzer 
 220 Ohm Widerstand 
 11 Jumperkabel 
 Breadboard 
 
 Beschreibung 
 Tastenfelder oder Keypads eignen sich perfekt zur Dateneingabe oder Menü-Navigation in Projekten wie Sicherheitssysteme, Zugangskontrollen, Embedded Systems, Smart Home Steuerungen, Fernbedienungen und Robotern. Die Einsatzmöglichkeiten sind unbegrenzt, da die Tasten nicht unbedingt die aufgedruckten Zeichen ausgeben müssen, sondern mit Hilfe eines Arduinos oder Raspberry Pis frei programmiert werden können. Am beliebtesten sind Tastenfelder mit 4x3 oder 4x4 Tasten, die einer klassischen Telefontastatur ähneln. 
 Funktionsweise 
 Das numerische Tastenfeld besteht aus 16 Tasten, die in einer Matrix angeordnet sind, d. h. alle Tasten einer Spalte sind mit einem Eingang und alle Tasten einer Zeile mit einem anderen verbunden. 
 Wenn eine Taste gedrückt wird, wird der entsprechende Eingang der Zeile mit dem der Spalte verbunden, wodurch der Stromkreis geschlossen wird. Der Vorteil dieses Aufbaus ist, dass 16 Tasten mit nur 8 Eingängen des Mikrocontrollers angesteuert werden können. 
 Schaltplan 
   
 Pinbelegung 
 
 
 
 
  Keypad  
 
 
  Arduino  
 
 
 
 
  C1  
 
 
  Pin 9  
 
 
 
 
  C2  
 
 
  Pin 8  
 
 
 
 
  C3  
 
 
  Pin 7  
 
 
 
 
  C4  
 
 
  Pin 6  
 
 
 
 
  L1  
 
 
  Pin 5  
 
 
 
 
  L2  
 
 
  Pin 4  
 
 
 
 
  L3  
 
 
  Pin 3  
 
 
 
 
  L4  
 
 
  Pin 2  
 
 
 
 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 &amp;nbsp; 
 Anschlussplan 
   
 Code für Arduino 
 Zur Verwendung von diesem Beispielcode wird die Keypad.h Bibliothek benötigt. 
 Mit diesem Beispiel können Sie eine Taste drücken und die gedrückte Taste im seriellen Monitor der Arduino IDE auslesen. Die Taste 1 lässt die LED aufleuchten und die Taste 2 betätigt den Buzzer. 
 #include &amp;lt;Keypad.h&amp;gt;  int led = 10; int buzzer = 11; const byte ROWS = 4; // Definiere vier Reihen const byte COLS = 4; // Definiere vier Spalten char keys[ROWS][COLS] = { {&#039;4&#039;,&#039;8&#039;,&#039;C&#039;,&#039;G&#039;}, {&#039;3&#039;,&#039;7&#039;,&#039;B&#039;,&#039;F&#039;}, {&#039;2&#039;,&#039;6&#039;,&#039;A&#039;,&#039;E&#039;}, {&#039;1&#039;,&#039;5&#039;,&#039;9&#039;,&#039;D&#039;} }; byte rowPins[ROWS] = {9,8,7,6}; // Pins fuer die Reihen byte colPins[COLS] = {5,4,3,2}; // Pins fuer die Spalten // Initialisiere Keypad Bibliothek Keypad keypad = Keypad( makeKeymap(keys), rowPins, colPins, ROWS, COLS ); void setup(){ Serial.begin(9600); pinMode(led, OUTPUT); pinMode(buzzer, OUTPUT); } 
 &amp;nbsp; 
                ]]>
            </content>

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

    
</feed>
