def setUp(self):
self.uri = uri_helper.uri_from_env(default='radio://0/80/2M/E7E7E7E7E7')
self.cf_mock = MagicMock(spec=Crazyflie)
self.cf_mock.connected = Caller()
self.cf_mock.connection_failed = Caller()
self.cf_mock.disconnected = Caller()
self.cf_mock.open_link = AsyncCallbackCaller(
cb=self.cf_mock.connected,
args=[self.uri],
delay=0.2
).trigger
self.close_link_mock = AsyncCallbackCaller(
cb=self.cf_mock.disconnected,
args=[self.uri],
delay=0.2
)
self.cf_mock.close_link = self.close_link_mock.trigger
# Mock the behaviour that param values are updated(downloaded) after connection
self.param_mock = MagicMock(spec=Param)
self.param_mock.all_updated = Caller()
self.cf_mock.param = self.param_mock
# Register a callback to be called when connected. Use it to trigger a callback
# to trigger the call to the param.all_updated() callback
self.cf_mock.connected.add_callback(self._connected_callback)
self.sut = SyncCrazyflie(self.uri, cf=self.cf_mock)
def __init__(self, crazyflie=None):
"""Instantiate class and connect callbacks"""
self.mems = []
# Called when new memories have been added
self.mem_added_cb = Caller()
# Called when new data has been read
self.mem_read_cb = Caller()
self.mem_write_cb = Caller()
self.cf = crazyflie
self.cf.add_port_callback(CRTPPort.MEM, self._new_packet_cb)
self._refresh_callback = None
self._fetch_id = 0
self.nbr_of_mems = 0
self._ow_mem_fetch_index = 0
self._elem_data = ()
self._read_requests = {}
self._read_requests_lock = Lock()
self._write_requests = {}
self._write_requests_lock = Lock()
self._ow_mems_left_to_update = []
self._getting_count = False
def __init__(self, crazyflie, logconf):
self.dataReceived = Caller()
self.error = Caller()
self.logconf = logconf
self.blockId = LogEntry.blockIdCounter
LogEntry.blockIdCounter += 1
self.cf = crazyflie
self.period = logconf.getPeriod() / 10
self.blockCreated = False
def __init__(self, crazyflie, logconf):
"""Initialize the entry"""
self.data_received = Caller()
self.error = Caller()
self.logconf = logconf
self.block_id = LogEntry.block_idCounter
LogEntry.block_idCounter += 1
self.cf = crazyflie
self.period = logconf.getPeriod() / 10
self.block_created = False
def setUp(self):
self.cf_mock = MagicMock(spec=Crazyflie)
self.cf_mock.disconnected = Caller()
self.log_mock = MagicMock(spec=Log)
self.cf_mock.log = self.log_mock
self.log_config_mock = MagicMock(spec=LogConfig)
self.log_config_mock.data_received_cb = Caller()
self.sut = SyncLogger(self.cf_mock, self.log_config_mock)
def setUp(self):
self.uri = 'radio://0/60/2M'
self.cf_mock = MagicMock(spec=Crazyflie)
self.cf_mock.connected = Caller()
self.cf_mock.connection_failed = Caller()
self.cf_mock.disconnected = Caller()
self.cf_mock.open_link = AsyncCallbackCaller(cb=self.cf_mock.connected,
args=[self.uri]).trigger
self.sut = SyncCrazyflie(self.uri, self.cf_mock)
def __init__(self, crazyflie=None):
self.log_blocks = []
# Called with newly created blocks
self.block_added_cb = Caller()
self.cf = crazyflie
self.toc = None
self.cf.add_port_callback(CRTPPort.LOGGING, self._new_packet_cb)
self.toc_updated = Caller()
self.state = IDLE
self.fake_toc_crc = 0xDEADBEEF
def __init__(self, cf: Crazyflie) -> None:
self._cf = cf
self._cf.connected.add_callback(self._connected)
self._cf.disconnected.add_callback(self._disconnected)
self.data_received_cb = Caller()
self.error_cb = Caller()
# The pose is an array containing
# X, Y, Z, roll, pitch, yaw
# roll, pitch and yaw in degrees
self.pose = self.NO_POSE
def add_update_callback(self, group, name=None, cb=None):
"""
Add a callback for a specific parameter name. This callback will be
executed when a new value is read from the Crazyflie.
"""
if not name:
if not group in self.group_update_callbacks:
self.group_update_callbacks[group] = Caller()
self.group_update_callbacks[group].add_callback(cb)
else:
paramname = "{}.{}".format(group, name)
if not paramname in self.param_update_callbacks:
self.param_update_callbacks[paramname] = Caller()
self.param_update_callbacks[paramname].add_callback(cb)
def __init__(self, crazyflie=None):
"""Instantiate class and connect callbacks"""
# Called when new memories have been added
self.mem_added_cb = Caller()
# Called when new data has been read
self.mem_read_cb = Caller()
self.mem_write_cb = Caller()
self.cf = crazyflie
self.cf.add_port_callback(CRTPPort.MEM, self._new_packet_cb)
self.cf.disconnected.add_callback(self._disconnected)
self._write_requests_lock = Lock()
self._clear_state()
def __init__(self, period, callback):
self._callbacks = Caller()
self._callbacks.add_callback(callback)
self._started = False
self._period = period
self._timer = Timer(period, self._expired)
self._timer.daemon = True
def __init__(self, crazyflie):
"""
Initialize the console and register it to receive data from the copter.
"""
self.receivedChar = Caller()
self.cf = crazyflie
self.cf.add_port_callback(CRTPPort.CONSOLE, self.incoming)
def __init__(self, crazyflie):
self.cf = crazyflie
self.param_update_callbacks = {}
self.group_update_callbacks = {}
self.all_update_callback = Caller()
self.param_updater = None
self.param_updater = _ParamUpdater(self.cf, self._param_updated)
self.param_updater.start()
self.cf.disconnected.add_callback(self.param_updater.close)
self.all_updated = Caller()
self._have_updated = False
self.values = {}
def __init__(self, parent=None):
super(QtCore.QObject, self).__init__(parent)
self.parent = parent
self.useBaro = False # Using barometer for current recovery
self.useBaroNext = False # Use barometer for next recovery
self.falling = False # Free fall Recovery active
self.kill = False
self.boostMSec = 45 # Max thrust for first 30ms. State also keeps track of mode, see step()
self.nr = 0 # step nr during non baro mode
self.falloff = FallOff(self)
# why the hell do we mix signals like this?
self.auto_input_updated = Caller()
self.althold_updated = Caller()
self.timerOut = QtCore.QTimer()
def __init__(self, crazyflie):
"""
Initialize the console and register it to receive data from the copter.
"""
self.receivedChar = Caller()
"""
This member variable is used to setup a callback that will be called
when text is received from the CONSOLE port of CRTP (0).
Example:
```python
[...]
def log_console(self, text):
self.log_file.write(text)
[...]
self.cf.console.receivedChar.add_callback(self.log_console)
```
"""
self.cf = crazyflie
self.cf.add_port_callback(CRTPPort.CONSOLE, self._incoming)
def __init__(self, crazyflie=None):
"""
Initialize the Extpos object.
"""
self._cf = crazyflie
self.receivedLocationPacket = Caller()
self._cf.add_port_callback(CRTPPort.LOCALIZATION, self._incoming)
class ConfigManager():
""" Singleton class for managing input processing """
conf_needs_reload = Caller()
configs_dir = sys.path[1] + "/input"
__metaclass__ = Singleton
def __init__(self):
"""Initialize and create empty config list"""
self._list_of_configs = []
def get_config(self, config_name):
"""Get the configuration for an input device."""
try:
idx = self._list_of_configs.index(config_name)
return self._input_config[idx]
except:
return None
def get_list_of_configs(self):
"""Reload the configurations from file"""
try:
configs = [
os.path.basename(f)
for f in glob.glob(self.configs_dir + "/[A-Za-z]*.json")
]
self._input_config = []
self._list_of_configs = []
for conf in configs:
logger.info("Parsing [%s]", conf)
json_data = open(self.configs_dir + "/%s" % conf)
data = json.load(json_data)
new_input_device = {}
for a in data["inputconfig"]["inputdevice"]["axis"]:
axis = {}
axis["scale"] = a["scale"]
axis["type"] = a["type"]
axis["key"] = a["key"]
axis["name"] = a["name"]
try:
ids = a["ids"]
except:
ids = [a["id"]]
for id in ids:
locaxis = copy.deepcopy(axis)
if "ids" in a:
if id == a["ids"][0]:
locaxis["scale"] = locaxis["scale"] * -1
locaxis["id"] = id
# 'type'-'id' defines unique index for axis
index = "%s-%d" % (a["type"], id)
new_input_device[index] = locaxis
self._input_config.append(new_input_device)
json_data.close()
self._list_of_configs.append(conf[:-5])
except Exception as e:
logger.warning("Exception while parsing inputconfig file: %s ", e)
return self._list_of_configs
def setUp(self):
self.uri = uri_helper.uri_from_env(
default='radio://0/80/2M/E7E7E7E7E7')
self.cf_mock = MagicMock(spec=Crazyflie)
self.cf_mock.connected = Caller()
self.cf_mock.connection_failed = Caller()
self.cf_mock.disconnected = Caller()
self.cf_mock.open_link = AsyncCallbackCaller(cb=self.cf_mock.connected,
args=[self.uri],
delay=0.2).trigger
self.close_link_mock = AsyncCallbackCaller(
cb=self.cf_mock.disconnected, args=[self.uri], delay=0.2)
self.cf_mock.close_link = self.close_link_mock.trigger
self.sut = SyncCrazyflie(self.uri, self.cf_mock)
def __init__(self, name, period_in_ms):
"""Initialize the entry"""
self.data_received_cb = Caller()
self.error_cb = Caller()
self.started_cb = Caller()
self.added_cb = Caller()
self.err_no = 0
self.id = 0
self.cf = None
self.period = int(period_in_ms / 10)
self.period_in_ms = period_in_ms
self._added = False
self._started = False
self.valid = False
self.variables = []
self.default_fetch_as = []
self.name = name
def add_update_callback(self, paramname, cb):
"""
Add a callback for a specific parameter name. This callback will be
executed when a new value is read from the Crazyflie.
"""
if ((paramname in self.paramUpdateCallbacks) is False):
self.paramUpdateCallbacks[paramname] = Caller()
self.paramUpdateCallbacks[paramname].add_callback(cb)
def __init__(self):
self.cf = None
self.menu = None
self.logConfigReader = None
self.referenceHeight = 0.400
self.hover_input_updated = Caller()
self.useReferenceHeight = False
self.inputType = 0
self.inputTimer = 0.000
self.sinewaveFrequency = 1.0 # 1s
def __init__(self, name, period_in_ms):
"""Initialize the entry"""
self.data_received_cb = Caller()
self.error_cb = Caller()
self.started_cb = Caller()
self.added_cb = Caller()
self.err_no = 0
self.id = LogConfig._config_id_counter
LogConfig._config_id_counter = (LogConfig._config_id_counter + 1) % 255
self.cf = None
self.period = period_in_ms / 10
self.period_in_ms = period_in_ms
self._added = False
self._started = False
self.valid = False
self.variables = []
self.default_fetch_as = []
self.name = name
def __init__(self, crazyflie=None):
self.logBlocks = []
self.cf = crazyflie
self.cf.add_port_callback(CRTPPort.LOGGING, self._new_packet_cb)
self.tocUpdated = Caller()
self.state = IDLE
self.fakeTOCCRC = 0xBABEBABA
def __init__(self,
drone_id: str,
radio_id: int = 0,
channel: int = 80,
address: str = "E7E7E7E7E7",
data_rate: str = "2M"):
""" Initializes the drone with the given uri."""
# Initialize public variables
self.id: str = drone_id
self.var_x: float = 0
self.var_y: float = 0
self.var_z: float = 0
self.pos_x: float = 0
self.pos_y: float = 0
self.pos_z: float = 0
self.yaw: float = 0
self.battery_voltage: float = 0
self.is_connected: bool = False
self.status: DroneState = DroneState.OFFLINE
self.link_uri: str = "radio://" + str(radio_id) + "/" + str(
channel) + "/" + data_rate + "/" + address
# Initialize limits
self._max_velocity: float = 0.2
self._min_duration: float = 1
self._max_yaw_rotations: float = 1
self._arena: Arena = Arena()
# Event to asynchronously wait for the connection
self._connect_event = threading.Event()
# Initialize the crazyflie
self._cf = Crazyflie(rw_cache='./cache')
# Initialize the callbacks
self._cf.connected.add_callback(self._connected)
self._cf.disconnected.add_callback(self._disconnected)
self._cf.connection_failed.add_callback(self._connection_failed)
self._cf.connection_lost.add_callback(self._connection_lost)
# Initialize events
self.drone_lost = Caller()
# Define the log configuration
self._log_config_1 = LogConfig(name='DroneLog_1', period_in_ms=500)
self._log_config_1.add_variable('kalman.varPX', 'float')
self._log_config_1.add_variable('kalman.varPY', 'float')
self._log_config_1.add_variable('kalman.varPZ', 'float')
self._log_config_1.add_variable('pm.vbat', 'float')
self._log_config_2 = LogConfig(name='DroneLog_2', period_in_ms=500)
self._log_config_2.add_variable('kalman.stateX', 'float')
self._log_config_2.add_variable('kalman.stateY', 'float')
self._log_config_2.add_variable('kalman.stateZ', 'float')
self._log_config_2.add_variable('stabilizer.yaw', 'float')
def __init__(self, do_device_discovery=True):
# TODO: Should be OS dependant
self.inputdevice = PyGameReader()
self.maxRPAngle = 0
self.thrustDownSlew = 0
self.thrustSlewEnabled = False
self.slewEnableLimit = 0
self.maxYawRate = 0
self.detectAxis = False
self.emergencyStop = False
self.oldThrust = 0
self._trim_roll = Config().get("trim_roll")
self._trim_pitch = Config().get("trim_pitch")
# TODO: The polling interval should be set from config file
self.readTimer = PeriodicTimer(0.01, self.readInput)
if do_device_discovery:
self._discovery_timer = PeriodicTimer(1.0,
self._do_device_discovery)
self._discovery_timer.start()
self._available_devices = {}
# Check if user config exists, otherwise copy files
if not os.path.isdir(ConfigManager().configs_dir):
logger.info("No user config found, copying dist files")
os.makedirs(ConfigManager().configs_dir)
for f in glob.glob(sys.path[0] +
"/cfclient/configs/input/[A-Za-z]*.json"):
shutil.copy2(f, ConfigManager().configs_dir)
ConfigManager().get_list_of_configs()
self.input_updated = Caller()
self.rp_trim_updated = Caller()
self.emergency_stop_updated = Caller()
self.device_discovery = Caller()
self.device_error = Caller()
def _clear_state(self):
self.mems = []
# Called when new memories have been added
self.mem_added_cb = Caller()
# Called to signal completion of read or write
self.mem_read_cb = Caller()
self.mem_read_failed_cb = Caller()
self.mem_write_cb = Caller()
self.mem_write_failed_cb = Caller()
self._refresh_callback = None
self._fetch_id = 0
self.nbr_of_mems = 0
self._ow_mem_fetch_index = 0
self._elem_data = ()
self._read_requests = {}
self._write_requests = {}
self._ow_mems_left_to_update = []
self._getting_count = False
def __init__(self, crazyflie):
self.toc = Toc()
self.cf = crazyflie
self._useV2 = False
self.param_update_callbacks = {}
self.group_update_callbacks = {}
self.all_update_callback = Caller()
self.param_updater = None
self.param_updater = _ParamUpdater(
self.cf, self._useV2, self._param_updated, crazyflie.on_params_flushed)
self.param_updater.start()
self.cf.disconnected.add_callback(self._disconnected)
self.all_updated = Caller()
self.is_updated = False
self.values = {}
def __init__(self, name, period_in_ms):
"""Initialize the entry"""
self.data_received_cb = Caller()
self.error_cb = Caller()
self.started_cb = Caller()
self.added_cb = Caller()
self.err_no = 0
# These 3 variables are set by the log subsystem when the bock is added
self.id = 0
self.cf = None
self.useV2 = False
self.period = int(period_in_ms / 10)
self.period_in_ms = period_in_ms
self._added = False
self._started = False
self.valid = False
self.variables = []
self.default_fetch_as = []
self.name = name
def __init__(self):
self.cf = None
self.menu = None
self.logConfigReader = None
self.referenceHeight = 0.400
self.hover_input_updated = Caller()
self.useReferenceHeight = False
self.inputType = 0
self.inputTimer = 0.000
self.sinewaveFrequency = 1.0 # 1s
self.mainUI = None
self.plotTab = None
self.pose_logger = None
self.connectivity_manager = None
self.init_time = time.time()
def setUp(self):
self.cf_mock = MagicMock(spec=Crazyflie)
self.log_config_mock = MagicMock(spec=LogConfig)
self.log_config_mock.data_received_cb = Caller()
self.log_mock = MagicMock(spec=Log)
self.cf_mock.log = self.log_mock
self.front_data = 2345
self.back_data = 2345
self.left_data = 123
self.right_data = 5432
self.up_data = 3456
self.down_data = 1212
self.log_data = {
self.FRONT: self.front_data,
self.BACK: self.back_data,
self.LEFT: self.left_data,
self.RIGHT: self.right_data,
self.UP: self.up_data,
self.DOWN: self.down_data,
}
