Color Sensor Menu Selection

[PollyJSk8]

Hi there! I could use some guidance and help. I'm new to Python and Spike Prime and aren't even sure I'm going in the right direction.

I have been trying to use a color sensor to select which program to call while maintaining the ability to manually select a program on the hub. For example, if the color green is detected, then a "1" appears on the hub, and program 1 plays once the center hub button is pressed. The hub display can also be overridden, and other programs selected regardless of what color is detected. Since different people are working on various programs, I do not want to combine everything in a single program. I'd like to have a menu that compiles it together.

I can get the numbers to appear on the hub, but it does not execute the related program. All programs are currently songs/beeps, but none of them play through the menu. They play stand-alone when I test them independently, but the menu doesn't seem to import them.

Is what I am attempting possible on Pybricks? If so, what is going wrong with my attempt?

Thanks in advance for your help.

Below is what was coded.

-----
from pybricks.hubs import PrimeHub
from pybricks.pupdevices import Motor, ColorSensor, UltrasonicSensor, ForceSensor
from pybricks.parameters import Button, Color, Direction, Port, Side, Stop
from pybricks.robotics import DriveBase
from pybricks.tools import wait, StopWatch

hub = PrimeHub()


# -------- Config --------
COLOR_SENSOR_PORT = Port.E
LOOP_DELAY_MS = 80

# Menu choices (circular). 
CHOICES = [1, 2, 3]

# HSV ranges for robust detection (degrees 0–360, S/V 0–100)
# Tune these to your mat/lighting.
GREEN_H_RANGE = (80, 160)    # typical LEGO "green"
GREEN_S_MIN   = 25
GREEN_V_MIN   = 20
ORANGE_H_RANGE = (20, 40)    # typical LEGO "orange"
ORANGE_S_MIN   = 35
ORANGE_V_MIN   = 25

# “Close enough” extra tolerance (degrees) if just outside range
HUE_TOLERANCE_DEG = 10

# -------- Setup --------
hub = PrimeHub()
try:
    sensor = ColorSensor(COLOR_SENSOR_PORT)
except Exception:
    sensor = None

# -------- Utilities --------
def clamp01(x):
    return 0 if x < 0 else (1 if x > 1 else x)

def rgb_to_hsv_deg(r, g, b):
    """
    r,g,b expected in 0..100 from Pybricks ColorSensor.rgb()
    Returns (H_degrees 0..360, S 0..100, V 0..100)
    """
    R = clamp01(r / 100.0)
    G = clamp01(g / 100.0)
    B = clamp01(b / 100.0)
    cmax = max(R, G, B)
    cmin = min(R, G, B)
    delta = cmax - cmin

    # Hue
    if delta == 0:
        H = 0.0
    elif cmax == R:
        H = (60 * (((G - B) / (delta + 1e-9)) % 6))
    elif cmax == G:
        H = (60 * (((B - R) / (delta + 1e-9)) + 2))
    else:  # cmax == B
        H = (60 * (((R - G) / (delta + 1e-9)) + 4))

    # Saturation
    S = 0.0 if cmax == 0 else (delta / cmax) * 100.0
    # Value
    V = cmax * 100.0
    return H, S, V

def hue_in_range(h, lo, hi):
    """Return True if hue h is within [lo, hi] on circular 0..360 scale."""
    if lo <= hi:
        return lo <= h <= hi
    # wrap-around case (not used here but robust)
    return h >= lo or h <= hi

def hue_distance_deg(h1, h2):
    """Smallest circular distance between two hues (degrees)."""
    d = abs(h1 - h2) % 360
    return d if d <= 180 else 360 - d

def read_hsv():
    """Get HSV from the color sensor; returns (H,S,V) or None."""
    if sensor is None:
        return None
    try:
        r, g, b = sensor.rgb()  # 0..100 each
        return rgb_to_hsv_deg(r, g, b)
    except Exception:
        return None

def detect_code_from_hsv():
    """
    Returns 1 if green, 2 if orange (by HSV with tolerance), else None.
    """
    hsv = read_hsv()
    if hsv is None:
        return None
    H, S, V = hsv

    # Check GREEN
    if (hue_in_range(H, GREEN_H_RANGE[0], GREEN_H_RANGE[1]) and
        S >= GREEN_S_MIN and V >= GREEN_V_MIN):
        return 1
    # Close to GREEN?
    if (min(hue_distance_deg(H, GREEN_H_RANGE[0]), hue_distance_deg(H, GREEN_H_RANGE[1])) <= HUE_TOLERANCE_DEG and
        S >= max(10, GREEN_S_MIN - 10) and V >= max(10, GREEN_V_MIN - 10)):
        return 1

    # Check ORANGE
    if (hue_in_range(H, ORANGE_H_RANGE[0], ORANGE_H_RANGE[1]) and
        S >= ORANGE_S_MIN and V >= ORANGE_V_MIN):
        return 2
    # Close to ORANGE?
    if (min(hue_distance_deg(H, ORANGE_H_RANGE[0]), hue_distance_deg(H, ORANGE_H_RANGE[1])) <= HUE_TOLERANCE_DEG and
        S >= max(10, ORANGE_S_MIN - 10) and V >= max(10, ORANGE_V_MIN - 10)):
        return 2

    return None

def next_choice(current, step):
    i = CHOICES.index(current)
    return CHOICES[(i + step) % len(CHOICES)]

def show_selection(sel):
    if isinstance(sel, int):
        hub.display.number(sel)
    else:
        hub.display.text(str(sel))

def edge_pressed(target, prev, cur):
    return (target not in prev) and (target in cur)

def module_name_for(sel):
    if isinstance(sel, int):
        return f"run{sel}"
    return f"run{str(sel).upper()}"

def try_import_and_run(sel):
    # Minimal feedback only via beeps/display
    try:
        mod = __import__(module_name_for(sel))
        fn = getattr(mod, "main", None)
        if callable(fn):
            fn(hub)
        else:
            hub.speaker.beep(220, 150)  # missing main(hub)
    except Exception:
        hub.speaker.beep(220, 200)      # import error / missing file

# -------- Selector (CENTER required) --------
def pick_code():
    auto = detect_code_from_hsv()
    selection = auto if (auto in CHOICES) else CHOICES[0]
    show_selection(selection)

    prev = set()
    while True:
        cur = set(hub.buttons.pressed())

        if edge_pressed(Button.LEFT, prev, cur):
            selection = next_choice(selection, -1)
            show_selection(selection)

        if edge_pressed(Button.RIGHT, prev, cur):
            selection = next_choice(selection, +1)
            show_selection(selection)

        # Live auto-update only for GREEN->1 and ORANGE->2
        auto = detect_code_from_hsv()
        if auto in (1, 2) and auto != selection and not (
            Button.LEFT in cur or Button.RIGHT in cur
        ):
            selection = auto
            show_selection(selection)

        if edge_pressed(Button.CENTER, prev, cur):
            hub.speaker.beep(880, 80)  # confirm
            return selection

        prev = cur
        wait(LOOP_DELAY_MS)

# -------- App --------
def main():
    if sensor is None:
        hub.speaker.beep(300, 120)
        wait(200)

    while True:
        chosen = pick_code()       # waits for CENTER
        try_import_and_run(chosen) # imports runX and executes main(hub)
        show_selection(chosen)     # back to selector
        wait(300)

main()

[laurensvalk]

Your code seems to attempt to read RGB and then convert them to HSV. But the sensor gives HSV, not RGB. So this code:

    try:
        r, g, b = sensor.rgb()  # 0..100 each
        return rgb_to_hsv_deg(r, g, b)
    except Exception:
        return None

Will find that there isn't an rgb() method, go to the exception, and always return None. All of the conversion utility code to HSV never runs. Also, it looks like you are manually converting from HSV to a particular color. There is also the detectable_colors method that will configure this for you :)

When working on a project like this, I recommend taking smaller steps and testing as you go. So perhaps you could start with smaller programs to experiment with:

• Color detection
• Importing functions and running them.

[PollyJSk8]

Thank you. This is really helpful!

[BertLindeman]

Small thing next to the solid advice from Laurens:
If you want to use the CENTER button in your program,
you want to replace it by another button or None.

Something like:

hub.system.set_stop_button(None)