1.00 on god frfr

Reviewed-on: #1

README.md

@@ -1,3 +1,70 @@
 # ROB
 
-Für RoboCup 2025
+Für RoboCup 2025
+
+// ---- Ereignisse zuerst prüfen ----
+```
+    wenn links == grün UND rechts == grün:
+        // Sackgasse → 180°
+        drehe 180°
+
+    wenn links == grün ODER rechts == grün:
+        // Kreuzung → 90° Turn
+        wenn links == grün:
+            drehe 90° nach links
+        sonst:
+            drehe 90° nach rechts
+
+    // ---- Fahrbahn: Linie folgen ----
+
+    wenn links == schwarz UND rechts == weiß:
+        // Linie ist links → nach links korrigieren
+        drehe nach links
+
+    wenn rechts == schwarz UND links == weiß:
+        // Linie ist rechts → nach rechts korrigieren
+        drehe nach rechts
+
+    // ---- Geradeaus ---- 
+    wir haben im Moment wenn beide weiß und die Sensoren weiter auseinander vlt funktioniert das so smoother?
+    wenn links == schwarz UND rechts == schwarz:
+        beide Motoren gleich schnell
+
+    // ---- Weiß auf beiden Seiten = Linie verloren ----
+    wenn links == weiß UND rechts == weiß:
+        langsam drehen bis schwarz gefunden
+
+    // ---- Terrain ----
+    // 5 weil ich nicht mehr den Wert wusste
+    wenn winkel > +5:
+        Motorleistung += 20%
+        
+	 // Bergab
+    wenn winkel < -5:
+        Motorleistung -= 20%
+```
+
+### Wippe Notizen
+    Logik implementiert in Rampen Logik. Bleibe stehen, wenn der Rollwinkel sich um mehr als 10 (?) ändert.
+    RS-Flipflop-Logik:
+        Set (= tue nichts), wenn der Winkel sich ändert;
+        Reset (= bleibe stehen), solange sich der Rollwinkel ändert, danach fahre normal weiter
+    
+def flipflop(state, r, s):
+    return False if r else (True if s else state)
+
+### Obstacle Notizen
+- Sensor ~12cm über dem Boden einbauen; insg. 3 Abstandssensoren benötigt (oder 2 mit aufwändigerer Logik und drehendem Sensor)
+ 1. Wenn vorderer Sensor bestimmten Abstand feststellt, stoppen, zurückfahren bis ein Abstand d feststeht
+ 2. Drehen, bis ein Seitensensor Abstand d oder kleiner feststellt. Kleinsten Abstand bestimmen:
+    1. Bei Drehung niedrigsten Wert des Sensors merken
+    2. Wenn Abstand größer wird, zurückdrehen, bis kleinster Wert wieder erreicht ist
+3. Losfahren und in entsprechende Richtung drehen, wenn Abstand kleiner/größer wird
+4. Abbrechen, wenn Farbsensoren Schwarz erkennen
+
+### Bumper Notizen
+Änderungen von Gier- und Neigungswinkeln, sowie das Verhalten des Roboters zu beobachten
+Vermutlich Protokoll einbauen, was passiert, wenn für eine bestimmte Zeit die Linie nicht mehr zu finden ist.
+
+### Ziellinie Notizen
+Wenn beide Sensoren Farbe rot feststellen, stoppe die Motoren, beende das Programm

src/main.llsp3

@@ -0,0 +1,176 @@
+from hub import port, motion_sensor as ms
+import motor_pair as mp
+import distance_sensor as ds
+import color_sensor as cs
+import sys
+import runloop
+import time
+
+BLACK = 0
+GREEN = 6
+WHITE = 10
+RED = 9
+
+async def turn_right(angle=85):
+    mp.move_tank(mp.PAIR_1, 200, -200)
+    await runloop.sleep_ms(int(angle * 7))# 6 ms per degree → tune this!
+    mp.stop(mp.PAIR_1)
+
+async def turn_left(angle=85):
+    mp.move_tank(mp.PAIR_1, -200, 200)
+    await runloop.sleep_ms(int(angle * 7))
+    mp.stop(mp.PAIR_1)
+
+# drive forward X centimeters
+async def drive_cm(cm, speed=200):
+    # convert cm → ms (you must tune this constant!)
+    mp.move_tank(mp.PAIR_1, -speed, -speed)
+    await runloop.sleep_ms(cm * 70)
+    mp.stop(mp.PAIR_1)
+
+async def avoid_obstacle(speed=100):
+    mp.stop(mp.PAIR_1)
+    await runloop.sleep_ms(500)
+    mp.move_tank(mp.PAIR_1, -speed, -speed)
+
+    await turn_right(85)
+    await drive_cm(15)
+    await turn_left(85)
+    await drive_cm(38)
+    await turn_left(85)
+    while cs.reflection(port.C) > 25:
+        mp.move_tank(mp.PAIR_1, -speed, -speed)
+    while cs.color(port.B) != BLACK:
+        mp.move_tank(mp.PAIR_1, 10, -110)
+
+async def move_on_color():
+    won = False
+    speed = 100
+    saw_green_left = False
+    saw_green_right = False
+    last_seen_black = ""
+
+    old = time.ticks_ms()
+    while not won:
+        
+
+        # Farbcodes lesen
+        left_color = cs.color(port.B)
+        right_color = cs.color(port.F)
+        front_sens = cs.reflection(port.C)
+
+        gradient = ms.tilt_angles()[2]
+        # Farbcodes
+        BLACK = 0
+        GREEN = 6
+        WHITE = 10
+        RED = 9
+
+        # Distanzsensor
+        ds_front = ds.distance(port.D)
+
+        if gradient < -120:
+            speed = -120
+        elif gradient > 50:
+            speed = -50
+        else:
+            speed = -100
+
+        # --- LOGIK NUR MIT FARBEN ---
+        if left_color == RED or right_color == RED:
+            won = True
+
+
+        elif ds_front < 75 and ds_front > -1:
+            await avoid_obstacle()
+
+        # Linker Sensor sieht Grün → Linksabbiegen
+        elif left_color == GREEN and right_color != GREEN:
+            saw_green_left = True
+            old = time.ticks_ms()
+
+
+        elif right_color == GREEN and left_color != GREEN:
+            saw_green_right = True
+            old = time.ticks_ms()
+
+        # Beide Sensoren sehen Grün (z.B. Kreuzung / Markierung)
+        elif left_color == GREEN and right_color == GREEN:
+            saw_green_right = False
+            saw_green_left = False
+            mp.move_tank(mp.PAIR_1, -speed, speed)
+            time.sleep_ms(2300)
+
+        elif saw_green_left and left_color == BLACK:
+            saw_green_left = False
+            mp.move_tank(mp.PAIR_1, speed, speed)
+            time.sleep_ms(1200)
+            mp.move_tank(mp.PAIR_1, speed, -speed)
+            time.sleep_ms(1000)
+            mp.move_tank(mp.PAIR_1, speed, speed)
+            time.sleep_ms(300)
+
+        # Rechter Sensor sieht Grün → Rechtsabbiegen
+        elif saw_green_right and right_color == BLACK:
+            saw_green_right = False
+            mp.move_tank(mp.PAIR_1, speed, speed)
+            time.sleep_ms(1200)
+            mp.move_tank(mp.PAIR_1, -speed, speed)
+            time.sleep_ms(1000)
+            mp.move_tank(mp.PAIR_1, speed, speed)
+            time.sleep_ms(300)
+
+        # Schwarz-Logik
+        elif front_sens > 25 and last_seen_black == "left":
+            while cs.reflection(port.C) > 25: # front_sensor
+                if cs.color(port.B) == BLACK and cs.color(port.F) == WHITE: # left_color
+                    last_seen_black = "left"
+                    
+                if cs.color(port.F) == BLACK and cs.color(port.B) == WHITE: # right_color
+                    last_seen_black = "right"
+                    break
+                old = time.ticks_ms()
+                mp.move_tank(mp.PAIR_1, -125, -20)
+
+
+        elif front_sens > 25 and last_seen_black == "right":
+            while cs.reflection(port.C) > 25:
+                if cs.color(port.F) == BLACK and cs.color(port.B) == WHITE:
+                    last_seen_black = "right"
+
+                if cs.color(port.B) == BLACK and cs.color(port.F) == WHITE:
+                    last_seen_black = "left"
+                    break
+                old = time.ticks_ms()
+                mp.move_tank(mp.PAIR_1, -20, -125)
+
+        elif right_color == BLACK or left_color == BLACK:
+            old = time.ticks_ms()
+            if right_color == BLACK and left_color == BLACK:
+                mp.move_tank(mp.PAIR_1, speed, speed)
+                time.sleep_ms(20)
+                
+
+            # Linker Sensor ist Schwarz, rechter Weiß → sanft nach links
+            elif left_color == BLACK and right_color == WHITE:
+                last_seen_black = "left"
+
+            # Rechter Schwarz, linker Weiß → sanft nach rechts
+            elif right_color == BLACK and left_color == WHITE:
+                last_seen_black = "right"
+
+        # Beide Weiß, Front Schwarz → geradeaus
+        elif cs.color(port.B) == WHITE and cs.color(port.F) == WHITE and front_sens < 25:
+            if time.ticks_diff(time.ticks_ms(), old) > 1000:
+                last_seen_black = ""
+                old = time.ticks_ms()
+            mp.move_tank(mp.PAIR_1, speed, speed)
+            runloop.sleep_ms(50)
+
+async def main():
+    mp.pair(mp.PAIR_1, port.A, port.E)
+    await move_on_color()
+
+    sys.exit()
+
+runloop.run(main())