Warum dieses Sumo-Roboter-Tutorial anders ist – und du es nicht verpassen solltest

Einführung & Besonderheiten

Willkommen zum vielleicht bestdurchdachtesten, didaktisch fundiertesten und praxisnahesten Roboter-Tutorial im gesamten Netz.

Während andere Tutorials oft mit losen Codefragmenten, fehlender Struktur oder oberflächlichen Erklärungen glänzen, bekommst du hier etwas völlig anderes:

Ein vollständiges, getestetes Lernsystem, das auf echter Unterrichtspraxis basiert – entwickelt an internationalen Schulen, optimiert mit echten Schülern und so aufgebaut, dass du nicht nur deinen Roboter zum Laufen bringst, sondern wirklich verstehst, wie ein System funktioniert.

◤ Systemisches Denken statt Copy & Paste

» Du lernst nicht nur was funktioniert, sondern warum.
» Alle Codeentscheidungen sind nachvollziehbar, modular und durchdacht – ganz im Sinne echter Robotik-Logik.

◤ Modular aufgebaut – wie ein echtes Robotersystem

» Sicherheitssystem und Angriffssystem sind getrennt entwickelt und getestet.
» Erst am Ende verschmelzen sie zu einem intelligenten Gesamtverhalten – realitätsnah, optimal zum Lernen und Optimieren.

◤ Fokus auf echte Strategie statt Zufallsverhalten

» Drei Ultraschallsensoren arbeiten zusammen, um den Gegner zu orten, zu verfolgen und gezielt zu attackieren.
» Statt blindem Geradeausfahren entsteht ein echtes Jagdverhalten – reaktiv, effizient und turnierfähig.

◤ Vollständig dokumentiert & in der Praxis bewährt

» Jede Entscheidung im Aufbau und Code ist begründet.
» Du kannst jede Funktion einzeln testen – und bei Bedarf erweitern, kombinieren oder debuggen.
» Das hier ist keine lose Sammlung von Ideen – das hier ist ein durchdachtes System.

◤ Didaktisch erprobt – und als Basis frei zugänglich

» Was normalerweise Teil eines kostenpflichtigen Schulcurriculums ist, kannst du hier als Einstieg kostenfrei nutzen.
» Bildung sollte keine Preisbarrieren kennen – aber für vertiefte Projekte, Baupläne und Strategien gibt es später optionale Erweiterungen.

Damit wirst du nicht nur einen Roboter bauen –
sondern etwas viel Wertvolleres entwickeln:
Dein Verständnis, wie man Systeme entwirft, integriert, optimiert und steuert –
und die Fähigkeit, eigene Ideen darauf aufzubauen.

Bereit? Dann schnall dich an:
Wir bauen nicht nur einen Roboter –
wir bauen Wissen. Und vielleicht auch deinen ersten kleinen Sieg im Ring.

(Am Ende kleiner Block:)

📚 Hinweis:
Dieses kostenlose Tutorial bildet die Grundlage.
Wenn du tiefer einsteigen möchtest – mit vollständigen Codesystemen, mechanischen Erweiterungen und Wettbewerbsstrategien – findest du bald alle Details im begleitenden Sumo Robotics Buchprojekt.

Voraussetzungen & Motivation

Was du können solltest, bevor du loslegst

Du brauchst keine Profi-Kenntnisse – aber ein paar Grundlagen solltest du mitbringen:

» Du hast schon mit Arduino gearbeitet (z. B. LED blinken, Taster abfragen, kleine Programme schreiben).
» Du hast schon mal einen Motor oder Sensor angeschlossen – oder traust dir das zu.
» Du hast Lust, zu tüfteln, zu testen und Dinge selbst zu lösen.

Wenn du diese Fragen mit Ja beantworten kannst, dann bist du hier genau richtig.
Dieser Kurs ist gemacht für alle, die nicht nur basteln, sondern wirklich verstehen wollen, wie man aus Sensorik, Code und Strategie ein funktionierendes System aufbaut.

🎥 Der fertige Roboter in Aktion

⟶ (Hier später dein Video einfügen – z. B. 20–30 Sekunden Sumo-Bot in der Arena, mit erklärendem Text oder Voiceover. Ideal als Appetizer für „Ich will das auch!“)

💬 Hinweis in eigener Sache

Damit du direkt loslegen kannst, habe ich alle verwendeten Komponenten, Werkzeuge und Materialien für dich zusammengestellt – basierend auf echten Praxistests.

Viele dieser Links sind sogenannte Affiliate-Links.
Wenn du darüber bestellst, unterstützt du dieses Projekt – ohne dass du mehr zahlst.

🛠️ Zur empfohlenen Einkaufsliste ➝ [Hier später Link einfügen]

Damit ermöglichst du mir, diese Inhalte dauerhaft kostenlos anzubieten – und gleichzeitig hochwertige, tiefere Erweiterungen zu entwickeln, wie z. B. das kommende Buchprojekt oder interaktive Kurse.

📌 Strategischer Zusatz (CTA)

Tipp:
Wenn du tiefer einsteigen willst – mit vollständigem Code, Bauplänen, Strategiemodulen und STL-Dateien – dann findest du alles im Sumo Robotics Premium-Paket, das aktuell in Entwicklung ist.

Benötigte Komponenten für deinen Sumo-Roboter

Erprobte Komponenten – ideal für Anfänger mit Vorwissen

Bevor du loslegst, hier die komplette Materialliste für deinen Sumo-Roboter. 
Ich habe bewusst nur Komponenten ausgewählt, die robust, bewährt und didaktisch sinnvoll sind – viele davon habe ich mehrfach im Unterricht getestet.

◾ Die kompakte Basis-Version – ohne Display
Die günstigste und platzsparendste Version kommt ohne Anzeige. Sie ist ideal für den festen Einbau und wenn du ohnehin ein Multimeter griffbereit hast.

Vorteile:
» Sehr kompakt, passt auch in enge Gehäuse
» Kein zusätzlicher Stromverbrauch
» Günstiger als Display-Varianten
» Schraubklemmen statt Lötverbindungen → schnelle, werkzeuglose Verbindung möglich

Nachteile:
» Zum Einstellen der Ausgangsspannung ist ein Multimeter zwingend erforderlich
» Kein visuelles Feedback – versehentliche Fehlspannung bleibt unbemerkt
» Umständlicher, wenn man später etwas nachjustieren will

◾ Die LCD-Variante – praktisch im Kurs
In meinen Kursen setze ich gezielt auf die LM2596-Variante mit LCD-Anzeige –
aus einem ganz praktischen Grund:
Sie spart Zeit und ist deutlich einfacher in der Handhabung.

Die Ausgangsspannung lässt sich direkt am Modul ablesen – ganz ohne Multimeter.
Das macht die Einrichtung nicht nur sicherer, sondern reduziert auch typische Fehlerquellen.
Zusätzlich verfügt auch diese Version über Schraubanschlüsse, wodurch kein Löten nötig ist.
Gerade im Kursbetrieb ist das ein enormer Vorteil, weil Auf- und Umbauten so deutlich schneller gelingen.

Vorteile:
» Direkte Spannungsanzeige – kein Multimeter notwendig
» Schnelles Nachjustieren ohne Umstecken
» Kein Löten nötig – Schraubklemmen machen die Arbeit einfach
» Ideal für Workshops, Schülerprojekte und Einsteiger
» Visualisiertes Feedback → Lernbarriere sinkt

Nachteile:
» Etwas größer, braucht mehr Platz
» Minimale Stromaufnahme durch das Display
» Bei sehr günstigen Modellen: gelegentlich ungenaue Anzeige

Fazit
In diesem Tutorial verwenden wir die LCD-Variante, weil sie den Einstieg erleichtert,
den Aufbau beschleunigt und sich durch die Schraubklemmen komplett lötfrei realisieren lässt.
Aber: Ich zeige dir natürlich auch, wie du die klassische Version mit Multimeter korrekt einstellst,
sodass du mit beiden sicher umgehen kannst – ganz nach deinem Stil und deinen Möglichkeiten.

Kleinteile & Zubehör

Hilfsmittel für den Aufbau und die Befestigung

◾ Jumper-Kabel
» 3x Set 20cm männlich/weiblich
» 1x Set 10cm männlich/weiblich

◾ Heißkleber
 oder besser Sekundenkleber
◾ Schutzbrille
◾ Optional: Karton 2mm dick, 3D-Druckteile oder Lasercut-Designs für den Aufbau

Hinweis: Eine Komplettset-Zusammenstellung folgt demnächst –
oder du stellst dir dein individuelles Starter-Kit aus meinen Empfehlungen zusammen.

Mechanischer Aufbau

Der mechanische Aufbau deines Sumo-Roboters bildet das Fundament für Funktion, Strategie und Präzision. Du hast zwei Möglichkeiten:

⬙ Karton-Variante zum Einstieg

⬙ 3D-Druck-Variante für maximale Performance

◾ Variante 1: Karton-Gehäuse (kostenlos)

Diese Version ist ideal für Einsteiger, Schulen und alle, die schnell und einfach starten wollen.

Was du brauchst:

» Stabilen Karton (z. B. Verpackungskarton oder Bastelkarton)

» Heißkleber oder doppelseitiges Klebeband
▫ Cutter, Lineal und Bleistift

» Optional: Farbstifte oder Marker zur Gestaltung

⟶ Schablone als PDF:
[Download Karton-Schablone]

Vorteile:

» Kein 3D-Drucker notwendig

» Schnell verfügbar & kostengünstig

» Perfekt für kreative Gestaltungsideen

◾ Variante 2: 3D-Druck-Gehäuse (Premium)

Für alle, die mehr wollen: Stabilität, Präzision und ein professionelles Erscheinungsbild.

Was du bekommst:
» STL-Dateien aller Teile (Bodenplatte, Sensorhalter, Batteriehalter etc.)

» Tipps für Filamentwahl, Druckeinstellungen & Montage

» Optionales Erweiterungsset für alternative Sensorpositionierung

Vorteile:

» Kompakt & robust
: Integrierte Steckverbindungen für einfachen Zusammenbau

» Wiederverwendbar & kompatibel mit Erweiterungen

⟶ Jetzt erhältlich im Shop:
[Zum 3D-Druck-Paket]

◾ Hinweis zur Lizenz & Verwendung

Die Karton-Version ist frei verfügbar zur privaten & schulischen Nutzung.
Die STL-Dateien sind urheberrechtlich geschützt und ausschließlich im Premium-Paket enthalten.

◾ Karton vs. 3D-Druck – Was passt besser zu dir?

Beide Varianten haben ihre Stärken – entscheidend ist, was du gerade brauchst:

» Schnell & einfach starten? Dann ist die Karton-Version perfekt für dich.


» Stabilität & Design stehen bei dir im Fokus? Dann wirst du die 3D-Druck-Version lieben.

⟶ Tipp: Du kannst jederzeit später upgraden. Der Code bleibt gleich – das Gehäuse ist austauschbar.

Bereit? Dann starten wir mit dem Karton-Gehäuse.

Wir zeigen dir jetzt Schritt für Schritt,

» welche Materialien du brauchst,

» wie du sie zuschneidest und

» wie dein erster Sumo-Roboter Form annimmt.

Und ganz nebenbei empfehlen wir dir Werkzeuge, die dir den Einstieg erleichtern – natürlich nur solche, die wir selbst nutzen und empfehlen können.

Los geht’s: Bau dein erstes Gehäuse – aus Karton, mit Köpfchen.

Detaillierter Aufbau – Karton-Version

Bauzeichnung & Grundform

1. Grundplatte:

» Maße: ca. 12 × 10 cm (anpassbar je nach Radstand)

» Aussparung für Motoren einplanen

» Vorne leicht abgeschrägt oder rund für besseres Manövrieren

2. Motorhalter:

» Motoren (gelbe T-Getriebemotoren) seitlich anbringen

» Entweder mit Heißkleber fixieren oder mit Draht durch Karton stecken

» Abstand so wählen, dass genug Bodenfreiheit bleibt

3. Batteriehalter:

» Platz für Batterien zentral oder hinten

» Evtl. Halteband oder Karton-Schacht für Akkupack

4. Sensorhalter:

» Für Linien-Sensoren: vorne & hinten je eine Aussparung

» Für Ultraschallsensoren: Halterung frontal mittig, evtl. mit Verstärkung

Balance & Design – Was beim Bau des Roboters zählt

Ein erfolgreicher Sumo-Roboter ist nicht nur gut programmiert – auch das physische Design entscheidet mit über Sieg oder Niederlage. Bereits kleine Unterschiede in Gewicht, Schwerpunkt oder Sensorposition können darüber bestimmen, ob dein Roboter souverän in der Arena besteht oder frühzeitig hinausgeschoben wird.

Tiefer Schwerpunkt – für maximale Standfestigkeit

Platziere schwere Komponenten wie Akkus oder Batterien so tief wie möglich im Gehäuse. Das senkt den Schwerpunkt und macht den Roboter standfester – besonders bei schnellen Schiebemanövern oder plötzlichen Richtungswechseln. Leichtere Bauteile wie Kabel, Sensoren oder die Hauptplatine gehören nach oben.

Gewichtsverteilung – lieber hinten schwer

Ein Schwerpunkt im hinteren Bereich verhindert, dass der Roboter bei Widerstand vorne abhebt. Die Traktion verbessert sich – besonders wenn es im Wettbewerb intensiv wird. Achte darauf, dass das Gewicht gleichmäßig auf beide Antriebsräder wirkt, aber leicht hecklastig bleibt.

Sensorpositionierung – so nah wie möglich an der Kante

Linien-Sensoren sollten möglichst weit vorne (für den Angriff) und hinten (für Rückzug) sowie möglichst nah an der Außenkante des Roboters sitzen. Wenn Sensoren zu weit innen liegen, reagieren sie zu spät – der Roboter hat die Arena dann oft schon verlassen, bevor die Sensoren überhaupt die weiße Linie erkennen. Besonders bei hoher Geschwindigkeit ist eine präzise Platzierung entscheidend.

Abstand der Motoren – Balance zwischen Drehfreude und Stabilität

Ein zu großer Abstand zwischen den Rädern sorgt für Stabilität, aber erschwert enge Wendemanöver. Ein zu kleiner Abstand dagegen macht den Roboter zwar wendig, aber instabil. Finde die ideale Balance, sodass dein Roboter sich schnell um die eigene Achse drehen kann – ohne an Bodenhaftung zu verlieren.

Logik-Setup


Verständnis der Sensor-Kombinationen im Sicherheitssystem

Um sicherzustellen, dass dein Sumo-Roboter stets innerhalb des Spielfelds bleibt und nicht versehentlich die Ringgrenze überschreitet, nutzen wir ein Sicherheitssystem basierend auf drei strategisch platzierten Infrarot-Liniensensoren:

⟶ Links vorne

⟶ Rechts vorne

⟶ Hinten mittig

Jeder dieser Sensoren liefert einen digitalen Zustand:

⟶ 1: Schwarzer Boden erkannt (sicher)

⟶ 0: Weiße Linie erkannt (Gefahr)

Es ist faszinierend, wie viel Intelligenz sich mit nur drei einfachen Sensoren realisieren lässt:
Der Roboter analysiert permanent den Untergrund und erkennt allein durch die binären Zustände seiner Sensoren, ob er sich sicher im Spielfeld befindet – oder kurz davor steht, hinausgeschoben zu werden.

Insgesamt ergeben sich durch die Kombination der drei Sensoren acht mögliche Szenarien (2³ Kombinationen).
Jede dieser Konstellationen lässt sich eindeutig interpretieren und führt zu einer gezielten Reaktion:
Ausweichen, zurückweichen, drehen oder – im schlimmsten Fall – eine Notdrehung einleiten.

Und das Beste:
All das funktioniert ohne Kameras, ohne KI – nur mit cleverem Code und Logik.
Ein schönes Beispiel dafür, wie Reduktion zur Meisterschaft führen kann.

⟶ Im Folgenden werden wir jede dieser acht Kombinationen detailliert analysieren. Dabei erläutern wir die jeweilige Position des Roboters, die daraus resultierende Aktion und zusätzliche Hinweise zur Strategie. Dieses Verständnis ist essenziell, um die Entscheidungslogik des Roboters nachvollziehen und optimieren zu können.


⟶ Hinweis: Die genaue Platzierung und Kalibrierung der Sensoren ist entscheidend für die Zuverlässigkeit des Systems. Es empfiehlt sich, die Sensoren vor dem Einsatz gründlich zu testen und die Schwellenwerte entsprechend der Umgebungsbedingungen anzupassen.

Erklärung der Sensor- Kombinationen im Sicherheitssystem


Dein Roboter nutzt drei Linienfolger (links, hinten, rechts), die jeweils einen digitalen Zustand zurückgeben:

⟶ 0 = Schwarzer Boden (ok)

⟶ 1 = Weiße Fläche erkannt (Grenze!)

Angriffssystem: „Win the Game“


Die untere Grafik zeigt die Entscheidungslogik des Roboters in zwei klar getrennten Phasen: Zunächst sorgt das Sicherheitssystem (linke Tabelle) dafür, dass der Roboter innerhalb des Rings bleibt. Sobald alle Liniensensoren schwarz erkennen (000), wechselt er in den Angriffsmodus (rechte Tabelle). Hier orientiert er sich an den Ultraschallsensoren, um die Position des Gegners zu bestimmen und gezielt anzugreifen. Jede Sensor-Kombination löst eine spezifische Reaktion aus – ob Angriff, Drehung oder Suche. Dadurch entsteht ein klares, reaktives Verhaltensmuster, das sowohl verständlich als auch effektiv ist.

Wie funktioniert die Sensorlogik?


◾ Die Ultraschallsensoren geben analoge Messwerte in Zentimetern oder Millimetern zurück.

⟶ In unserem Beispiel hat sich ein Schwellwert von 15 cm bewährt:

⟶ < 15 cm: Ein Objekt (vermutlich der Gegner) wurde erkannt

⟶ ≥ 15 cm: Kein Objekt im relevanten Bereich

⟶ Daraus leiten wir eine vereinfachte Entscheidungslogik ab, um das Verhalten des Roboters zu steuern.

Entscheidungslogik: Was passiert bei welcher Sensor-Kombination?

Wir betrachten zunächst nur die vier grundlegendsten Bedingungen, da sie in den meisten Kampfsituationen am sinnvollsten sind – wie wir gleich im Detail erläutern werden. Diese einfachen, klar interpretierbaren Szenarien bilden die Grundlage für ein reaktives Angriffssystem und lassen sich später leicht zu komplexeren Strategien erweitern.

Zusammenfassung:

Warum behandeln wir nur diese vier Fälle?


Die Kombinationen mit zwei oder drei gleichzeitig erkannten Gegnern (z. B. links und rechts) werden bewusst ignoriert. Warum?

1. Realitätsfern:

Solche Messwerte würden bedeuten, dass der gegnerische Roboter gleichzeitig an mehreren Stellen vor deinem Bot auftaucht – was bei den erlaubten Größen im Sumo-Roboter-Wettbewerb unwahrscheinlich ist.

2. Fehlinterpretationen durch Schallstreuung:

Ultraschall kann durch Kanten, Neigungen oder die Form des Gegners leicht reflektiert werden. Je mehr Sensoren gleichzeitig anschlagen, desto unsicherer ist die Aussage.

3. Reduktion auf das Wesentliche:

Ein einfacher, robuster Code ist besser als ein komplexer, fehleranfälliger. Mit nur vier klaren Fällen kannst du einen zuverlässigen Gegnerverfolgungsmodus umsetzen.

Was passiert, wenn kein Gegner erkannt wird?

Wenn kein Ultraschallsensor einen Wert unterhalb der 15 cm-Schwelle meldet, geht der Roboter in den Suchmodus:

» Er dreht sich auf der Stelle – idealerweise so lange, bis mindestens ein Sensor einen Gegner erfasst.

» Dieser Spin stellt sicher, dass der Roboter aktiv bleibt und nicht „blind“ umherfährt.

Fazit

» Mit nur drei einfachen Sensoren und einem festen Abstandsschwellwert von 15 cm kannst du ein effektives Angriffssystem umsetzen – ganz ohne KI oder Kameras.


» Die Kombination aus Sicherheitspriorität + gezieltem Gegner-Tracking macht deinen Sumo-Roboter nicht nur reaktionsschnell, sondern auch turnierfähig – und das mit minimalem Codeaufwand.

◤ Architekturunterschied:
Sicherheitssystem vs. Angriffssystem

Beim Entwurf eines reaktiven Roboters ist es entscheidend zu verstehen, dass Sicherheits- und Angriffssysteme unterschiedliche Anforderungen an die Logikstruktur stellen. Dieser Unterschied zeigt sich besonders deutlich in der Art, wie Sensorinformationen verarbeitet werden.

Sicherheitssystem: Alle Kombinationen müssen berücksichtigt werden!

Jede Kombination zählt.

Denn jede Konstellation steht für eine klare Situation, auf die unmittelbar reagiert werden muss. Das Sicherheitssystem muss alle 8 möglichen Kombinationen auswerten. Da es sich um ein verbundenes System handelt, reicht es nicht, einzelne Sensoren isoliert zu betrachten. Wird eine Kombination übersehen, riskiert der Roboter Fehlverhalten – gerade in kritischen Momenten am Rand der Arena.

Zwei exemplarische Fälle – mit besonderer Bedeutung

Nicht alle Sensor-Kombinationen sind gleich bedeutsam. Zwei Fälle stechen besonders hervor – sowohl aus praktischer als auch aus pädagogischer Sicht:

❶ Kombination 000 – Alle Sensoren melden Schwarz

→ Der Roboter steht stabil innerhalb der Arena – es besteht keine Gefahr.

Diese Kombination ist etwas Besonderes, denn sie bildet den einzigen legitimen Eingang zum Angriffssystem. Nur wenn alle drei Abgrundsensoren Schwarz erkennen, ist der Roboter eindeutig innerhalb des Rings – und darf in den Angriffsmodus wechseln.

Im aktuellen System löst dieser Zustand ein einfaches Vorwärtsmanöver aus, um direkt mit dem Gegnerkontakt zu beginnen.

Doch dieser Moment bietet viel mehr:
Er ist der Startpunkt für künftige Angriffstaktiken. In weiterentwickelten Versionen oder im SumoRobot Advanced Kurs werden wir genau hier strategische Eröffnungen platzieren – etwa eine gezielte Drehung zur Gegnerorientierung, das Aktivieren eines Scanning-Modus oder eine anpassbare Startpositionierung. Diese scheinbar neutrale Situation ist also der Schlüssel zu intelligentem Verhalten – der Übergang von Sicherheit zu Strategie.

❽ Kombination 111 – Alle Sensoren melden Weiß

→ Der Roboter hat den Ring vollständig verlassen.

In nahezu allen offiziellen Wettbewerben bedeutet dies das sofortige Ausscheiden aus der Runde – ganz gleich, was danach passiert. Daher behandeln wir diesen Fall in diesem Grundlagentutorial nicht weiter, da er taktisch keine Relevanz hat.

Und doch bietet genau dieser Zustand einen einzigartigen Lernanlass:
Im Präsenzkurs SumoRobot Advanced nutzen wir ihn gezielt, um komplexere und realitätsnahe Szenarien zu entwickeln:
» Wie erkennt der Roboter, dass er sich außerhalb der Arena befindet?
» Welche gespeicherten Daten kann er nutzen, um sich zu orientieren?
» Wie kann er autonom entscheiden, ob eine Rückkehr noch möglich oder sinnvoll ist?

Solche Fragen eröffnen Raum für fortgeschrittene Programmierkonzepte wie:
» Positionshistorie und Speicherstrategien
» Richtungsentscheidungen auf Basis letzter gültiger Sensordaten
» Differenzierung zwischen Notfallrückkehr und endgültigem Stopp

Fazit
Auch wenn 111 im Wettbewerb das AUS bedeutet, wird es im pädagogischen Kontext zur Gelegenheit, tiefere Einsichten in Entscheidungsarchitekturen, Fehlerbehandlung und Systemdenken zu gewinnen.

Angriffssystem: Fokussiert auf die ersten vier Fälle

Das Angriffssystem arbeitet völlig anders: Es nutzt Ultraschallsensoren, die analoge Distanzwerte liefern. Hier steht nicht die Kombination, sondern die Priorität einzelner Sensoren im Vordergrund.

Die Entscheidungslogik ist entsprechend schlank:

» Es wird immer nur die erste zutreffende Bedingung ausgeführt – alle weiteren ignoriert.
» Auch wenn mehrere Sensoren gleichzeitig „anschlagen“, greift die Reihenfolge.
» Fälle wie LEFT + CENTER < 20 werden automatisch korrekt behandelt – z. B. durch
den Check von CENTER an erster Stelle.

Der Unterschied auf einen Blick

Fazit
Der entscheidende Unterschied liegt in der Systemarchitektur: Während das Sicherheitssystem alle 8 Kombinationen vollständig abbilden muss, genügt beim Angriffssystem eine einfache, priorisierte Entscheidungsstruktur. Diese Entscheidung reduziert die Komplexität, erhöht die Reaktionsgeschwindigkeit und macht dein System insgesamt robuster.

◤ Struktur des Tutorials: Schritt für Schritt zum funktionierenden Sumo-Roboter


◾ Damit dein Roboter nicht nur fährt, sondern zielgerichtet kämpft, haben wir dieses Tutorial in vier klar abgegrenzte Etappen unterteilt.
 Jede Etappe behandelt ein eigenes Subsystem oder eine logische Funktionseinheit – praxisnah, verständlich und aufbauend.

◾ Das Ziel
Am Ende dieser Serie soll dein Roboter sicher in der Arena navigieren, gezielt angreifen – und seine Gegner zuverlässig aus dem Ring schieben.
 Und du wirst jede einzelne Entscheidung im Code und Aufbau nachvollziehen können.

Die vier Etappen im Überblick

1. Kalibrierung des Sicherheitssystems ("Stay in the Game")


2. Kalibrierung des Angriffssystems ("Win the Game")

3. Systemintegration: Sicherheit + Angriff


4. Erweiterung & Optimierung


Einführung in das Code-System


◾ Ein Sumo-Roboter sieht auf den ersten Blick simpel aus – zwei Räder, ein paar Sensoren, fertig.

⟶ Doch unter der Haube arbeitet ein durchdachtes System aus zwei unabhängigen Subsystemen, die gemeinsam dafür sorgen, dass der Roboter intelligent, kontrolliert und strategisch agieren kann.

⟶ In diesem Kapitel bekommst du einen Überblick darüber, wie der Code aufgebaut ist und warum die klare Trennung zwischen Sicherheit und Angriff so entscheidend ist.

Das Code-System


◾ Der Code steuert das gesamte Verhalten deines Roboters
⟶ „Ist der Gegner in Reichweite?“ bis hin zur Reaktion

⟶ „Ich drehe lieber ab, bevor ich aus dem Ring fliege!“.


◾ Er verbindet alle verbauten Komponenten miteinander:

⟶ Sensoren zur Wahrnehmung der Umgebung (Ultraschall & Arenarand)

⟶ Aktoren zur Bewegung (Motoren)

⟶ Entscheidungslogik für Reaktion und Strategie

Zwei Subsysteme – Zwei Ziele

◾ 1. Sicherheitssystem – „Stay in the Game“

⟶ Ziel: Der Roboter bleibt sicher innerhalb der schwarzen Arena.

⟶ Grundlage: Drei Farbsensoren am Rand des Roboters erkennen die weiße Ringgrenze.

◾ 2. Angriffssystem – „Win the Game“

⟶ Ziel: Den Gegner aufspüren und möglichst aus dem Ring drängen.

⟶ Grundlage: Drei Ultraschallsensoren messen Entfernungen nach vorne, links und rechts.

Warum diese Trennung sinnvoll ist


◾ Ohne klare Prioritäten würde dein Roboter permanent zwischen Zielen schwanken –

⟶ z. B. angreifen, obwohl er kurz davor ist, aus dem Ring zu stürzen.


◾ Darum gilt im Code eine einfache Regel:

⟶ Sicherheit geht immer vor.

⟶ Erst wenn alle Rand-Sensoren schwarz melden (→ innerhalb der Arena), darf überhaupt über einen Angriff nachgedacht werden.

Besonderheit dieses Tutorials


◾ Der Code ist so gestaltet, dass beide Subsysteme leicht verständlich und modular erweiterbar sind. Wir konzentrieren uns in diesem Kurs bewusst auf eine robuste, klar priorisierte Basisstruktur:

⟶ Verständlich für Einsteiger

⟶ Schnell anpassbar für Fortgeschrittene

⟶ Realistisch und stabil im Wettkampf

◾ In späteren Kursen wirst du lernen,

⟶ wie du die Angriffssysteme intelligenter, die Bewegungen geschmeidiger und die Sicherheitslogik noch raffinierter machst –

⟶ aber jetzt starten wir erstmal solide und durchdacht.

◤ Motoren & Motortreiber verstehen


Bevor wir in den Code eintauchen, müssen wir zunächst unser Setup mit Jumper-Kabeln verbinden und die Funktionsweise des Motortreibers L298N verstehen.


⟶ Wenn du bereits Erfahrung mit Motortreibern hast, kannst du diesen
Abschnitt überspringen – aber es lohnt sich, trotzdem einen Blick darauf zu werfen.

Ziel: Die Grundlagen der Bewegung verstehen – von Theorie zu Praxis

Wenn du versuchst, einen Gleichstrommotor (z. B. die gelben T-Getriebemotoren) direkt an den Arduino anzuschließen, stößt du auf zwei zentrale Probleme:

1. Zu wenig Strom:


» Der Arduino kann nur rund 200 mA bereitstellen – ein Motor braucht aber
leicht das Zehnfache (oft über 1500 mA).

» Zum Vergleich: Eine LED benötigt nur ca. 10 mA.

» Ein direkter Anschluss kann den Arduino überlasten oder sogar zerstören.

2. Keine Richtungsumkehr möglich:

» Wenn du einen Motor mit einem digitalen Pin steuerst und GND verbindest, dreht er sich nur in eine Richtung.

» Für einen echten Roboter brauchen wir aber Vorwärts- und Rückwärtsbewegung.

Wie funktioniert das?


Im Kern des L298N steckt eine sogenannte H-Brücke – benannt nach ihrer Form.

⟶ Sie ermöglicht es, den Stromfluss gezielt umzulenken, sodass der Motor in beide Richtungen laufen kann.

◾ Dank dieser Schaltung kannst du jeden Motor gezielt:

» Vorwärts bewegen

» Rückwärts laufen lassen

» Anhalten

◾ Und wenn du zwei Motoren gleichzeitig steuerst, ergeben sich komplexere Bewegungsmuster:
» Geradeaus fahren

» Kurven fahren

» Drehen auf der Stelle

» Rückwärts flüchten

» Oder: Volle Attacke!

Lass uns den L298N genauer ansehen

⟶ Wir schauen uns an, welche Anschlüsse es hat, wo die Stromversorgung angeschlossen
wird, und wie wir es mit dem Arduino verbinden.


⟶ Bereit? Dann schnapp dir dein Modul – wir gehen es Schritt für Schritt durch!

◤ Der Motortreiber L298N –
verstehen und sicher anschließen


Der L298N ist einer der meistgenutzten Motortreiber für Arduino-Projekte – robust, preiswert und leistungsstark. Er eignet sich perfekt, um zwei Gleichstrommotoren unabhängig voneinander zu steuern. Im Zentrum des Boards sitzt der namensgebende L298N-Chip, der unter einem schwarzen Kühlkörper verborgen ist. In diesem Chip befinden sich zwei sogenannte H-Brücken – elektronische Schaltungen, mit denen man die Drehrichtung und Geschwindigkeit von Motoren flexibel kontrollieren kann. In diesem Abschnitt konzentrieren wir uns bewusst auf das Wesentliche, um dir einen klaren und praxisnahen Einstieg zu ermöglichen.

Weil der Chip bei voller Motorleistung viel Wärme produziert, dient der Kühlkörper als passive Temperaturregelung – und er wird bei Belastung auch richtig heiß.

Anschlüsse und Jumper beim L298N – was du wissen musst

Im unteren Bereich des L298N-Moduls befindet sich eine Schraubklemme mit drei Anschlüssen:

Der wichtige Jumper: „5V-EN“ oder „+5V Jumper“

Ob der 5V-Anschluss als Eingang oder Ausgang funktioniert, hängt vom kleinen Jumper direkt hinter der 5V-Pinreihe ab. Dieser ist oft beschriftet mit „5V-EN“, „+5V“ oder ähnlichem. Ein Jumper ist ein kleiner, abnehmbarer Steckkontakt aus Kunststoff mit einem leitenden Metallkern. Er wird auf zwei benachbarte Pins gesteckt, um eine elektrische Verbindung herzustellen – ähnlich wie ein Schalter.

◾ Fall 1: Jumper gesteckt (Werkseinstellung)
Ist der kleine Jumper auf dem L298N-Modul gesteckt, wird der interne Spannungsregler aktiviert. Dadurch funktioniert der 5V-Anschluss als Ausgang – du kannst hierüber z. B. Sensoren oder kleine Module mit Strom versorgen. Wichtig: In diesem Modus darfst du keine 5V von außen einspeisen, da dies den Spannungsregler beschädigen kann.

◾ Fall 2: Jumper entfernt
Wird der Jumper entfernt, ist der interne Spannungsregler deaktiviert. In diesem Fall muss der 5V-Pin von außen mit Spannung versorgt werden – etwa über den 5V-Ausgang des Arduino oder ein separates, geregeltes Netzteil. Diese 5V dienen nicht zur Motorversorgung, sondern ausschließlich zur Versorgung der internen Steuerelektronik (Logikspannung) des L298N.

◾ Wann solltest du den Jumper entfernen?
Den kleinen Jumper solltest du nur dann entfernen, wenn du den L298N mit einer Versorgungsspannung von mehr als 12V betreiben möchtest – beispielsweise mit einem 18V-Akku. Der auf dem Board verbaute Spannungsregler ist nicht dafür ausgelegt, höhere Spannungen sicher herunterzuwandeln. Alternativ kann es auch sinnvoll sein, den Jumper zu entfernen, wenn du ganz gezielt selbst bestimmen möchtest, woher die 5V-Logikspannung kommen soll – etwa direkt vom 5V-Pin deines Arduino. In beiden Fällen muss die 5V-Spannung dann manuell über den mittleren Anschluss des Schraubblocks eingespeist werden.

⚠️ Wichtig:
 Der mittlere Anschluss ist GND (Masse).

⟶ Wenn du hier Plus und Minus vertauschst, riskierst du ernsthaften Schaden:

» Der Motortreiber kann durchbrennen

» Kabel können schmelzen

» Akkus – vor allem 18650 Lithium-Zellen – können explodieren oder in Flammen aufgehen

Ein echtes Beispiel

Auf dem Bild siehst du das Batterie-Setup aus einem früheren Kurs.
 Eine Teilnehmerin hat Plus und Minus vertauscht – innerhalb von Sekunden rauchte die Platine, die Isolierung schmolz, und wir mussten den Akku sofort sichern.

⚠️ Bitte achte bei diesem Schritt doppelt und dreifach auf die richtige Verkabelung.

Steuerung über IN-Pins


Direkt rechts neben dem Anschlussblock des L298N befinden sich vier mit IN1, IN2, IN3 und IN4 beschriftete Pins. Diese stehen für „INPUT“ – also die digitalen Steuersignale, die vom Arduino an das Modul gesendet werden. Die Pins IN1 und IN2 steuern Motor A, während IN3 und IN4 für Motor B zuständig sind.

Geschwindigkeit regeln mit ENA / ENB


Links und rechts neben den IN-Pins findest du zwei weitere Anschlüsse mit den Bezeichnungen ENA und ENB. Diese stehen für „Enable“ – also das Aktivieren der Motoren. Über ENA wird Motor A, über ENB Motor B freigegeben. Standardmäßig sind auf beiden Pins kleine Jumper aufgesteckt. Das bedeutet: Die Motoren erhalten ein konstantes HIGH-Signal – sie sind dauerhaft aktiviert und laufen mit voller Leistung, sobald ein entsprechendes Steuersignal an IN1–IN4 gesendet wird.

Wenn du jedoch die Jumper entfernst und stattdessen ein PWM-Signal vom Arduino einspeist (z. B. mit analogWrite(ENA, wert)), kannst du die Drehgeschwindigkeit der Motoren feinjustieren – von sanfter Bewegung bis zur Maximalgeschwindigkeit. Das ist besonders nützlich für präzisere Bewegungen oder um Kurvenfahrten dynamischer zu gestalten. In diesem Tutorial belassen wir jedoch die Jumper auf den ENA- und ENB-Pins – der Roboter fährt also mit voller Kraft. Für die geplanten Aufgaben ist das völlig ausreichend.

Ausgang für die Motoren


Links und rechts auf dem L298N-Modul befinden sich jeweils zwei Schraubklemmen – das sind die Ausgänge zu den Motoren. An jeden dieser Schraubblöcke schließt du die zwei Leitungen eines Motors an: links für Motor A, rechts für Motor B. Genau hier gibt der L298N den gesteuerten Stromfluss aus, der zuvor über die H-Brücke im Inneren des Chips geregelt wurde.

Was ist eine H-Brücke?

Um einen Gleichstrommotor kontrolliert vorwärts und rückwärts laufen zu lassen, brauchst du mehr als nur Strom an oder aus. Du musst die Richtung des Stromflusses umkehren können – genau hier kommt die sogenannte H-Brücke ins Spiel. Sie ist das zentrale Schaltelement, das diese Aufgabe übernimmt.

Im L298N-Chip befinden sich gleich zwei dieser H-Brücken – je eine für Motor A und Motor B. Dadurch kannst du zwei Motoren unabhängig voneinander steuern, was ideal für Roboterfahrzeuge ist.

Aufbau einer H-Brücke (bildlich erklärt)

Stell dir vor, du hast vier elektronische Schalter, die so um einen Motor angeordnet sind, dass sie zusammen ein „H“ bilden – daher der Name. Oben zwei Schalter (links/rechts), unten zwei Schalter – der Motor sitzt in der Mitte zwischen den vertikalen Streben.

Die Steuerung erfolgt über zwei Pins am L298N:
Für Motor A: IN1 und IN2
Für Motor B: IN3 und IN4

Zwei typische Steuerungsbeispiele – so steuerst du die Drehrichtung

In diesem Fall wird der Stromfluss in einer definierten Richtung durch den Motor geleitet – zum Beispiel von links nach rechts. Der Motor beginnt sich zu drehen, etwa im Uhrzeigersinn – abhängig davon, wie er eingebaut ist. Diese Konstellation nutzt du typischerweise, wenn dein Roboter geradeaus fahren oder ein Rad vorwärts antreiben soll.

Jetzt kehrst du den Stromfluss um: Die Spannung liegt auf der anderen Seite des Motors an.
Dadurch wird der Stromfluss umgekehrt, und der Motor dreht sich in die entgegengesetzte Richtung – etwa gegen den Uhrzeigersinn.

Diese Variante brauchst du z. B., um den Roboter rückwärts fahren zu lassen oder ein Rad gezielt in die entgegengesetzte Richtung zu bewegen.

Solche einfachen digitalen Steuerungen bilden die Grundlage für komplexere Bewegungsmuster deines Roboters – wie Wenden, Ausweichen oder gezieltes Drehen auf der Stelle. Je nachdem, welches Signalpaar du an welchen Motor sendest, kannst du präzise kontrollieren, wie sich dein Roboter verhält.

Die vier möglichen Kombinationen mit IN1 und IN2 – und was sie bewirken – findest du im nächsten Abschnitt.

Bremsen mit der H-Brücke – aktiv oder passiv?

Wann ist der Unterschied spürbar?

Bei sehr kleinen oder leichtgängigen Motoren ist das oft kaum wahrnehmbar – der Unterschied zu LOW/LOW ist subtil.

Die vier möglichen Kombinationen im Überblick

⟶ Diese vier Zustände sind das Fundament jeder Bewegungssteuerung – ob einfaches Fahren, präzises Drehen oder strategisches Verhalten auf der Arena.

Fazit

Der L298N ist ein solides, robustes Modul zur Motorsteuerung – aber auch fehleranfällig, wenn man nicht genau weiß, was man tut.

◾ Verpolung = gefährlich
◾ Signalpaare = Richtungssteuerung
◾ ENA / ENB = Geschwindigkeit optional steuerbar

⟶ Mit dem Verständnis dieses Moduls legst du den Grundstein für alles, was folgt – ganz gleich ob Sensorik, Angriff oder komplexe Strategie: Bewegung ist der Anfang von allem.

◤ Verkabelung des Motortreibers


Jetzt wird’s praktisch – wir kümmern uns um die Verkabelung des L298N-Motortreibers mit dem Arduino, den beiden Motoren und dem Step-Down-Spannungsregler.

Wichtiger Hinweis vorab: Wir brauchen mehr Stromanschlüsse


Bevor wir tiefer in die Sensorlogik einsteigen, ein praktisches Problem:
 Der Arduino UNO hat nur begrenzt viele GND- und 5V-Pins.
Genauer gesagt:

◾ 2x 5V

◾ 3x GND

⟶ Das reicht für einfache Projekte – aber nicht, wenn du wie hier mehrere Sensoren gleichzeitig anschließen willst.

Fortgeschrittene wissen:
 Ja, man könnte sich zusätzliche Pins z. B. über die ICSP-Leiste holen (dort gibt es je einen 5V- und GND-Pin).
 Ich selbst nutze das manchmal für schnelle Tests – aber nur kurzfristig, nicht für stabile Langzeitprojekte.
 Die ICSP-Pins sind primär für Programmierzwecke gedacht – also bitte nur im Notfall zweckentfremden.

Die bessere Lösung: Power Distribution Board

Statt mit Breadboard oder wilden Kabelsträngen zu arbeiten, nutzen wir ein Power Distribution Board (auch bekannt als GND-/5V-Multiplier).
 Es ist ein kleines Modul mit:

◾ einem Anschlussblock (z. B. mit Schraubklemmen oder JST-Stecker)

◾ mehreren Ausgängen über Pinleisten

Vorteil:
 Du schließt einmal 5V und GND vom Arduino an – und bekommst gleich mehrere saubere Ausgänge für Sensoren, Servos, etc.

Ab sofort:
 Alle Sensoren und Aktoren bekommen ihre Stromversorgung über dieses Board.
 In deinem Fall:
 Stecke die drei Liniensensoren gemäß Schaltplan direkt an das Verteilerboard an (GND & VCC) – und verbinde nur die Signalleitungen mit dem Arduino.

Noch ein wichtiger Hinweis: Step-Down vor dem Anschließen einstellen!

Bevor du den Step-Down-Spannungsregler mit dem Arduino verbindest, musst du unbedingt die Ausgangsspannung korrekt einstellen. Ein zu hoher Wert kann deinen Arduino dauerhaft beschädigen.

◾ Was du dafür brauchst:
» Ein voll bestücktes Batteriepack (vollaufgeladene 4x 18650 Lithium-Zellen)
» Einen Step-Down-Spannungsregler (z. B. LM2596-Modul)
» Ein Multimeter zur Spannungsmessung

◾ So stellst du den Step-Down mit LCD-Anzeige richtig ein:
Die LCD-Variante des LM2596 macht das Einstellen besonders einfach –
denn du brauchst kein Multimeter, um die Ausgangsspannung zu kontrollieren.
Das Modul zeigt dir direkt auf dem integrierten Display an, welche Spannung aktuell anliegt.

❗ Wichtig:
Einige Module zeigen nicht automatisch die Ausgangsspannung an. Stattdessen verfügen sie über einen kleinen Taster, mit dem du zwischen Eingangsspannung (IN) und Ausgangsspannung (OUT) umschalten kannst. Drücke diesen Taster, bis auf dem Display eindeutig die Ausgangsspannung („OUT“) angezeigt wird - nur dann kannst du den korrekten Wert einstellen.

1. Schließe dein Batteriepack am Eingang des Step-Down-Reglers an (IN+ und IN−).

2. Achte auf das Display: Es sollte jetzt aktiv sein und entweder „IN“ oder „OUT“ anzeigen.
   Drücke ggf. auf den kleinen Taster, um zur Ausgangsanzeige zu wechseln.

3. Drehe nun langsam und vorsichtig am kleinen Schraubpotentiometer auf dem Modul,
   bis auf dem Display ein stabiler Wert von 9 V erscheint.

Tipp: 9 V ist ein sicherer Wert für den Arduino, wenn du ihn über den VIN-Pin versorgst. Wenn du Energie sparen möchtest, kannst du auch auf 7 V herunterdrehen – das liegt immer noch im stabilen Betriebsbereich.

Schritt-für-Schritt-Anleitung zur Verkabelung

Verbinde die vier Steuersignale (IN1–IN4) vom L298N-Motortreiber mit deinem Arduino:

Spannungsversorgung für Motortreiber, Arduino und Sensoren

⚠️ Achtung: Stromversorgung = kritisch!

Der L298N-Motortreiber sowie der Step-Down-Wandler reagieren empfindlich auf falsche Polung. Eine vertauschte Leitung (z. B. bei 18650-Lithium-Zellen) kann zu Kurzschlüssen, Rauchentwicklung oder im Extremfall sogar zu Brandschäden führen.

» Schließe dein Batteriepack (z. B. 3× 18650) an den Eingang (IN+ / IN−) des Step-Down-Moduls an.
» Setze den Schalter in die Plusleitung (OUT+), um den Strom sicher ein- und ausschalten zu können.

Wichtig: Der Schalter gehört immer in die Plusleitung (VCC)

Wenn du einen Ein-/Ausschalter in dein Stromversorgungssystem einbaust, solltest du ihn unbedingt in die Plusleitung (rote Leitung) und nicht in die Minusleitung (GND) setzen. Für Anfänger mag das egal erscheinen – schließlich unterbricht ein Schalter doch den Stromfluss, oder? Aber es gibt einen wichtigen Unterschied: Der Minuspol ist die gemeinsame Bezugsebene (GND) für alle Bauteile in deinem System – auch für das Arduino-Board. Wenn du stattdessen den Minuspol unterbrichst, kann es passieren, dass dein Arduino oder andere Module ungewollt über USB, Sensorleitungen oder andere Wege "irreführend" mit Strom versorgt werden. Das kann zu Fehlverhalten führen – oder im schlimmsten Fall sogar Bauteile beschädigen. Merke dir deshalb: Schalter immer in die Plusleitung – dann ist dein System sauber getrennt, sicher und zuverlässig.

Der Step-Down gibt z. B. 9 V aus – diesen Strom brauchst du gleichzeitig für:
VIN des Arduino

» +12 V-Eingang des Motortreibers (L298N)

Lösung: Nutze einen kleinen Power Distribution Block (z. B. Schraubklemme oder WAGO-Klemme):

⚠️ Wichtig: Jetzt kommt der sensibelste Teil des Projekts – die korrekte Stromverteilung. Eine falsche Polung kann zu ernsten Schäden führen, besonders bei leistungsstarken 18650-Akkus.

» OUT+, +12 V (Motortreiber) und VIN (Arduino)→ zusammengefasst und verschraubt in der Plusseite des Verteilers

OUT−, GND (Motortreiber) und GND (Arduino) → zusammengefasst und verschraubt in der Minusseite

Alle Komponenten müssen denselben GND-Bezugspunkt haben – sonst funktioniert das System nicht stabil.

Anschlussübersicht am L298N:

Der 5 V-Ausgang des Motortreibers funktioniert nur, wenn ein Jumper gesetzt ist. Wir verzichten hier bewusst auf diese Option, um Konflikte zu vermeiden.

Der Arduino erzeugt über seinen Regler eine saubere 5 V-Spannung, die du zur Versorgung deiner Sensoren nutzen kannst:

» Verbinde den 5 V-Pin des Arduino mit einem weiteren Power-Verteiler.
» Von dort aus leitest du 5 V an:
3× Ultraschallsensoren (VCC)
3× Linien- oder Abgrundsensoren (VCC)

Die GND-Leitungen der Sensoren kommen natürlich auch in den gemeinsamen GND-Verteilerblock.

◤ Der Roboter kommt in Schwung – Bewegungsmodi verstehen & umsetzen


Jetzt, wo dein Roboter vollständig verkabelt ist, wird es Zeit, ihn in Bewegung zu bringen!
 In diesem Abschnitt programmieren wir die fünf grundlegenden Bewegungen:

◤ Bewegungen in Funktionen verpacken


Damit unser Code übersichtlich, lesbar und leicht erweiterbar bleibt, verwenden wir sogenannte externe Funktionen. Falls du dieses Prinzip noch nicht kennst:
 Eine Funktion ist ein benannter Codeblock, den du beliebig oft aufrufen kannst – wie ein Mini-Programm im Programm.

Das bringt viele Vorteile:

» bessere Übersicht

» weniger Fehler

» keine doppelten Codezeilen

» leicht erweiterbar

Sketch: Linksdrehung mit externer Funktion

Was passiert hier?

Externe Funktionen – einfach gedacht


Externe Funktionen sind im Grunde nur ein Weg, deinen Code zu strukturieren.
 Sie machen deinen Code modular, aufgeräumt und wiederverwendbar. Natürlich kann man Funktionen auch Parameter übergeben (z. B. Geschwindigkeit, Richtung), wodurch sie noch viel mächtiger werden – aber das heben wir uns für spätere Kurse auf. In diesem Tutorial konzentrieren wir uns auf klare, fest definierte Bewegungen, die du beliebig kombinieren kannst.

◤ Bewegungslogik verstehen: So funktioniert die Drehung


Die Bewegungen basieren auf den Signal-Paaren an den L298N-Motortreiber. Hier im Beispiel:

Ergebnis: Der Roboter dreht sich nach links – auf der Stelle.

Unterschiedliche Dreharten bei Differential-Drive-Robotern
Die meisten zweirädrigen Roboter (wie unser Sumo-Bot) nutzen das sogenannte Differential-Drive-Prinzip. Dabei gibt es drei Arten der Drehung:

Curved Turn

Beide Räder fahren vorwärts, aber mit unterschiedlicher Geschwindigkeit.

⟶ Der Roboter fährt eine Kurve.
 Je größer der Geschwindigkeitsunterschied, desto enger der Kurvenradius.

Pivot Turn

Ein Rad bleibt stehen, das andere dreht sich.

⟶ So entsteht eine scharfe Kurve um das stehende Rad.

In-Place Turn
(unsere Variante)
Beide Räder drehen sich in entgegengesetzter Richtung.

⟶ Der Roboter rotiert auf der Stelle.
 Das ist die schnellste und direkteste Drehart – perfekt für Sumo-Kämpfe!

◤ Erste Bewegung: Dein Roboter lernt laufen


Jetzt wird’s ernst – wir bringen deinen Roboter in Bewegung.
 Du hast alles verkabelt – jetzt kalibrieren wir die Richtung der Motoren.
 Denn obwohl du die Kabel korrekt angeschlossen hast, kann es sein, dass sich die Räder falsch herum drehen. 
Kein Problem – das lösen wir im Code.

Ziel:
 Teste, in welcher Richtung sich der Roboter bei den jeweiligen Signalpaaren bewegt.

⟶ So stellst du sicher, dass Vorwärts, Rückwärts und Drehungen korrekt funktionieren.

Vorgehen Schritt für Schritt:

◾ Wenn du alle Bewegungen durchkalibriert hast, läuft dein Antriebssystem wie ein Uhrwerk.

Sketch: Kalibrierung der Motorrichtungen

Übersicht: Welche Signale bewirken welche Bewegung?

◾ Fazit

Die Motorsteuerung ist das Fundament deines gesamten Roboters.
 Wenn du sie verstanden und kalibriert hast, steht dir die Tür offen für:


⟶ Sensorlogik

⟶ Rückzugsstrategien

⟶ Gegnerverfolgung

⟶ Sumo-Strategien

◤ Bewegungen testen – Alle auf einmal!


Jetzt, wo dein Roboter vollständig verkabelt ist und du die Funktionsweise des Motortreibers verstehst, wird es Zeit für den ultimativen Test:
 Wir prüfen alle Bewegungen – in einer einzigen Sequenz.

◾ Warum das sinnvoll ist?

⟶ Schneller Überblick: Du erkennst auf einen Blick, ob alle Bewegungen wie erwartet funktionieren.

⟶ Fehlersuche leicht gemacht: Wenn z. B. der Roboter rückwärts fährt, obwohl er vorwärts fahren sollte, kannst du das sofort erkennen und gezielt korrigieren – entweder im Code oder durch Umstecken der Kabel.

◾ Was passiert im Test?
 Der Roboter führt nacheinander diese Bewegungen aus:

⟶ So erkennst du bei jedem Schritt, ob die Bewegungsrichtung und Geschwindigkeit korrekt umgesetzt werden – ohne zusätzliche Sensoren oder Logik.

◾ Tipp:
 Falls sich eine Bewegung falsch anfühlt (z. B. Rückwärts ist Vorwärts), liegt es entweder an:

⟶ der Signal-Kombination im Code
 oder

⟶ die Verkabelung der Motoren ist vertauscht
. Beides kannst du ganz einfach anpassen.

Jetzt werden alle Bewegungen automatisch nacheinander getestet – jeweils 500ms lang, inklusive 1000ms Pausen zum Beobachten.
 So erkennst du schnell, ob ein Motor falsch angeschlossen ist oder ob eine Bewegung in die falsche Richtung läuft.

Nächster Schritt: Beobachte jede Phase und korrigiere bei Bedarf die Signalrichtung – dann sitzt dein Bewegungs-Setup perfekt!

◤ Sicherheitssystem – Stay in the Game


Beim Sumo-Roboter geht es nicht nur darum, den Gegner aus dem Ring zu drängen – sondern auch darum, selbst in der Arena zu bleiben, und zwar unter allen Umständen.
 Deshalb entwickeln wir ein Sicherheitssystem, das erkennt, wann der Roboter sich der Ringgrenze nähert – und sofort reagiert, um ihn zurück in den sicheren Bereich zu bringen.

◾ Die goldene Regel lautet:
 Sicherheit hat immer Vorrang vor Angriff.
Der Liniensensor – Wie erkennt der Roboter den Arenarand?

Damit dein Roboter nicht über die weiße Begrenzung der Arena hinausfährt, braucht er „Augen“, die zwischen schwarz und weiß unterscheiden können.
 Genau dafür setzen wir Infrarot-Liniensensoren ein – klein, günstig, zuverlässig.

◾ Funktionsprinzip – Licht rein, Logik raus
. Ein Liniensensor besteht aus:
» einer IR-LED (Sender), die unsichtbares Infrarotlicht nach unten strahlt, und
» einem Fototransistor (Empfänger), der misst, wie viel Licht reflektiert wird.

⟶ Erkannte Farbe je nach Reflexion:

Das bedeutet: 
1 = sicher,
 0 = Gefahr (weiße Fläche erkannt!)

Anschluss des Sensors


Unsere Sensoren (z. B. TCRT5000 oder MH-Sensor Series) haben in der Regel vier Pins:

◾ Warum nutzen wir nur den digitalen Ausgang?

Der Sensor bietet zusätzlich einen analogen Pin (A0), der die Lichtmenge als Zahlenwert (0–1023) überträgt. Damit könnte man besonders fein auf Helligkeitsunterschiede reagieren. In unserem Fall reicht jedoch ein einfaches Ja/Nein-Signal:

» Linie erkannt → Ja oder Nein

» Das digitale Signal ist direkt nutzbar und erfordert keine eigene Auswertung oder Kalibrierung im Code.

Tipp:
 Die Empfindlichkeit lässt sich über das kleine Potentiometer (Poti) auf dem Sensor einstellen – falls dein Sensor zu früh oder zu spät reagiert.

◾ Test ohne Arduino – geht das?

Ja – und das ist besonders praktisch!
 Um die korrekte Funktionsweise des Sensors zu überprüfen, brauchst du nicht einmal einen Arduino:

Schließe einfach 5 V und GND an – z. B. über ein Netzteil oder ein Step-Down-Modul.

» Die Power-LED auf dem Sensor leuchtet sofort.

» Die zweite Status-LED zeigt dir direkt, ob gerade eine helle oder dunkle Fläche erkannt wird:

⟶ Das macht das Testen und Justieren extrem einfach – ganz ohne Programmcode.

Warum verwenden wir drei Sensoren?

Ein einzelner Sensor kann nur erkennen, was sich direkt unter ihm befindet. Das reicht für einfache Anwendungen – etwa um festzustellen, ob der Roboter über einer schwarzen oder weißen Fläche steht. Aber sobald der Roboter in Bewegung ist, wird ein einzelner Sensor schnell zum Flaschenhals, denn er liefert nur punktuelle Informationen – ohne Kontext, ohne Richtung, ohne Dynamik.

◾ Mehr Sensoren = mehr Information = bessere Entscheidungen
Mit drei strategisch platzierten Sensoren – typischerweise links, hinten und rechts – erhält der Roboter ein viel umfassenderes Bild seiner aktuellen Umgebung.

Dadurch kann er:
◾ Gefahrenzonen frühzeitig erkennen
» Der Roboter „spürt“, ob er der Kante von der Seite oder von hinten zu nahe kommt – noch bevor er darüber fährt.
» Die Entscheidung, ob er sich retten, drehen oder stoppen muss, kann vorausschauend getroffen werden.

◾ Gezielter und differenzierter reagieren
» Erkennt der Sensor rechts eine Linie → Roboter kann sofort nach links ausweichen.

» Erkennt der Sensor hinten Gefahr → Roboter kann direkt nach vorne fliehen oder einen schnellen Richtungswechsel einleiten.

» Erkennt nur einer der drei Sensoren die Linie → es reicht, einen Teil des Systems (z. B. ein Rad) gezielt anzusteuern.

◾ Angriff sofort unterbrechen, wenn Gefahr droht
Die drei Sensoren agieren dabei wie ein Sicherheitsnetz: Sobald eine Linie erkannt wird, wird der Angriff unterbrochen – ohne Verzögerung.

◾ Warum das so wichtig ist:
Je mehr Sensoren verwendet werden, desto höher wird die „Auflösung“ des Umweltbildes, das der Roboter wahrnehmen kann. Statt nur „Linie erkannt“ oder „nicht erkannt“ entstehen durch Sensor-Kombinationen detaillierte Muster:

111 → alles sicher
101 → Gefahr hinten
011 → links droht Gefahr
…etc.

Dadurch kann der Roboter nicht nur reagieren, sondern fast schon antizipieren. Er wird in der Lage sein, schneller, intelligenter und effizienter zu handeln – besonders in dynamischen Wettbewerbsumgebungen wie beim Sumo-Kampf.

⚠️ Achtung: Pin-Knappheit – und ein genialer Workaround

Beim Bau deines Sumo-Roboters brauchst du viele Pins – und die werden auf dem Arduino UNO schnell knapp.

◾ So viele Pins brauchst du wirklich:

◾ Der Haken
Der Arduino UNO hat nur 14 digitale Pins: D0–D13. Davon sind jedoch: D0 und D1 für die serielle Kommunikation reserviert. ⚠️ Nicht verwenden, wenn du den Seriellen Monitor brauchst

Bleiben realistisch: nur 12 nutzbare digitale Pins. Dir fehlt genau 1 digitaler Pin, um alle Komponenten gleichzeitig zu betreiben.

◾ So funktioniert’s im Code:

◾ Warum das so praktisch ist:
Statt auf Module zu verzichten oder externe Multiplexer einzubauen, nutzt du einfach vorhandene Pins intelligent weiter. Keine zusätzliche Hardware, kein Aufwand – nur cleveres Pinmapping.

Problem gelöst: Du hast wieder genug digitale Anschlüsse und dein Roboter kann alle Sensoren gleichzeitig betreiben.

Verdrahtung der Liniensensoren (Sicherheitssystem)


Auf dem Bild siehst du die Verbindung von drei Infrarot-Liniensensoren mit dem Arduino über ein Power Distribution Board.

◾ Anschlüsse im Überblick:

◾ Alle Sensoren korrekt mit Strom versorgt
Dank der zentralen Stromverteilung erhalten alle drei Liniensensoren zuverlässig ihre 5V-Versorgung und den gemeinsamen GND. Die digitalen Signale der Sensoren (gelbe Leitungen) gehen direkt an die Arduino-Pins 15, 16 und 17 und können dort im Code ausgewertet werden.

⬙ Im unteren Bereich der Grafik erkennst du, dass VCC (rot) und GND (schwarz) bei jedem Sensor nicht direkt mit Linien verbunden sind, sondern mit Pfeilen markiert wurden.

Das ist Absicht:
Um den Schaltplan übersichtlich zu halten, wurden die vielen Stromleitungen nicht gezeichnet, sondern durch Pfeile ersetzt. Diese Pfeile zeigen an, dass alle entsprechenden VCC- und GND-Leitungen zum gemeinsamen Stromverteilerblock führen. Stelle dir vor, dass die Pfeilspitzen direkt mit dem Stromverteiler verbunden werden müssen.

So entsteht ein übersichtliches, sicheres und modular erweiterbares Versorgungssystem – ideal für Projekte mit mehreren Sensoren, wie z. B. deinem Sumo-Roboter.

◾ Serientest der Liniensensoren – mit dem Seriellen Monitor prüfen, ob alles funktioniert

Bevor wir mit der komplexeren Sicherheitslogik starten, machen wir etwas viel Wichtigeres:
⟶ Wir testen, ob die Liniensensoren korrekt angeschlossen sind und sinnvoll reagieren.

Der einfachste Weg: der Serielle Monitor in der Arduino-IDE. So kannst du live mitlesen, was der Roboter „sieht“.

Testcode: Lesen & Ausgeben der Sensordaten

Was zeigt dir dieser Code?

Beispielausgabe im Seriellen Monitor

Aber Achtung: Manche Sensoren liefern invertierte Signale!

Es gibt Sensoren, die bei schwarzem Boden eine 0 und bei weißem eine 1 ausgeben – also genau umgekehrt!
In diesem Fall musst du das Signal im Code invertieren, damit die Logik wieder stimmt.

So geht das:

💡 Was macht das !?

Das Ausrufezeichen (!) ist ein logischer NOT-Operator.
Er kehrt true (1) in false (0) um – und umgekehrt.
Wenn also digitalRead(CLIFF_L) eine 0 liefert, wird durch ! daraus eine 1.

Das ist superpraktisch, wenn du einen invertierten Sensor verwendest, aber trotzdem dieselbe Code-Logik beibehalten willst.

So testest du die Sensoren in der Praxis

1. Öffne den Seriellen Monitor in der Arduino-IDE (Lupe oben rechts )
2. Stelle unten die Baudrate auf 9600
3. Bewege den Roboter vorsichtig über den Ring:
» Schwarzer Untergrund → Sensor zeigt 1
» Weiße Fläche → Sensor zeigt 0

Tipp: Halte ein Blatt schwarzen und weißen Karton unter den Sensor – und beobachte die Status-LED beim Übergang.

❗ Häufige Fehler und schnelle Lösungen

💡 Tipp: Halte ein Blatt schwarzer und weißer Karton unter den Sensor – und beobachte die Status-LED beim Übergang.

Sensor-Kombinationen verstehen – und gezielt reagieren

Dein Roboter nutzt drei Liniensensoren, die jeweils eine einfache Information liefern:

Was „sieht“ der Roboter?

Jeder Sensor gibt nur einen einzelnen digitalen Wert zurück – aber gemeinsam ergeben sich daraus 8 verschiedene Kombinationen (2³). Jede dieser Kombinationen steht für eine typische Situation im Ring – und ermöglicht dem Roboter eine gezielte Reaktion.

Ziel dieser Logik:

Der Roboter soll auf jede dieser Situationen intelligent reagieren:

» Gefahr frühzeitig erkennen
» Zurückweichen oder ausweichen, bevor er die Ringlinie überquert
» Und nur dann angreifen, wenn alle Sensoren „grün“ melden

Sicherheitslogik im Code

Unten findest du den vollständigen loop()-Ausschnitt mit der zentralen Entscheidungsstruktur für dein Sicherheitssystem – inklusive Debug-Ausgaben über Serial.println().

So kannst du jederzeit im Seriellen Monitor mitlesen, wie der Roboter denkt und warum er sich gerade so verhält.

Alle 8 Kombinationen auf einen Blick
Diese Tabelle hilft dir, den Code besser zu durchdenken:

◤ Sicherheitslogik im Code – Schritt für Schritt

Jetzt programmieren wir das Herzstück des Sicherheitssystems: eine Entscheidungsstruktur, die jede der 8 Kombinationen auswertet, interpretiert und eine passende Reaktion ausführt. Jede Bedingung ist durch ein if / else if abgebildet. Alle Bewegungen sind mit Serial.println()-Ausgaben versehen – so kannst du jeden Fall im Seriellen Monitor live beobachten.

⚠️ Wichtiger Hinweis zur Performance

Der gezeigte Sketch ist speziell für Testzwecke gedacht – vor allem, um im Seriellen Monitor zu verfolgen, wie dein Roboter denkt und auf die verschiedenen Sensorzustände reagiert.

Verwende diesen Sketch nicht 1:1 für den realen Sumo-Einsatz!

Warum? Die Serial.println()-Befehle verlangsamen das gesamte Programm, da die serielle Ausgabe Zeit kostet. Vor allem bei schnellen Bewegungen kann es passieren, dass der Roboter die Linie zu spät erkennt und aus dem Ring fährt, bevor er reagieren kann.

Lösung

Wenn du dein Sicherheitssystem im echten Kampf einsetzen willst:

1. Kommentiere alle Serial.println()-Zeilen aus, oder

2. Erstelle eine optimierte Variante des Sketches ohne serielle Ausgaben, oder

3. Nutze eine Debug-Variable, die du nur im Test aktivierst:

Damit kannst du bequem zwischen Test- und Wettkampfmodus umschalten.

Warum das wichtig ist

Ein Sumo-Roboter muss in Echtzeit reagieren – ohne Verzögerung.
Jede unnötige Wartezeit, sei es durch serielle Ausgabe oder überlange delay()-Befehle, kann über Sieg oder Niederlage entscheiden.

Im loop()-Teil wird dir bewusst: Hier passiert etwas Besonderes. Wir betrachten nicht jeden Sensor einzeln – sondern alle drei Liniensensoren gleichzeitig. Diese parallele Auswertung ist entscheidend. Warum? Ein einzelner Sensor liefert nur eine sehr lokale Information – z. B. „Ich sehe weiß“ oder „Ich sehe schwarz“. Doch erst durch den Vergleich aller drei Sensoren entsteht ein vollständiges Bild der Umgebungssituation.

Diese gleichzeitige Betrachtung der drei Zustände (links, hinten, rechts) bildet ein Muster – wie ein Fingerabdruck einer bestimmten Gefahrensituation im Ring.

Jedes dieser Muster – also jede Kombination aus LOW und HIGH – entspricht einer bestimmten Lage im Spielfeld. Und genau deshalb ordnen wir jeder dieser Kombinationen eine gezielte Reaktion zu: zurückfahren, drehen, stoppen oder sogar den Angriff starten (wenn alles sicher ist).

Diese Struktur nennt man auch eine Entscheidungsmatrix – und sie ist das Herzstück deines Sicherheitssystems. So entsteht ein sehr einfaches, aber wirkungsvolles Abbild der Umwelt – mit einer niedrigen Auflösung, aber trotzdem klarer Logik. Die Komplexität bleibt gering, aber die Effektivität ist hoch – ideal für schnelle Entscheidungen in einem Turnierumfeld.

Warum zuerst stoppen & zurückfahren?

Dir ist sicher aufgefallen: Der Roboter stoppt, fährt kurz zurück und dreht sich erst danach. Das wirkt vielleicht im ersten Moment ungewöhnlich – ist aber bewusst so programmiert.

Hintergrund – warum das wichtig ist:

» Arduino & Liniensensoren reagieren nicht blitzschnell
→ Zwischen Erkennung und Reaktion vergeht eine winzige, aber entscheidende Zeitspanne.

» Ein sofortiges Drehen reicht nicht aus → Ohne das Rückwärtsfahren nach Erkennung der Arena-Grenze kann es passieren, dass sich der Roboter – vor allem bei hoher Geschwindigkeit – schon vollständig außerhalb des schwarzen Bereichs befindet, während er sich weiterdreht.

» Das bedeutet: keine saubere Flucht, sondern ein orientierungsloses Manövrieren auf gefährlichem Terrain.

» Im Turnier wäre das fatal
→ Ein kleiner Fehler, und der Roboter verlässt den Ring: automatisch verloren!

Das Zurückfahren ist deine Rettung!

Mit dem kurzen Rückwärtsschub bringst du den Roboter wieder vollständig in den sicheren Bereich (schwarzer Boden) zurück –
bevor du eine neue Entscheidung triffst.

Das sorgt für:
» Stabilität
» Reaktionssicherheit
» Klar erkennbare Bewegungsphasen
» Bessere Kontrolle im Wettbewerb

Was du im Monitor sehen kannst:

Wenn du den Roboter testest und dich der Ringkante näherst, wird z. B. ausgegeben:

Wichtig:

Die Kombination 1 1 1 (alle Sensoren sehen Schwarz) bedeutet:
» Alles ist sicher. Der Roboter darf angreifen.

In allen anderen Fällen (mindestens ein Sensor sieht Weiß)
» muss der Roboter sofort in den Sicherheitsmodus wechseln.

◤ Ein schlaues Muster – und warum es dir beim Programmieren hilft

⟶ Von maximaler Sicherheit zur vollen Alarmstufe

Die Tabelle beginnt oben mit dem Zustand, bei dem alle drei Sensoren aktiv sind – also schwarzen Boden erkennen (111). Das ist die ideale Situation: Dein Roboter befindet sich vollständig auf dem sicheren Untergrund, alles ist stabil.

In jeder weiteren Zeile nimmt die Anzahl aktiver Sensoren systematisch ab:
▸ Erst melden noch zwei Sensoren Sicherheit,
▸ dann nur noch einer,
▸ und ganz unten reagiert kein einziger Sensor mehr auf

Schwarz (000) – das bedeutet: alle erkennen Weiß → maximale Gefahr.

Diese Abfolge ergibt eine absteigende Sicherheitslogik, die du direkt für deine Programmierung nutzen kannst.
Sie hilft dir, das Verhalten deines Roboters nicht chaotisch, sondern priorisiert und situationsbewusst zu steuern.

⟶ Ein kurzer Ausblick: Was ist eine FSM?

Vielleicht bist du schon einmal über den Begriff FSM – Finite State Machine gestolpert.
Das bedeutet: Ein Roboter befindet sich immer in einem definierten Zustand (zum Beispiel: „Geradeaus fahren“, „Zurücksetzen“, „Stopp“) –
und wechselt automatisch in einen anderen Zustand, sobald sich die Sensorwerte ändern.

Die acht Sensor-Kombinationen aus der Tabelle eignen sich hervorragend, um genau solch ein System aufzubauen.
Du kannst jedem dieser Zustände eine klare Reaktion zuweisen – strukturiert, nachvollziehbar und sicher.

Aber keine Sorge:
➡ FSM ist ein fortgeschrittenes Konzept, das in diesem Einführungstutorial noch nicht behandelt wird.

📚 In meinem Advanced SumoBot Kurs lernst du, wie du mithilfe einer FSM eine hochpräzise, intelligente und reaktionsschnelle Entscheidungslogik entwickelst – ideal für Wettbewerbe, komplexe Arenen und strategisch denkende Roboter.

⟶ Eine besondere Form der Symmetrie

Wenn du die Tabelle noch genauer betrachtest, fällt dir vielleicht auf: In der Mitte gibt es eine Art Spiegelung (logische Grenze) – allerdings nicht mit identischem Inhalt, sondern mit einem umgekehrten Muster.

Was oben noch „aktiv“ (schwarz) war, ist weiter unten „inaktiv“ (weiss) – und umgekehrt. Das erzeugt eine visuelle Spannung (Kippmoment):

Der Roboter verliert schrittweise seine sichere Lage – bis zur völligen Desorientierung.

Diese invertierte Spiegelung ist nicht technisch notwendig, aber sie kann dir helfen, den Übergang von Sicherheit zu Gefahr konzeptionell zu verstehen. Du entwickelst so ein besseres Gefühl dafür, wie dein Roboter auf „Verlust von Sicherheit“ reagieren sollte.

⟶ Warum das wichtig ist

Du lernst hier nicht nur, was technisch möglich ist – du entwickelst ein systemisches Verständnis dafür, wie dein Roboter denkt, reagiert und Entscheidungen trifft.

Die strukturierte Ordnung der Tabelle hilft dir dabei:
▸ Logisch zu priorisieren, welche Situationen wie gefährlich sind
▸ Gefahr rechtzeitig zu erkennen – bevor es kritisch wird
▸ Deine Programmstruktur klar und nachvollziehbar zu gestalten

Statt vieler chaotischer if-Bedingungen denkst du in Zuständen und Übergängen. Und auch wenn wir in diesem Kurs noch keine FSM umsetzen, ist diese Tabelle der perfekte Startpunkt für genau so ein System.

Fazit

Diese scheinbar einfache Tabelle ist mehr als nur eine Übersicht:
Sie ist eine Entscheidungsmatrix, eine Sicherheits-Skala – und der perfekte Einstieg, um deinen Roboter intelligent und verantwortungsvoll zu steuern.

Nutze sie bewusst, um deinen Code klar, robust und zukunftsfähig aufzubauen. Denn: Gutes Programmieren beginnt mit klarem Denken.

◤ Technische Einordnung: Warum ist Situation 5 gefährlicher als Situation 4?

Auch wenn beide Situationen auf den ersten Blick ähnlich wirken, gibt es einen entscheidenden Unterschied:
Die physikalische Realität deines Roboters macht deutlich, dass Gefahr an der Front (Situation 5) wesentlich kritischer einzuschätzen ist als Gefahr am Heck (Situation 4).

⟶ Warum die Gefahr vorne (Situation 5) kritischer ist

In Situation 5 melden die beiden vorderen Sensoren (L und R) bereits Weiße Linie – nur der hintere Sensor erkennt noch sicheren Boden (Schwarz). Der Roboter steht somit mit der Front direkt an der Ringkante.

Das ist aus mehreren Gründen besonders kritisch:

➤ Vorwärtsbewegung ist der Standardzustand

In diesem Tutorial gilt: Rückwärtsbewegungen sind nur als Fluchtreaktion vorgesehen – nicht als Bestandteil einer aktiven Strategie. Dein Roboter – wie die meisten Sumo-Bots – ist so programmiert, dass er sich standardmäßig nach vorne bewegt. Vorwärts bedeutet: Angriff, Raumgewinn, Druck auf den Gegner.

Rückwärtsfahren hingegen wird nur ausgelöst, wenn Gefahr erkannt wird.
➡ Das heißt: Situation 5 ist besonders kritisch, weil der Roboter mit der Front in die Gefahr hineinläuft. Wenn er nicht rechtzeitig reagiert, besteht die reale Gefahr, dass er sich selbst über die Ringkante hinaus katapultiert.

➤ Situation 4: Gefahr durch Gegnerdruck – nicht durch Eigenbewegung

Dass ein Roboter mit dem Heck über die Ringlinie hinausragt, ist in der Praxis äußerst selten – und fast nie selbstverschuldet. Das passiert nur in zwei Fällen:

1. Der Gegner hat dich geschoben.
   → Ein realistisches Szenario im Wettkampf.

2. Der Roboter fährt bewusst rückwärts.
   → Wird in diesem Tutorial nicht behandelt, da keine aktiven Rückwärtsstrategien implementiert sind.

➡ Rückwärtsbewegung ist in deinem System eine reine Notfallreaktion – kein planbares Manöver. Deshalb ist Situation 4 meist das Ergebnis eines äußeren Einflusses – und kein Programmierfehler oder Fehlverhalten deines Roboters.

Der Vorteil: Die Front steht noch sicher im Ring – der Roboter kann sich problemlos nach vorn retten.

➤ Vorwärtsbewegung ist dynamischer – Rückwärtsbewegung ist verzögert

Warum ist Gefahr vorne kritischer? Weil dein Roboter – wie viele Sumo-Bots – für schnelle, kraftvolle Vorwärtsbewegung ausgelegt ist. Das zeigt auch der Code: fwd() ist die Standardreaktion, wenn kein Sensor Gefahr meldet.

Rückwärtsmanöver dagegen laufen langsamer und verzögert ab – erst halt(), dann delay(), dann rev().

➡ Fazit:
Wenn die Gefahr vorne erkannt wird, ist die Reaktionszeit besonders knapp – und der Roboter kann sich bei zu spätem Eingreifen selbst aus dem Spielfeld bewegen.

➤ Mechanische Konstruktion: Schwerpunkt hinten – Kontrolle vorn

Dein Roboter hat – wie viele Sumo-Designs – einen Schwerpunkt auf der Hinterachse:

• Zwei Antriebsräder hinten, dort sitzt die Masse.

• Vorne kein Rad, sondern eine Gleitfläche oder ein Schleifpunkt.

• Die Folge: Stabilität hinten – Sensibilität vorne.

➡ Das wirkt sich direkt auf das Verhalten bei Gefahr aus:

• Wenn die Front über den Ringrand ragt (Situation 5), ist der Roboter sofort instabil.
  Ein minimaler Vorwärtsimpuls reicht aus, um die Bodenhaftung zu verlieren.

• Wenn das Heck übersteht (Situation 4), bleibt die Front in sicherem Bereich – und der Roboter bleibt steuerbar.

→ Bedeutet konkret:

• Ein Vorwärtsimpuls kann die Front leicht anheben oder destabilisieren.

• Die vordere Sensorzone ist besonders kritisch – hier entscheidet sich, ob dein Roboter im Ring bleibt.

➤ Reaktionszeit ist entscheidend

In Situation 5 steht der Roboter mit der Front an der Kante.
Er muss in Bruchteilen von Sekunden reagieren – entweder durch sofortiges Rückwärtsfahren oder eine Drehung.

Selbst kleinste Verzögerungen – etwa durch delay()-Befehle oder zu lange Entscheidungslogik – können dazu führen, dass der Roboter den Ring verlässt, bevor er reagieren kann. In Situation 4 ist die Gefahr hinter dem Roboter – vorne ist noch sicher. Das gibt dir mehr Spielraum: Eine Flucht nach vorn ist möglich, ohne sofortige Konsequenz.

➡ Fazit:
Je weiter vorne die Gefahr erkannt wird, desto schneller muss dein System reagieren – und desto anfälliger ist es für Verzögerungen im Code oder in der Mechanik.

Zusammengefasst:

Angriffssystem – „Win the Game“

Jetzt, da dein Sicherheitssystem steht, ist dein Roboter bereit, aktiv zu werden.
 Das Ziel: Den Gegner erkennen – und gezielt aus dem Ring schieben! Dazu nutzen wir Ultraschallsensoren, die Distanzen messen und dem Roboter ein einfaches, aber effektives „Bild“ seiner Umgebung liefern.

Dein Roboter besitzt sechs „Augen“ – drei Liniensensoren, die nach unten blicken, und drei Ultraschallsensoren, die den Raum vor ihm erfassen. Beide Sensorarten arbeiten grundlegend verschieden, aber ergänzen sich zu einem gemeinsamen Ziel: Orientierung und Handlungsfähigkeit. Die Liniensensoren prüfen den Boden direkt unter dem Roboter. Sie erkennen, ob er sich noch innerhalb des sicheren Bereichs befindet – also auf schwarzem Untergrund – oder ob er kurz davor ist, den Ring zu verlassen.

Sie reagieren binär: Gefahr oder Sicherheit, Weiß oder Schwarz. Die Ultraschallsensoren hingegen blicken voraus in die Welt, messen Entfernungen und ermöglichen es dem Roboter, Gegner zu orten, zu verfolgen und anzugreifen. Während die Liniensensoren vor dem Absturz schützen, ermöglichen die Ultraschallsensoren Bewegung nach vorn. Das Zusammenspiel dieser beiden Sinnesgruppen erinnert an ein fundamentales Prinzip: Erst wenn wir uns sicher fühlen – fest verwurzelt und orientiert –, können wir mutig in die Welt hinaustreten und Initiative ergreifen. Auch dein Roboter greift nur an, wenn der Boden unter ihm sicher ist.

Ultraschallsensoren verstehen – wie „sieht“ der Roboter?

Ultraschallsensoren wie der HC-SR04 sind ein echtes Technik-Wunder im Miniformat.
 Sie funktionieren nach dem Prinzip der Echoortung – ähnlich wie eine Fledermaus. Was viele nicht wissen: Der Sensor übernimmt bereits viele Aufgaben für uns.
 Du erkennst das daran, dass auf seiner kleinen Platine mehrere integrierte Schaltungen (ICs) verbaut sind.

Diese Elektronik sorgt dafür, dass der Sensor selbstständig:
» Ultraschallsignale erzeugt,
» die Zeit misst, bis das Echo zurückkommt,
» und daraus ein digitales Signal liefert, das wir mit dem Arduino direkt auswerten können.

Aufbau des HC-SR04
Wenn du den Sensor ansiehst, fallen dir sofort die zwei metallenen Zylinder mit feinem Gitter auf:

» T → Transmitter (Sender): sendet die Ultraschallwellen
» R → Receiver (Empfänger): empfängt das Echo

Zusätzlich findest du vier Pins:
» VCC → 5 V Stromversorgung
» GND → Masse
» TRIG → Triggersignal vom Arduino
» ECHO → Liefert Rückmeldung über die Zeit bis zum Echo

Wie funktioniert das Ganze?

Kommunikation in zwei Richtungen

» Wir triggern den Sensor mit einem Signal → Sensor startet Messung
» Der Sensor antwortet mit einem Echo-Zeitwert → Arduino verarbeitet das Ergebnis

Ergebnis: Ein cleverer Baustein, der dir das Leben als Roboterentwickler massiv erleichtert!

Anschluss & Positionierung

Wir verwenden drei Sensoren:

Die Stromversorgung (5 V & GND) erfolgt über dein Power Distribution Board – wie auch bei den Liniensensoren.

🧪 Serientest – Ultraschallsensoren mit dem Seriellen Monitor testen

Bevor du mit der eigentlichen Angriffserkennung oder komplexen Logik beginnst, solltest du sicherstellen, dass deine Ultraschallsensoren korrekt funktionieren. Der einfachste Weg: ein Live-Test mit dem Seriellen Monitor der Arduino-IDE.

Hier ein kompakter Testaufbau für einen einzelnen Sensor – z. B. mit TRIG → D10 und ECHO → D9:

Wenn alles richtig angeschlossen ist, zeigt dir der Serielle Monitor live, was der Sensor „sieht“. Halte einfach deine Hand oder ein Objekt davor – die Ausgabe sollte sich sofort ändern.

Was passiert eigentlich im Codeblock?

Um den Ablauf noch besser zu verstehen, werfen wir einen genaueren Blick auf diesen Abschnitt:

digitalWrite(trigPin, LOW);

delayMicroseconds(2);

digitalWrite(trigPin, HIGH);

delayMicroseconds(10);

digitalWrite(trigPin, LOW);

🔍 Schritt für Schritt erklärt:

1. digitalWrite(trigPin, LOW);
→ Setzt das Signal auf LOW, um eventuelle Reste vom letzten Impuls zu löschen.

2. delayMicroseconds(2);
→ Eine minimale Pause (2 µs), um das LOW-Signal zu stabilisieren. Diese Klarheit ist entscheidend für den Start der Messung.

3. digitalWrite(trigPin, HIGH);
→ Jetzt senden wir ein Startsignal – wir triggern den Sensor.

4. delayMicroseconds(10);
→ Das HIGH-Signal wird für 10 µs gehalten. Das ist exakt die Dauer, die der Sensor als Triggerimpuls benötigt, um aktiv zu werden.

5. digitalWrite(trigPin, LOW);
→ Danach deaktivieren wir das Signal – der Sensor beginnt nun, den Abstand zu messen.

🧠 Und warum delayMicroseconds(...)?
Weil Schall extrem schnell ist! Eine normale delay(...)-Funktion (in Millisekunden) wäre viel zu ungenau.

⏱️ Was macht pulseIn(...)?

long duration = pulseIn(echoPin, HIGH);

Diese Funktion wartet darauf, dass das Echo zurückkommt – und misst die Zeit, wie lange der ECHO-Pin auf HIGH steht. Genau das ist die Zeit, die der Schall vom Sensor zum Objekt und zurück gebraucht hat.

💡 Vorteil: pulseIn() nimmt dir die komplette Zeitmessung ab – du bekommst direkt den Wert, den du brauchst.

📏 Entfernung berechnen

int distance = duration * 0.034 / 2;

* duration = Zeit in Mikrosekunden

* 0.034 = Schallgeschwindigkeit in cm/µs (entspricht 340 m/s)

* /2 = da der Schall den Weg hin und zurück zurücklegt

➡️ Die Formel ist simpel, aber wirkungsvoll – und gibt dir die Distanz in Zentimetern zurück.

🔢 Warum long statt int?

Vielleicht ist dir aufgefallen, dass wir für duration den Datentyp long verwendet haben:

long duration = pulseIn(...);

Das hat einen guten Grund:

* int kann nur Werte bis etwa 32.767 speichern (bzw. 65.535 bei unsigned int)

* long hingegen reicht bis über 2 Milliarden – also auch bei sehr großen Distanzen oder Messwerten keine Gefahr eines Überlaufs

➡️ Du brauchst long, wenn du zuverlässig mit größeren Messwerten arbeiten willst – und bei Ultraschall ist das oft der Fall.

🎯 Einfache Distanzlogik – < 15 cm = Gegner erkannt

Jetzt, wo du weißt, dass dein Sensor korrekt funktioniert, können wir eine einfache Kampf-Logik aufbauen:

Wenn der Sensor einen Abstand von unter 15 cm misst → Gegner erkannt!

Diese einfache Regel reicht für den Einstieg völlig aus. Später kannst du natürlich Schwellenwerte anpassen oder differenzierter vorgehen.

🧠 Integration ins Hauptsystem – nur bei „grünem Licht“

Doch Vorsicht: Das Angriffssystem darf nur dann aktiv werden, wenn das Sicherheitssystem grünes Licht gibt – also wenn kein Liniensensor eine Gefahr erkennt.

Beispiel:

if (arenaSensorLeft == LOW && arenaSensorBack == LOW && arenaSensorRight == LOW) {

// Angriff freigegeben

if (distanceLeft < 15) {

rotateLeft();

}

else if (distanceRight < 15) {

rotateRight();

}

else if (distanceFront < 15) {

driveForward();

}

else {

rotateLeft(); // Suchmodus – Gegner noch nicht gefunden

}

}

Diese Struktur ist modular – du kannst sie später um weitere Sensorwerte, Strategien oder Gewichtungen erweitern.

✅ Fazit

Mit dem Ultraschallsensor steht dir ein mächtiges Werkzeug zur Verfügung, um Gegner zu erkennen – präzise, schnell und zuverlässig.

In Kombination mit deinem Sicherheitssystem kannst du intelligent reagieren und angreifen – genau wie ein echter Sumo-Champion 🤖💥

Und das Beste?
Du bist jetzt nicht mehr weit vom fertigen Kampfroboter entfernt.
Bleib im Sprint bis Ende September – und wir bringen dieses Biest gemeinsam zum Sieg! 🚀

Drei Ultraschallsensoren gleichzeitig – der Rundumblick deines Roboters

Damit dein Roboter nicht nur blind geradeaus stürmt, sondern Gegner gezielt ortet und einkreist, statten wir ihn mit drei Ultraschallsensoren aus.
 Durch den Einsatz von drei Sensoren erreichst du ein deutlich größeres Sichtfeld und eine höhere Auflösung beim Erkennen von Gegnern in der Arena – das macht den Unterschied zwischen planlosem Zufallsangriff und gezielter Strategie.

🤝 Wie arbeiten die Sensoren zusammen?

Die Sensoren sind strategisch so verteilt, dass sie aufeinander abgestimmt funktionieren:

* Erkennt der rechte oder linke Sensor einen Gegner, dreht sich der Roboter in dessen Richtung.

* Sobald der mittlere Sensor den Gegner dann ebenfalls erfasst, prescht der Roboter nach vorne.

🔁 Das bedeutet:
Die seitlichen Sensoren arbeiten dem mittleren Sensor „zu“ – sie dienen als Suchorgane, um den Gegner ins Zentrum zu bringen.
Erst wenn dieser zentriert erfasst wird, beginnt der Angriff.

📐 Pin-Zuweisung – so haben wir’s aufgebaut:

💡 Diese Pins A0–A5 verwendest du wie normale digitale Pins, indem du einfach die Werte 14–19 nutzt.

💻 Code: Drei Sensoren gleichzeitig messen

Hier ein funktionierender Testcode mit allen drei Sensoren:

📊 Was zeigt dir der Monitor?

Beobachte beim Testen:

* Was passiert, wenn du ein Hindernis vor einen der Sensoren hältst?

* Wie schnell reagieren die Werte?

* Gibt es Unterschiede bei der Erkennungsweite?

🔧 Du kannst später individuell für jeden Sensor einen anderen Schwellwert definieren (z. B. links = 20 cm, vorne = 15 cm, rechts = 25 cm).

✅ Fazit

Mit dieser Erweiterung hast du dem Roboter echte „Augen“ in alle Richtungen gegeben.
Die Sensoren arbeiten nicht einzeln – sie bilden ein Team: Die Seiten „führen“, das Zentrum „entscheidet“.
→ Die Grundlage für dynamische Angriffssysteme und clevere Strategien ist gelegt.

🧩 Eleganter Code – Ultraschallsensor-Abfrage als eigene Funktion

Du hast vielleicht bemerkt, dass wir die Messlogik der Ultraschallsensoren nicht direkt im loop() platziert haben, sondern in eine eigene Hilfsfunktion ausgelagert haben:

🧠 Warum machen wir das?

1. Mehr Übersichtlichkeit:
Der loop()-Teil bleibt schlank, verständlich und klar strukturiert. Das erleichtert das Debuggen und Weiterentwickeln enorm.

2. Weniger Code-Wiederholungen:
Alle drei Ultraschallsensoren nutzen exakt dieselbe Messlogik – also warum dreimal das Gleiche schreiben?

3. Mehr Effizienz:
Die Funktion wird intern nur einmal geladen, aber mehrfach ausgeführt – dadurch läuft der Code deutlich flüssiger und schneller.

✅ Beispiel im loop():

So sparst du nicht nur Zeit beim Programmieren, sondern auch Ressourcen auf dem Mikrocontroller – ein echtes Win-win!

Wenn du möchtest, bauen wir als nächstes ein kleines Timing-System, das dem Roboter z. B. sagt:
„Wenn du 3 Sekunden keinen Gegner findest, ändere deine Strategie.“

Oder sollen wir jetzt mit der Fusion von Angriff + Sicherheit weitermachen?
Dein Sprint, dein Takt – ich bin an deiner Seite bis zum Ziel im September 💪🚀

Bereit für den nächsten Schritt?
Dann bauen wir jetzt die Angriffslogik, die alle drei Sensoren einbindet – und deinem Roboter das taktische Denken beibringt.
(Und nicht vergessen: Bis Ende September soll alles stehen – Sprintmodus ON! 🚀)

🛠️ Angriffssystem ohne Arena-Sensorik – Modul für sich allein

Ziel:
Der Roboter soll sich auf Gegner konzentrieren und dynamisch auf Ultraschallsensor-Signale reagieren – ohne Rücksicht auf den Arenarand. Ideal für Tests auf freier Fläche!

🧠 Sensorlogik – Zusammenarbeit der drei Ultraschallsensoren:

* Seitensensoren (links & rechts): Suchen aktiv nach Gegnern.

* Sobald einer etwas entdeckt: Roboter dreht sich in dessen Richtung.

* Erst wenn der mittlere Sensor aktiv wird: Roboter fährt geradeaus und greift frontal an. ➡️ Die Seitensensoren „arbeiten dem Frontsensor zu“ – sie helfen, den Gegner ins Zentrum zu bekommen.

📦 Beispielcode (ohne Arena-Erkennung)

✅ Was kannst du mit diesem Modul testen?

* Funktioniert die Kommunikation aller drei Sensoren?

* Dreht sich der Roboter in die Richtung, aus der der Gegner kommt?

* Geht er in den Angriff, wenn der mittlere Sensor anspricht?

*

Sobald das stabil läuft, kannst du das Sicherheitsmodul modular hinzuschalten – z. B. per if (arenaSafe)-Abfrage.
Das erlaubt dir maximale Kontrolle und gezieltes Debugging.

Ready for the next phase? Alles klar – jetzt kommt der große Moment: Fusion starten!
Wir kombinieren das Sicherheitssystem (Liniensensoren) mit dem Angriffssystem (Ultraschallsensoren), um einen reaktiven, kampfbereiten Roboter zu erschaffen. 🎯

Fusion – Sicherheit trifft Angriff

Bisher hast du die beiden Systeme separat getestet:

* Das Sicherheitssystem sorgt dafür, dass dein Roboter in der Arena bleibt.

* Das Angriffssystem erkennt den Gegner und steuert gezielt auf ihn zu.

Jetzt vereinen wir beide – aber mit einer ganz wichtigen Regel:

Angriff nur bei voller Sicherheit.

Dazu führen wir eine neue Kontrollvariable ein:

🧠 Neue Variable: bool arenaSafe

bool arenaSafe = false;

🔍 Was ist bool?

* bool steht für Boolean, also ein Wahrheitswert.

* Er kann nur zwei Zustände haben:

* true → wahr

* false → falsch

Das eignet sich perfekt für unsere Anwendung:

* arenaSafe = true → Kein Sensor erkennt Weiß = Roboter darf angreifen

* arenaSafe = false → Mindestens ein Sensor erkennt die Begrenzung = Roboter muss aufpassen

🛠️ Beispielstruktur im Code:

✅ Vorteile dieser Fusion:

* Klarer Code durch Trennung von Sicherheit und Angriff

* Weniger Konflikte: Sicherheitsroutinen blockieren nicht versehentlich Angriffsmanöver

* Modular: Du kannst später Angriff oder Sicherheit einzeln optimieren, ohne das andere System zu zerschießen

* Effizient & schnell: Durch die gemeinsame readUltrasonic(...)-Funktion sparst du Zeilen und behältst Kontrolle

aktueller code:

Alles klar – jetzt kommt der große Moment: Fusion starten!
Wir kombinieren das Sicherheitssystem (Liniensensoren) mit dem Angriffssystem (Ultraschallsensoren), um einen reaktiven, kampfbereiten Roboter zu erschaffen. 🎯

🤝 Fusion – Sicherheit trifft Angriff

Bisher hast du die beiden Systeme separat getestet:

* Das Sicherheitssystem sorgt dafür, dass dein Roboter in der Arena bleibt.

* Das Angriffssystem erkennt den Gegner und steuert gezielt auf ihn zu.

Jetzt vereinen wir beide – aber mit einer ganz wichtigen Regel:

Angriff nur bei voller Sicherheit.

Dazu führen wir eine neue Kontrollvariable ein:

🧠 Neue Variable: bool arenaSafe

bool arenaSafe = false;

🔍 Was ist bool?

* bool steht für Boolean, also ein Wahrheitswert.

* Er kann nur zwei Zustände haben:

* true → wahr

* false → falsch

Das eignet sich perfekt für unsere Anwendung:

* arenaSafe = true → Kein Sensor erkennt Weiß = Roboter darf angreifen

* arenaSafe = false → Mindestens ein Sensor erkennt die Begrenzung = Roboter muss aufpassen

🛠️ Beispielstruktur im Code:

✅ Vorteile dieser Fusion:

* Klarer Code durch Trennung von Sicherheit und Angriff

* Weniger Konflikte: Sicherheitsroutinen blockieren nicht versehentlich Angriffsmanöver

* Modular: Du kannst später Angriff oder Sicherheit einzeln optimieren, ohne das andere System zu zerschießen

* Effizient & schnell: Durch die gemeinsame readUltrasonic(...)-Funktion sparst du Zeilen und behältst Kontrolle

Bereit für die nächste Etappe?
Dann bauen wir jetzt gemeinsam die finale Struktur auf: mit
🔹 runSafetySystem()
🔹 runAttackSystem()
🔹 und readUltrasonic(...) als universelle Messfunktion

Du bist kurz davor, ein richtig taktisches Robotersystem zu besitzen. Und:
Du hast’s fast geschafft! 💪🔥 (Sprint bis September – volle Energie!)