kk logo

MINT

📘 ARDUINO R4_LOGICKISTE Handbuch

Details
Kategorie: M-I-N-T
Zugriffe: 830

Die R4_LogicKiste ist eine visuelle Programmierumgebung, die speziell für den Arduino UNO R4 WiFi entwickelt wurde. Anstatt C++ Code von Hand tippen zu müssen, steckst du das Programm aus Logik-Blöcken zusammen.

Wie funktioniert das?

Das Herzstück der LogicKiste ist ein intelligenter Generator, der direkt im Browser läuft. Während Blöcke auf die Arbeitsfläche gezogen werden, übersetzt das System die Logik im Hintergrund in C++ Code. Du lernst das EVA-Prinzip (Eingabe, Verarbeitung, Ausgabe) intuitiv kennen und kannst dir den Code ansehen, um den Übergang zur Textprogrammierung zu meistern.

 

Inhaltsverzeichnis: Schnellnavigation

 

⚙️ Grundfunktion: Die Arduino Programmstruktur

Das absolute Herzstück jedes Projekts! Der Block "Arduino Programmstruktur" ist das zwingende Grundgerüst für deinen Code und darf in keinem Programm fehlen. Er teilt dein Projekt in drei entscheidende Bereiche auf:

- Globaler Bereich: Hier werden Variablen und Einstellungen definiert, die überall im gesamten Programm gültig und abrufbar sein sollen.
- Setup: Dieser Code-Abschnitt wird beim Einschalten oder nach einem Reset des Arduinos genau ein einziges Mal ausgeführt (ideal, um Sensoren oder Displays zu starten).
- Loop (Hauptschleife): Das eigentliche Programm. Alles, was hier angedockt wird, wiederholt der Arduino endlos und rasend schnell immer wieder von vorne.

 

 

🔌 Erweiterte Eingänge & Ausgänge

Neben den Standard-Pins bietet die LogicKiste einige clevere Spezialblöcke, um Eingabegeräte noch effizienter auszulesen.

- Universal Joystick: Erlaubt das komfortable Auslesen der X- und Y-Achsen sowie des integrierten Drucktasters eines klassischen Analog-Joysticks.
- Analoge Taster-Leiter (Button Ladder): Ein echter Geheimtipp! Hiermit kannst du mehrere physische Taster über ein Widerstandsnetzwerk an nur einem einzigen analogen Pin anschließen und sauber auswerten (spart enorm viele Pins).
- Profi-Taster (Klasse 2): Eine erweiterte Variante des Taster-Blocks für noch tiefgreifendere Abfragen von Klick- und Halte-Events bei komplexen Projekten.

 

 

🧮 Logik, Mathematik & Texte

Für Bedingungen, fortgeschrittene Berechnungen und Textausgaben auf Displays stehen dir kompakte Helfer-Blöcke zur Verfügung.

- Grundlegende Logik: Vergleiche Werte miteinander (größer, kleiner, gleich), verknüpfe Bedingungen (UND / ODER), kehre sie um (NICHT) oder nutze einfache Wahrheitswerte (WAHR / FALSCH).
- Texte verknüpfen (Text Join): Verbindet mehrere Textbausteine, Variablen, Wörter oder Zahlen zu einem einzigen, langen Satz zusammen.
- Werte begrenzen (Constrain): Zwingt eine Zahl in einen fest definierten Bereich (z.B. minimal 0, maximal 255. Alle Zahlen darüber oder darunter werden automatisch abgeschnitten.
- Gerade / Ungerade: Prüft blitzschnell, ob eine eingehende Zahl gerade oder ungerade ist (gibt WAHR oder FALSCH zurück).
- Komplexe Mathematik: Stellt fortgeschrittene Funktionen wie Pi, Potenzen, Wurzeln und Trigonometrie (Sinus, Cosinus, Tangens) für aufwendigere Berechnungen bereit.
- Bedingte Zuweisung (Ternary): Eine extrem kompakte Mini-WENN-DANN-Abfrage, die in eine einzige Zeile passt und einen Wert direkt zuweist (nach dem Prinzip: Bedingung erfüllt ? Wahr-Wert : Falsch-Wert).

 

 

🛡️ Kompakte Hardware-Shields

Für die beliebtesten Arduino-Lernplatinen (Shields) gibt es vorgefertigte Blöcke, bei denen du dich um keine Pin-Belegungen mehr kümmern musst.

- Multi Function Shield (MFS & V2): Direkte Steuerungsblöcke für die 4 Onboard-Taster, die LEDs, den Piezo-Summer und das 4-stellige Segment-Display.
- Rich Shield (V1 & V2): Liefert extrem einfache Abfragen für alle verbauten Sensoren (Licht, Temperatur, Poti), den Bewegungsmelder (PIR), den Drehgeber (Encoder) und die Spannungsüberwachung.
- Keyestudio Easy Module: Vorgefertigte und sofort einsatzbereite Funktionen für die Onboard RGB-LEDs, Infrarot und Sensoren auf den Keyestudio V1 & V2 Platinen.

 

Die DMX-Steuerung: Profi-Wissen für deine Projekte

DMX512 ist der Industriestandard für die professionelle Lichttechnik und basiert physikalisch auf dem robusten RS-485-Bus. Im Kern funktioniert DMX wie eine exakt getaktete Datenautobahn: Bevor überhaupt Daten fließen, signalisiert ein langer Pegelwechsel der sogenannte „Break“ (Reset) allen angeschlossenen Lampen, dass jetzt ein komplett neues Bild übertragen wird.

Danach werden die Helligkeitswerte für jeden einzelnen Kanal nacheinander über die serielle Schnittstelle (Serial1 des Arduino R4) herausgerattert. Jedes einzelne Byte (ein Kanalwert von 0 bis 255) ist dabei hardwareseitig exakt verpackt:

- 1 Start-Bit (Leitung geht auf LOW, um den Takt zu starten)
- 8 Daten-Bits (Der eigentliche Helligkeitswert)
- 2 Stopp-Bits (Leitung geht auf HIGH, um das Byte sauber abzuschließen)

Dieser strikte Aufbau sorgt dafür, dass selbst Scheinwerfer am Ende einer langen Kabelkette im Saal präzise wissen, wann ein Wert beginnt und auf welchem Kanal sie zuhören müssen. Damit diese Kommunikation fehlerfrei bleibt, ist das Einhalten des timings kritisch und genau diese Drecksarbeit nimmt dir die Library im Hintergrund ab.

Die 3 Betriebsmodi in Blockly

Um sowohl Anfängern, Show-Programmierern als auch Code-Hackern die maximale Freiheit zu geben, stehen dir in Blockly drei völlig unterschiedliche Logik-Welten zur Verfügung:

⚡ 1. Der Direkt-Modus (Dunkelblaue Blöcke)

Dieser Modus ist dein „Live-Werkzeug“. Sobald das Programm den Block ⚡ DMX Live-Kanal sofort auf Wert setzen ausführt, öffnet der Arduino im Hintergrund das Paket, schreibt den Wert und schickt es sofort auf die Reise.

- Ideal für: Einfache Setups, statische Raumbeleuchtungen oder das gezielte Schalten von Scheinwerfern per Tastendruck (Events).
- ⚠️ Achtung: Nutze diese blauen Blöcke niemals innerhalb von schnellen, nackten Wiederhol-Schleifen oder direkt in einer rasenden Haupt-LOOP! Da jedes Mal ein physisches Paket erzeugt wird, bricht sonst durch die permanente Bus-Überlastung das Signal auf dem Oszilloskop zusammen.

📦 2. Der Puffer-Modus (Lila Blöcke)

Hier wird im RAM des Arduino mit einem Zwischenspeicher (Buffer) gearbeitet. Wenn du Werte änderst, passiert auf der XLR-Leitung erst einmal gar nichts. Die Daten werden unsichtbar gesammelt. Erst wenn der große, umschließende Klammer-Block 🚀 DMX Paket senden aufgerufen wird, feuert der Controller alle Werte gesammelt als ein einziges, sauberes DMX-Paket ab.

- Ideal für: Komplexe Lightshows, weiche Fades (Dimmen), Lauflichter und LED-Matrizen.
- 💡 Profi-Tipp: Mathematische Berechnungen oder Schleifen gehören in den Bauch dieser lila Klammer. So wird der Puffer im RAM blitzschnell gefüllt und nur ein einziges Mal stabil übertragen.

🟢 3. Der Simple-Modus (Grüne Blöcke)

Das ist der "Hacker-Modus" für maximale, rohe Flexibilität. Hier bestimmst du im Code völlig ungeschützt selbst, wann das Paket geöffnet wird (Start), welche Kanäle geschrieben werden und wann der Frame abgeschlossen und abgesendet wird (Ende).

- Ideal für: Fortgeschrittene Anwender, die eigene, hochoptimierte Protokoll-Strukturen programmieren wollen.
- ⚠️ Achtung: Zwischen dem Öffnen- und dem Schließen-Block dürfen keine blockierenden Pausen liegen.

🚫 Wichtige Grundregel: Mische niemals die Farben im Setup!

Füge immer nur einen Setup Block ein, die Blöcke im Loop kannst du wild kombinieren. Aber Achtung DMX ist zeitkritisch, achte besonders auf deine Delay Funktionen.

🛠️ Hardware & Pin-Belegung der DMX-Kiste

Für die physische Ausgabe benötigst du ein MAX485-Modul (RS-485 Konverter) und eine 3-polige XLR-Buchse (Female). Um maximale Stabilität auf der Platine deiner Logikkiste zu garantieren, ist der Richtungs-Umschaltpin hardwareseitig fest auf Pin 4 verdrahtet.

arduino dmx controler tutorial

Pin Belegung:

Funktion Pin (Arduino / XLR) Beschreibung
DMX Transmit (TX) 1 (Arduino) Daten zum MAX485 (DI - Driver Input)
DMX Receive (RX) 0 (Arduino) Daten vom MAX485 (RO - Receiver Output)
DMX Enable (DE/RE) 4 (Arduino) Steuert Senderichtung (DE & RE am Modul gebrückt)
GND GND (Arduino) Masse für alle Komponenten
VCC 5V (Arduino) Stromversorgung (5V)
XLR Pin 1 (GND) - Abschirmung / Masse (verbunden mit GND)
XLR Pin 2 (Data -) - Invertierte Datenleitung (A/Cold)
XLR Pin 3 (Data +) - Nicht-invertierte Datenleitung (B/Hot)

 

 

Die Klickzähler-Funktionen in Blockly

Um Projekten wie Spielen, Menüsteuerungen oder komplexen Abläufen die volle Flexibilität zu geben, kannst du neben den reinen Klick-Events auch den internen Klickzähler deiner Taster auswerten. In Blockly stehen dir dafür drei spezialisierte, dunkelbraune Funktions-Blöcke zur Verfügung:

📊 1. Der Auslese-Block (Get)

Dieser Block ist dein Messwerkzeug. Er hat eine Nase an der rechten Seite und liefert dir die exakte Anzahl der bisher gezählten Klicks als reine Zahl zurück.

- Anwendung: Du kannst diesen Block überall dort hineinstecken, wo Zahlen erwartet werden.
- Ideal für: Punktezähler in Arcade-Spielen, das Durchschalten von Menü-Ebenen.

🔄 2. Der Reset-Block (Reset)

Dieser Block ist deine Notbremse. Er sorgt dafür, dass der interne Zähler des ausgewählten Pins sofort und ohne Umwege wieder auf den Startwert 0 zurückgesetzt wird.

- Anwendung: Da es sich um einen Befehl handelt, der aktiv etwas tut, kannst du ihn einfach in deine Programmkette einfügen.
- Ideal für: Das Starten eines neuen Spiels (Game Over -> Reset), das Zurücksetzen eines Timers.

⚙️ 3. Der Setzen-Block (Set)

Das ist das Werkzeug für maximale Kontrolle. Mit diesem Block löschst du den Zähler nicht einfach nur, sondern überschreibst ihn mitten im laufenden Betrieb mit einem völlig frei definierbaren Wert.

- Anwendung: Der Block besitzt eine Öffnung, an die du eine beliebige Zahl oder eine mathematische Berechnung andocken kannst.
- Ideal für: Das Vorgeben von Startwerten (z. B. "Du startest mit 3 Leben").

💡 Profi-Hardware-Tipp

Alle diese Blöcke nutzen im Hintergrund die automatische Pin-Verwaltung der LogicKiste. Sobald du einen der Blöcke in dein Programm ziehst, wird der interne INPUT_PULLUP des Arduino für diesen Pin aktiviert. Du musst dich um keine Widerstände kümmern: Schließe deinen Taster einfach direkt zwischen dem PIN und GND an.

 

 

⏳ Intervall-Timer & Zähler: Multitasking ohne Blockieren

Wenn du in deinen Programmen möchtest, dass eine Aktion regelmäßig ausgeführt wird, greift man anfangs gerne zum Warte ms (Delay) Block. Der große Haken dabei: Ein Delay friert deinen kompletten Arduino ein. Während der Controller wartet, kann er keine Taster abfragen, keine Displays aktualisieren und nicht auf Webserver-Anfragen reagieren.

Um dieses Problem zu lösen, arbeiten die Intervall-Blöcke der LogicKiste mit einem cleveren Blick auf die Systemzeit (millis). Der Arduino schaut kontinuierlich auf seine interne Stoppuhr und prüft, ob die von dir gewünschte Zeitspanne bereits vergangen ist. Wenn ja, führt er den Code im Bauch des Blocks blitzschnell aus und macht sofort im Hauptprogramm weiter. So bleibt dein Programm absolut flüssig und multitaskingfähig.

⚡ 1. Der einfache Intervall-Timer

Dieser Block ist dein Werkzeug für unkomplizierte, wiederkehrende Aufgaben. Du dockst einfach eine Zahl für die Millisekunden an und packst die Befehle in den MACHE-Zweig.

- Ideal für: Regelmäßiges Auslesen von Sensoren, zyklisches Senden von Daten.
- Hintergrund-Logik: Für jeden dieser Blöcke legt das System im Hintergrund eine eigene, unsichtbare Zeitvariable an.

📊 2. Der Timer mit integriertem Zähler

Manchmal reicht es nicht aus, eine Aktion nur alle X Millisekunden auszuführen du musst auch wissen, wie oft das schon passiert ist. Er kombiniert die zeitliche Steuerung mit einer automatischen Zählvariable im RAM des Arduino.

Damit das fehlerfrei funktioniert, vergibst du im Textfeld des Blocks einen eindeutigen Namen (z. B. Takt1). Jedes Mal, wenn das eingestellte Intervall abgelaufen ist, erhöht der Arduino diesen spezifischen Zähler automatisch um +1.

Um diesen Zähler voll auszureizen, stehen dir drei dunkelbraune Funktions-Blöcke zur Verfügung:

- Lese Zähler: Dieser Block liefert dir den aktuellen Zählerstand als reine Zahl zurück.
- Setze Zähler auf [X]: Hiermit kannst du den Zählerstand mitten im laufenden Betrieb aktiv überschreiben.
- Setze Zähler auf 0: Deine klassische Reset-Funktion.

💡 Profi-Tipp für sauberen Code: Achte unbedingt darauf, dass du bei den Blöcken zum Lesen, Setzen oder Zurücksetzen immer exakt denselben Namen eintippst, den du auch im Haupt-Timer-Block vergeben hast!

 

 

🎵 Audio & Sound: MP3-Wiedergabe mit dem YX5300-Modul

Mit den Audio-Blöcken der LogicKiste kannst du das beliebte YX5300 MP3-Serial-Modul kinderleicht ansteuern. Das Modul liest Musik- und Sprachdateien direkt von einer Micro-SD-Karte und entlastet den Arduino komplett.

💾 Wichtig: Die richtige Ordnerstruktur auf der SD-Karte

Damit das MP3-Modul deine Dateien fehlerfrei findet, musst du dich an eine strikte Namensgebung auf deiner Micro-SD-Karte halten:

1. Erstelle Ordner mit zweistelligen Nummern (z. B. 01, 02, 03).
2. Benenne die MP3-Dateien innerhalb der Ordner mit einer dreistelligen Nummer am Anfang (z. B. 001_sound.mp3, 002_alarm.mp3).

🛠️ Die MP3-Blöcke im Detail

1. MP3 YX5300 Setup

Bevor du Töne abspielen kannst, musst du dem Arduino sagen, wo das MP3-Modul angeschlossen ist. Ziehe diesen Block einfach an den Anfang deines Programms.

- Der serielle Port: Beim Arduino UNO R4 WiFi nutzt du im Dropdown-Menü standardmäßig Serial1 (Pin 0/1). Verbinde den TX-Pin des MP3-Moduls mit Pin 0 (RX) und den RX-Pin mit Pin 1 (TX).
- Hintergrund-Logik: Die LogicKiste bindet automatisch die passende Bibliothek ein und startet die Kommunikation.

2. MP3 Lautstärke auf (0-30)

Mit diesem Block regelst du die Lautstärke deines Lautsprechers oder Kopfhörers. (0 = stumm, 30 = maximal).

3. MP3 Spiele Ordner

Das ist der eigentliche Befehl, um Musik oder Soundeffekte zu starten.

- Modus (Einmalig): Spielt den Inhalt des Ordners genau einmal ab.
- Modus (Dauerschleife): Spielt die Titel im Ordner unendlich oft hintereinander ab.

4. MP3 Aktion (Play, Pause, Stop...)

Dieser Block ist deine Fernbedienung für die laufende Wiedergabe (Play, Pause, Stop, Nächster / Vorheriger Titel).

💡 Profi-Tipp für fehlerfreien Sound: Schicke einen Befehl wie "Spiele Ordner" nur einmalig bei einem Event (z. B. wenn ein Taster gedrückt wurde) und niemals dauerhaft nackt in einer rasenden Haupt-LOOP.

 

 

💻 Processing & PC-Visu: Die HMI-Schnittstelle (Mensch-Maschine-Interface)

Wenn du am PC-Bildschirm große, bunte Schieberegler bedienen, Live-Diagramme deiner Sensoren zeichnen oder eine komplette Steuerungsoberfläche (HMI) aufbauen möchtest, verbindet die Processing-Kategorie deinen Arduino über das USB-Kabel direkt mit der Processing-App auf deinem Computer.

Das System arbeitet extrem effizient mit sogenannten Kanälen (A bis J). Ein Datensatz besteht dabei immer aus dem Kanalbuchstaben und den eigentlichen Werten, die durch ein Komma getrennt sind (z. B. A,23.5,100,Text).

🛠️ Die HMI-Blöcke im Detail

1. Starte HMI Verbindung

Dieser Block gehört zwingend in den Setup-Bereich deines Programms. Er öffnet die serielle Datenautobahn über das USB-Kabel. Achte darauf, dass in der Processing-App auf dem PC exakt dieselbe Geschwindigkeit eingestellt ist!

2. Wenn Datensatz auf Kanal X ankommt (Event-Block)

Dieser Block hat keine Puzzleteile-Einkerbungen und schwebt frei auf deiner Arbeitsfläche. Die LogicKiste lauscht im Hintergrund permanent am USB-Anschluss. Sobald der PC ein Paket schickt, springt der Arduino sofort in diesen Block.

3. Werte auslesen (Zahl oder Text)

Der PC kann dir mehrere Werte auf einmal in einer Zeile schicken. Mit dem Index (Position) bestimmst du, welchen Wert du greifen willst.

4. Sende Datensatz auf Kanal X

Mit diesem roten Block sendest du aktiv Daten vom Arduino zurück zum PC, um sie dort auf der Oberfläche anzuzeigen (bis zu 5 Werte gleichzeitig).

💡 Profi-Tipp für eine stabile Verbindung

1. Nicht dauerhaft nackt senden: Packe den roten Sende Datensatz-Block niemals einfach so nackt in den Haupt-Loop. Nutze immer einen Intervall-Timer.
2. Datenformat einhalten: Stelle sicher, dass der PC die richtigen Formate (Zahl oder Text) schickt.

 

 

🎛️ P-Manipulation & TCA9555: Mehr Pins für große Projekte

Wenn dir die Pins ausgehen, spendiert dir der TCA9555 Portexpander über den I2C-Bus satte 16 zusätzliche digitale Pins! Das Modul teilt seine 16 Pins in zwei logische Gruppen auf: Port 0 (Pins 0 bis 7) und Port 1 (Pins 0 bis 7). Jeder dieser Pins kann frei als Eingang oder Ausgang konfiguriert werden.

🛠️ Die TCA9555-Blöcke im Detail

1. TCA Senden (Einzelner Pin)

Mit diesem Block schaltest du einen Ausgang ein (HIGH oder 1) oder aus (LOW oder 0). Die Kiste erkennt automatisch, welchen Pin du als Ausgang nutzt, und trägt den pinMode selbstständig ein.

2. TCA Empfangen (Einzelner Pin)

Dieser Block liest den aktuellen Zustand eines Pins aus und liefert WAHR (HIGH) oder FALSCH (LOW).

🚀 Schneller arbeiten mit Bit-Mustern (Muster-Blöcke)

Wenn du viele Pins gleichzeitig schalten willst, verarbeiten diese Blöcke ein 8-Bit-Muster, das du als Text eintippst. Das Muster liest sich immer von links (Pin 0) nach rechts (Pin 7).

3. TCA Muster Senden

- 1 = Schaltet den Pin auf HIGH.
- 0 = Schaltet den Pin auf LOW.
- _ (Unterstrich) = Ignorieren (Zustand bleibt erhalten).

4. TCA Muster Prüfen

Genial für Sicherheitsabfragen oder Matrix-Tastaturen. Gibt WAHR zurück, wenn das reale Signal exakt mit deinem Wunschmuster übereinstimmt (nutze 1, 0, oder X für "Egal").

💡 Profi-Tipp für Adressen und Verkabelung

Du kannst bis zu acht dieser TCA9555-Module gleichzeitig betreiben. Ändere die Adresse einfach über Lötbrücken (A0, A1, A2) auf dem Modul:

Pin A2 Pin A1 Pin A0 I2C-Adresse (Hex)
GND GND GND 0x70 (Standard)
GND GND VCC 0x71
GND VCC GND 0x72
GND VCC VCC 0x73
VCC GND GND 0x74
VCC GND VCC 0x75
VCC VCC GND 0x76
VCC VCC VCC 0x77

 

 

👆 TTP229 Touch Numpad (16 Tasten & T9-Eingabe)

Mit diesen Blöcken verwandelst du ein simples TTP229 16-Tasten Touch-Modul in ein echtes Eingabeterminal für deine LogicKiste. Das System arbeitet völlig asynchron im Hintergrund (ohne Delay) und bietet dir neben der einfachen Tastenabfrage auch einen genialen T9-Textmodus (wie bei alten Handys) sowie eine saubere Zahlenreihen-Eingabe.

⚠️ Hardware-Wichtig: Der 16-Tasten Jumper

Viele dieser Module (z. B. das rote HW-136) werden im 8-Tasten-Modus ausgeliefert. Damit alle 16 Pads funktionieren, musst du auf der Platine zwingend eine Lötbrücke oder einen Jumper bei TP2 setzen!

🛠️ Die TTP229-Blöcke im Detail

1. Setup & Update (Die Basis)

- TTP229 Touch Setup: Legt die Pins für SCL (Takt) und SDO (Daten) fest. Hier stellst du auch die Entprellzeit (z. B. 80 ms gegen Flackern) und die Lock-In Zeit (z. B. 800 ms für den T9-Modus) ein. Gehört fest in den SETUP-Bereich.
- TTP229 Touch Update (Hintergrund): Der Motor des Systems! Dieser Block muss zwingend und regelmäßig in der Haupt-LOOP aufgerufen werden. Er liest den Sensor blitzschnell aus und verwaltet die Timer, ohne dein Programm zu blockieren.

2. Einfache Zahlen & Steuerungen

- Lese Taste (0 wenn losgelassen): Gibt direkt die aktuell berührte Taste (1-16) zurück. Nimmst du den Finger weg, fällt der Wert sofort wieder auf 0.
- Lese Taste (behält letzten Wert): Ideal für Menüs oder Fahrstufen! Speichert die zuletzt gedrückte Taste dauerhaft. Fällt niemals auf 0 zurück.

3. Komplexe Eingaben (T9-Text & Zahlenreihe)

Das Modul speichert Eingaben automatisch in zwei Puffern parallel. Die Tasten sind dabei logisch belegt: 1-9 sind Ziffern/Buchstaben, 10 ist die 0, 13 ist Löschen (Zurück), 14 ist Alles Löschen, 15 ist der Dezimalpunkt und 16 ist Enter (Bestätigen).

- TTP229 aktuellen T9-Text lesen: Verhält sich wie eine alte Handy-Tastatur (Taste 2 = a, dann b, dann c, dann 2). Der Block gibt dir jederzeit den aktuell gebauten Text als Zeichenkette (String) zurück inklusive dem gerade "wackelnden" Auswahl-Zeichen.
- TTP229 aktuelle Zahlenreihe lesen: Ignoriert die Buchstaben und baut eine saubere numerische Zeichenkette (z. B. "12.5"). Das versehentliche Tippen von zwei Kommapunkten wird dabei automatisch blockiert.
- TTP229 'Enter' (16) gedrückt?: Gibt den Wahrheitswert WAHR aus, wenn der Nutzer die Eingabe mit Pad 16 bestätigt hat. Perfekt für WENN-DANN-Abfragen.
- TTP229 Text & Enter zurücksetzen: Leert nach der erfolgreichen Verarbeitung alle Puffer und setzt den Enter-Status zurück, um Platz für die nächste Eingabe zu machen.

 

 

🔄 Ablaufsteuerung: Die Profi-Schrittkette (State Machine 2.0)

Egal ob komplexe Menüführungen, smarte Alarmanlagen oder Spielabläufe die neue Profi-Schrittkette 2.0 hebt deine Projekte auf ein völlig neues Level: Sie hat für jeden einzelnen Schritt eine unsichtbare, automatische Stoppuhr integriert!

🛠️ Die Schrittketten-Blöcke im Detail

1. Profi-Schrittkette für Wert (Container-Block)

Sobald sich der Wert der angebundenen Variable (Zustand) ändert, setzt die LogicKiste im Hintergrund automatisch die Zeit für diesen Schritt auf 0 Millisekunden zurück und beginnt neu zu zählen.

2. Aktuelle Schrittzeit in ms

Gibt dir jederzeit auf die Millisekunde genau an, wie lange der aktuelle Zustand schon aktiv ist. Perfekt für automatische Wechsel ohne delay()!

3. Verlasse aktuellen Schritt / Schleife sofort (Break)

Der Notausgang. Bricht den aktuellen Durchlauf sofort ab und das Programm geht geordnet weiter.

4. Starte Hauptprogramm (Loop) sofort neu (Return)

Der absolute "Not-Aus"-Schalter. Zwingt den Arduino, augenblicklich wieder ganz oben in der allerersten Zeile deiner LOOP zu beginnen.

5. Erstelle Merker (static)

Erstellt eine Variable, die nur innerhalb des aktuellen Schritts existiert, sich aber ihren Wert merkt, wenn der Schritt beim nächsten Loop-Durchlauf wieder aufgerufen wird.

💡 Profi-Tipp für sauberen Code:

Nutze innerhalb einer State Machine niemals den Warte (delay)-Block! Nutze stattdessen immer den neuen [Aktuelle Schrittzeit in ms]-Block, um Wartezeiten elegant zu programmieren.

 

⚙️ Ablaufsteuerung: Die State Engine (4-Zonen-Modell)

Die State Engine ist das absolute Kraftpaket für die professionelle Ablaufsteuerung in der LogicKiste. Während einfache Schrittketten im Hintergrund ständig suchen oder abfragen müssen, in welchem Zustand sie sich befinden, arbeitet die State Engine mit hochperformanten C++ Funktionszeigern. Sie springt ohne jeden Zeitverlust und ohne zeitraubende Abhak-Listen direkt im Speicher an die Stelle des aktiven Zustands.

🧠 Die Architektur: Das strukturierte 4-Zonen-Modell

Um sauberen, fehlerfreien Code zu garantieren, zwingt die State Engine das Programm in eine extrem übersichtliche Struktur. Der Haupt-Block unterteilt deinen Ablauf in vier fest definierte Ausführungs-Zonen:

- Zone 0: Echtzeit-Schutz (Laufzeitunabhängig): Dieser Bereich steht ganz oben und wird bei jedem einzelnen Loop-Durchlauf in Mikroskunden-Geschwindigkeit abgearbeitet. Hier gehören kritische Sicherheitsabfragen hinein (Not-Aus, Übertemperatur, Endschalter), die niemals auch nur eine Millisekunde auf Verzögerungen warten dürfen.
- Zone 1: Eingänge (Read / Im Zyklustakt): Hier werden alle normalen Taster, Sensoren und Messwerte zentral eingelesen, die für den regulären Ablauf benötigt werden. Alle nachfolgenden Zustände greifen dadurch auf exakt denselben, stabilen Signalstand zu.
- Zone 2: Zustände (Zeiger / Im Zyklustakt): Das Herzstück! Hier liegen deine einzelnen Zustands-Definitionen. Die State Engine führt hier blitzschnell nur die Funktion aus, deren Zustand aktuell aktiv ist.
- Zone 3: Ausgänge (Write / Im Zyklustakt): Der Bereich für universelle Ausgaben. Hier werden Signale an Displays, LEDs oder Relais gesendet, globale Timer aktualisiert oder übergreifende Schutzverriegelungen durchgesetzt.

🛠️ Die State Engine Blöcke im Detail

1. State Engine (Ablaufsteuerung) ⚙️ (Haupt-Container)

Der umschließende Steuerungsblock für deine 4 Zonen. Er besitzt zwei integrierte Einstellmöglichkeiten direkt im Kopfbereich:

- Zykluszeit (ms): Funktioniert wie die Task-Taktung einer Industrie-SPS. Begrenzt die Ausführung der Zonen 1 bis 3 auf einen festen Rhythmus (z. B. alle 10 ms). Das schont Displays vor Flimmern und entlastet den Bus, während Zone 0 (Echtzeit-Schutz) unbeeinflusst mit voller Geschwindigkeit weiterläuft! Ein Wert von 0 deaktiviert die Sperre.
- Start-Zustand (ID): Bestimmt die Nummer des Zustands, der beim Einschalten oder Reset des Arduinos als allererstes aktiv sein soll.

2. Zustands-IDs (z. B. 1, 5, 7) (State-Block)

Dieser Block wird ausschließlich in Zone 2 angedockt und nimmt deinen eigentlichen Programm-Code für diesen Schritt auf.

- Mehrfach-Zuweisung (ODER-Logik): Ein echtes Highlight! Du musst den Code für identische Aktionen nicht mehrfach kopieren. Tippst du im Textfeld mehrere IDs durch Komma getrennt ein (z. B. 1, 5, 7), lässt der Generator die Funktionszeiger dieser drei Zustände im Hintergrund automatisch auf denselben C++-Codeblock verweisen.

3. Wechsle zu Zustand (ID) (Transition)

Der Befehl zum Umschalten. Sobald dieser Block aufgerufen wird, überschreibt das System den Funktionszeiger auf die neue Ziel-ID, setzt den integrierten Timer automatisch zurück und springt aus dem aktuellen Zustand sauber direkt weiter in Zone 3.

4. Dauer im aktuellen Zustand (ms) (Automatischer Timer)

Jeder Zustand besitzt eine unsichtbare, automatische Stoppuhr im Hintergrund. Dieser Werte-Block gibt dir jederzeit auf die Millisekunde genau zurück, wie lange der aktuelle Zustand bereits ohne Unterbrechung aktiv ist. Perfekt für zeitgesteuerte Abläufe, Einschaltverzögerungen (TON) oder Timeout-Überwachungen!

 

 

🧠 SPS Multi-Logik: Komplexe Bedingungen leicht gemacht

Mit der neuen Multi-Logik im SPS-Stil gehören riesige ODER-Block-Wüsten der Vergangenheit an. Du kannst nun bis zu vier Bedingungen übersichtlich in einem einzigen Block untereinander stapeln.

🛠️ Die Multi-Logik-Blöcke im Detail

1. UND (3-fach / 4-fach)

Die angeschlossene Logik wird nur dann ausgeführt, wenn wirklich ALLE angedockten Bedingungen gleichzeitig erfüllt (wahr) sind.

2. ODER (3-fach / 4-fach)

Die angeschlossene Logik wird ausgeführt, sobald MINDESTENS EINE der angedockten Bedingungen erfüllt (wahr) ist.

💡 Profi-Tipp für leere Eingänge:

- Beim ODER-Block: Ein leerer Eingang wird einfach ignoriert.
- Beim UND-Block: Achtung! Ein einziger leerer (also falscher) Eingang macht direkt den ganzen Block falsch! Nutze immer den exakt passenden Block.

 

🗂️ Ablaufsteuerung: Das Klassen-Register (State Pattern)

Das Klassen-Register bildet die Spitze der objektorientierten Ablaufsteuerung in der LogicKiste. Während herkömmliche Schrittketten Variablen oft global ablegen und gegenseitig überschreiben können, arbeitet dieses System nach dem professionellen State Pattern: Jeder einzelne Zustand wird als völlig isolierte, geschlossene C++ Klasse generiert.

🛡️ Höchste Sicherheit durch Kapselung

Das größte Problem bei komplexen Projekten sind unbeabsichtigte Überschneidungen zum Beispiel, wenn ein Schritt eine Variable ändert, die eigentlich für einen ganz anderen Schritt gedacht war. Durch die objektorientierte Kapselung ist jeder Zustand eine geschützte "Kiste" für sich. Variablen und Logik innerhalb eines Zustands können benachbarte Zustände nicht versehentlich beeinflussen.

🛠️ Die Klassen-Register Blöcke im Detail

1. Zustands-Register (Klassen-Modell) 🗂️ (Haupt-Container)

Der zentrale Sammelordner für dein Projekt. Dieser Block liegt auf der Arbeitsfläche und nimmt alle deine definierten Zustands-Blöcke geordnet untereinander auf.

- Start-Zustand (Name): Tippe hier einfach den exakten Namen des Zustands ein (z. B. Start oder Idle), der beim Einschalten oder Reset des Arduinos als allererstes aktiv werden soll.

2. Zustand (Name) (Der Klassen-Block)

Dieser Block wird direkt in den Bauch des Zustands-Registers geschoben. Jeder Zustand ist in drei klare Lebenszyklus-Phasen unterteilt:

- Einmalig beim Start (Enter): Code in diesem Schlitz wird exakt ein einziges Mal ausgeführt, wenn der Zustand betreten wird. Ideal, um Relais gezielt einzuschalten, Statusmeldungen auszugeben oder Timer zu starten.
- Zyklisch (Update): Das Hauptprogramm des Zustands. Solange dieser Zustand aktiv ist, wird der enthaltene Code in Dauerschleife wiederholt (z. B. Sensoren auslesen, Werte prüfen).
- Einmalig beim Ende (Exit): Die automatische Aufräum-Funktion! Dieser Code wird genau ein einziges Mal ausgeführt, kurz bevor der Zustand verlassen wird. So wird garantiert, dass beispielsweise Motoren oder Heizungen sicher abgeschaltet werden, bevor der nächste Zustand übernimmt.

3. Wechsle zu Zustand (Name) (Transition)

Der Umschalt-Befehl innerhalb deiner Zustände. Tippe im Textfeld einfach den Namen des Ziel-Zustands ein, den du im Register angelegt hast.

- Ablauf beim Wechsel: Sobald dieser Block aufgerufen wird, beendet das System den aktuellen Zustand (führt dessen Exit-Code aus) und startet sofort den neuen Zustand (führt dessen Enter-Code aus).

💡 Profi-Tipp für saubere Strukturen

Da das Klassen-Modell auf strikter Trennung basiert, nutze diesen Baustein besonders bei Anlagen und Projekten, die klar voneinander abgegrenzte Modi haben (z. B. Initialisierung ➔ Automatikbetrieb ➔ Handbetrieb ➔ Störung). Das sorgt für ein absolut flackerfreies und sauberes Schaltverhalten deiner Hardware.

 

 

🦾 16-Kanal-PWM mit dem PCA9685-Shield

Mit den PCA9685-Blöcken kannst du das 16-Kanal-12-Bit-PWM-Shield kinderleicht über den I2C-Bus ansteuern. Das Shield braucht nur zwei Datenleitungen und übernimmt die komplette Taktung der Servos selbst.

🧠 Wichtig: Das automatische Positions-Gedächtnis

Damit deine Konstruktionen nicht wild zucken, merkt sich das System jederzeit den exakten Ist-Zustand jedes Servos. Wenn du eine Rampe startest, weiß das Programm haargenau, an welchem Winkel der Servo steht und fährt weich los.

🛠️ Die PCA9685-Blöcke im Detail

1. Setup PCA9685 Shield

Bindet die Bibliothek ein und legt Startwinkel (90°) fest. Gehört in den SETUP-Bereich.

2. PCA9685 Startwert festlegen

Definiert eine feste Parkposition für deine Servos beim Einschalten.

3. PCA9685 Servo (0-180°)

Der Servo springt ohne Verzögerung direkt auf die gewünschte Position.

4. PCA9685 Servo Rampe

Fährt den Servo nicht ruckartig, sondern in kleinen Einzelschritten (blockiert die LOOP, bis das Ziel erreicht ist).

5. PCA9685 Servo trennen (Stromlos)

Der Servo verliert seine Haltekraft und lässt sich von Hand bewegen (spart Energie).

6. PCA9685 Servo verbinden (Haltekraft)

Bestromt den Servo blitzschnell wieder auf exakt seinem letzten Winkel.

7. PCA9685 360° Servo

Spezialblock für durchlaufende Servos ohne mechanischen Anschlag. (90 = Stopp).

8. PCA9685 PWM

Verwandelt einen Kanal in einen klassischen analogen Ausgang (0 bis 255) zum Dimmen von LEDs oder DC-Motoren.

💡 Profi-Tipp für stabile Hardware

Versorge das Shield niemals allein über den 5V-Pin des Arduinos! Schließe an die grüne Schraubklemme immer ein separates, starkes Netzteil an.

 

 

🖥️ Anlagen-Simulationen in Echtzeit

Mit den Simulations-Blöcken der LogikKiste kannst du deine Programme am PC visuell testen, bevor du Hardware baust. Über USB verbindet sich dein Arduino mit der interaktiven Python-Simulation auf dem Monitor.

🐍 Die Basis: Python & die Simulations-Erweiterung

Installiere auf deinem PC Python und die Erweiterungen (pyserial). Starte die `main.py` und wähle den COM-Port deines Arduinos.

🧠 Wichtig: Das SPS-Prinzip & die Zykluszeit

Der Arduino aktualisiert Ein- und Ausgänge in einem festen Takt (Prozessabbild), was deinen PC-Prozessor massiv schont.

🛠️ Die Simulations-Blöcke im Detail

⏱️ 1. SPS Zykluszeit

Legt fest, in welchem Takt dein Arduino Daten liest und an die PC-Simulation überträgt (z. B. "Normal 100 ms").

🏭 2. Förderband Motor PWM

Steuert den Bandantrieb der Förderband-Simulation stufenlos an (0 bis 255).

🏭 3. Lichtschranke belegt?

Gibt True zurück, sobald ein Paket den Lichtstrahl der Lichtschranke unterbricht.

🚪 4. Tor Motor mit Speed (PWM)

Steuert den Hauptantrieb des Automatiktores (HOCH, RUNTER, STOPP).

🚪 5. Tor Stepper | Gehe zu Schritt

Setzt das Tor über eine präzise Schrittmotor-Positionierung an ein exaktes Ziel.

🚪 6. HMI Text senden

Schreibt individuelle Textmeldungen (z. B. Status/Fehler) auf das virtuelle Schaltschrank-Display.

💥 7. Presse | Förderband Motor & Stempel

Schaltet das Zufuhrband ein/aus oder steuert die Bewegung des Pressstempels.

💥 8. Presse | Aktueller Pressdruck (Bar)

Gibt den aktuellen Druck in Bar als Zahlenwert zurück.

💡 Profi-Tipp für fehlerfreies Testen

Wenn du deine Schaltung auf den Arduino überträgst, musst du die Python-Simulation am PC nicht schließen! Der Schutzschild fängt den Abbruch automatisch ab.

 

 

🖥️ Das LCD Keypad Shield: Display & Taster in einer Einheit

Das LCD Keypad Shield kombiniert ein zweizeiliges Textdisplay (16x2) mit fünf programmierbaren Tastern. Mit den Blöcken der LogikKiste kannst du Texte ausgeben und Menüsteuerungen direkt umsetzen.

📟 Hardware-Aufbau & Funktionsweise

- Fixe Display-Pins: Die Pin-Belegung übernimmt der Setup-Block automatisch.
- Analoge Taster-Leiter (Pin A0): Alle fünf Taster hängen an einem einzigen analogen Eingang.
- Taster-Profi-Events: Die LogikKiste stellt dir Komfort-Funktionen wie Einfachklick, Doppelklick, langes Halten bereit.

⚙️ Setup LCD Keypad Shield

Initialisiert das Display und bereitet den analogen Taster-Handler vor. Die Schwellenwerte für Standard-Shields sind bereits optimal eingestellt.

📝 LCD Shield Schreibe

Schreibt einen festen Text oder eine Variable auf das Display. Ideal für statische Ausgaben.

🔄 LCD Shield Überschreibe mit

Schreibt den neuen dynamischen Wert und hängt sofort unsichtbare Leerzeichen an. Alte, längere Zahlen werden nahtlos überschrieben, ohne das Display komplett zu leeren. Das verhindert Bildschirm-Flackern!

🎬 LCD Shield Aktion

Führt Steuerungsbefehle aus (z. B. Display leeren, Cursor blinken EIN/AUS). Nutze "Display leeren" nur beim kompletten Menüwechsel.

🔘 LCD Shield Taster

Liest die Tasten (Rechts, Oben, Unten, Links, Select) aus und wertet nach Events (Einfachklick, Doppelklick etc.) oder direktem Druckzustand aus.

💡 Profi-Tipp für ein ruhiges Display

Ein Arduino durchläuft die loop() tausende Male pro Sekunde. Wenn du Werte ununterbrochen auf das LCD schreibst, fängt die Anzeige an zu flimmern. So machst du es richtig: Setze den Block LCD Shield Überschreibe mit immer in einen Timer-Block (z. B. alle 200 ms). Das verbraucht kaum Rechenleistung und sorgt für ein glasklares, ruhiges Schriftbild!

 

 

⏳ Einfacher Intervall-Timer (Ohne Delay)

Dieser Block führt deinen Code in regelmäßigen Abständen aus, ohne den restlichen Arduino zu blockieren. Die Zeitsteuerung arbeitet im Hintergrund automatisch über die millis()-Funktion.

- Intervall festlegen: Du dockst einfach eine Zahl für die gewünschten Millisekunden an.
- Aktion definieren: Der Code, der wiederholt ausgeführt werden soll, wird in den MACHE-Zweig eingefügt.

 

 

🔄 Intervall-Timer mit integriertem Zähler

Dieser erweiterte Timer führt den Code im gewünschten Intervall aus und zählt gleichzeitig automatisch eine Variable (den Zähler) hoch.

- Timer definieren: Du vergibst im Block einen eindeutigen Namen (z. B. Takt1). Das System legt im Hintergrund automatisch globale Variablen für die Zeit und den Zähler an.
- Zähler lesen: Dieser runde Block gibt dir den aktuellen Zählerstand deines gewählten Timers als Zahl zurück.
- Zähler auf X setzen: Setzt den Zähler des Timers mitten im Betrieb auf einen bestimmten, von dir gewählten Wert.
- Zähler auf 0 setzen: Eine schnelle Reset-Funktion, die den Zählerstand sofort wieder auf 0 zurückstellt.

 

 

⏱️ Die Stoppuhr-Funktionen

Mit diesen Blöcken kannst du völlig unabhängig vom restlichen Programmablauf Zeitspannen messen.

- Stoppuhr anlegen: Erstellt eine neue Stoppuhr mit einem frei wählbaren Namen. Dieser Name erscheint danach bequem als Auswahl im Dropdown-Menü der anderen Stoppuhr-Blöcke.
- Stoppuhr steuern: Über einen Dropdown-Befehl kannst du die ausgewählte Uhr jederzeit starten, stoppen, zurücksetzen oder komplett neu starten.
- Zeit auslesen: Du kannst die gemessene Zeit in verschiedenen Formaten abrufen. Zur Auswahl stehen unter anderem Millisekunden, Sekunden, Minuten oder auch Stunden.

 

 

📉 Analog Glätten (Durchschnittswerte)

Dieser Block liest einen analogen Wert mehrfach aus und berechnet daraus automatisch den Durchschnitt. Das ist besonders nützlich, um unruhige oder schwankende Sensorsignale zu beruhigen.

- Pin-Auswahl: Wähle den gewünschten analogen Eingang (A0 bis A5).
- Messungen & Pause: Bestimme, wie viele Messungen (1 bis 100) durchgeführt werden sollen und wie lange die Pause in Millisekunden (0 bis 100) zwischen den einzelnen Messungen ist.

 

 

🔘 Profi-Taster & Events (inkl. Klickzähler)

Dieser hochoptimierte Hauptblock erkennt verschiedene Klick-Arten eines Tasters zuverlässig und stellt gleichzeitig Zähler-Funktionen zur Verfügung. Im Hintergrund wird dafür automatisch die KK_ButtonHandler Bibliothek geladen.

- Event-Erkennung: Der Block erkennt zuverlässig Einfachklicks, Doppelklicks sowie langes Halten.
- Pin-Auswahl: Du kannst die Taster an den digitalen Pins (2 bis 13) oder den analogen Pins (A0 bis A5) anschließen.
- Zeit-Parameter: Für die Erkennung von Doppelklicks und langem Halten kannst du die benötigte Zeit in Millisekunden flexibel andocken.
- Integrierter Klickzähler: Mit den drei passenden Zähler-Blöcken kannst du die aktuelle Anzahl der Klicks als Zahl auslesen, den Zähler auf einen bestimmten Wert überschreiben oder ihn sofort auf 0 zurücksetzen.

 

 

🚌 CAN-Bus Kommunikation

Mit diesen Blöcken kannst du mehrere Arduino R4 Boards über den robusten CAN-Bus (Pins: CRX / CTX) miteinander vernetzen und Daten austauschen.

🛠️ Die CAN-Blöcke im Detail

- CAN-Bus Setup: Initialisiert den CAN-Bus an deinem Arduino. Hier legst du deine eigene Modul-ID (Modul 1 bis 11) fest, damit dich andere Boards im Netzwerk erkennen können.
- CAN Senden (Zyklisch): Sendet einen Wert automatisch im festgelegten Takt (in Millisekunden) auf den Bus. Du kannst den Kanal und den Datentyp (z.B. Bit, Ganze Zahl oder Kommazahl) frei wählen.
- CAN Senden (Bei Änderung): Sendet den Wert nur dann, wenn er sich seit dem letzten Durchlauf tatsächlich verändert hat (Flankenauswertung). Das spart extrem viel Bus-Auslastung!
- Wenn CAN empfangen: Führt den angehefteten Code aus, sobald eine Nachricht von einem bestimmten Modul auf dem gewählten Kanal eintrifft. Der empfangene Wert wird dabei direkt in deiner ausgewählten Variable gespeichert.

 

 

💳 RFID-Kartenleser (RC522)

Diese Blöcke ermöglichen das Einlesen von RFID-Chips und Karten über das SPI-Protokoll.

🛠️ Die RFID-Blöcke im Detail

- RFID-Leser starten: Startet den RC522 und gehört in den SETUP-Bereich. Die Pins SCK, MOSI und MISO müssen zwingend an die festen SPI-Pins des Arduinos angeschlossen werden. Die SDA/SS- und RST-Pins kannst du im Block frei definieren.
- ID ausgeben (Serial): Liest eine RFID Karte und gibt die ausgelesene ID direkt auf dem seriellen Monitor des PCs aus. Dieser Block gehört in die Haupt-LOOP.
- Irgendeine Karte erkannt: Gibt den Wahrheitswert WAHR zurück, wenn eine beliebige Karte auf dem Leser liegt. Perfekt als einfache Bedingung in einem WENN-Block.
- Spezifische Karte: Gibt nur dann WAHR zurück, wenn die aufgelegte Karte exakt der eingetippten ID (z.B. "33 0E B9 17") entspricht. Ideal für Zugangskontrollen!

 

 

📦 Struktur-Container (Gruppieren)

Diese farbigen Container dienen ausschließlich der Übersichtlichkeit in deinem Arbeitsbereich. Du kannst damit Logik-Blöcke optisch gruppieren und als ganzes Paket verschieben oder kopieren.

- Funktion: Sie haben keinerlei Einfluss auf den generierten C++ Code im Hintergrund. Der Code der darin liegenden Blöcke wird einfach ganz normal durchgereicht.
- Farben: Für ein sauberes visuelles Leitsystem stehen dir 7 verschiedene Gruppen-Farben (z.B. Rot, Grün, Blau) zur Verfügung. Das Textfeld im Block kannst du zur Beschriftung völlig frei anpassen.

 

 

🔄 Arduino Neustart (System Reset)

Mit diesem Block kannst du den Arduino UNO R4 per Software hart neu starten lassen.

- Anwendung: Sobald das Programm diesen Block erreicht, wird ein sofortiger Reset ausgelöst (ähnlich wie das Drücken des Reset-Tasters auf der Platine).
- ⚠️ Achtung: Nicht gespeicherte Daten (die nicht fest im EEPROM stehen) gehen bei diesem Vorgang unwiderruflich verloren!

 

 

🔢 Einfacher Tastendruck-Zähler (Entprellt)

Dieser Block zählt jeden physischen Tastendruck (die abfallende Flanke) und speichert den Wert direkt in einer von dir gewählten Variable. Die Variable wird dabei im Hintergrund automatisch als Integer-Zahl erstellt.

- Automatische Hardware-Konfiguration: Der ausgewählte Pin wird vollautomatisch mit dem internen PULLUP-Widerstand (INPUT_PULLUP) deines Arduinos initialisiert.
- Entprell-Zeit: Um Fehlzählungen durch mechanisches "Prellen" (Flackern) des Tasters zu verhindern, dockst du eine Entprell-Zeit in Millisekunden an. Das System prüft die Zeitspanne seit dem letzten Tastendruck sauber über die millis()-Funktion.

 

 

📏 Ultraschall Distanzsensor (HC-SR04)

Dieser Block misst die Entfernung zu einem Objekt in Zentimetern über den bekannten HC-SR04 Ultraschallsensor. Um das Programm nicht zu blockieren, arbeitet der Block mit einem intelligenten Zeitintervall.

- Pin-Definition: Du kannst den Trigger-Pin (Trig) und den Echo-Pin frei im Block festlegen. Die Pin-Modi (OUTPUT / INPUT) werden im Hintergrund automatisch konfiguriert.
- Mess-Intervall (ms): Das Intervall (Standard: 60 ms) verhindert störende Echo-Überlagerungen, ohne die Haupt-LOOP deines Arduinos einzufrieren. Bis zum Ablauf des Intervalls liefert der Block stabil den letzten gemessenen Wert zurück.

 

 

🔄 Gyro- & Beschleunigungssensor (MPU6050)

Mit diesen Blöcken liest du die Neigung, Bewegung und Raumlage über den MPU6050 Lagesensor aus (verwendet die Adafruit MPU6050 & Wire Bibliothek).

🛠️ Die Gyro-Blöcke im Detail

- SETUP MPU6050: Initialisiert den I2C-Sensor und stellt die Messbereiche (±8g Beschleunigung, ±500°/s Rotation) sowie den Filter automatisch ein. Dieser Block gehört fest in den SETUP-Bereich.
- Gyro auslesen: Dieser Werte-Block liefert dir die Messwerte als Zahl zurück. Über ein Dropdown-Menü wählst du bequem aus, was du messen möchtest: Beschleunigung (X, Y, Z), Rotation/Gyroskop (X, Y, Z) oder die aktuelle Chip-Temperatur in °C.

 

 

📜 E-Paper Display 4.2" (Waveshare Rev 2.2)

E-Paper Displays behalten ihr Bild selbst dann bei, wenn der Strom komplett abgeschaltet wird. Diese Blöcke steuern das 4.2-Zoll Schwarz-Weiß-Display (Rev 2.2) im extrem sparsamen Paged-Mode an.

🛠️ Die E-Paper Blöcke im Detail

- E-Paper Setup: Initialisiert das Display über die Pins CS, DC, RST und BUSY. Zusätzlich kannst du die Bildschirm-Ausrichtung/Rotation (0°, 90° Querformat, 180°, 270°) festlegen. Gehört ins SETUP.
- E-Paper Aktualisieren (Steuer-Container): Das wichtigste Element! Da E-Paper Displays im Paged-Mode arbeiten, müssen alle Text-, Grafik- und Zeichenbefehle zwingend in den Bauch dieses Container-Blocks gelegt werden. Du kannst zwischen "Full Update" (vollständiger Neuaufbau) und "Fast Refresh" (schneller Teillauf) wählen.
- Schriftart setzen: Wechselt die Schriftart für nachfolgende Texte. Zur Auswahl stehen die Standard-Systemschrift sowie verschiedene Adafruit-Schriftarten (Mono Fett, Sans, Serif).
- Text schreiben (X/Y): Platziert einen Text oder Wert an exakten Koordinaten (X/Y) inklusive Wahl der Textgröße, Textfarbe (Schwarz/Weiß) und Hintergrundfarbe (Transparent, Weiß, Schwarz).
- Text drucken (Fließtext): Druckt Text oder Variablen fortlaufend wie auf einer Schreibmaschine, wahlweise mit automatischem Zeilenumbruch (neue Zeile).
- Formen & Pixel zeichnen: Ermöglicht das Zeichnen von Linien, Rechtecken, abgerundeten Rechtecken, Kreisen, Dreiecken (jeweils gefüllt oder als Rahmen) sowie einzelnen Pixeln.
- Bild aus Designer einfügen: Über einen komfortablen Pop-up Editor kannst du vorbereiteten Pixel-Code direkt aus dem Pixel-Designer einfügen, um eigene Grafiken und Logos anzuzeigen.

 

 

🖥️ Standard I2C LCD Display (16x2 / 20x4)

Im Gegensatz zum Direkt-Shield sparen diese Blöcke wertvolle Pins, indem sie Standard-LCDs über den I2C-Bus (nur 2 Datenleitungen) ansteuern. Sie nutzen im Hintergrund die `LiquidCrystal_I2C` Bibliothek.

🛠️ Die I2C-LCD Blöcke im Detail

- I2C Setup: Initialisiert das Display im SETUP-Bereich. Du kannst das Format (16x2, 20x4 oder 20x2 Zeichen) und die I2C-Adresse (standardmäßig 0x27 oder alternativ 0x3F) auswählen.
- Text schreiben: Schreibt einen Text oder Variablenwert an eine exakte Position (Zeile und Spalte, Zählung beginnt bei 0).
- Display löschen: Leert den gesamten Bildschirm des Displays komplett (clear).
- Aktionen & Effekte: Über diesen Block kannst du spezielle Display-Funktionen schalten. Dazu gehören das Ein-/Ausschalten des Hintergrundlichts, das Ein-/Ausschalten der Textanzeige sowie blinkende oder Unterstrich-Cursor-Linien.

 

 

🌈 NeoPixel RGB-LEDs (WS2812)

Mit den NeoPixel-Blöcken steuerst du einzeln adressierbare WS2812 RGB-LED-Streifen oder -Ringe über eine einzige Datenleitung an (basiert auf der `Adafruit_NeoPixel` Bibliothek).

🛠️ Die NeoPixel-Blöcke im Detail

- NeoPixel Setup: Legt den verwendeten Daten-Pin und die Gesamtanzahl der LEDs fest. Dieser Block gehört ins SETUP.
- Einzelnen Pixel schalten: Setzt die Farbe eines bestimmten Pixels über die Farbwerte Rot, Grün und Blau (RGB von 0 bis 255). Wichtig: Die Zählung der LEDs beginnt im Code bei 0!
- Pixel-Liste schalten: Schaltet eine ganze Gruppe von LEDs gleichzeitig auf dieselbe Farbe, indem du die Nummern einfach kommagetrennt eintippst (z. B. "0, 1, 2, 5").
- Aktualisieren (Show): Sehr wichtig: Die Farbbefehle werden im RAM gesammelt. Erst wenn dieser Block aufgerufen wird, werden die Farben physikalisch an die LEDs übertragen und leuchten auf!
- Code aus Web-Designer: Erlaubt das direkte Einfügen von kopiertem C++ Code aus dem NeoPixel Web-Designer für komplexe Farbmuster und Animationen.

 

 

🔠 MAX7219 LED-Punktmatrix & Laufschrift

Diese Blöcke steuern 8x8 LED-Punktmatrizen an, die über den MAX7219-Chip kaskadiert sind. Sie nutzen die leistungsfähige `MD_Parola` Bibliothek für Texte und Animationen.

🛠️ Die MAX7219-Blöcke im Detail

- Setup Dot-Matrix: Konfiguriert den CS-Pin, die Anzahl der zusammengesteckten Module und die Grundhelligkeit (0 bis 15). Gehört ins SETUP (Hardware SPI nutzt DIN an Pin 11, CLK an Pin 13).
- Statischer Text: Zeigt festen Text auf der Matrix an (ausgerichtet nach Links, Mitte oder Rechts).
- Einzel-Pixel & Pixel-Liste: Ermöglicht das gezielte Einschalten (AN/AUS) einzelner LED-Punkte über X/Y-Koordinaten oder über eine kommagetrennte Liste von LED-IDs.
- Animation & Laufschrift: Der mächtigste Block für dynamische Texte! Muss zwingend in den Haupt-LOOP gelegt werden. Du kannst Laufschriften in alle Richtungen scrollen lassen oder Effekte wie Pacman, Überblenden (Fade), Wischen (Wipe), Auflösen (Dissolve) oder Zufallseffekte für den Ein- und Austritt des Textes definieren. Tempo und Pausezeiten lassen sich frei anpassen.
- Helligkeit ändern: Passt die Helligkeit der gesamten Matrix mitten im laufenden Betrieb dynamisch an (0 = sehr dunkel, 15 = maximale Leuchtkraft).
- Matrix Aktionen: Bietet Schnellbefehle zum Invertieren der Anzeige (Negativbild), Zurückkehren in den Normalmodus oder zum sofortigen Löschen aller LEDs.

 

 

🖥️ OLED Display 128x64 / 128x32 (SSD1306)

Diese Blöcke steuern kompakte, kontrastreiche OLED-Grafikdisplays über den I2C-Bus an (basiert auf der Adafruit SSD1306 & GFX Bibliothek).

🛠️ Die OLED-Blöcke im Detail

- Setup OLED: Wähle die Display-Größe (0.96 Zoll mit 128x64 Pixeln oder 0.91 Zoll mit 128x32 Pixeln) sowie die I2C-Taktfrequenz (100 kHz, 400 kHz Schnell oder 1000 kHz Ultra). Gehört ins SETUP.
- Schriftart & Größe: Wechselt die Darstellung der Schrift für nachfolgende Texte (z. B. System5x7, font5x7, lcd5x7 oder Retro font8x8).
- Display löschen & Hintergrund füllen: Ermöglicht das komplette Löschen der Anzeige (Setzen auf Schwarz) oder das Füllen des gesamten Bildschirms mit Weiß bzw. Schwarz.
- Text schreiben (Fließtext & X/Y): Platziert Texte oder Zahlen fortlaufend oder an exakten Koordinaten (X/Y). Über den Farbauswahl-Block kannst du gezielt in Weiß schreiben oder in Schwarz schreiben, um alten Text sauber wegzuradieren!
- Formen zeichnen: Ermöglicht das Zeichnen von Linien, Rechtecken, Kreisen und Dreiecken (jeweils gefüllt oder als Rahmen) in Weiß oder Schwarz.
- OLED Bild einfügen: Öffnet einen komfortablen Code-Editor, um eigene Grafiken aus dem OLED Pixel-Designer direkt auf das Display zu zaubern.

 

 

📺 TFT Farbdisplays (ST7735 & ILI9486)

Mit diesen Blöcken steuerst du hochauflösende TFT-Farbdisplays über den schnellen SPI-Bus an.

🛠️ Die TFT-Blöcke im Detail

- TFT Setup (ST7735 & ILI9486): Konfiguriert die Pins für Chip Select (CS), Data/Command (DC) und Reset (RST) sowie die Bildschirm-Rotation (0° bis 270°). Für das ILI9486 lässt sich zudem eine Startfarbe festlegen. Optionale Häkchen erlauben SPI-Optimierungen und Korrekturen. Gehört ins SETUP.
- Text schreiben: Schreibt Text an eine exakte X/Y-Position inklusive Wahl der Schriftgröße, Textfarbe (z. B. Weiß, Rot, Grün, Blau, Gelb) und Hintergrundfarbe (oder Transparent).
- Formen zeichnen: Bietet Funktionen zum Zeichnen von Linien, Rechtecken (auch abgerundet), Kreisen und Dreiecken (jeweils als Rahmen oder ausgefüllt) in allen Hauptfarben.
- Bildschirm füllen (fillScreen): Überflutet das gesamte Display auf einen Schlag mit einer wählbaren Hintergrundfarbe.

 

 

🔢 TM1637 & TM1638 Displays & Keypads

Diese Blöcke steuern beliebte 7-Segment-Displays und Tastatur-Platinen an, die extrem wenig Pins am Arduino verbrauchen.

1. TM1637 (Kleines 4-Digit Display)

- Setup: Initialisiert das 4-stellige Display über die Pins CLK und DIO im SETUP-Bereich.
- Helligkeit setzen: Passt die Leuchtkraft des Displays an (Wertebereich von 0 = sehr dunkel bis 7 = maximal hell).
- Zahl anzeigen: Gibt eine Zahl auf dem Display aus, wahlweise mit aktivierter oder deaktivierter Doppelpunkt-Anzeige in der Mitte (ideal für Uhren).

2. TM1638 Modell 1 (8 Siebensegment-Anzeigen, 8 LEDs & 8 Tasten)

- Setup & Helligkeit: Konfiguriert das Modul über die Pins STB, CLK und DIO sowie die Helligkeit (0-7) im SETUP.
- Zahl anzeigen: Stellt Zahlen auf den 8 Segmenten dar (mit Ausrichtung nach Links oder Rechts und schaltbaren führenden Nullen).
- LEDs schalten: Ermöglicht das An- und Ausschalten der 8 roten Einzel-LEDs (über dem Display) per fester LED-Nummer (1-8) oder dynamisch per Variable.
- Tasten abfragen: Liest die 8 Taster aus. Du kannst die gedrückte Taste (1-8) in einer Variable speichern, prüfen ob eine spezifische Taste gedrückt ist oder abfragen, ob überhaupt irgendeine Taste gedrückt wird.

3. TM1638 Modell 2 (16 Tasten Feld)

- Funktionsumfang: Spezieller Setup- und Steuerungsblock für das Modell 2 mit 16 Tasten. Bietet erweiterte Punkt-Steuerungen (DOTS 0-255) für Kommastellen sowie Abfragen für alle 16 Tasten.

 

 

⚙️ Klassische Schrittmotoren (ULN2003 / Stepper.h)

Mit diesen Blöcken steuerst du Standard-Schrittmotoren (wie den 28BYJ-48 mit ULN2003 Treiber-Platine) über die offizielle Arduino `Stepper.h` Bibliothek an.

🛠️ Die Stepper-Blöcke im Detail

- Stepper anlegen (Setup): Registriert einen neuen Motor mit frei wählbarem Namen (z. B. meinMotor), den Steuer-Pins IN1 bis IN4 sowie den Schritten pro Umdrehung (z. B. 2048). Über ein Häkchen lässt sich das automatische Positions-Tracking aktivieren.
- Motor bewegen: Fährt den ausgewählten Motor um eine bestimmte Anzahl an Schritten mit der gewünschten Geschwindigkeit (RPM / Umdrehungen pro Minute) und Richtung (1 = Vorwärts, -1 = Rückwärts).
- Position zurücksetzen (Reset): Überschreibt den internen Schrittzähler (Positionstracking) im laufenden Betrieb mit einem neuen Startwert.

 

 

🏗️ NEMA Schrittmotoren (Blockierend & Kooperativ)

Diese Hochleistungs-Blöcke steuern kraftvolle NEMA-Schrittmotoren über Schritt- und Richtungs-Treiber (z. B. A4988 oder DRV8825) an. Sie bieten integrierte, exponentielle Anlauf-Rampen für weiche Bewegungen.

🛠️ Die NEMA-Blöcke im Detail

- NEMA Stepper (blockierend): Führt die angegebene Schrittanzahl am Stück aus. Positive Schrittzahlen fahren vorwärts, negative Schrittzahlen rückwärts. Das Tempo wird über die Puls-Pause in Mikrosekunden (µs) bestimmt. Die Anlauf-Rampe (Aus, Schnell, Medium, Langsam) verhindert Schrittverluste beim Anfahren.
- NEMA Stepper (Kooperativ / Non-Blocking): Fährt die Gesamtschritte in kleinen "Häppchen" (Teilschritte pro Loop-Durchlauf) ab. Dadurch bleibt das Hauptprogramm flüssig und reagiert weiterhin auf Sensoren oder Taster. Ausgestattet mit demselben Vorzeichen- und Rampen-System.
- Position auslesen & resetten (Motor 1): Ermöglicht das Auslesen der exakten, mitgezählten Schrittposition von NEMA-Motor 1 als Zahl oder das Überschreiben der Position auf einen neuen Referenzwert.

 

 

🎛️ Virtuelle Ports (Pin-Gruppen A-F)

Mit diesen Blöcken fasst du mehrere beliebige Pins zu einer logischen Gruppe (A bis F) zusammen. Dadurch kannst du mehrere Ausgänge (z. B. eine LED-Reihe) oder Eingänge (z. B. eine Schalter-Kombination) mit einem einzigen Bit-Muster schalten oder abfragen.

🛠️ Die Virtuellen-Port Blöcke im Detail

- Virtuellen Port definieren: Erstellt eine Pin-Gruppe (A bis F) im SETUP. Du wählst den Modus (OUTPUT für Ausgänge, INPUT oder INPUT_PULLUP für Eingänge) und gibst die Pins einfach kommagetrennt ein (z. B. "3, 4, 5, 6, 7").
- Virtuellen Port schalten (Muster senden): Schaltet die Pins der Gruppe nacheinander von links nach rechts per Bit-Muster. (1 = Pin AN/HIGH, 0 = Pin AUS/LOW, _ = Zustand ignorieren/unverändert lassen).
- Virtuellen Port prüfen (Muster lesen): Prüft die Zustände aller Pins der Gruppe gleichzeitig. Gibt WAHR zurück, wenn das eingehende Signal exakt deinem Muster entspricht (1 = HIGH erwartet, 0 = LOW erwartet, X = Zustand egal).

 

 

🌡️ DS18B20 OneWire Temperatursensoren

Diese Blöcke ermöglichen das präzise Auslesen von einem oder mehreren DS18B20 Wasserdichten Temperatursensoren über eine einzige Datenleitung (OneWire-Bus).

🛠️ Die DS18B20-Blöcke im Detail

- DS18B20 Setup: Initialisiert den OneWire-Datenbus an einem frei wählbaren Pin im SETUP-Bereich.
- Sensor zuweisen (Index / Adresse): Weist einem Sensor einen Namen zu, entweder über seine Reihenfolge am Bus (Index 0, 1, ...) oder über seine eindeutige 64-Bit Hardware-Adresse.
- Temperatur auslesen: Liest die gemessene Temperatur des gewählten Sensors direkt in Grad Celsius (°C) aus.
- Diagnose-Block: Prüft, ob Sensoren am Bus gefunden wurden und gibt Statusmeldungen auf dem Seriellen Monitor aus.

 

📡 Infrarot (IR) Senden & Empfangen

Mit den IR-Blöcken kannst du Signale von handelsüblichen Infrarot-Fernbedienungen empfangen oder selbst IR-Befehle an Geräte (z. B. Fernseher) senden.

🛠️ Die IR-Blöcke im Detail

- IR Transceiver Setup: Legt den Empfänger-Pin (z. B. VS1838B) und optional den Sende-Pin fest. Gehört ins SETUP.
- Wenn IR empfangen (Event-Block): Dieser Container-Block wird automatisch ausgeführt, sobald ein IR-Signal von einer Fernbedienung empfangen wird.
- IR Wert auslesen: Liest den empfangenen Hex-Code der gedrückten Taste als Zahl oder Text aus.
- IR Standard Senden: Sendet einen spezifischen Hex-Befehl nach gängigen Protokollen (z. B. NEC, Sony, RC5).
- IR Raw Senden: Sendet rohe Timing-Signale für exotische oder unbekannte Infrarot-Protokolle.

 

 

🔲 Arduino R4 Onboard LED-Matrix (12x8)

Der Arduino UNO R4 WiFi besitzt direkt auf der Platine eine rote 12x8 LED-Matrix. Diese Blöcke nutzen die originale `Arduino_LED_Matrix` Bibliothek.

🛠️ Die R4-Matrix Blöcke im Detail

- Matrix Setup: Initialisiert die Onboard-Matrix des R4 im SETUP-Bereich.
- Symbol anzeigen: Spielt fertige Symbole und Icons (z. B. Herz, Pfeile, Ausrufezeichen, Smiley) direkt auf der Matrix ab.
- Text & Zahlen (Statisch / Laufschrift): Zeigt einzelne Zeichen an oder lässt lange Texte flüssig über die 12x8 Pixel scrollen.
- Einzel-Pixel steuern: Ermöglicht das gezielte Ansteuern oder Zeichnen einzelner Punkte über X- (0-11) und Y-Koordinaten (0-7).
- Matrix löschen: Schaltet alle roten LEDs der Onboard-Matrix sofort aus.

 

 

🕒 Echtzeituhr (RTC & NTP-Zeit)

Verwaltet die interne Echtzeituhr (RTC) des Arduino UNO R4 WiFi für uhrzeitgesteuerte Schaltungen oder Smarthome-Projekte.

🛠️ Die RTC-Blöcke im Detail

- RTC Setup: Startet die interne Uhr des R4 im SETUP.
- Uhrzeit lesen & schreiben: Ruft einzelne Werte (Stunde, Minute, Sekunde, Tag, Monat, Jahr) ab oder stellt die Uhrzeit manuell ein.
- Uhrzeit als Text: Gibt die formatierte Zeit direkt als sauberen String (z. B. "14:30:00") zurück.
- NTP-Sync (WLAN): Synchronisiert die interne Uhr des R4 vollautomatisch über das Internet mit einem NTP-Zeitserver.

 

 

 

🔄 Schleifen-Steuerung (Break, Continue & Until)

Mit diesen Blöcken erhältst du die volle Kontrolle über den Ablauf deiner Wiederholungen und Schleifen im Programm.

- Wiederhole bis: Im Gegensatz zur normalen "Solange"-Schleife führt dieser Block die enthaltenen Aktionen genau so lange aus, bis deine angehängte Bedingung endlich WAHR wird (z. B. bis ein Endschalter gedrückt ist).
- Schleife abbrechen (break): Die Notbremse für Schleifen! Bricht den aktuellen Durchlauf komplett ab, verlässt die Schleife sofort und macht geordnet im restlichen Hauptprogramm weiter.
- Nächsten Durchlauf starten (continue): Überspringt den gesamten restlichen Code innerhalb der aktuellen Schleife und fängt augenblicklich wieder oben beim nächsten Durchgang an.

 

 

🛑 System-Kontrolle (Not-Aus & Run Once)

Manchmal muss dein Programm sofort stoppen oder bestimmte Aktionen dürfen absolut nur ein einziges Mal passieren. Dafür gibt es jetzt die neuen System-Blöcke.

- Programm dauerhaft anhalten: Ein echter Not-Aus-Schalter! Erreicht dein Programm diesen Block, friert die Ausführung dauerhaft ein. Das System im Hintergrund (wie das WLAN des R4) stürzt dabei dank intelligenter yield()-Logik nicht ab.
- Nur einmal ausführen (Run Once): Alles, was du in den Bauch dieses Blocks packst, wird exakt ein einziges Mal ausgeführt. Das funktioniert dank interner Speicherung selbst dann absolut zuverlässig, wenn der Block mitten in der rasenden Haupt-LOOP liegt.

 

 

📈 Flankenerkennung (Steigende / Fallende Flanke)

Wenn du nicht wissen willst, ob ein Taster gedrückt ist, sondern exakt den Millisekunden-Moment abpassen möchtest, in dem er gedrückt wird, brauchst du die Flankenerkennung.

- Steigende Flanke (0 ➔ 1): Schlägt genau dann für einen Durchlauf an, wenn ein Signal von AUS auf AN wechselt.
- Fallende Flanke (1 ➔ 0): Schlägt an, wenn ein Signal von AN auf AUS fällt (z. B. exakt beim Loslassen eines Tasters).
- Zwei Varianten: Es gibt die Flankenerkennung als spitzen Wahrheitswert-Block (ideal zum Einsetzen in eine WENN-Bedingung) oder als umschließenden Aktions-Block, der die Befehle in seinem Bauch bei einem Wechsel direkt ausführt.

 

 

🔀 Dynamische WENN-DANN-SONST Verzweigung

Vorbei sind die Zeiten von komplizierten Zahnrad-Menüs! Der neue dynamische Logik-Block lässt sich direkt auf der Arbeitsfläche kinderleicht anpassen.

- Integrierte Buttons: Klicke einfach auf die Plus- (+) und Minus- (-) Symbole direkt unten am Block, um blitzschnell neue "SONST WENN" oder "SONST" Zweige hinzuzufügen oder wieder zu entfernen.
- Sauberer Code: Der erzeugte C++ Code reiht alle deine gestapelten Bedingungen perfekt und übersichtlich untereinander auf.

 

 

⚡ Echter Analoger Ausgang (DAC am Arduino R4)

Im Gegensatz zu normalen PWM-Pins (die nur schnell an und aus schalten) besitzt der Arduino UNO R4 WiFi an Pin A0 einen echten Digital-Analog-Wandler (DAC). Damit kannst du stufenlos echte Gleichspannungen ausgeben! Die LogicKiste steuert diesen Pin hochpräzise mit einer 12-Bit Auflösung an.

🛠️ Die DAC-Blöcke im Detail

- Spannung (Dropdown): Wähle die gewünschte Spannung (0.0 bis 5.0 Volt) bequem aus zwei Dropdown-Menüs aus. Ideal und sicher für Anfänger.
- Spannung über Variable: Übergib eine Volt-Zahl (z. B. aus einer mathematischen Rechnung) direkt an den Block. Werte über 5 Volt werden aus Sicherheitsgründen automatisch vom Code begrenzt.
- DAC-Rohwert (Profi): Setze den puren 12-Bit Wert (0 bis 4095) direkt. Dabei entspricht die 0 exakt 0 Volt und 4095 den vollen 5 Volt.

 

🕒 Externe RTC & Zeitschaltuhren

Neben der internen Uhr des Arduino R4 kannst du jetzt auch externe I2C-Echtzeituhren (wie die DS3231) anbinden und professionelle Zeitschaltuhren programmieren.

- Externe RTC (I2C): Initialisiere und lese externe Uhrenmodule zuverlässig über den I2C-Bus aus.
- Schaltuhr Universal: Bietet eine komplette Logik zur Auswertung von Zeitfenstern (z. B. "Schalte Relais von 08:00 bis 17:30 Uhr"). Perfekt kombinierbar mit Drehgebern (Encodern), um Einstellungs-Menüs auf Displays zu bauen.
- Schaltuhr TM1638: Speziell angepasste Schaltuhr-Logik zur direkten Bedienung und Anzeige über das beliebte TM1638 Tasten- und Segment-Modul.

 

 

📊 Tabellen (Arrays) & Datenverarbeitung

Eine der mächtigsten neuen Funktionen in der LogicKiste! Tabellen (Arrays) erlauben es dir, viele Werte unter einem einzigen Namen zu speichern und blitzschnell auszuwerten, anstatt dutzende einzelne Variablen anzulegen.

- Einfach vs. Erweitert: Lege simple Listen an oder nutze erweiterte Arrays, bei denen du Startwerte und die exakte Datengröße selbst definierst.
- Signal & Puffer (FIFO): Ideal für Sensor-Glättung! Schiebe neue Werte in die Tabelle (Push), während alte Werte automatisch herausfallen. Du kannst per Knopfdruck den Minimal-, Maximal- oder Durchschnittswert der gesamten Tabelle berechnen lassen.
- Mathematik: Errechne die Gesamtsumme aller Einträge, ersetze gezielt Werte oder nutze die Zähl-Funktion, um zu prüfen, wie oft ein bestimmter Zustand (z. B. "Temperatur > 25") in der Tabelle vorkommt.

 

 

🔢 Bit / Byte Anzeige

Perfekt für den Informatik-Unterricht oder zur Fehlersuche. Mit diesen Blöcken kannst du Zahlenwerte direkt in ihre binäre Form (Einsen und Nullen) zerlegen und optisch darstellen.

- Flexibles Setup: Du entscheidest, wie du die Bits anzeigst! Wähle zwischen normalen Arduino-Pins (z. B. eine Reihe normaler LEDs), einem NeoPixel-Streifen oder einer MAX7219 Dot-Matrix.
- Werte schreiben: Übergib einfach eine Zahl, und der Block wandelt sie automatisch um und lässt die entsprechenden Lämpchen für die gesetzten Bits leuchten.

 

 

🏎️ L298 Motor Shield

Das klassische Kraftpaket für Gleichstrommotoren. Mit diesem Shield kannst du zwei kräftige DC-Motoren unabhängig voneinander steuern.

- Einzelmotoren & Robot-Modus: Steuere die Motoren entweder einzeln (Geschwindigkeit und Richtung) oder nutze den gekoppelten "Beide Motoren"-Block, um ein Roboter-Auto bequem vorwärts, rückwärts oder in Kurven fahren zu lassen.
- Strommessung (Current): Der Treiber erlaubt es dir, den aktuellen Stromverbrauch der Motoren auszulesen – ideal, um Blockaden oder Überlastungen (z. B. wenn das Auto gegen eine Wand fährt) zu erkennen.

 

 

🦾 Servo Shield (KS0258)

Wenn du viele Servomotoren brauchst (z. B. für einen Roboterarm oder eine Spinne), ist das KS0258 Shield deine Zentrale.

- Servos & Rampen: Bewege Servos gezielt auf Winkel (0-180°) oder nutze die integrierte Rampen-Funktion für butterweiche, langsame Bewegungen ohne Ruckeln.
- Alle synchron: Mit einem speziellen Block kannst du alle angeschlossenen Servos gleichzeitig auf eine Position zwingen.
- Stromsparmodus: Du kannst Servos gezielt vom Strom trennen (Detach), damit sie nicht brummen oder heiß werden, wenn sie gerade keine Haltekraft brauchen.

 

 

💳 NFC Kartenleser (PN532)

Der große Bruder des RFID-Moduls. Der PN532 Chip liest NFC-Tags, Schlüsselanhänger und sogar kompatible Smartphones aus.

- Ereignis-Überwachung: Rufe regelmäßig den Update-Block in der Loop auf. Sobald ein Tag erkannt wird, schlägt der Event-Block an.
- Identifikation: Vergleiche gelesene UIDs (Unique Identifier) direkt im Block, um Zugangskontrollen oder smarte Schlösser zu programmieren, oder lies gespeicherte Nutzdaten vom Tag aus.

 

 

🎮 KS Motor/Servo Shield & PS2 Gamepad

Das ultimative Shield für ferngesteuerte Fahrzeuge. Es kombiniert Motoranschlüsse mit einem direkten Steckplatz für drahtlose PS2-Controller-Empfänger.

- DC-Motoren (KS0363): Komfortable Blöcke, um die Motorausgänge für deinen Antrieb zu steuern.
- PS2 Gamepad: Verbinde den Controller und frage jeden einzelnen Button (Kreuz, Kreis, Viereck, Dreieck, Schultertasten) ganz einfach ab, um deinem Fahrzeug oder Roboterarm Befehle zu erteilen.

 

 

Ronnie

schwäbischer tüftler und bastler, kraftsportler, neurodivers, 45 Jahre, 1 Frau, 5 Kinder und 1003 Ideen. 

1.2 ronnie berzins

logickiste

Blockly für Arduino: Grafische Programmierung als echtes C++ Werkzeug
für deine eigenen, kreativen Projekte und Ideen auf hohem Niveau.

https://www.logickiste.de/

blockly for arduino

Beliebte Beiträge

Neueste Beiträge