Merge pull request 'Update README.md' (#54) from dev into main

Reviewed-on: #54

LINEUPS.md

@@ -2,14 +2,14 @@
 
 ## These are the line-up positions for the robot game for various missions.
 
-- Mission Run #1 (Mission #1) [Right/Blue Home] - The left yellow part of the right arm attachment is positioned with its right edge on the 5th thin line from the left. Note that this is NOT positioned from the back of the robot.
+- Mission Run #1 (Run #1) [Right/Blue Home] - The left yellow part of the right arm attachment is positioned with its right edge on the 5th thin line from the left. Note that this is NOT positioned from the back of the robot. Also, when counting these lines, make sure you count from the inside curve, not the outside.
 
-- Mission Run #2 (Send Over) [Right/Blue Home] - The robot should be lined up on the vertical edge of the left home. The robot's right side should be positioned on the 1st thin line from the top. Note that the 0th line is the one that is not part of the curve.
+<img src="https://codes.fll-65266.org/FLL_65266_LEGO_DYNAMICS/solutions_season_unearthed/raw/branch/do-not-merge/r1l.png" alt="Alt text" width="300"/>
 
-- Mission Run #3 (Sand mission) [Right/Blue Home] - The robot should be lined up on the vertical edge of the left home. The robot's left side should be positioned on the 1/2th thin line from the bottom.
+- Mission Run #2 (Tip the scales) [Right/Blue Home] - The middle of the left edge of the robot should be positioned on the 2nd thick line from the left.
 
-- Mission Run #4 (Boat mission) [Left/Red Home] - The robot should be lined up on the vertical edge of the left home. The robot's right side should be positioned on the 2nd thick line from the bottom.
+- Mission Run #3 (Send Over) [Right/Blue Home] - The robot should be lined up on the vertical edge of the right home. The robot's right edge should be positioned on the 1st thin line from the top. Note that the 0th line is the one that is in the inner curve.
 
-- Mission Run #5 (Bautism) [Left/Red Home] - The robot's left edge should be positioned at the 1st thick, 2nd thin line from the left.
+- Mission Run #4 (Run #4) [Left/Red Home] - The robot's left edge should be positioned on the 2nd thick line from the left.
 
-- Mission Run #6 (Not-so-heavy Lifting) [Right/Blue Home] - The robot's right edge should be positioned at the 1st thick from the right.
+- Mission Run #5 (Boat mission) [Left/Red Home] - There are two alignments for this. When sending off the robot for part 1, the robot should be facing the right home. It's right edge should be positioned at the very bottom edge of the board. Once it completes the pulling part, once it comes back begin part 2. For part 2, the middle of the robot's right side should be positioned in the middle of the 3rd thick and the 3rd thick, 1st thin lines from the top. For both runs the robot should be facing the blue home.

README.md

@@ -63,17 +63,14 @@ Repository
 
 ### Installation & Deployment - from the server - everyday
 
-1. Download the file codes_for_scrimmage/hazmat/mainhazmatUPD.py
+1. Download the file competition_codes/sectionals/sectional_main_dec_6.py 
  - You can do this through the repo, by using cURL, or by using git.
- - Repo - Go to [codes_for_scrimmage/hazmat/mainhazmatUPD.py](codes_for_scrimmage/hazmat/mainhazmatUPD.py) and click the "Download" button.
- - cURL or another HTTP data transferrer - 
-
- ```curl -o mainhazmatUPD.py https://codes.fll-65266.org/FLL_65266_LEGO_DYNAMICS/solutions_season_unearthed/raw/branch/main/codes_for_scrimmage/hazmat/mainhazmatUPD.py```
+ - Repo - Go to the [latest release](https://codes.fll-65266.org/FLL_65266_LEGO_DYNAMICS/solutions_season_unearthed/releases) and click the "Download as ZIP" button to get the full repository.
+ - Single file - Go to the latest release and click the file link to get the raw master file.
  - git CLI - 
+ ```git clone https://codes.fll-65266.org/FLL_65266_LEGO_DYNAMICS/solutions_season_unearthed.git```
  
- ```git clone -b dev https://codes.fll-65266.org/FLL_65266_LEGO_DYNAMICS/solutions_season_unearthed.git && cd solutions_season_unearthed/codes_for_scrimmage/hazmat```
- 
-   Then use mainhazmatUPD.py.
+   Then use the master file.
 
 2. Open https://code.pybricks.com/ and select the "Import a file" button on the top of the left bar. Import the .py file. Pair your robot via Bluetooth in Pybricks by selecting the Bluetooth button.
 

RegionalFinal.py

@@ -0,0 +1,220 @@
+from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
+from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
+from pybricks.tools import run_task, multitask
+from pybricks.tools import wait, StopWatch
+from pybricks.robotics import DriveBase
+from pybricks.hubs import PrimeHub
+
+# Initialize hub and devices
+hub = PrimeHub()
+left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
+right_motor = Motor(Port.B)
+left_arm = Motor(Port.C)
+right_arm = Motor(Port.D)
+lazer_ranger = UltrasonicSensor(Port.E)
+color_sensor = ColorSensor(Port.F)
+
+# DriveBase configuration
+WHEEL_DIAMETER = 68.8  # mm (adjust for your wheels)
+AXLE_TRACK = 180  # mm (distance between wheels)
+drive_base = DriveBase(left_motor, right_motor, WHEEL_DIAMETER, AXLE_TRACK)
+drive_base.settings(600, 500, 300, 200)
+drive_base.use_gyro(True)
+
+WALL_DISTANCE = 300  # mm
+
+async def drive_forward():
+    """Drive forward continuously using DriveBase."""
+    drive_base.drive(400, 0)
+
+
+async def monitor_distance():
+    """Monitor ultrasonic sensor and stop when wall is detected."""
+    while True:
+        distance = await lazer_ranger.distance()
+        print('Distancing...',distance)
+        
+        if distance < WALL_DISTANCE:
+            # Stop the drivebase
+            await drive_base.stop
+            print(f"Wall detected at {distance}mm!")
+            break
+        
+        # Small delay to prevent overwhelming the sensor
+        await wait(50)
+
+# New Section
+async def Run1():  # From M8_5.py
+    right_arm.run_angle(1000,450)
+    left_arm.run_angle(500,90)
+    await drive_base.straight(200)
+
+    await drive_base.turn(-40)
+    await drive_base.straight(325)
+    await left_arm.run_angle(500,-90)
+
+    await drive_base.straight(-100)
+    await drive_base.straight(50)
+    await left_arm.run_angle(500,180)
+
+    await drive_base.straight(-90)
+    left_arm.run_angle(500,-180)
+    await drive_base.turn(-20)
+    await drive_base.turn(15)
+
+    await drive_base.straight(-173)
+    await drive_base.turn(45)
+    await drive_base.straight(120)
+    left_arm.run_angle(1000,670)
+
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    await right_arm.run_angle(5000,450, Stop.HOLD)
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    await right_arm.run_angle(5000,450, Stop.HOLD)
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    right_arm.run_angle(5000,450, Stop.HOLD)
+
+    await drive_base.turn(-35)
+    await drive_base.straight(297)
+    await drive_base.turn(63)
+    await drive_base.straight(170)
+
+    await drive_base.turn(-80)
+    await drive_base.straight(87)
+    await drive_base.turn(-15)
+
+    await drive_base.straight(-90)
+    await drive_base.turn(-100)
+    await drive_base.arc(-500,None,600)
+
+    
+async def Run2():  # From Heavy_lifting_final.py
+    await drive_base.straight(200)
+    await drive_base.turn(-20)
+    await drive_base.straight(536)
+    await drive_base.turn(60, Stop.HOLD)
+    await drive_base.straight(30)
+    await right_arm.run_angle(5000, 2900)
+    await drive_base.straight(40)
+    await right_arm.run_angle(5000, -4000)
+    await drive_base.straight(-60)
+    await drive_base.turn(-60)
+    await drive_base.straight(-670)
+
+
+async def Run3():  # tip the scale.py
+    right_arm.run_angle(500,400)
+    await drive_base.straight(800)
+    await drive_base.turn(90)
+    await drive_base.straight(86)
+    await right_arm.run_angle(800,-600)
+    await right_arm.run_angle(900,800)
+    
+    await drive_base.straight(-100)
+    await drive_base.turn(90)
+    await drive_base.straight(800)
+    drive_base.brake()
+
+
+async def Run4():  # From Send_Over_Final.py
+    
+    await drive_base.straight(920)
+    await drive_base.turn(-90,Stop.HOLD)
+    await drive_base.straight(65)
+    #Solve
+    drive_base.turn(-10)
+    await left_arm.run_angle(10000,-4000)
+    await drive_base.straight(-110)
+    await drive_base.turn(90)
+
+    await multitask(
+        drive_forward(), 
+        monitor_distance()
+    )
+
+# Add Rishi's code here
+async def Run5(): 
+    await drive_base.straight(700)
+    await drive_base.turn(-20)
+    await drive_base.straight(110)
+    await drive_base.straight(-210)
+    await drive_base.turn(63)
+    await drive_base.straight(130)
+    await right_arm.run_angle(1000, -1200)
+    await drive_base.straight(84)
+    await right_arm.run_angle(300, 1200)
+    await drive_base.straight(-900)
+
+
+# Add - Adi's code here
+async def Run6():
+    await drive_base.straight(500)
+    await right_arm.run_angle(300,500)
+    await drive_base.straight(-75)
+    await right_arm.run_angle(300, -900)
+    await drive_base.straight(-350)
+    await wait(1000)
+    await drive_base.straight(800)
+    await drive_base.straight(-200)
+    await drive_base.turn(-15)
+    await drive_base.straight(350)
+    await drive_base.turn(-102.5)
+    await drive_base.straight(-80)
+    await left_arm.run_angle(500, -900)
+    await drive_base.straight(50)
+    await drive_base.straight(50)
+    await left_arm.run_angle(700, 270)
+    await drive_base.turn(30)
+    await drive_base.straight(-60)
+
+
+
+# Function to classify color based on HSV
+def detect_color(h, s, v, reflected):
+    if reflected > 4:
+        if h < 4 or h > 350:  # red
+            return "Red"
+        elif 3 < h < 40 and s > 70:  # orange
+            return "Orange"
+        elif 47 < h < 56:  # yellow
+            return "Yellow"
+        elif 70 < h < 160:  # green - do it vertically not horizontally for accuracy
+            return "Green"
+        elif 210 < h < 225:  # blue - do it vertically not horizontally for accuracy
+            return "Blue"
+        elif 260 < h < 350:  # purple
+            return "Purple"
+        else:
+            return "Unknown"
+    return "Unknown"
+
+
+async def main():
+    while True:
+        h, s, v = await color_sensor.hsv()
+        reflected = await color_sensor.reflection()
+        color = detect_color(h, s, v, reflected)
+        
+        if color == "Red":
+            print('Running Mission 3')
+            await Run3() #red
+        elif color == "Orange":
+            print('Running Mission 6')
+            await Run6() #orange
+        elif color == "Yellow":
+            print('Running Mission 4')
+            await Run4() #yellow
+        elif color == "Green": 
+            print('Running Mission 1')
+            await Run1() #green - vertically
+        elif color == "Blue":
+            print('Running Mission 5')
+            await Run5() #blue - vertically
+        elif color == "Purple":
+            print('Running Mission 2')
+            await Run2()  #purple - vertically
+        else:
+            print(f"Unknown color detected (Hue: {h}, Sat: {s}, Val: {v})")
+        await wait(10)
+# Run the main function
+run_task(main())

competition_codes/hazmat/mainhazmatUPD.py

@@ -45,22 +45,28 @@ async def monitor_distance():
 
 # New Section
 async def Run1():  # From M8_5.py
+    
     right_arm.run_angle(1000,450)
-    left_arm.run_angle(500,80)
+    left_arm.run_angle(500,-90)
     await drive_base.straight(200)
 
     await drive_base.turn(-40)
     await drive_base.straight(325)
-    await left_arm.run_angle(500,-80)
+    await left_arm.run_angle(500,90)
 
     await drive_base.straight(-100)
     await drive_base.straight(50)
-    await left_arm.run_angle(500,170)
+    await left_arm.run_angle(500,-180)
 
-    await drive_base.straight(-270)
-    await drive_base.turn(40)
-    await drive_base.straight(135)
-    left_arm.run_angle(1000,670)
+    await drive_base.straight(-90)
+    left_arm.run_angle(500,180)
+    await drive_base.turn(-20)
+    await drive_base.turn(15)
+
+    await drive_base.straight(-173)
+    await drive_base.turn(45)
+    await drive_base.straight(120)
+    left_arm.run_angle(1000,-670)
 
     await right_arm.run_angle(5000,-450, Stop.HOLD)
     await right_arm.run_angle(5000,450, Stop.HOLD)
@@ -70,7 +76,7 @@ async def Run1():  # From M8_5.py
     right_arm.run_angle(5000,450, Stop.HOLD)
 
     await drive_base.turn(-35)
-    await drive_base.straight(300)
+    await drive_base.straight(297)
     await drive_base.turn(63)
     await drive_base.straight(170)
 
@@ -78,12 +84,9 @@ async def Run1():  # From M8_5.py
     await drive_base.straight(87)
     await drive_base.turn(-15)
 
-    await drive_base.straight(-120)
+    await drive_base.straight(-90)
     await drive_base.turn(-100)
-    await drive_base.straight(300)
-    await drive_base.turn(-45)
-    await drive_base.straight(500)
-
+    await drive_base.arc(-500,None,600)
     
 async def Run2():  # From Heavy_lifting_final.py
     await drive_base.straight(200)
@@ -142,16 +145,16 @@ async def Run4():  # From Send_Over_Final.py
 
 # Add Rishi's code here
 async def Run5(): 
-    await drive_base.straight(700)
-    await drive_base.turn(-18)
+    await drive_base.straight(600)
+    await drive_base.straight(-100)
+    await drive_base.straight(150)
+    await drive_base.turn(60)
     await drive_base.straight(100)
-    await drive_base.straight(-205)
-    await drive_base.turn(63)
-    await drive_base.straight(125)
-    await arm_motor.run_angle(1000, -1200)
-    await drive_base.straight(84)
-    await arm_motor.run_angle(300, 1200)
-    await drive_base.straight(-875)
+    await drive_base.turn(-86)
+    await drive_base.straight(120)
+    await drive_base.turn(-45)
+    await drive_base.straight(-200)
+    await drive_base.turn(75)
 
 # Add - Adi's code here
 async def Run6():

competition_codes/regional-final/Final_combined.py

@@ -0,0 +1,221 @@
+from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
+from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
+from pybricks.tools import run_task, multitask
+from pybricks.tools import wait, StopWatch
+from pybricks.robotics import DriveBase
+from pybricks.hubs import PrimeHub
+
+# Initialize hub and devices
+hub = PrimeHub()
+left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
+right_motor = Motor(Port.B)
+left_arm = Motor(Port.C)
+right_arm = Motor(Port.D)
+lazer_ranger = UltrasonicSensor(Port.E)
+color_sensor = ColorSensor(Port.F)
+
+# DriveBase configuration
+WHEEL_DIAMETER = 68.8  # mm (adjust for your wheels)
+AXLE_TRACK = 180  # mm (distance between wheels)
+drive_base = DriveBase(left_motor, right_motor, WHEEL_DIAMETER, AXLE_TRACK)
+drive_base.settings(600, 500, 300, 200)
+drive_base.use_gyro(True)
+
+WALL_DISTANCE = 300  # mm
+
+async def drive_forward():
+    """Drive forward continuously using DriveBase."""
+    drive_base.drive(400, 0)
+
+
+async def monitor_distance():
+    """Monitor ultrasonic sensor and stop when wall is detected."""
+    while True:
+        distance = await lazer_ranger.distance()
+        print('Distancing...',distance)
+        
+        if distance < WALL_DISTANCE:
+            # Stop the drivebase
+            await drive_base.stop
+            print(f"Wall detected at {distance}mm!")
+            break
+        
+        # Small delay to prevent overwhelming the sensor
+        await wait(50)
+
+# New Section
+async def Run1():  # From M8_5.py
+    right_arm.run_angle(1000,450)
+    left_arm.run_angle(500,90)
+    await drive_base.straight(200)
+
+    await drive_base.turn(-40)
+    await drive_base.straight(325)
+    await left_arm.run_angle(500,-90)
+
+    await drive_base.straight(-100)
+    await drive_base.straight(50)
+    await left_arm.run_angle(500,180)
+
+    await drive_base.straight(-90)
+    left_arm.run_angle(500,-180)
+    await drive_base.turn(-20)
+    await drive_base.turn(15)
+
+    await drive_base.straight(-173)
+    await drive_base.turn(45)
+    await drive_base.straight(120)
+    left_arm.run_angle(1000,670)
+
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    await right_arm.run_angle(5000,450, Stop.HOLD)
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    await right_arm.run_angle(5000,450, Stop.HOLD)
+    await right_arm.run_angle(5000,-450, Stop.HOLD)
+    right_arm.run_angle(5000,450, Stop.HOLD)
+
+    await drive_base.turn(-35)
+    await drive_base.straight(297)
+    await drive_base.turn(63)
+    await drive_base.straight(170)
+
+    await drive_base.turn(-80)
+    await drive_base.straight(87)
+    await drive_base.turn(-15)
+
+    await drive_base.straight(-90)
+    await drive_base.turn(-100)
+    await drive_base.arc(-500,None,600)
+
+    
+async def Run2():  # From Heavy_lifting_final.py
+    await drive_base.straight(200)
+    await drive_base.turn(-20)
+    await drive_base.straight(536)
+    await drive_base.turn(60, Stop.HOLD)
+    await drive_base.straight(30)
+    await right_arm.run_angle(5000, 2900)
+    await drive_base.straight(40)
+    await right_arm.run_angle(5000, -4000)
+    await drive_base.straight(-60)
+    await drive_base.turn(-60)
+    await drive_base.straight(-670)
+
+
+async def Run3():  # tip the scale.py
+    right_arm.run_angle(500,400)
+    await drive_base.straight(800)
+    await drive_base.turn(90)
+    await drive_base.straight(86)
+    await right_arm.run_angle(800,-600)
+    await right_arm.run_angle(900,800)
+    
+    await drive_base.straight(-100)
+    await drive_base.turn(90)
+    await drive_base.straight(800)
+    drive_base.brake()
+
+
+async def Run4():  # From Send_Over_Final.py
+    
+    await drive_base.straight(920)
+    await drive_base.turn(-90,Stop.HOLD)
+    await drive_base.straight(65)
+    #Solve
+    drive_base.turn(-10)
+    await left_arm.run_angle(10000,-4000)
+    await drive_base.straight(-110)
+    await drive_base.turn(90)
+
+    await multitask(
+        drive_forward(), 
+        monitor_distance()
+    )
+
+# Add Rishi's code here
+async def Run5(): 
+    await drive_base.straight(700)
+    await drive_base.turn(-20)
+    await drive_base.straight(110)
+    await drive_base.straight(-210)
+    await drive_base.turn(63)
+    await drive_base.straight(130)
+    await right_arm.run_angle(1000, -1200)
+    await drive_base.straight(84)
+    await right_arm.run_angle(300, 1200)
+    await drive_base.straight(-875)
+
+# Add - Adi's code here
+async def Run6():
+    await drive_base.straight(500)
+    await right_arm.run_angle(300,500)
+    await drive_base.straight(-75)
+    await right_arm.run_angle(300, -900)
+    await drive_base.straight(-350)
+    await wait(1000)
+    await drive_base.straight(800)
+    await drive_base.straight(-200)
+    await drive_base.turn(-15)
+    await drive_base.straight(350)
+    await drive_base.turn(-100)
+    await drive_base.straight(-80)
+    await left_arm.run_angle(500, -900)
+    await drive_base.straight(50)
+    await drive_base.straight(50)
+    await left_arm.run_angle(700, 250)
+    await drive_base.turn(30)
+    await drive_base.straight(-60)
+    await drive_base.turn(80)
+    await drive_base.straight(-900)
+
+
+
+# Function to classify color based on HSV
+def detect_color(h, s, v, reflected):
+    if reflected > 4:
+        if h < 4 or h > 350:  # red
+            return "Red"
+        elif 3 < h < 40 and s > 70:  # orange
+            return "Orange"
+        elif 47 < h < 56:  # yellow
+            return "Yellow"
+        elif 70 < h < 160:  # green - do it vertically not horizontally for accuracy
+            return "Green"
+        elif 210 < h < 225:  # blue - do it vertically not horizontally for accuracy
+            return "Blue"
+        elif 260 < h < 350:  # purple
+            return "Purple"
+        else:
+            return "Unknown"
+    return "Unknown"
+
+
+async def main():
+    while True:
+        h, s, v = await color_sensor.hsv()
+        reflected = await color_sensor.reflection()
+        color = detect_color(h, s, v, reflected)
+        
+        if color == "Red":
+            print('Running Mission 3')
+            await Run3() #red
+        elif color == "Orange":
+            print('Running Mission 6')
+            await Run6() #orange
+        elif color == "Yellow":
+            print('Running Mission 4')
+            await Run4() #yellow
+        elif color == "Green": 
+            print('Running Mission 1')
+            await Run1() #green - vertically
+        elif color == "Blue":
+            print('Running Mission 5')
+            await Run5() #blue - vertically
+        elif color == "Purple":
+            print('Running Mission 2')
+            await Run2()  #purple - vertically
+        else:
+            print(f"Unknown color detected (Hue: {h}, Sat: {s}, Val: {v})")
+        await wait(10)
+# Run the main function
+run_task(main())

competition_codes/sectionals/mukwonago_sectionals_final.py

@@ -0,0 +1,372 @@
+from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
+from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
+from pybricks.tools import run_task, multitask
+from pybricks.tools import wait, StopWatch
+from pybricks.robotics import DriveBase
+from pybricks.hubs import PrimeHub
+
+# Initialize hub and devices
+hub = PrimeHub()
+left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
+right_motor = Motor(Port.B,Direction.CLOCKWISE) # Specify default direction
+left_arm = Motor(Port.C, Direction.CLOCKWISE) # Specify default direction
+right_arm = Motor(Port.D, Direction.CLOCKWISE,[[12,36],[12,20,24]]) #Added gear train list for gear ration
+lazer_ranger = UltrasonicSensor(Port.E)
+color_sensor = ColorSensor(Port.F)
+
+# DriveBase configuration
+WHEEL_DIAMETER = 68.8  # mm (adjust for your wheels)
+AXLE_TRACK = 180  # mm (distance between wheels)
+drive_base = DriveBase(left_motor, right_motor, WHEEL_DIAMETER, AXLE_TRACK)
+drive_base.settings(600, 500, 300, 200)
+drive_base.use_gyro(True)
+
+WALL_DISTANCE = 200  # mm
+
+async def drive_forward():
+    """Drive forward continuously using DriveBase."""
+    drive_base.drive(400, 0)
+
+async def drive_backward():
+    """Drive forward continuously using DriveBase."""
+    drive_base.drive(400, 0)
+
+
+async def monitor_distance():
+    """Monitor ultrasonic sensor and stop when wall is detected."""
+    while True:
+        distance = await lazer_ranger.distance()
+        print('Distancing...',distance)
+        
+        if distance < WALL_DISTANCE:
+            # Stop the drivebase
+            drive_base.stop()
+            print(f"Wall detected at {distance}mm!")
+            break
+        if distance is None:
+            continue
+
+        
+        # Small delay to prevent overwhelming the sensor
+        await wait(50)
+
+"""
+Run#1
+- Removed forge and who lived here part
+- What's on sale + Silo
+- Green Key
+"""
+async def Run1():  
+    await solve_whats_on_sale()
+    await solve_silo()
+
+    # return to base
+    await drive_base.straight(-90)
+    #await drive_base.turn(-100)
+    await drive_base.arc(200,None,-300)
+    drive_base.stop()
+    
+async def solve_whats_on_sale():
+
+    right_arm.run_angle(500,30)
+    left_arm.run_angle(500,90)
+    await drive_base.straight(200)
+
+    await drive_base.turn(-40)
+    await drive_base.straight(325)
+    await left_arm.run_angle(500,-90)
+
+    await drive_base.straight(-100)
+    await drive_base.straight(50)
+    await left_arm.run_angle(500,180)
+
+    await drive_base.straight(-90)
+    left_arm.run_angle(500,-180)
+    await drive_base.turn(-20)
+    await drive_base.turn(15)
+
+async def solve_silo():
+    await drive_base.straight(-173)
+    await drive_base.turn(45)
+    await drive_base.straight(120)
+    left_arm.run_angle(1000,670)
+
+    await right_arm.run_angle(4000,-30, Stop.HOLD)
+    await right_arm.run_angle(4000,30, Stop.HOLD)
+    await right_arm.run_angle(4000,-30, Stop.HOLD)
+    await right_arm.run_angle(4000,30, Stop.HOLD)
+    await right_arm.run_angle(4000,-30, Stop.HOLD)
+    right_arm.run_angle(4000,30, Stop.HOLD)
+
+
+"""
+Run#2
+- This to solve forge, who lived here and heavy lifting combined
+- Red Key
+"""
+async def Run2():  
+    await solve_forge()
+    await solve_heavy_lifting()
+    await solve_who_lived_here()
+
+    # return to base
+    await drive_base.arc(-500,None,600)
+    drive_base.stop()
+
+async def solve_forge():
+    await right_arm.run_target(50,50)
+    # await right_arm.run_angle(50,-30)
+    await drive_base.arc(350,113, None)
+
+    await drive_base.straight(20)
+    await drive_base.turn(-60)
+    await drive_base.straight(-47)
+
+async def solve_heavy_lifting():
+    await right_arm.run_angle(500,-160) # arm down
+    await wait(100)
+    await drive_base.turn(20) # turn right a little bit
+    await right_arm.run_angle(500,160) #arm up
+    await drive_base.turn(-20) #reset position
+
+async def solve_who_lived_here():
+    await drive_base.straight(50)
+    await drive_base.turn(-15)
+    await drive_base.straight(50)
+    await drive_base.turn(-25)
+    await drive_base.straight(-50)
+    await drive_base.turn(-100)
+
+"""
+Run#2.1
+- Alternate solution for Forge, Who lived here and Heavy Lifting combined
+- Light Blue Key
+- Different alignment
+"""
+async def Run2_1():  
+    await solve_forge_straight()
+    await solve_heavy_lifting()
+    await solve_who_lived_here()
+
+    # return to base
+    await drive_base.arc(-500,None,600)
+    drive_base.stop()
+
+async def solve_forge_straight():
+    await right_arm.run_target(50,50)
+    await right_arm.run_angle(50,-30)
+    await drive_base.straight(700)
+    # await drive_base.turn(-30)
+    # await drive_base.straight(20)
+    await drive_base.turn(-40)
+    await drive_base.straight(-30)
+
+"""
+Run#3
+- Combined angler artifacts and tip the scale
+- Yellow key
+"""
+async def Run3(): 
+    await solve_angler_artifacts()
+    await solve_tip_the_scale()
+    
+    #cross over to red side
+    await multitask(
+        drive_forward(), 
+        monitor_distance()
+    )
+
+async def solve_angler_artifacts():
+    await drive_base.straight(940)
+    await drive_base.turn(-90,Stop.HOLD)
+    await drive_base.straight(65)
+    #Solve
+    drive_base.turn(-10)
+    await left_arm.run_angle(10000,-3000)
+    await drive_base.straight(-110)
+    
+    await drive_base.turn(90)
+    await drive_base.arc(-150,-103, None)
+
+async def solve_tip_the_scale():
+    await drive_base.turn(3)
+    await drive_base.straight(142.5)
+    await right_arm.run_angle(800,-150)
+    await right_arm.run_angle(900,150)
+    
+    await drive_base.straight(-100)
+    await drive_base.turn(-65)
+    await drive_base.straight(300,Stop.COAST_SMART)
+    await drive_base.arc(10,-47, None)
+    #await drive_base.turn(-23, Stop.COAST_SMART)
+
+
+
+
+
+
+"""
+Run #4 
+- Solves the Mineshaft explorer + 2/3 Surface Brush + 1/3 Map Reveal
+- Blue Key
+"""
+async def Run4(): 
+    await drive_base.straight(700)
+    await drive_base.turn(-18)
+    await drive_base.straight(120)
+    await drive_base.straight(-210)
+    await drive_base.turn(61)
+    await drive_base.straight(133)
+    await right_arm.run_angle(400, -200)
+    await drive_base.straight(90)
+    await right_arm.run_angle(100, 95)
+    await drive_base.straight(-875)
+
+async def solve_brush_reveal():
+    await drive_base.straight(700)
+    await drive_base.turn(-20)
+    await drive_base.straight(110)
+    await drive_base.straight(-210)
+
+async def solve_mineshaft_explorer():
+    await drive_base.turn(63)
+    await drive_base.straight(130)
+    await right_arm.run_angle(1000, -90)
+    await drive_base.straight(84)
+    await right_arm.run_angle(300, 90)
+
+"""
+Run#5
+- Solves Salvage Operation + Statue Rebuild
+- Orange Key
+"""
+async def Run5():
+    await drive_base.straight(550)
+    await right_arm.run_angle(300,100)
+    await drive_base.straight(-75)
+    await right_arm.run_angle(300, -100)
+    await drive_base.straight(300)
+    await drive_base.straight(-200)
+    await drive_base.turn(-15)
+    #solving statue
+    await drive_base.straight(350)
+    await drive_base.turn(-104)
+    await drive_base.straight(-80)
+    await left_arm.run_angle(500, -900)
+    await drive_base.straight(120)
+    await drive_base.turn(5)
+    await left_arm.run_angle(500, 290)
+    await drive_base.turn(18)
+    await drive_base.straight(-100)
+    await drive_base.turn(-90)
+    await drive_base.straight(900)
+    drive_base.stop()
+
+
+async def solve_salvage_operation():
+    await drive_base.straight(500)
+    await right_arm.run_angle(300,500)
+    await drive_base.straight(-75)
+    await right_arm.run_angle(300, -900)
+    await drive_base.straight(-350)
+    await wait(1000)
+    await drive_base.straight(800)
+    await drive_base.straight(-200)
+    await drive_base.turn(-15)
+    await drive_base.straight(350)
+
+async def solve_statue_rebuild():
+    await drive_base.turn(-100)
+    await drive_base.straight(-80)
+    await left_arm.run_angle(500, -900)
+    await drive_base.straight(50)
+    await drive_base.straight(50)
+    await left_arm.run_angle(700, 250)
+    await drive_base.turn(30)
+
+"""
+Run#6
+- Solve 2/3 Site Markings
+- Run only if have time
+- Purple Key
+"""
+async def Run6_7():  # experiment with ferris wheel for Site Markings
+    solve_site_mark_1()
+    solve_site_mark_2()
+    #return to base
+    await drive_base.straight(-300)
+    drive_base.stop()
+
+async def solve_site_mark_1():
+    await drive_base.straight(500)
+    await right_arm.run_angle(100, -10)
+    await wait(50)
+    await drive_base.straight(-300)
+    await drive_base.arc(-150, -140, None)
+
+async def solve_site_mark_2():
+    await drive_base.straight(-300)
+    await wait(50)
+    await right_arm.run_angle(50, 50)
+
+
+
+# Function to classify color based on HSV
+def detect_color(h, s, v, reflected):
+    if reflected > 4:
+        if h < 4 or h > 350:  # red
+            return "Red"
+        elif 3 < h < 40 and s > 70:  # orange
+            return "Orange"
+        elif 47 < h < 56:  # yellow
+            return "Yellow"
+        elif 70 < h < 160:  # green - do it vertically not horizontally for accuracy
+            return "Green"
+        elif 195 < h < 198:  # light blue
+            return "Light_Blue"
+        elif 210 < h < 225:  # blue - do it vertically not horizontally for accuracy
+            return "Blue"
+        elif 260 < h < 350:  # purple
+            return "Purple"
+       
+        else:
+            return "Unknown"
+    return "Unknown"
+
+
+async def main():
+    while True:
+        h, s, v = await color_sensor.hsv()
+        print(color_sensor.color())
+        print(h,s,v)
+        reflected = await color_sensor.reflection()
+        color = detect_color(h, s, v, reflected)
+        print(color)
+        
+
+        if color == "Green":
+            print('Running Mission 1')
+            await Run1() 
+        elif color == "Red":
+            print('Running Mission 2')
+            await Run2() 
+        elif color == "Yellow":
+            print('Running Mission 3')
+            await Run3() 
+        elif color == "Blue": 
+            print('Running Mission 4')
+            await Run4() 
+        elif color == "Orange":
+            print('Running Mission 5')
+            await Run5() 
+        elif color == "Purple":
+            print('Running Mission 6')
+            await Run6_7()  
+        elif color == "Light_Blue":
+            print("Running Mission 2_1")
+            await Run2_1()
+        else:
+            print(f"Unknown color detected (Hue: {h}, Sat: {s}, Val: {v})")
+        await wait(10)
+# Run the main function
+run_task(main())

missions/M8_5.py

@@ -21,20 +21,25 @@ drive_base.use_gyro(True)
 async def main():
     
     right_arm.run_angle(1000,450)
-    left_arm.run_angle(500,-80)
+    left_arm.run_angle(500,-90)
     await drive_base.straight(200)
 
     await drive_base.turn(-40)
     await drive_base.straight(325)
-    await left_arm.run_angle(500,80)
+    await left_arm.run_angle(500,90)
 
     await drive_base.straight(-100)
     await drive_base.straight(50)
-    await left_arm.run_angle(500,-170)
+    await left_arm.run_angle(500,-180)
 
-    await drive_base.straight(-270)
-    await drive_base.turn(40)
-    await drive_base.straight(135)
+    await drive_base.straight(-90)
+    left_arm.run_angle(500,180)
+    await drive_base.turn(-20)
+    await drive_base.turn(15)
+
+    await drive_base.straight(-173)
+    await drive_base.turn(45)
+    await drive_base.straight(120)
     left_arm.run_angle(1000,-670)
 
     await right_arm.run_angle(5000,-450, Stop.HOLD)
@@ -45,7 +50,7 @@ async def main():
     right_arm.run_angle(5000,450, Stop.HOLD)
 
     await drive_base.turn(-35)
-    await drive_base.straight(300)
+    await drive_base.straight(297)
     await drive_base.turn(63)
     await drive_base.straight(170)
 
@@ -53,10 +58,8 @@ async def main():
     await drive_base.straight(87)
     await drive_base.turn(-15)
 
-    await drive_base.straight(-120)
+    await drive_base.straight(-90)
     await drive_base.turn(-100)
-    await drive_base.straight(300)
-    await drive_base.turn(-45)
-    await drive_base.straight(500)
+    await drive_base.arc(-500,None,600)
 
 run_task(main())

missions/New_MapReveal/New_MapReveal_Mineshaft.py

@@ -0,0 +1,38 @@
+from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
+from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
+from pybricks.tools import run_task, multitask
+from pybricks.tools import wait, StopWatch
+from pybricks.robotics import DriveBase
+from pybricks.hubs import PrimeHub
+
+# Initialize hub and devices
+hub = PrimeHub()
+left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
+right_motor = Motor(Port.B)
+left_arm = Motor(Port.C)
+right_arm = Motor(Port.D)
+lazer_ranger = UltrasonicSensor(Port.E)
+color_sensor = ColorSensor(Port.F)
+
+# DriveBase configuration
+WHEEL_DIAMETER = 68.8  # mm (adjust for your wheels)
+AXLE_TRACK = 180  # mm (distance between wheels)
+drive_base = DriveBase(left_motor, right_motor, WHEEL_DIAMETER, AXLE_TRACK)
+drive_base.settings(600, 500, 300, 200)
+drive_base.use_gyro(True)
+
+WALL_DISTANCE = 200  # mm
+
+async def main():
+    await drive_base.straight(700)
+    await drive_base.turn(-20)
+    await drive_base.straight(110)
+    await drive_base.straight(-220)
+    await drive_base.turn(63)
+    await drive_base.straight(130)
+    await right_arm.run_angle(1000, -1200)
+    await drive_base.straight(84)
+    await right_arm.run_angle(300, 1200)
+    await drive_base.straight(-875)
+
+run_task(main())

utils/FINAL_STARTER_BLANK_CODE.py

@@ -0,0 +1,29 @@
+from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
+from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
+from pybricks.tools import run_task, multitask
+from pybricks.tools import wait, StopWatch
+from pybricks.robotics import DriveBase
+from pybricks.hubs import PrimeHub
+
+# Initialize hub and devices
+hub = PrimeHub()
+left_motor = Motor(Port.A, Direction.COUNTERCLOCKWISE)
+right_motor = Motor(Port.B)
+left_arm = Motor(Port.C)
+
+right_arm = Motor(Port.D)
+lazer_ranger = UltrasonicSensor(Port.E)
+color_sensor = ColorSensor(Port.F)
+# DriveBase configuration
+WHEEL_DIAMETER = 68.8  # mm
+AXLE_TRACK = 180  # mm
+drive_base = DriveBase(left_motor, right_motor, WHEEL_DIAMETER, AXLE_TRACK)
+drive_base.settings(600, 500, 300, 200)
+drive_base.use_gyro(True)
+
+WALL_DISTANCE = 200  # mm
+
+async def main():
+    # Your code goes here
+
+run_task(main())    

utils/tests/colorsensortest.py

@@ -1,69 +0,0 @@
-from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
-from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
-from pybricks.tools import run_task, multitask
-from pybricks.tools import wait, StopWatch
-from pybricks.robotics import DriveBase
-from pybricks.hubs import PrimeHub
-
-# Initialize hub and devices
-hub = PrimeHub()
-
-color_sensor = ColorSensor(Port.F)
-
-# Color Settings
-# https://docs.pybricks.com/en/latest/parameters/color.html
-print("Default Detected Colors:", color_sensor.detectable_colors())
-
-# Custom color Hue, Saturation, Brightness value for Lego bricks
-Color.MAGENTA = Color(315,100,60)
-Color.BLUE = Color(240,100,100)
-Color.CYAN = Color(180,100,100)
-Color.RED = Color(350, 100, 100)
-LEGO_BRICKS_COLOR = [
-    Color.BLUE, 
-    Color.GREEN, 
-    Color.WHITE,
-    Color.RED, 
-    Color.YELLOW, 
-    Color.MAGENTA, 
-    Color.NONE
-]
-magenta_counter = 0
-stable_color = None
-real_color = None
-#Update Detectable colors
-color_sensor.detectable_colors(LEGO_BRICKS_COLOR)
-print(f'Yellow:{Color.YELLOW} : {Color.YELLOW.h}, {Color.YELLOW.s}, {Color.YELLOW.v}')
-print("Updated Detected Colors:", color_sensor.detectable_colors())
-async def main():  
-    while True:
-        global magenta_counter, stable_color, real_color
-        color_reflected_percent = await color_sensor.reflection()
-        print("Reflection: ", color_reflected_percent)
-        if color_reflected_percent > 15:
-            color_detected = await color_sensor.color()
-
-            if color_detected == Color.MAGENTA:
-                magenta_counter += 1
-            else:
-                magenta_counter = 0
-                stable_color = color_detected
-
-            # Only accept magenta if it's been stable for a while - usually triggers before other colors so we gotta do this :|
-            if magenta_counter > 10:
-                stable_color = Color.MAGENTA
-                if stable_color != Color.MAGENTA:
-                    stable_color = await color_sensor.color()
-
-            real_color = stable_color
-            #if(color_detected != Color.NONE):
-            #    return
-            
-            print("Magenta counter: ", magenta_counter)
-            if real_color is not None:
-                print(f'Detected color: {real_color} : {real_color.h}, {real_color.s}, {real_color.v}')
-            else:
-                print("No valid color detected yet.")
-        await wait(50)
-
-run_task(main())