pushed existing code base and cleanup

MoveOnColorLine.llsp3

@@ -0,0 +1,73 @@
+from hub import button, port, motion_sensor as ms
+import motor
+import motor_pair as mp
+import color_sensor as cs
+import color
+import sys
+import runloop
+import time
+
+# await mp.move_for_degrees(mp.PAIR_1, 360, 45, velocity=280)
+
+# motor.run_for_degrees(portNum, 200, 300)
+# await runloop.sleep_ms(2000)
+
+# mp.move_tank(mp.PAIR_1, 280, -280)
+# await runloop.sleep_ms(2000)
+
+# WANTED_COLOR = color.BLACK
+
+async def move_on_color():
+    start_time = time.time()
+    print(ms.tilt_angles())
+    while True:
+        roll_value = ms.tilt_angles()[2]
+        if cs.reflection(port.C) < 60:
+            mp.move_tank(mp.PAIR_1, -100, 100)
+        elif cs.reflection(port.E) < 60:
+            mp.move_tank(mp.PAIR_1, 100, -100)
+        elif roll_value < -150: # uphill function
+            mp.move(mp.PAIR_1, 0, velocity=450)
+        else:
+            mp.move(mp.PAIR_1, 0, velocity=200)
+
+    # Geradeaus
+
+    # linkskurve
+    # rechtskurve 
+
+    # Kreuzung (grüner Punkt)
+    # wenn grün, dann biege um 90 Grad in die richtung ab (wenn vor schwarzer linie)
+
+
+    # Sackgasse (= zwei grüne Punkte)
+    # -> Drehung 180 Grad
+
+    # Bergauf
+    # Bergab
+
+    # Speedbumper (Schräge Bumper)
+
+
+# Wippe Notizen
+def flipflop(state, r, s):
+    """
+    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
+    """
+    return False if r else (True if s else state)
+
+# Obstacle Notizen
+
+# Ziellinie Notizen
+# Wenn beide Sensoren rot, stoppe die Motoren
+
+async def main():
+    mp.pair(mp.PAIR_1, port.A, port.D)
+    await move_on_color()
+
+    sys.exit()
+
+runloop.run(main())

README.md

@@ -1,70 +1,3 @@
 # ROB
 
-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
+Für RoboCup 2025

src/main.llsp3

@@ -1,169 +0,0 @@
-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
-
-# Implementation of Basic operations and misc. ##############################################
-
-# await mp.move_for_degrees(mp.PAIR_1, 360, 45, velocity=280)
-
-# motor.run_for_degrees(portNum, 200, 300)
-# await runloop.sleep_ms(2000)
-
-# mp.move_tank(mp.PAIR_1, 280, -280)
-# await runloop.sleep_ms(2000)
-
-# WANTED_COLOR = color.BLACK
-
-# Productive Code ###########################################################################
-
-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(30)
-    await turn_left(85)
-    await drive_cm(15)
-    await turn_right(85)
-old = 0
-async def move_on_color():
-    won = False
-    old = time.ticks_ms()
-    speed = 100
-    saw_green_left = False
-    saw_green_right = False
-
-    while not won:
-
-        # Farbcodes lesen
-        left_color = cs.color(port.B)
-        right_color = cs.color(port.F)
-
-        gradient = ms.tilt_angles()[2]
-        # Farbcodes
-        BLACK = 0
-        GREEN = 6
-        WHITE = 10
-        RED = 9
-        straight = False
-        turn_way_if_lost_right = True
-
-        # Distanzsensor
-        ds_front = ds.distance(port.D)
-
-        if gradient < -120:
-            speed = -80
-        elif gradient > 50:
-            speed = -50
-        else:
-            speed = -100
-
-        # --- LOGIK NUR MIT FARBEN ---
-                # Finish line logik
-        if left_color == RED or right_color == RED:
-            won = True
-            break
-
-        elif ds_front < 75 and ds_front > -1:
-            #await avoid_obstacle()
-            pass
-
-        # Linker Sensor sieht Grün → Linksabbiegen
-        elif left_color == GREEN and right_color != GREEN:
-            saw_green_left = True
-
-        elif right_color == GREEN and left_color != GREEN:
-            saw_green_right = True
-
-        # 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(1050)
-            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(1050)
-            mp.move_tank(mp.PAIR_1, speed, speed)
-            time.sleep_ms(300)
-
-        elif right_color == BLACK or left_color == BLACK:
-            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:
-                mp.move_tank(mp.PAIR_1, speed, -(int (speed / 4)))
-
-
-        # Rechter Schwarz, linker Weiß → sanft nach rechts
-            elif right_color == BLACK and left_color == WHITE:
-                mp.move_tank(mp.PAIR_1,  -(int (speed / 4)), speed)
-
-        # Beide Weiß → geradeaus (vermutlich neben der Linie)
-        elif left_color == WHITE and right_color == WHITE:
-            straight = True
-            mp.move_tank(mp.PAIR_1, speed, speed)
-            runloop.sleep_ms(50)
-
-        if straight:
-            if time.ticks_diff(time.ticks_ms(), old) > 2750:
-                old = time.ticks_ms()
-                if turn_way_if_lost_right:
-                    mp.move_tank(mp.PAIR_1, speed, 0)
-                    await runloop.sleep_ms(200)
-                    turn_way_if_lost_right = not turn_way_if_lost_right
-                else:
-                    mp.move_tank(mp.PAIR_1, 0, speed)
-                    await runloop.sleep_ms(200)
-                    turn_way_if_lost_right = not turn_way_if_lost_right
-
-        else:
-            old = time.ticks_ms()
-
-async def main():
-    mp.pair(mp.PAIR_1, port.A, port.E)
-    await move_on_color()
-    sys.exit()
-
-runloop.run(main())