2 trains and a switch track

[captshadab]

hello
i have been trying to make this work since last 2 days but have failed

i have 2 trains
master and slave

one loop with a switch at one end.

color sensors installed in both trains

program i need to work

master runs and stops at black tile
broadcasts REQUEST_RUN

slave train runs when it receives this command
slave see the red tile
stops and broadcasts RUN_COMPLETE

also the switch track motor is configured to turn when these commands are received

my code

master train

from pybricks.pupdevices import DCMotor, Motor, Remote, Light
from pybricks.parameters import Port, Stop, Button, Color
from pybricks.hubs import CityHub
from pybricks.tools import wait, StopWatch
from pybricks.iodevices import PUPDevice
from pybricks.pupdevices import ColorDistanceSensor 
from uerrno import ENODEV
from pybricks.parameters import *  # Color

# -----------------------------------------------
#  Set user defined values
# -----------------------------------------------

# define the two profiles
# profil_x = (minimun speed,maximum Speed,accelerate in steps of ..., wait for next acceleration(in ms)

Profil_A = (20,100,10,100)  #min,max,step,acc
Profil_B = (10,500,5,200)   #min,max,step,acc

# define direction of motors

dirMotorA = 1       # Direction 1 or -1
dirMotorB = -1       # Direction 1 or -1

autoacc = True      # accelarate continously when holding butten 

lightValue = 0      # the initial light value, any number between 0 and 100

shouldBroadcast = True    # whether the hub should broadcast data for a second hub to observe

broadcastChannel = 1    # channel number to broadcast on (0 to 255). Needs to match the value the second hub is observing.
CHANNEL = 2

hub = CityHub(broadcast_channel=1, observe_channels=[CHANNEL])
sensor = ColorDistanceSensor(Port.B)

watch = StopWatch()
watch.reset()
last_delta = 0  # in milliseconds

plate_timestamps = {}
plate_index = None
previous_plate_index = None

last_command_processed = None

slave_data = hub.ble.observe(2)
# -----------------------------------------------
#  Set general values
# -----------------------------------------------

# assign buttons to function1 
# syntax: function = "name"
# name may  be "A+","A-","A0","B+","B-","B0","CENTER"

UP = "A+"
DOWN = "A-"
STOP = "A0"
SWITCH = "CENTER"
BUP = "B+"
BDOWN = "B-"
BSTOP = "B0"

mode=1              # start with function number...
watchdog = False    # "True" or "False": Stop motors when loosing remote connection
remoteTimeout =50   # hub waits x seconds for remote connect after starting hub
remoteName = ""     # connect this remote only

# Color and brightness of Hub LEDs
LEDconn = Color.GREEN*0.3       # if Hub connected, color * brightness
LEDnotconn = Color.RED*0.5      # if Hub is not connect, color * brightness

LED_A = Color.GREEN*0.3       # Remote Profil_A, color * brightness
LED_B = Color.RED*0.5      # Remote Profil_B, color * brightness

auto_mode_speed = 50

# -----------------------------------------------
#  function 1 / drive motors
# -----------------------------------------------

def function1():

    vmax = profile[mode].vmax
    vmin = profile[mode].vmin
    accdelay =  profile[mode].acc
    step = profile[mode].step
  
    global v
   
    if CheckButton(UP) and not CheckButton(STOP) : 
        for x in range (1, step + 1):
            v = v + 1
            if v > vmax :
                v = vmax
            if v > 0 and v < vmin:    
                v = vmin
            if abs(v) < vmin:
                v = 0
            drive()
            wait (accdelay)  
            if v==0: 
                break 
        # further acceleration if button keeps pressed
        while autoacc == False and CheckButton(UP) :    
            wait (100)
        # avoid changing direction when reaching "0"     
        while v == 0 and  CheckButton(UP):  
            wait (100)

    if CheckButton(DOWN) and not CheckButton(STOP):
        for x in range (1, step + 1):
            v = v-1
            if v < vmax*-1 :
                v = vmax*-1
            if v < 0 and v > vmin*-1:    
                v = vmin*-1
            if abs(v) < vmin :
                v = 0   
            drive()
            wait (accdelay)  
            if v==0: 
                break 
        # further acceleration if button keeps pressed
        while autoacc == False and CheckButton(DOWN) :    
            wait (100)
        # avoid changing direction when reaching "0"
        while v == 0 and  CheckButton(DOWN) :    
            wait (100)
  
    if CheckButton(STOP):
        global auto_mode, auto_mode_active

        if v != 0 or auto_mode:  # If moving in manual or auto mode is active
            auto_mode = False
            auto_mode_active = False
            v = 0
            drive()
            print("Train stopped. Auto Mode OFF.")
        else:  # Train is stopped, toggle auto mode ON
            auto_mode = True
            auto_mode_active = False
            auto_state = "running"
            auto_timer.reset()
            v = auto_mode_speed
            drive()
            print("Auto Mode Started.")

        wait(500)  # Debounce

 
        
class setprofile():
    def __init__(self,pr):
        self.vmin=pr[0]
        self.vmax=pr[1]
        self.step=pr[2]
        self.acc=pr[3]

profile = [0,0,0]
profile[1] = setprofile(Profil_A)
profile[2] = setprofile(Profil_B)

# -----------------------------------------------
#  function 2
# -----------------------------------------------
           
'''
def function2():
    if CheckButton(UP):
        timer[1].set(3000)
    if timer[1].check(): 
        print("Do something")
'''

# -----------------------------------------------
# updateLights
# -----------------------------------------------

def updateLights():
    global lightValue
    max = 100;
    min = 0;
    step = 10;

    waitBetweenSteps = 0;

    if CheckButton(BUP) and not CheckButton(BSTOP) :
        waitBetweenSteps = 100
        lightValue += step

    if CheckButton(BDOWN) and not CheckButton(BSTOP) :
        waitBetweenSteps = 100
        lightValue -= step

    if CheckButton(BSTOP) :
        waitBetweenSteps = 300
        if lightValue == min :
            lightValue = max
        else :
            lightValue = min
    
    if lightValue > max:
        lightValue = max
    if lightValue < min:
        lightValue = min

    
    if hasLights:
        for x in range(1,3):
            if motor[x].getType() == "Light":
                if lightValue == min:
                    motor[x].obj.off()
                else:
                    motor[x].obj.on(lightValue)

    wait (waitBetweenSteps)


# -----------------------------------------------
# general program routines and classes
# -----------------------------------------------

# ----CheckButton -------------------------------------------

def CheckButton(x):
    try:
        button = remote.buttons.pressed()
        if x == "A+"  : x = Button.LEFT_PLUS
        if x == "A-" : x = Button.LEFT_MINUS
        if x == "A0"  : x = Button.LEFT

        if x == "B+"  : x = Button.RIGHT_PLUS
        if x == "B-" : x = Button.RIGHT_MINUS
        if x == "B0"  : x = Button.RIGHT
    
        if x == "CENTER"  : x = Button.CENTER
        
        if x in button:
            return True
        else:
            return False
    except:
        return()

# ----delay -------------------------------------------

class delay:
    def __init__(self,id,time=0,watch=StopWatch(),busy=False):
        self.id=id
        self.time=time
        self.watch=watch
        self.busy=busy
        print ("Init Timer",id)
    # set a timer        
    def set(self,x):
        if  self.busy == False:
            self.busy = True
            self.watch.reset()
            self.time = x
            print("Timer",timer[1].id, "set to",x)
    #check if timer is reached, then return "True"
    def check(self):
        if self.busy == True:
            if self.watch.time() > self.time:
                self.busy = False
                self.time=0 
                print("Timer",timer[1].id, "stopped")
                return(True)
        else:
            return(False)

# ----drive -------------------------------------------

def drive():
    global vold
    global v
    
    
    if vold != v:
        # for each motor 1,2 
        for x in range(1,3):
            # set speed and direction
            s = v*round(motor[x].getDir())
            # real motor commands depending on motor type
            if motor[x].getType() == "Motor" :
                motor[x].obj.run(s*motor[x].getSpeed()) #  in 2.7
            if motor[x].getType() == "DCMotor" : 
                motor[x].obj.dc(s) 
            if v == 0 and (motor[x].getType() == "Motor" or motor[x].getType() == "DCMotor"):  
                print("stop",x)
                motor[x].obj.stop()      
            #if motor[x].getDir() != 0 and motor[x].getType() == "DCMotor" : motor[x].obj.dc(s) 
        vold = v
            
# ----portcheck -------------------------------------------

def portcheck(i):
    # list of motors, 1 +2 contain string "DC"
    devices = {
    1: "Wedo 2.0 DC Motor",
    2: "Train DC Motor",
    8: "Light",
    37: "Color & Distance Sensor",
    38: "BOOST Interactive Motor",
    46: "Technic Large Motor",
    47: "Technic Extra Large Motor",
    48: "SPIKE Medium Angular Motor",
    49: "SPIKE Large Angular Motor",
    75: "Technic Medium Angular Motor",
    76: "Technic Large Angular Motor",
}
    port = motor[i].getPort()
    # Try to get the device, if it is attached.
    try:
        device = PUPDevice(port)
    except OSError as ex:
        if ex.args[0] == ENODEV:
            # No device found on this port.
            motor[i].setType("---")
            print(port, ": not connected")
            return ("---")
        else:
            raise

    # Get the device id
    id = device.info()['id']
    
    # Look up the name.
    try:
        # get the attributes for tacho motors
        if "Motor" in devices[id] and not("DC" in devices[id]): 
            motor[i].setType("Motor")
            motor[i].obj = Motor(port)

            #new in 2.7
            # if motor[x].getDir() != 0 and motor[x].getType() == "Motor" : motor[x].obj.run(s*motor[x].getSpeed()) #  in 2.7
            devs_max_speed = {38:1530,46:1890,47:1980,48:1367,49:1278,75:1367,76:1278 }
            dspeed = devs_max_speed.get(PUPDevice(port).info()['id'], 1000)
            motor[i].obj.stop()
            motor[i].obj.control.limits(speed=dspeed,acceleration=10000)
            motor[i].setSpeed(dspeed/100*0.9)

        # and set type for simple DC Motors    
        if "DC" in devices[id]:
            motor[i].setType("DCMotor")
            motor[i].obj = DCMotor(port)

        if "Light" in devices[id]:
            motor[i].setType("Light")
            motor[i].obj = Light(port)
            if lightValue > 0:
                motor[i].obj.on(lightValue)

            global hasLights
            hasLights = True

        wait(100)    
        print ("--")
        print(port, ":", devices[id], motor[i].getType(),motor[i].getSpeed(),motor[i].getAcc())
    except KeyError:
        motor[i].setType("unkown")
        print(port, ":", "Unknown device with ID", id)
    


# ---- device  -------------------------------------------
    
class device():
    # store the device infos for each motor
    def __init__(self,port,dir):
        self.port = port
        self.dir = dir
        self.type=""
        self.speed=99
        self.acc=99
        self.obj=""
                
    def setType(self,x) : self.type = x
    def setSpeed(self,x): self.speed = x
    def setAcc(self,x)  : self.acc = x
    
    def getType(self)   : return self.type
    def getPort(self)   : return self.port
    def getDir(self)    : return self.dir
    def getSpeed(self)  : return self.speed
    def getAcc(self)    : return self.acc

# -----------------------------------------------
# globals
# -----------------------------------------------
auto_mode = False
auto_mode_active = False
auto_timer = StopWatch()
auto_state = "stopped"

v = 0
vold = 0
#remoteConnected = False

# -----------------------------------------------
# Ininitialize
# -----------------------------------------------


#define timers
timer = [0,0,0]
timer[1] = delay(1)
timer[2] = delay(2)
           
#define motors
motor = [0,0,0]
motor[1] = device(Port.A,dirMotorA)
motor[2] = device(Port.B,dirMotorB)

hasLights = False

# get the port properties
portcheck(1)
portcheck(2)    


# HSV to RGB conversion function
def hsv_to_rgb(hsv):
    h, s, v = hsv[0], hsv[1] / 100, hsv[2] / 100
    c = v * s
    h1 = h / 60
    x = c * (1 - abs(h1 % 2 - 1))
    if h1 < 1:
        r1, g1, b1 = c, x, 0
    elif h1 < 2:
        r1, g1, b1 = x, c, 0
    elif h1 < 3:
        r1, g1, b1 = 0, c, x
    elif h1 < 4:
        r1, g1, b1 = 0, x, c
    elif h1 < 5:
        r1, g1, b1 = x, 0, c
    else:
        r1, g1, b1 = c, 0, x

    m = v - c
    return (int((r1 + m) * 255), int((g1 + m) * 255), int((b1 + m) * 255))



# -----------------------------------------------
# remote connect
# -----------------------------------------------

hub.light.on(Color.RED)
print (hub.system.name())
try:
    remote = Remote(name=remoteName,timeout=remoteTimeout*1000)
except OSError as ex:
    hub.system.shutdown()

# -----------------------------------------------
# main loop
# -----------------------------------------------

def auto_mode_function():
    global auto_mode_active, auto_timer, auto_state, v, last_command_processed

    if not auto_mode:
        auto_mode_active = False
        return

    if not auto_mode_active:
        auto_mode_active = True
        print("Auto Mode Started")

    # Read sensor
    hsv = sensor.hsv()
    rgb = hsv_to_rgb(hsv)
    r, g, b = hsv_to_rgb(hsv)
    # --- Dark patch detected ---
    if r < 50 and g < 50 and b < 50:
        v = 0
        drive()  # Stop immediately

        print("\nDark patch detected. Sending 'REQUEST_RUN'...")
        for i in range(5):
            hub.ble.broadcast(b"REQUEST_RUN")
            wait(100) # Wait for 100 milliseconds
        
    

        # --- STAGE 1: Wait for Acknowledgment ---
        waiting_for_ack = True
        print("Waiting for ACK from slave...")
        while waiting_for_ack:
            data = hub.ble.observe(2)
            if data == b"ACK_RUN":
                print("Received 'ACK_RUN'. Slave is running.")
                waiting_for_ack = False
            wait(20)

        # --- STAGE 2: Wait for Completion ---
        waiting_for_completion = True
        while waiting_for_completion:
            data = hub.ble.observe(2)
            if data == b"RUN_COMPLETE":
                print("Received 'RUN_COMPLETE'. Resuming master...")
                v = auto_mode_speed  # Resume speed
                drive()
                waiting_for_completion = False
            wait(20)
    else:
        # Normal auto mode speed
        v = auto_mode_speed
        drive()

   
# ---- broadcast -----------------------------------------


while True:
    

    wait(10)
   
    # --check if remote is connected ---------------------------------
    
    try:
        button = remote.buttons.pressed()
        hub.light.on(LEDconn)
        remoteConnected = True
    except OSError as ex:
        hub.light.on(LEDnotconn)
        print("Remote not connected")
        remoteConnected = False
       
        if watchdog == True:
            v=0
            drive()
        try:
            # reconnect remote
            remote = Remote(timeout=1000)
            wait(100)
            print("Remote reconnected")
            remoteConnected = True
        except OSError as ex:
            print("Remote not connected")

            
    if CheckButton(SWITCH):
        mode = mode+1
        if mode > 2: 
            mode = 1
        print (mode)
        if mode == 1 : remote.light.on(LED_A)
        if mode == 2 : remote.light.on(LED_B)    
   
        while CheckButton(SWITCH):
            button = remote.buttons.pressed()
            wait (100)

    if mode == 1 : function1()     
    if mode == 2 : function1()

    if hasLights or shouldBroadcast : updateLights()
    
    if auto_mode:
        auto_mode_function()

                    
                

    wait(10)
    

slave train

from pybricks.pupdevices import DCMotor, Motor, Remote, Light
from pybricks.parameters import Port, Stop, Button, Color
from pybricks.hubs import CityHub
from pybricks.tools import wait, StopWatch
from pybricks.iodevices import PUPDevice
from pybricks.pupdevices import ColorDistanceSensor 
from uerrno import ENODEV
from pybricks.parameters import *  # Color

# --- Configuration ---
MOTOR_PORT = Port.A
SENSOR_PORT = Port.B 
MOTOR_POWER = -60

last_command_processed = None

# --- Initialization ---
hub = CityHub(broadcast_channel=2, observe_channels=[1])
motor = DCMotor(MOTOR_PORT)
sensor = ColorDistanceSensor(SENSOR_PORT)



# HSV to RGB conversion function
def hsv_to_rgb(hsv):
    h, s, v = hsv[0], hsv[1] / 100, hsv[2] / 100
    c = v * s
    h1 = h / 60
    x = c * (1 - abs(h1 % 2 - 1))
    if h1 < 1:
        r1, g1, b1 = c, x, 0
    elif h1 < 2:
        r1, g1, b1 = x, c, 0
    elif h1 < 3:
        r1, g1, b1 = 0, c, x
    elif h1 < 4:
        r1, g1, b1 = 0, x, c
    elif h1 < 5:
        r1, g1, b1 = x, 0, c
    else:
        r1, g1, b1 = c, 0, x

    m = v - c
    return (int((r1 + m) * 255), int((g1 + m) * 255), int((b1 + m) * 255))



print("✅ Slave train with Handshake Protocol ready.")
print("Waiting for 'REQUEST_RUN' on channel 1...")

# --- Main Loop ---
while True:
    data = hub.ble.observe(1)

    if data and data != last_command_processed:
        last_command_processed = data

        if data == b"REQUEST_RUN":
            # (ACK and motor run logic is the same)
            # ...
            hub.ble.broadcast(b"ACK_RUN")
            motor.dc(MOTOR_POWER)
            while True:
                hsv = sensor.hsv()
                rgb = hsv_to_rgb(hsv)
                r, g, b = hsv_to_rgb(hsv)
                if r > 170 and g < 25 and b < 25:
                    break
                wait(5)
            motor.stop()

            # Tell the master the run is complete (on channel 2)
            for i in range(5):
                hub.ble.broadcast(b"RUN_COMPLETE")
                wait(100) # Wait for 100 milliseconds

            
            print("\nSequence complete. Waiting for next request...")
        
        # FIX: The logic for STANDBY is no longer needed.
        # elif data == b"STANDBY":
        #    print("Received STANDBY from master. Ready for new cycle.")

    wait(10)

it does work like 1 or 2 times and then just nothing happens. both trains remain stopped

please help me solve this thing. my first ever train set and i want it to work
MASTER_SWITCHTRACK.py
Slave.py