Swarm flight synchronization.

[sextta-feira]

I am trying to apply a sequence of actions to three drones, but I am facing some issues with the order of events. I have created a class for the drone and instantiated an object to call actions like take-off, flying, etc. For the flight, I am using a custom RST controller and the send_velocity_world_setpoint command, which works very well for a single drone. However, when applying it to three drones, I am encountering synchronization problems.

def run_sequence(scf, sequence):
    try:
        print(f'Crazyflie conectado: {scf.cf.link_uri}')
        drone1 = Drone({scf.cf.link_uri}, shared_state, data_log, scf)

        # Connects and configures the drone with the scf object
        drone1.connect(scf)

        synchronize_drones(scf.cf.link_uri, sincron_drone, all_drones_connected, scf)

        time.sleep(0.1)

        print(f"The position is: X = {drone1.position[x]}, Y = {drone1.position[y]}, Z = {drone1.position[z]}")

        positionX = sequence[0]
        positionY = sequence[1]

        
        print(f'The drone {scf.cf.link_uri} go fly to X = {positionX}, Y = {positionY}, Z = {sequence[2]}')
        
        drone1.take_off(positionX, positionY, sequence[2])

        drone1.center(positionX, positionY, sequence[2])

        synchronize_drones(scf.cf.link_uri, sincron_drone, all_drones_connected,scf)

        drone1.flying(positionX, positionY, sequence[3])

        synchronize_drones(scf.cf.link_uri, sincron_drone, all_drones_connected, scf)

        drone1.landing(positionX, positionY)


    except Exception as e:
        print(f"Error in {scf.cf.link_uri}: {e}")

if __name__ == '__main__':
    # Initializing internal drivers
    cflib.crtp.init_drivers()

    # Creates the shared state
    shared_state = SharedState()

    # Starts the thread to monitor the keyboard
    interface = InterfaceUtilizador(shared_state) # Creating the keyboard object
    interface_thread = threading.Thread(target=interface.monitor_keyboard, daemon=True)
    interface_thread.start()

    # Creating the controller object
    controller = Controller() 

    # Creates the SyncCrazyflie instance
    factory = CachedCfFactory(rw_cache='./cache')
    with Swarm(uris, factory=factory) as swarm:
        swarm.parallel(wait_for_param_download)
        swarm.parallel_safe(run_sequence, args_dict=seq_args)
        print("Execução paralela `concluída.")

I tried creating my own synchronization function, but it wasn’t very effective. I would like to know if the swarm has any built-in function to make the drones wait until they reach the same point in the code before continuing, or if there is a more effective way to perform swarm control.

[ToveRumar]

Hi @sextta-feira!

Since the parallel() functions spawns one thread per Crazyflie, its inherently asynchronous. You could sync the threads using maybe some semaphores or similar.
However i would suggest to change your program a little.
Instead of sending the full sequence to the parallel function, send bit by bit.

The parallel() function will join all threads before exiting, which means every call to parallel will end with the Crazyflies being synchronized.
This would mean you would do something like this.

swarm.parallel_safe(run_sequence, args_dict=first_part_of_sequence)
swarm.parallel_safe(run_sequence, args_dict=second_part_of_sequence)
swarm.parallel_safe(run_sequence, args_dict=third_part_of_sequence)

This should accomplish what I think you are asking for.

If you want to do more complex swarming using the Crazyflies i would suggest looking at Crazyswarm2 and Skybrush.