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.

!!! Handbuch grad im Umbau, deshalb ist ausführlicher Text und die Container beides noch vorhanden!!! 

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.

🚀 Arduino Code direkt aus dem Browser hochladen: So funktioniert's!

Vielleicht wunderst du dich, warum du für den Upload ein kleines Zusatzprogramm auf deinem PC brauchst. Der Grund dafür ist reine Browser-Sicherheit: Moderne Webbrowser (wie Chrome, Edge oder Firefox) laufen in einer sogenannten "Sandbox". Sie sind komplett vom restlichen PC abgeschirmt und haben absolut keinen Zugriff auf deine Hardware oder deine USB-Anschlüsse (COM-Ports). Das ist auch gut so, damit keine fremde Webseite Unsinn mit deinem Rechner anstellen kann!

Damit die LogikKiste deine Blöcke trotzdem auf den Arduino schieben kann, nutze ich einen cleveren Trick im Hintergrund:

• Das Frontend (Die Webseite): Der Editor im Browser übersetzt deine Blöcke blitzschnell in echten C++ Arduino-Code.
• Die Brücke (Das Zusatzprogramm): Wenn du auf "Upload" klickst, schickt der Browser diesen Code an ein kleines, lokales Programm auf deinem PC (eine sogenannte Python-Flask-Bridge).
• Der Arbeiter (Arduino-CLI): Dieses Hintergrund-Tool nimmt den Code entgegen, nutzt die offiziellen Werkzeuge von Arduino (die originale Entwicklungsumgebung als Kommandozeilen-Tool) und schiebt das fertige Programm über das USB-Kabel auf dein Board.

Das Geniale daran: Sobald die Einrichtung einmal erledigt ist, passiert die gesamte Übersetzung und der Upload zu 100 % lokal auf deinem PC. Es werden keine Daten ins Internet geschickt.

🛠️ Schritt-für-Schritt-Anleitung

Folge einfach diesen Schritten, um den direkten Upload freizuschalten:

• Schritt 1: Das Paket herunterladen (R4_Upload_Bridge.zip).
• Schritt 2: Die ZIP-Datei entpacken Entpacke die heruntergeladene ZIP-Datei vollständig in einen beliebigen Ordner auf deinem PC (zum Beispiel direkt auf deinen Desktop). Wichtig: Verschiebe die Dateien darin nicht einzeln, sie müssen alle zusammen in ihrem Ordner bleiben!
• Schritt 3: Das Programm starten Mach einfach einen Doppelklick auf die Datei start_bridge.bat. Es öffnet sich ein schwarzes Konsolenfenster, das ist die übertragung.
• Schritt 4: Das Fenster offen lassen Lass das schwarze Fenster während des Programmierens einfach im Hintergrund geöffnet. Das ist dein persönlicher Upload-Server. Wenn du fertig bist, kannst du es einfach über das "X" schließen.
• Schritt 5: Loslegen im Web-Editor Öffne jetzt die LogikKiste im Browser. Wähle oben im Menü dein passendes Arduino-Board und den richtigen COM-Port (USB-Anschluss) aus. Klicke auf 🚀 Upload und schon blinkt dein Board!
• Schritt 6: Du musst ggf. eine ggf. eine Meldung bestitigen dass der Upload erfolgenden darf. 

📌 Voraussetzung: Du musst Python auf deinem PC installiert haben. Falls du es noch nicht hast, kannst du es dir einfach kostenlos im Windows Store herunterladen.

⚠️Hinweis zu Download-Warnungen: Da in diesem Paket eine .bat-Datei (für den Start) und Skripte stecken, schlagen manche Browser beim Download und Windows beim Starten Alarm. Das ist völlig normal, weil Windows und Google das Programm noch nicht kennen. Du kannst die Warnung ignorieren, auf „Trotzdem behalten/ausführen“ klicken das Paket ist absolut sicher und der Code ist zu 100 % offen einsehbar! Leider kostet es extrem viel Geld und Zeit eine Software bei Windows als sicher zu "registrieren" und das lohnt sich für mich einfach noch nicht. 

📌 Logickiste offline nutzen: Hier gibt es die komplette Logickiste als .zip Download, mit einem Doppelcklick auf index.html startet die Logickiste in deinem Browser. Vermutlich mekert erst Chrom beim Download und dann beim öffnen. Aber damit kannst du die komplett offline Arbeiten.

 

📘 Handbuch: 1. Board & Struktur

In dieser Kategorie findest du die grundlegenden Bausteine, um dein Programm zu strukturieren, Ordnung auf deiner Arbeitsfläche zu halten, zeitkritische Hardware-Ereignisse abzufangen oder flexibel eigenen Textcode einzubinden.

📦 1.1 Farb-Container (ard_container_*)

Wenn deine Programme wachsen, verliert man auf der großen Arbeitsfläche schnell den Überblick. Die Farb-Container sind dein visuelles Leitsystem in der LogicKiste. Es gibt sie in 7 verschiedenen Farben: Rot, Orange, Gelb, Grün, Hellblau, Blau und Lila.

• Beschreibung: Diese Blöcke dienen rein der optischen Sortierung. Du kannst den Text im Kopf des Containers völlig frei umbenennen (z. B. „Schrittmotor Achse X“ oder „DMX Lichtsteuerung“). Wenn du einen Container verschiebst oder kopierst, nimmst du automatisch alle Blöcke mit, die sich in seinem Bauch befinden.
• Praxis-Beispiel: Packe komplexe Logik-Abschnitte in einen lila Container, um sie optisch vom restlichen Programm zu trennen.
• Wichtiger Hinweis: Diese Blöcke haben absolut keinen Einfluss auf den C++ Code deines Arduinos. Sie erzeugen keine Schleifen oder Bedingungen, sondern reichen den Code der inneren Blöcke einfach 1:1 und unverändert an das Hauptprogramm weiter. Sie verbrauchen also weder Speicherplatz noch Rechenleistung!

⚡ 1.2 Hardware Interrupts (board_pc_interrupt)

Normalerweise arbeitet der Arduino seinen Code im Haupt-Loop von oben nach unten ab. Wenn du jedoch ein extrem schnelles Signal hast (z. B. die Impulse eines Durchflussmessers oder den Klick eines Sicherheits-Endschalters), kann es passieren, dass der Arduino gerade mit einer anderen Aufgabe beschäftigt ist und das Signal verpasst. Hier hilft ein Hardware-Interrupt.

• Beschreibung: Dieser Block schwebt frei auf deiner Arbeitsfläche und verhält sich wie ein eigener Start-Block. Sobald an dem ausgewählten Pin ein passendes elektrisches Signal ankommt, stoppt der Arduino sein aktuelles Hauptprogramm sofort, springt in den Interrupt-Block, arbeitet den dortigen Code ab und kehrt danach exakt an die Stelle zurück, an der er unterbrochen wurde.
• Die Einstellungen im Detail:
  • Pin: Wähle den physischen Pin deines Arduinos (z. B. Pin 2 oder Pin 3).
  • Modus: Bestimme, ob der interne Widerstand (PULL-UP) aktiviert werden soll (dann schaltet dein Taster sauber gegen GND) oder ob der Pin als normaler INPUT arbeitet.
  • Auslösen bei:
    • RISING: Löst aus, wenn die Spannung von LOW auf HIGH wechselt (Flankenwechsel).
    • FALLING: Löst aus, wenn die Spannung von HIGH auf LOW wechselt.
    • CHANGE: Löst bei jeder Änderung des Zustands aus.
    • LOW / HIGH: Löst aus, solange der Pegel dauerhaft anliegt.
• Praxis-Beispiel: Das fehlerfreie Auslesen eines schnellen Dreh-Encoders oder das sofortige Abschalten einer Pumpe beim Auslösen eines Niveauschauglases.
• ⚠️ Wichtiger Hinweis: Halte den Code im Bauch des Interrupts so kurz wie möglich! Verwende darin niemals blockierende Pausen wie Warte ms (Delay), da dies den kompletten Controller abstürzen lässt.
• ⚠️ Wichtiger Hinweis: Beachte die spezielle Variable für die Interrupt. 

📝 1.3 Kommentare

Guter Code zeichnet sich dadurch aus, dass man auch nach Monaten noch versteht, was man sich beim Programmieren gedacht hat.

• Beschreibung: Dieser Block fügt eine einfache Textzeile in deinen Programmablauf ein.
• Praxis-Beispiel: Schreibe über einen Ausgangs-Block: 📝 Kommentar: Pin 4 steuert das Hauptrelais für den Kompressor.
• Hintergrund-Logik: Beim Übersetzen in C++ wird aus diesem Block ein klassischer Zeilenkommentar (beginnend mit //). Der Arduino ignoriert diesen Text beim Ausführen komplett. Er dient ausschließlich dir als Gedankenstütze.

 

📘 Handbuch: 2. Steuerung, Schleifen & Logik

Dieses Kapitel bildet das logische Gehirn deiner Programme. Hier erfährst du, wie dein Arduino Entscheidungen trifft, Abläufe wiederholt und wie du eigene, übersichtliche Unterprogramme (Funktionen) erstellen kannst.

🛑 2.1 Bedingungen & Entscheidungen (WENN / DANN)

Mit diesen Blöcken steuerst du den Programmfluss basierend auf sensorischen Ereignissen oder Berechnungen. Der Arduino prüft, ob eine Bedingung erfüllt ist, und zweigt entsprechend ab.

WENN - DANN (logic_if)

• Beschreibung: Der einfachste Entscheidungs-Block. Der Code im DANN-Teil wird nur ein einziges Mal ausgeführt, wenn die angehängte Bedingung WAHR ist. Ist sie falsch, springt das Programm direkt weiter.
• Praxis-Beispiel: WENN Temperatur > 30 ➔ DANN Klimaanlage einschalten.

WENN - DANN - SONST (logic_if_else)

• Beschreibung: Bietet eine feste Gabelung im Programm. Wenn die Bedingung WAHR ist, läuft der DANN-Zweig. Wenn sie FALSCH ist, wird stattdessen ohne Ausnahme der SONST-Zweig ausgeführt.
• Praxis-Beispiel: WENN Helligkeit < 200 ➔ DANN Außenlicht an ➔ SONST Außenlicht aus.

WENN - SONST WENN - SONST (logic_if_elseif_else)

• Beschreibung: Die Kaskaden-Abfrage für komplexe Steuerungen. Der Arduino klappert die Bedingungen der Reihe nach ab. Sobald eine Bedingung zutrifft, führt er den zugehörigen Bereich aus. Passt gar nichts, greift der rettende SONST-Zweig am Ende.
• Praxis-Beispiel: Für dreistufige Ampel- oder Betriebssteuerungen: WENN Fehler aktiv ➔ DANN rote LED an ➔ SONST WENN Warnung aktiv ➔ DANN gelbe LED an ➔ SONST grüne LED an.

❓ Der Fragezeichen-Tester (Ternärer Operator) (logic_ternary)

• Beschreibung: Eine extrem kompakte, elegante Inline-Abfrage, die du direkt an Variablen oder Schreib-Blöcke anstecken kannst. Sie prüft einen Test. Ist er wahr, gibt der Block den ersten Wert zurück, ansonsten den zweiten.
• Praxis-Beispiel: Ermöglicht das direkte Setzen eines Textes oder Wertes in einer einzigen Zeile: Setze Display-Text auf: (❓ Test: Fehler == WAHR ➔ Wenn WAHR: "Stoerung" ➔ Wenn FALSCH: "Betrieb").

🔄 2.2 Wiederholungen & Schleifen (Loops)

Schleifen zwingen den Arduino dazu, bestimmte Befehle mehrfach zu wiederholen, ohne dass du den Code dafür zehnmal untereinander setzen musst.

Wiederhole X-mal (loop_repeat)

• Beschreibung: Die einfachste Zählschleife. Sie führt die innen liegenden Blöcke exakt so oft aus, wie du als Zahl vorgibst. Im Hintergrund wird dafür eine temporäre Variable (lk_i1, lk_i2...) hochgezählt.
• Praxis-Beispiel: Lasse eine Alarmleuchte beim Start genau 5 mal kurz aufblitzen.

Zähle mit (For-Schleife) (loop_for)

• Beschreibung: Das Profi-Werkzeug für Index-Listen. Du vergibst einen Variablennamen (z. B. i), einen Start- und einen Endwert sowie die Schrittweite. Der Arduino erhöht (oder verringert) den Zähler bei jedem Durchlauf um die Schrittweite, bis der Endwert erreicht ist.
• Praxis-Beispiel: Du hast LEDs an den Pins 2, 3, 4, 5 und 6 angeschlossen. Mit Zähle i von 2 bis 6 mit Schrittweite 1 und dem Baustein Digital Schreiben Pin [i] auf HIGH schaltest du alle fünf Lampen flüssig nacheinander ein.
• 💡 Intelligente Hintergrund-Logik: Die LogicKiste scannt deine Arbeitsfläche. Hast du die Zählvariable bereits manuell global deklariert, nutzt die Schleife diese einfach mit. Wenn nicht, erzeugt der Generator das benötigte int i im Schleifenkopf vollautomatisch, um Code-Fehler (Shadowing) zu vermeiden.

Solange (While-Schleife) (ard_loop_while)

• Beschreibung: Diese Schleife wiederholt den inneren Code so lange, wie die angegebene Bedingung ununterbrochen WAHR bleibt.
• Praxis-Beispiel: Solange Füllstandssensor == FALSCH ➔ mache: Pumpe einschalten.
• ⚠️ Wichtiger Sicherheitshinweis: Vorsicht vor der "Endlosschleife"! Wenn sich die Bedingung innerhalb der Schleife niemals ändert (weil z. B. der Sensor im Bauch der Schleife gar nicht neu eingelesen wird), bleibt dein Arduino für immer in dieser Schleife gefangen und reagiert auf überhaupt nichts anderes mehr.

⚖️ 5. Logik, Vergleiche und Konstanten

Diese mathematisch-logischen Bausteine liefern das Fundament (WAHR oder FALSCH), damit deine WENN-Bedingungen und Schleifen überhaupt wissen, was sie tun sollen.

Vergleichen (ard_logic_compare)

• Beschreibung: Vergleicht zwei Werte flexibel miteinander. Du kannst über das Dropdown-Menü die mathematischen Operatoren wählen: Gleich (=), Ungleich (≠), Kleiner (<), Kleiner-Gleich (≤), Größer (>) oder Größer-Gleich (≥).
• Praxis-Beispiel: WENN Ist-Wert ≥ Soll-Wert.

Verknüpfen (UND / ODER) (ard_logic_operation)

• Beschreibung: Kombiniert zwei logische Bedingungen zu einer einzigen Gesamtaussage.
  • UND (&&): Gibt nur dann ein WAHR zurück, wenn beide Seiten gleichzeitig wahr sind.
  • ODER (||): Gibt bereits ein WAHR zurück, wenn mindestens eine der beiden Seiten wahr ist.
• Praxis-Beispiel: WENN (Taster1 gedrückt) UND (Taster2 gedrückt) ➔ Schalte Maschine ein (Zweihand-Sicherheitsschaltung).

Umkehren (NICHT) (ard_logic_negate)

• Beschreibung: Dreht den Wahrheitswert eines Logik-Zustands komplett um. Aus einem WAHR wird ein FALSCH – und aus einem FALSCH wird ein WAHR. Im C++ Code entspricht das dem Ausrufezeichen (!).
• Praxis-Beispiel: WENN NICHT (Taster gedrückt) ➔ Bedeutet im Klartext: Solange der Taster in Ruhe gelassen wird.

WAHR / FALSCH Konstante (ard_logic_boolean)

• Beschreibung: Ein simpler, fester Logik-Wert (true oder false), den du als festen Zustand an Bedingungen oder Parameter anstecken kannst.

🛠️ 7. Unterprogramme & Funktionen (Eigene Befehle bauen)

Je größer deine Projekte werden, desto länger wird dein Haupt-Loop. Damit dein Code übersichtlich bleibt und du identische Programmabläufe nicht mehrfach bauen musst, kannst du eigene Unterprogramme (Funktionen) definieren. Diese stehen frei auf dem Raster und werden erst aktiv, wenn du sie gezielt aufrufst.

1. Unterprogramme OHNE Rückgabewert (void)

• Bauen (ard_function_define): Erstellt einen großen Container, dem du einen eindeutigen Namen gibst (z. B. BerechneKlima). Alles, was du in diesen Bauch hineinsteckst, wird gekapselt abgespeichert.
• Ausführen (ard_function_call): Im Loop nutzt du den Block Führe Unterprogramm aus: [BerechneKlima]. Das Programm springt nun sofort in dein Unterprogramm, rattert den Code ab und arbeitet danach im Haupt-Loop weiter.
• Hinweis: Die Dropdown-Auswahlliste aktualisiert sich auf deiner Arbeitsfläche vollautomatisch, sobald du ein neues Unterprogramm benennst!

2. Funktionen MIT Rückgabewert

• Bauen (ard_function_define_return): Manchmal soll ein Unterprogramm nicht nur Befehle ausführen, sondern eine mathematische Berechnung anstellen und das fertige Ergebnis an den Haupt-Loop zurückschicken. Hier wählst du zusätzlich den Datentyp des Ergebnisses aus: int (Ganzzahl), float (Kommazahl), bool (Wahr/Falsch) oder String (Text).
• Ausgeben (ard_function_return): Am Ende deiner Funktion musst du zwingend den Block ↩ Gib zurück verwenden und den errechneten Wert dort anstecken.
• Auslesen (ard_function_call_return): Dieser Block hat eine Nase an der linken Seite (Wert-Ausgang). Du kannst ihn wie eine Variable direkt an Displays oder Rechenoperationen andocken.
• Praxis-Beispiel: Du baust eine Funktion LeseMittelwert. In ihr werden 5 analoge Messungen genommen und zusammengerechnet. Am Ende gibst du den Durchschnitt zurück. Im Haupt-Loop dockst du den Block Ergebnis von: [LeseMittelwert] einfach direkt an dein Display-Schreibmodul an.

 

💻 1.4  C++ 

Die LogicKiste bietet dir enorm viele Blöcke, aber manchmal möchte man eine ganz spezielle Bibliothek einbinden oder einen ganz bestimmten C++ Befehl nutzen, für den es keinen fertigen Block gibt. Dafür hast du die beiden Custom-Code Blöcke:

C++ Code (Ablauf) (ard_custom_code_inline)

• Beschreibung: Dieser Block lässt sich wie ein normales Puzzleteil flexibel in deine Programmkette (im Setup oder im Loop) einfügen. Der Text, den du hier eintippst, wird exakt so an dieser Stelle in den C++ Code geschrieben.
• Praxis-Beispiel: Schnelles Einfügen eines speziellen mathematischen Befehls oder Register-Befehls im Ablauf.
• Achtung: Du schreibst hier puren Text-Code. Vergiss am Ende deiner Befehlszeilen nicht das in C++ zwingend erforderliche Semikolon (;)!

C++ Code (Global) (ard_custom_code_global)

• Beschreibung: Dieser Block besitzt keine Puzzleteile-Einkerbungen und schwebt frei auf der Arbeitsfläche. Alles, was du in dieses mehrzeilige Textfeld eintippst, landet beim Code-Export ganz oben im Header deines C++ Programms – noch vor dem Setup.
• Praxis-Beispiel: Perfekt, um eigene Bibliotheken einzubinden (z. B. #include <MeineSpezielleKlimaLib.h>) oder globale Variablen und Definitionen von Hand anzulegen.

 

 

 

 

 O-LED Koordinaten und Beschreibung der Funktionen.

Hinweis zur Orientierung: Der Nullpunkt liegt auf dem Display immer in der oberen linken Ecke. Die X-Achse läuft nach rechts, die Y-Achse läuft nach unten.

Gewählte Form	X / Y	B / X2 / Rad	H / Y2	X3 / Y3	Funktion / Beschreibung
Linie	Startpunkt (X/Y)	Endpunkt X2	Endpunkt Y2	(wird ignoriert)	Zeichnet eine gerade Linie vom Start- zum Endpunkt.
Rechteck (Rand)	Obere linke Ecke	Breite (B) in Pixeln	Höhe (H) in Pixeln	(wird ignoriert)	Zeichnet den Rahmen eines Rechtecks.
Rechteck (Voll)	Obere linke Ecke	Breite (B) in Pixeln	Höhe (H) in Pixeln	(wird ignoriert)	Zeichnet ein komplett ausgefülltes Rechteck.
Kreis (Rand)	Mittelpunkt (X/Y)	Radius (Rad)	(wird ignoriert)	(wird ignoriert)	Zeichnet die Außenlinie eines Kreises.
Kreis (Voll)	Mittelpunkt (X/Y)	Radius (Rad)	(wird ignoriert)	(wird ignoriert)	Zeichnet einen komplett ausgefüllten Kreis.
Dreieck (Rand)	Erster Punkt (X/Y)	Zweiter Punkt X2	Zweiter Punkt Y2	Dritter Punkt (X3/Y3)	Verbindet drei frei definierbare Punkte zu einem Rahmen.
Dreieck (Voll)	Erster Punkt (X/Y)	Zweiter Punkt X2	Zweiter Punkt Y2	Dritter Punkt (X3/Y3)	Zeichnet ein komplett ausgefülltes Dreieck zwischen den drei Punkten.

 

🎮 G-Engine: Arcade-Action für deinen Arduino R4

Die G-Engine ist dein Werkzeugkasten, um eigene Arcade-Spiele direkt auf einer 32x32 LED-Matrix zu verwirklichen. Vergiss komplizierte Matrix-Programmierung: Mit unseren hellgrünen G-Engine-Blöcken baust du in Sekunden Spielfiguren, steuerst sie per Arcade-Taster und definierst Kollisionen – ohne dass dein Programm ins Ruckeln gerät.

🛠️ Kurzanleitung: Die G-Engine Blöcke

• G-ENGINE START: Dein Sicherheits-Container. Alles, was hier drin steht, läuft in einer hochoptimierten Spielschleife.
• Akteure (Sprites): Erzeuge Spieler oder Gegner und bewege sie flüssig über das Spielfeld.
• Steuerung: Nutze die Falls Taste-Blöcke, um präzise auf Eingaben zu reagieren (wahlweise als Einzelschuss oder Dauerlauf).
• Logik & Events: Die Wenn trifft auf-Kollisionsabfrage erledigt die Treffererkennung für dich.
• Timer: Halte dein Spiel im Rhythmus, ohne den Programmfluss zu blockieren.

📥 Installation der Bibliothek

Damit dein Arduino die Befehle versteht, musst du die G-Engine Library einmalig hinzufügen:

1. Lade die GEngine.zip.
2. Öffne deine Arduino IDE.
3. Gehe auf Sketch ⮕ Bibliothek einbinden ⮕ .ZIP-Bibliothek hinzufügen...
4. Wähle die heruntergeladene Datei aus. Fertig!

⚠️ Hinweis: Die G-Engine befindet sich aktuell in der Experimentierphase. Das System wird ständig erweitert und optimiert es kann daher vorkommen, dass bestimmte Funktionen noch nicht zu 100 % stabil laufen oder noch geändert werden.

 

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 (z. B. mit der G-Engine).
• 💡 Profi-Tipp: Mathematische Berechnungen oder Schleifen (wie z. B. ein Master-Dimmer, der alle Kanäle gleichzeitig hochzählt) 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 (Kanal auf Wert schreiben) und wann der Frame abgeschlossen und abgesendet wird (Ende).

• Ideal für: Fortgeschrittene Anwender, die eigene, hochoptimierte Protokoll-Strukturen oder asynchrone Sende-Abläufe programmieren wollen und die volle Kontrolle über den C++ Ablauf verlangen.
• ⚠️ Achtung: Zwischen dem Öffnen- und dem Schließen-Block dürfen keine blockierenden Pausen (wie Warten ms) liegen, da die Hardware sonst die Übertragung wegen eines Timeouts abbricht.

🚫 Wichtige Grundregel: Mische niemals die Farben im Setup!

Füge immer nur einen Setuo 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.

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 – zum Beispiel direkt in einen Display-Schreib-Block oder in eine mathematische Bedingung (WENN Lese Klickzähler von PIN 2 >= 10).
• Ideal für: Punktezähler in Arcade-Spielen, das Durchschalten von Menü-Ebenen oder das Auslösen von "Joker-Funktionen" nach einer bestimmten Anzahl von Klicks.

🔄 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, hat er die typischen Einkerbungen oben und unten. Du kannst ihn einfach wie ein normales Puzzleteil in deine Programmkette einfügen (z. B. direkt innerhalb eines Doppelklick-Events).
• Ideal für: Das Starten eines neuen Spiels (Game Over -> Reset), das Zurücksetzen eines Timers oder das Neustarten einer Menüführung.

⚙️ 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 (Setze Klickzähler von PIN 2 auf [ 5 ]).
• Ideal für: Das Vorgeben von Startwerten (z. B. "Du startest mit 3 Leben"), das Abziehen von Punkten bei Fehlern oder das Erstellen von "+10 Joker"-Funktionen.

💡 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. Den Rest regelt die LogicKiste im Hintergrund für dich!

📥 Installation der Bibliothek

Damit dein Arduino die Befehle versteht, musst du die G-Engine Library einmalig hinzufügen:

1. Lade die KK_ButtonHandler Library.
2. Öffne deine Arduino IDE.
3. Gehe auf Sketch ⮕ Bibliothek einbinden ⮕ .ZIP-Bibliothek hinzufügen...
4. Wähle die heruntergeladene Datei aus. Fertig!

 

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

Wenn du in deinen Programmen möchtest, dass eine Aktion regelmäßig ausgeführt wird – zum Beispiel eine LED jede Sekunde blinkt oder ein Sensor alle 500 Millisekunden misst –, 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, die regelmäßig passieren sollen, in den MACHE-Zweig.

• Ideal für: Regelmäßiges Auslesen von Temperatursensoren, zyklisches Senden von Daten an eine Webseite oder einfache Status-Blinklichter.
• Hintergrund-Logik: Für jeden dieser Blöcke legt das System im Hintergrund eine eigene, unsichtbare Zeitvariable an. Du kannst also auch mehrere dieser Blöcke mit unterschiedlichen Zeiten (z. B. einen für 100 ms und einen für 2000 ms) parallel in deiner Loop nutzen, ohne dass sie sich gegenseitig stören.

📊 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. Genau hier kommt der erweiterte Intervall-Timer ins Spiel. 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 und führt danach den Code im Zähle hoch & MACHE-Bauch aus.

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. Du kannst ihn überall dort einsetzen, wo Zahlen gebraucht werden – etwa in einer WENN-Bedingung (WENN Lese Zähler Takt1 >= 10) oder direkt auf einem Display-Schreib-Block, um einen Timer anzuzeigen.
• Setze Zähler auf [X]: Hiermit kannst du den Zählerstand mitten im laufenden Betrieb aktiv auf einen völlig frei definierbaren Wert oder das Ergebnis einer mathematischen Berechnung überschreiben. Das ist perfekt, um beispielsweise Startwerte vorzugeben oder "Strafsekunden" hinzuzufügen.
• Setze Zähler auf 0: Deine klassische Reset-Funktion. Sie setzt den Zähler des ausgewählten Timers sofort wieder auf den Startwert 0 zurück, ohne den Zeitrhythmus des Timers selbst zu unterbrechen. Ideal, um Abläufe nach einem Ereignis von vorne starten zu lassen.

💡 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. Nur so weiß der Arduino, welchen der internen Zähler er manipulieren soll! Vermeide hierbei Sonderzeichen oder Leerzeichen im Namen, um einen sauberen C++ Ablauf im Hintergrund zu garantieren.

 

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

Egal ob für einen selbstgebauten Spielautomaten, eine akustische Alarmanlage oder einen sprechenden Bonbonspender – Soundeffekte und Musik bringen deine Projekte auf das nächste Level. 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, da es die gesamte Dekodierung der MP3-Dateien selbst übernimmt.

💾 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

Bibliothek für die MP3 Blöcke

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). Das bedeutet: Verbinde den TX-Pin des MP3-Moduls mit Pin 0 (RX) des Arduino und den RX-Pin des Moduls mit Pin 1 (TX) des Arduino. Vergiss nicht, auch VCC (5V) und GND anzuschließen!
• Hintergrund-Logik: Die LogicKiste bindet beim Verwenden dieses Blocks automatisch die passende YX5300_Player Bibliothek ein und startet die serielle Kommunikation im Hintergrund mit der richtigen Geschwindigkeit (9600 Baud).

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

Mit diesem Block regelst du die Lautstärke deines Lautsprechers oder Kopfhörers.

• Wertebereich: Du kannst eine Zahl von 0 (völlig stumm) bis 30 (maximale Lautstärke) andocken.
• Praxis-Tipp: Es ist ratsam, diesen Block einmalig im Start-Bereich deines Programms (direkt nach dem Setup) einzubinden, um die Standard-Lautstärke festzulegen, damit dich das Modul beim Einschalten nicht erschreckt.

3. MP3 Spiele Ordner

Das ist der eigentliche Befehl, um Musik oder Soundeffekte zu starten. Du übergibst dem Block die Nummer des Ordners, den du abspielen möchtest.

• Modus (Einmalig): Spielt den Inhalt des angegebenen Ordners genau einmal ab und stoppt danach automatisch. Ideal für Sprachausgaben oder kurze Effekte beim Drücken eines Tasters.
• Modus (Dauerschleife): Spielt die Titel im Ordner unendlich oft hintereinander ab. Perfekt für Hintergrundmusik in Spielen oder dauerhafte Ambient-Sounds.

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

Dieser Block ist deine Fernbedienung für die laufende Wiedergabe. Über das Dropdown-Menü kannst du flexibel auf die Musik einwirken:

• Play (Fortsetzen): Setzt die Wiedergabe an der Stelle fort, an der sie pausiert wurde.
• Pause: Hält den aktuellen Titel an.
• Stop: Beendet die Wiedergabe komplett.
• Nächster / Vorheriger Titel: Springt innerhalb des aktuell aktiven Ordners ein Lied weiter oder zurück.

💡 Profi-Tipp für fehlerfreien Sound: Genau wie der DMX-Bus ist auch die serielle Kommunikation mit dem Soundmodul zeitkritisch. Wenn du einen Befehl wie "Spiele Ordner" absendest, schicke ihn nur einmalig bei einem Event (z. B. wenn ein Taster gerade eben gedrückt wurde) und niemals dauerhaft nackt in einer rasenden Haupt-LOOP. Wenn du den Befehl in jeder Millisekunde neu sendest, startet das Modul den Titel permanent von vorne und du hörst nur ein unschönes Knacken!

 

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

Wenn du ein Projekt baust, reicht das kleine Display am Arduino manchmal einfach nicht aus. Vielleicht möchtest du am PC-Bildschirm große, bunte Schieberegler bedienen, Live-Diagramme deiner Sensoren zeichnen oder eine komplette Steuerungsoberfläche (HMI) aufbauen. Genau dafür ist die Processing-Kategorie da. Sie verbindet 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). Stell dir diese Kanäle wie Rohrleitungen vor: Du wirfst auf der einen Seite ein beschriftetes Paket hinein, und auf der anderen Seite kommt es genau in der passenden Sortierstation an. 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.

• Die Baudrate: Hier stellst du die Übertragungsgeschwindigkeit ein. Standardmäßig ist 9600 oder 115200 eine gute Wahl.
• Wichtig: Achte darauf, dass in der Processing-App auf dem PC exakt dieselbe Geschwindigkeit eingestellt ist, da sonst nur unleserlicher Datensalat ankommt!

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

Das ist ein ganz besonderer Block: Er hat keine Puzzleteile-Einkerbungen oben und unten, sondern schwebt frei auf deiner Arbeitsfläche. Er verhält sich wie ein eigener Startblock (ein sogenannter Event-Handler).

• Hintergrund-Logik: Die LogicKiste lauscht im Hintergrund des Hauptprogramms permanent am USB-Anschluss. Sobald der PC ein Paket schickt, das mit deinem gewählten Kanal (z. B. Kanal A) beginnt, springt der Arduino sofort in diesen Block und führt den darin platzierten Code aus. Kommen Daten für einen anderen Kanal an, ignoriert dieser Block sie einfach.

3. Werte auslesen (Zahl oder Text)

Wenn der Event-Block oben angeschlagen hat, möchtest du die mitgeschickten Daten natürlich auch verwenden. Dafür nutzt du die runden Auslese-Blöcke, die du an Variablen oder Logik-Blöcke anstecken kannst:

• Lese Zahl / Text aus Datensatz an Position [X]: Der PC kann dir mehrere Werte auf einmal in einer Zeile schicken. Mit dem Index (Position) bestimmst du, welchen Wert du greifen willst.
  • Beispiel: Schickt der PC das Paket B,22.5,Normal, dann holt der Block Lese Zahl an Position 1 den Wert 22.5. Der Block Lese Text an Position 2 holt das Wort Normal.

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.

• Flexibler Aufbau: Du wählst den Zielkanal (z. B. C) und kannst bis zu 5 Werte gleichzeitig anstecken. Das können feste Zahlen, Texte oder die Ergebnisse von Sensor-Messungen sein.
• Intelligente Lückenfüllung: Wenn du beispielsweise nur Wert 1 und Wert 3 belegst und die anderen Felder frei lässt, erkennt das der Code-Generator automatisch. Er überspringt die leeren Felder und setzt die Kommas im Hintergrund so zusammen, dass die Processing-App auf dem PC nicht verwirrt wird.

💡 Profi-Tipp für eine stabile Verbindung

Die Kommunikation zwischen PC und Arduino läuft rasend schnell. Damit die Verbindung stabil bleibt und der Puffer des Arduino nicht überläuft, solltest du zwei goldene Regeln beachten:

1. Nicht dauerhaft nackt senden: Packe den roten Sende Datensatz-Block niemals einfach so nackt in den Haupt-Loop. Der Arduino würde sonst tausende Male pro Sekunde Daten an den PC feuern, wodurch die Processing-App einfrieren kann. Nutze stattdessen immer einen Intervall-Timer (z. B. "Alle 500 ms ausführen") oder sende Daten nur dann, wenn sich ein Wert tatsächlich geändert hat.
2. Datenformat einhalten: Wenn du eine Position ausliest (z. B. Position 1 für eine Zahl), stelle sicher, dass der PC an dieser Stelle auch wirklich eine Zahl schickt. Wenn der Arduino versucht, ein normales Wort (wie "Hallo") in eine Kommazahl umzuwandeln, kommt mathematischer Unsinn (0.0) dabei heraus.

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

Wenn du ein größeres Projekt planst, merkst du schnell, dass die Standard-Pins am Arduino UNO R4 knapp werden können. Displays, Taster, Relais und LEDs belegen die Anschlüsse in Windeseile. Genau hier kommt der TCA9555 Portexpander ins Spiel: Dieses kleine Modul wird über den I2C-Bus (die Kontakte SDA und SCL) an deinen Arduino angeschlossen und spendiert dir mit nur zwei genutzten Leitungen 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 völlig frei als Eingang (z. B. für Taster) oder Ausgang (z. B. für LEDs oder Relais) konfiguriert werden.

🛠️ Die TCA9555-Blöcke im Detail

Bibliothek für die TCA Blöcke 

1. TCA Senden (Einzelner Pin)

Mit diesem Block schaltest du einen einzelnen, gezielten Ausgang auf dem Erweiterungsmodul ein (HIGH oder 1) oder aus (LOW oder 0).

• Die Einstellungen: Du wählst im Dropdown die I2C-Adresse deines Moduls (standardmäßig 0x20), den Port (0 oder 1) und den gewünschten Pin (0 bis 7). An den Zustand-Eingang dockst du einfach einen Logik-Wert (wahr/falsch) oder eine mathematische Zahl an.
• Hintergrund-Logik: Die Kiste ist schlau: Sie erkennt über den eingebauten Hardware-Scanner automatisch, welchen Pin du als Ausgang nutzen möchtest, und trägt den passenden pinMode(..., OUTPUT) selbstständig in den Setup-Bereich deines Arduino-Codes ein. Du musst dich darum nicht kümmern.

2. TCA Empfangen (Einzelner Pin)

Dieser Block liest den aktuellen Zustand eines bestimmten Pins auf dem Modul aus. Er liefert dir ein WAHR (wenn Spannung anliegt / HIGH) oder FALSCH (wenn keine Spannung anliegt / LOW) zurück.

• Anwendung: Da der Block eine Ausgängenase an der linken Seite hat, kannst du ihn direkt in eine WENN-Bedingung schieben – zum Beispiel: WENN 🎛️ TCA Empfangen | Adresse 0x20 Port 0 Pin 2 == WAHR.
• Hintergrund-Logik: Auch hier setzt das System im Hintergrund den Pin im Setup vollautomatisch auf INPUT.

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

Wenn du viele Pins gleichzeitig schalten oder abfragen willst, wird das Programm mit Einzelblöcken schnell unübersichtlich. Genau dafür gibt es die mächtigen Muster-Blöcke. Sie verarbeiten ein sogenanntes 8-Bit-Muster, das du einfach als Text eintippst. Das Muster liest sich immer von links (Pin 0) nach rechts (Pin 7).

3. TCA Muster Senden

Mit diesem Block setzt du alle 8 Pins eines kompletten Ports mit einem einzigen Befehl.

• Die Zeichen im Muster: * 1 = Schaltet den Pin sofort auf HIGH (Ausgang an).
  • 0 = Schaltet den Pin sofort auf LOW (Ausgang aus).
  • _ (Unterstrich) = Ignorieren. Dieser Pin behält einfach seinen aktuellen Zustand bei und wird im Programm nicht verändert.
• Beispiel: Das Muster 10_1____ schaltet Pin 0 ein, Pin 1 aus, ignoriert Pin 2, schaltet Pin 3 ein und lässt die Pins 4 bis 7 komplett unberührt.

4. TCA Muster Prüfen

Dieser Block ist genial für Sicherheitsabfragen, Codierschalter oder um den Zustand einer ganzen Tastaturmatrix mit einem Schlag zu überprüfen. Er vergleicht alle 8 Pins eines Ports gleichzeitig und gibt WAHR zurück, wenn das reale Signal exakt mit deinem Wunschmuster übereinstimmt.

• Die Zeichen im Muster:
  • 1 = Es wird an diesem Pin ein HIGH-Signal erwartet.
  • 0 = Es wird an diesem Pin ein LOW-Signal erwartet.
  • X = Egal. Der Zustand dieses Pins wird bei der Prüfung einfach übersprungen.
• Beispiel: Bei einem Muster von 11XXXXXX gibt der Block nur dann ein WAHR aus, wenn Pin 0 und Pin 1 gleichzeitig ein HIGH-Signal liefern. Was auf den restlichen Pins passiert, ist dem Block völlig gleichgültig.

💡 Profi-Tipp für Adressen und Verkabelung

Du kannst bis zu acht dieser TCA9555-Module gleichzeitig an deinem Arduino betreiben. Jedes Modul benötigt dafür lediglich eine eigene Hardware-Adresse, die du über die kleinen Lötbrücken oder DIP-Schalter (A0, A1, A2) direkt auf der Modulplatine einstellst.

Wenn du im Handumdrehen Modul 1 auf 0x20 und Modul 2 auf 0x21 stellst, weiß die LogicKiste im Code-Export genau, welches Modul sie auf dem I2C-Bus ansprechen muss. Das System trennt die Module im C++ Code sauber voneinander ab, sodass sich die Signale niemals in die Quere kommen!

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