Encountering problems with the swarm

[Snort0Vaulter]

Hello, so i am a student in a university, and we were given a project to make a drone show with the crazyflie 2.1, later down you'll find the code i wrote to make two drones fly diamatrically opposed in a circle, however we are finding problems with the drones, as sometimes one of the drones flips back on its head and falls, and we don't understand exactly how to create trajectories, so any help is welcome thank you.

here is the code :

import logging
import time
import math as m
import numpy as np
import cflib.crtp
from cflib.crazyflie.swarm import CachedCfFactory
from cflib.crazyflie.swarm import Swarm

from threading import Event 
import cflib.crazyflie
import cflib.crtp
from cflib.crazyflie import high_level_commander
from cflib.crazyflie import Crazyflie
from cflib.crazyflie.log import LogConfig
from cflib.crazyflie.syncCrazyflie import SyncCrazyflie
import cflib.positioning
from cflib.positioning.motion_commander import MotionCommander
import cflib.positioning.motion_commander
from cflib.utils import uri_helper


uris_copter_1 = 'radio://0/100/2M/E7E7E7E7E1' #adress of the first crazyflie
uris_copter_2 = 'radio://0/100/2M/E7E7E7E7E2' #adress of the second crazyflie

uris = {
    uris_copter_1,
    uris_copter_2
}

deck_attached_event = Event()

logging.basicConfig(level=logging.ERROR)

def activate_led_bit_mask(scf):
    scf.cf.param.set_value('led.bitmask', 255)

def deactivate_led_bit_mask(scf):
    scf.cf.param.set_value('led.bitmask', 0)

def light_check(scf):
    activate_led_bit_mask(scf)
    time.sleep(2)
    deactivate_led_bit_mask(scf)
    time.sleep(2)

def simple_connect():

    print("Yeah, I'm connected! :D")
    time.sleep(1)
    print("Now I will disconnect :'(")

def param_deck_flow(_, value_str):
    value = int(value_str)
    print(value)
    if value:
        deck_attached_event.set()
        print('Deck is attached!')
    else:
        print('Deck is NOT attached!')


def generate_sequence(x0,duration,hauteur,angle0,direction): #function to generate a sequence of points
    
    theta=np.linspace(0,2*m.pi,1500); radius=0.2
    sequence = []
    Y = np.zeros(len(theta))
    Z = np.zeros(len(theta))
    for i in range(1,len(theta)):
        Y[i]=radius*m.cos(theta[i]+angle0) # angle0 is there to change the position of the initial point, to another location on the circle
        Z[i]=direction*radius*m.sin(theta[i])+hauteur # hauteur is the height at which the center of the circle is found, as for direction it's either +1 or -1, for counterclockwise and clockwise respectively
        sequence.append([x0,Y[i],Z[i],duration])
    return sequence

"""sequence_1 = generate_sequence(x0=0.3,duration=0.001,hauteur=0.5,angle0=0,direction=1)
sequence_2 = generate_sequence(0.3,0.001,0.5,m.pi,1)

seq_args = {
    'radio://0/80/2M/E7E7E7E7E0':[sequence_1],
    'radio://0/80/2M/E7E7E7E7E9':[sequence_2],
}"""



def run_sequence(scf : SyncCrazyflie,sequence):

    for arguments in sequence:
        commander = scf.cf.high_level_commander
        x,y,z = arguments[0],arguments[1],arguments[2]
        duration = arguments[3]

        commander.go_to(x,y,z,0,duration)
        time.sleep(duration)
    commander.land(0,3)

def take_off(scf):
    commander= scf.cf.high_level_commander

    commander.takeoff(1.0, 2.0)
    time.sleep(3)

def land(scf):
    commander= scf.cf.high_level_commander

    commander.land(0.0, 2.0)
    time.sleep(2)

    commander.stop()

def hover_sequence(scf):
    take_off(scf)
    land(scf)

if __name__ == '__main__':
    cflib.crtp.init_drivers()
    
    with SyncCrazyflie(uris_copter_1, cf=Crazyflie(rw_cache = './chache')) as scf :
        scf.cf.high_level_commander.takeoff(0.5,2)
        time.sleep(2)
    with SyncCrazyflie(uris_copter_2, cf=Crazyflie(rw_cache = './chache')) as scf :
        scf.cf.high_level_commander.takeoff(0.5,2)
        time.sleep(2)

    factory = CachedCfFactory(rw_cache='./cache')
    with Swarm(uris,factory=factory) as swarm:

        swarm.reset_estimators()

        swarm.parallel_safe(light_check)
        sequence_1 = generate_sequence(x0=0.5,duration=0.001,hauteur=0.5,angle0=0,direction=1)
        sequence_2 = generate_sequence(x0=0.5,duration=0.001,hauteur=1.1,angle0=m.pi,direction=1)

        seq_args = {
            'radio://0/100/2M/E7E7E7E7E1':[sequence_2],
            'radio://0/100/2M/E7E7E7E7E2':[sequence_1],
        }

        swarm.parallel_safe(run_sequence,args_dict=seq_args)

[Bananazooka]

Hi! First of all, what positioning system are you using? Do you manage to fly the "jumpy" drone alone without any problems?

[Snort0Vaulter]

hello, thank you for your response, for the positioning system we are using two Lighthouse basestations V2.0, and yes when we fly the drones individually we have no problem at all, we thought we found a band-aid solution, by first initiating two different instances of the crazyflies, put them in the air, then engage the swarm, sometimes it worked, other times one of the drones just fliped on it head.

[ToveRumar]

Hi!

This is a tricky question to answer. Have you seen any pattern for when the drones flips? Is there a particular position or situation where they flip more times than others?
I would to some extra precautions to make sure it is not the system that is wrongly calibrated. Make sure that the positions of the base stations is exact, and that the drones can see both stations etc. However since it works well with one drone it looks like the issue is something else.

I think we would need some more input from more people in the team, to be able to narrow down the issue.
However we are entering the Holiday season and his means that the response might be a bit delayed.

I hope this answer helps you a bit forward in trying to understand this issue.