desc
stringlengths 3
26.7k
| decl
stringlengths 11
7.89k
| bodies
stringlengths 8
553k
|
|---|---|---|
'Stops all instances on this machine for a project.
Args:
project_id: A string specifying a project ID.'
| @staticmethod
def delete(project_id):
| if (not stop_app(project_id)):
raise HTTPError(HTTPCodes.INTERNAL_ERROR, 'Unable to stop application')
|
'Stops an AppServer instance on this machine.'
| @staticmethod
def delete(project_id, port):
| if (not stop_app_instance(project_id, int(port))):
raise HTTPError(HTTPCodes.INTERNAL_ERROR, 'Unable to stop instance')
|
'Load config from file'
| def load(self, recovery=False):
| try:
with open(self.filename) as f:
self.config = json.load(f)
logger.info('{} read'.format(self.filename))
except IOError:
self.config = {}
except ValueError:
if ((not recovery) and (self.failsafe_backups > 0) and self._recover_from_failsafe()):
return
raise
self.changed = False
|
'Load config from JSON string'
| def loads(self, json_str):
| self.config = json.loads(json_str)
self.changed = True
|
'Get item from config by path (list of keys)'
| def get_by_path(self, keys_list):
| return functools.reduce((lambda d, k: d[(int(k) if isinstance(d, list) else k)]), keys_list, self)
|
'Set item in config by path (list of keys)'
| def set_by_path(self, keys_list, value):
| self.get_by_path(keys_list[:(-1)])[keys_list[(-1)]] = value
self.changed = True
|
'Handle hangouts messages, preparing them to be sent to the
external service'
| def _handle_websync(self, bot, event, command):
| if isinstance(self.configuration, list):
for config in self.configuration:
try:
convlist = config['synced_conversations']
if (event.conv_id in convlist):
self._send_to_external_chat(bot, event, config)
except Exception as e:
logger.exception('EXCEPTION in _handle_websync')
|
'add tag to (type=conv|user|convuser) id'
| def add(self, type, id, tag):
| return self.update(type, id, 'set', tag)
|
'remove tag from (type=conv|user|convuser) id'
| def remove(self, type, id, tag):
| return self.update(type, id, 'remove', tag)
|
'completely remove the specified type (type="user|convuser|conv|tag|usertag|convtag") and label'
| def purge(self, type, id):
| remove = []
if ((type == 'user') or (type == 'convuser')):
for key in self.indices['user-tags']:
match_user = ((type == 'user') and ((key == id) or (id == 'ALL')))
match_convuser = (key.endswith(('|' + id)) or ((id == 'ALL') and ('|' in key)))
if (match_user or match_convuser):
for tag in self.indices['user-tags'][key]:
remove.append((('user' if match_user else 'convuser'), key, tag))
elif (type == 'conv'):
for key in self.indices['conv-tags']:
if ((key == id) or (id == 'ALL')):
for tag in self.indices['conv-tags'][key]:
remove.append(('conv', key, tag))
elif ((type == 'tag') or (type == 'usertag') or (type == 'convtag')):
if (type == 'usertag'):
_types = ['user']
elif (type == 'convtag'):
_types = ['conv']
else:
_types = ['conv', 'user']
for _type in _types:
_index_name = 'tag-{}s'.format(_type)
for tag in self.indices[_index_name]:
if ((tag == id) or (id == 'ALL')):
for key in self.indices[_index_name][tag]:
remove.append((_type, key, id))
else:
raise TypeError('{}'.format(type))
records_removed = 0
if remove:
for args in remove:
if self.remove(*args):
records_removed = (records_removed + 1)
return records_removed
|
'return active tags for conv_id, or generic GROUP, ONE_TO_ONE keys'
| def convactive(self, conv_id):
| active_tags = []
check_keys = []
if (conv_id in self.bot.conversations.catalog):
check_keys.extend([conv_id])
conv_type = self.bot.conversations.catalog[conv_id]['type']
if (conv_type == 'GROUP'):
check_keys.extend([self.wildcard['group']])
elif (conv_type == 'ONE_TO_ONE'):
check_keys.extend([self.wildcard['one2one']])
check_keys.extend([self.wildcard['conversation']])
else:
logger.warning('convactive: conversation {} does not exist'.format(conv_id))
for _key in check_keys:
if (_key in self.indices['conv-tags']):
active_tags.extend(self.indices['conv-tags'][_key])
active_tags = list(set(active_tags))
if ('tagging-merge' not in active_tags):
break
return active_tags
|
'return active tags of user for current conv_id if supplied, globally if not'
| def useractive(self, chat_id, conv_id='*'):
| active_tags = []
check_keys = []
if self.bot.memory.exists(['user_data', chat_id]):
if (conv_id != '*'):
if (conv_id in self.bot.conversations.catalog):
check_keys.extend([((conv_id + '|') + chat_id), ((conv_id + '|') + self.wildcard['user'])])
if (self.bot.conversations.catalog[conv_id]['type'] == 'GROUP'):
check_keys.extend([((self.wildcard['group'] + '|') + chat_id), ((self.wildcard['group'] + '|') + self.wildcard['user'])])
else:
check_keys.extend([((self.wildcard['one2one'] + '|') + chat_id), ((self.wildcard['one2one'] + '|') + self.wildcard['user'])])
else:
logger.warning('useractive: conversation {} does not exist'.format(conv_id))
check_keys.extend([chat_id, self.wildcard['user']])
else:
logger.warning('useractive: user {} does not exist'.format(chat_id))
for _key in check_keys:
if (_key in self.indices['user-tags']):
active_tags.extend(self.indices['user-tags'][_key])
active_tags = list(set(active_tags))
if ('tagging-merge' not in active_tags):
break
return active_tags
|
'return dict of participating chat_ids to tags, optionally filtered by tag/list of tags'
| def userlist(self, conv_id, tags=False):
| if isinstance(tags, str):
tags = [tags]
userlist = []
try:
userlist = self.bot.conversations.catalog[conv_id]['participants']
except KeyError:
logger.warning('userlist: conversation {} does not exist'.format(conv_id))
results = {}
for chat_id in userlist:
user_tags = self.useractive(chat_id, conv_id)
if (tags and (not set(tags).issubset(set(user_tags)))):
continue
results[chat_id] = user_tags
return results
|
'Start threads and bind ports'
| def __init__(self, base_url):
| cflib.crtp.init_drivers(enable_debug_driver=True)
self._cf = Crazyflie(ro_cache=None, rw_cache=(cfclient.config_path + '/cache'))
signal.signal(signal.SIGINT, signal.SIG_DFL)
self._base_url = base_url
self._context = zmq.Context()
cmd_srv = self._bind_zmq_socket(zmq.REP, 'cmd', ZMQ_SRV_PORT)
log_srv = self._bind_zmq_socket(zmq.PUB, 'log', ZMQ_LOG_PORT)
param_srv = self._bind_zmq_socket(zmq.PUB, 'param', ZMQ_PARAM_PORT)
ctrl_srv = self._bind_zmq_socket(zmq.PULL, 'ctrl', ZMQ_CTRL_PORT)
conn_srv = self._bind_zmq_socket(zmq.PUB, 'conn', ZMQ_CONN_PORT)
self._scan_thread = _SrvThread(cmd_srv, log_srv, param_srv, conn_srv, self._cf)
self._scan_thread.start()
self._ctrl_thread = _CtrlThread(ctrl_srv, self._cf)
self._ctrl_thread.start()
|
'Initialize the headless client and libraries'
| def __init__(self):
| cflib.crtp.init_drivers()
self._jr = JoystickReader(do_device_discovery=False)
self._cf = Crazyflie(ro_cache=None, rw_cache=(cfclient.config_path + '/cache'))
signal.signal(signal.SIGINT, signal.SIG_DFL)
self._devs = []
for d in self._jr.available_devices():
self._devs.append(d.name)
|
'Set up the device reader'
| def setup_controller(self, input_config, input_device=0, xmode=False):
| self._jr.device_error.add_callback(self._input_dev_error)
print ('Client side X-mode: %s' % xmode)
if xmode:
self._cf.commander.set_client_xmode(xmode)
devs = self._jr.available_devices()
print ('Will use [%s] for input' % self._devs[input_device])
self._jr.start_input(self._devs[input_device])
self._jr.set_input_map(self._devs[input_device], input_config)
|
'Return True if a controller is connected'
| def controller_connected(self):
| return (True if (len(self._jr.available_devices()) > 0) else False)
|
'List the available controllers and input mapping'
| def list_controllers(self):
| print '\nAvailable controllers:'
for (i, dev) in enumerate(self._devs):
print ' - Controller #{}: {}'.format(i, dev)
print '\nAvailable input mapping:'
for map in os.listdir((cfclient.config_path + '/input')):
print (' - ' + map.split('.json')[0])
|
'Connect to a Crazyflie on the given link uri'
| def connect_crazyflie(self, link_uri):
| self._cf.connection_failed.add_callback(self._connection_failed)
self._cf.connected.add_callback(self._connected)
self._cf.param.add_update_callback(group='imu_sensors', name='HMC5883L', cb=(lambda name, found: self._jr.set_alt_hold_available(eval(found))))
self._jr.assisted_control_updated.add_callback((lambda enabled: self._cf.param.set_value('flightmode.althold', enabled)))
self._cf.open_link(link_uri)
self._jr.input_updated.add_callback(self._cf.commander.send_setpoint)
|
'Callback for a successful Crazyflie connection.'
| def _connected(self, link):
| print 'Connected to {}'.format(link)
|
'Callback for a failed Crazyflie connection'
| def _connection_failed(self, link, message):
| print 'Connection failed on {}: {}'.format(link, message)
sys.exit((-1))
|
'Callback for an input device error'
| def _input_dev_error(self, message):
| print 'Error when reading device: {}'.format(message)
sys.exit((-1))
|
'Called when dialog is opened'
| def showEvent(self, event):
| self._input.pause_input()
|
'Called when dialog is closed'
| def closeEvent(self, event):
| self._input.stop_raw_reading()
self._input_device_reader.stop_reading()
self._input.resume_input()
|
'Stop polling data'
| def stop_reading(self):
| self._read_timer.stop()
|
'Start polling data'
| def start_reading(self):
| self._read_timer.start()
|
'Event when the about box is shown'
| def showEvent(self, event):
| self._interface_text = ''
interface_status = cflib.crtp.get_interfaces_status()
for key in list(interface_status.keys()):
self._interface_text += INTERFACE_FORMAT.format(key, interface_status[key])
firmware = None
self._device_text = ''
devs = self._helper.inputDeviceReader.available_devices()
for d in devs:
self._device_text += DEVICE_FORMAT.format(d.reader_name, d.id, d.name)
if (len(self._device_text) == 0):
self._device_text = 'None<br>'
self._input_readers_text = ''
for reader in cfclient.utils.input.inputreaders.initialized_readers:
self._input_readers_text += INPUT_READER_FORMAT.format(reader.name, len(reader.devices()))
if (len(self._input_readers_text) == 0):
self._input_readers_text = 'None<br>'
if self._uri:
firmware = FIRMWARE_FORMAT.format(self._fw_rev0, self._fw_rev1, ('MODIFIED' if self._fw_modified else 'CLEAN'))
self._debug_out.setHtml(DEBUG_INFO_FORMAT.format(version=cfclient.VERSION, system=sys.platform, pmajor=sys.version_info.major, pminor=sys.version_info.minor, pmicro=sys.version_info.micro, qt_version=QT_VERSION_STR, pyqt_version=PYQT_VERSION_STR, interface_status=self._interface_text, input_devices=self._device_text, input_readers=self._input_readers_text, uri=self._uri, firmware=firmware, imu_sensors=self._imu_sensors_text, imu_sensor_tests=self._imu_sensor_test_text))
|
'Callback when Crazyflie is connected'
| def _connected(self, uri):
| self._uri = uri
|
'Callback for firmware parameters'
| def _firmware_update(self, name, value):
| if ('revision0' in name):
self._fw_rev0 = eval(value)
if ('revision1' in name):
self._fw_rev1 = eval(value)
if ('modified' in name):
self._fw_modified = eval(value)
|
'Callback for sensor found parameters'
| def _imu_sensors_update(self, name, value):
| param = name[(name.index('.') + 1):]
if (param not in self._imu_sensors_text):
self._imu_sensors_text += IMU_SENSORS_FORMAT.format(param, eval(value))
|
'Callback for sensor test parameters'
| def _imu_sensor_tests_update(self, name, value):
| param = name[(name.index('.') + 1):]
if (param not in self._imu_sensor_test_text):
self._imu_sensor_test_text += SENSOR_TESTS_FORMAT.format(param, eval(value))
|
'Callback for Crazyflie disconnected'
| def _disconnected(self, uri):
| self._interface_text = ''
self._imu_sensors_text = ''
self._imu_sensor_test_text = ''
self._uri = None
self._fw_rev1 = None
self._fw_rev0 = None
self._fw_modified = None
|
'Called when a new mux is selected. The menu item contains a
reference to the raw mux object as well as to the associated device
sub-nodes'
| def _mux_selected(self, checked):
| if (not checked):
(mux, sub_nodes) = self.sender().data()
for s in sub_nodes:
s.setEnabled(False)
else:
(mux, sub_nodes) = self.sender().data()
for s in sub_nodes:
s.setEnabled(True)
self.joystickReader.set_mux(mux=mux)
for role_node in sub_nodes:
for dev_node in role_node.children():
if ((type(dev_node) is QAction) and dev_node.isChecked()):
dev_node.toggled.emit(True)
self._update_input_device_footer()
|
'Update the footer in the bottom of the UI with status for the
input device and its mapping'
| def _update_input_device_footer(self):
| msg = ''
if (len(self.joystickReader.available_devices()) > 0):
mux = self.joystickReader._selected_mux
msg = 'Using {} mux with '.format(mux.name)
for key in list(mux._devs.keys())[:(-1)]:
if mux._devs[key]:
msg += '{}, '.format(self._get_dev_status(mux._devs[key]))
else:
msg += 'N/A, '
key = list(mux._devs.keys())[(-1)]
if mux._devs[key]:
msg += '{}'.format(self._get_dev_status(mux._devs[key]))
else:
msg += 'N/A'
else:
msg = 'No input device found'
self._statusbar_label.setText(msg)
|
'Called when a new input device has been selected from the menu. The
data in the menu object is the associated map menu (directly under the
item in the menu) and the raw device'
| def _inputdevice_selected(self, checked):
| (map_menu, device, mux_menu) = self.sender().data()
if (not checked):
if map_menu:
map_menu.setEnabled(False)
else:
if map_menu:
map_menu.setEnabled(True)
(mux, sub_nodes) = mux_menu.data()
for role_node in sub_nodes:
for dev_node in role_node.children():
if ((type(dev_node) is QAction) and dev_node.isChecked()):
if ((device.id == dev_node.data()[1].id) and (dev_node is not self.sender())):
dev_node.setChecked(False)
role_in_mux = str(self.sender().parent().title()).strip()
logger.info('Role of {} is {}'.format(device.name, role_in_mux))
Config().set('input_device', str(device.name))
self._mapping_support = self.joystickReader.start_input(device.name, role_in_mux)
self._update_input_device_footer()
|
'Called when a new configuration has been selected from the menu. The
data in the menu object is a referance to the device QAction in parent
menu. This contains a referance to the raw device.'
| def _inputconfig_selected(self, checked):
| if (not checked):
return
selected_mapping = str(self.sender().text())
device = self.sender().data().data()[1]
self.joystickReader.set_input_map(device.name, selected_mapping)
self._update_input_device_footer()
|
'Called when new devices have been added'
| def device_discovery(self, devs):
| for menu in self._all_role_menus:
role_menu = menu['rolemenu']
mux_menu = menu['muxmenu']
dev_group = QActionGroup(role_menu, exclusive=True)
for d in devs:
dev_node = QAction(d.name, role_menu, checkable=True, enabled=True)
role_menu.addAction(dev_node)
dev_group.addAction(dev_node)
dev_node.toggled.connect(self._inputdevice_selected)
map_node = None
if d.supports_mapping:
map_node = QMenu(' Input map', role_menu, enabled=False)
map_group = QActionGroup(role_menu, exclusive=True)
dev_node.setData((map_node, d))
for c in ConfigManager().get_list_of_configs():
node = QAction(c, map_node, checkable=True, enabled=True)
node.toggled.connect(self._inputconfig_selected)
map_node.addAction(node)
node.setData(dev_node)
map_group.addAction(node)
if (d not in self._available_devices):
last_map = Config().get('device_config_mapping')
if ((d.name in last_map) and (last_map[d.name] == c)):
node.setChecked(True)
role_menu.addMenu(map_node)
dev_node.setData((map_node, d, mux_menu))
self._available_devices = ()
for d in devs:
self._available_devices += (d,)
for mux_node in self._all_mux_nodes:
(mux, sub_nodes) = mux_node.data()
if (len(mux.supported_roles()) <= len(self._available_devices)):
mux_node.setEnabled(True)
if self._all_mux_nodes[0].isEnabled():
self._all_mux_nodes[0].setChecked(True)
if (Config().get('input_device') in [d.name for d in devs]):
for dev_menu in self._all_role_menus[0]['rolemenu'].actions():
if (dev_menu.text() == Config().get('input_device')):
dev_menu.setChecked(True)
else:
self._all_role_menus[0]['rolemenu'].actions()[0].setChecked(True)
logger.info('Select first device')
self._update_input_device_footer()
|
'Initialize'
| def __init__(self, curve):
| self.data = []
self.ts = []
self.curve = curve
|
'Add a point to the curve.
p - point
ts - timestamp in ms'
| def add_point(self, p, ts):
| self.data.append(p)
self.ts.append(ts)
|
'Set what data should be shown from the curve. This is done to keep
performance when many points have been added.'
| def show_data(self, start, stop):
| limit = min(stop, len(self.data))
self.curve.setData(y=self.data[start:limit], x=self.ts[start:limit])
return [self.ts[start], self.ts[(limit - 1)]]
|
'Callback from the auto redraw checkbox'
| def _auto_redraw_change(self, state):
| if (state == 0):
self._draw_graph = False
else:
self._draw_graph = True
|
'Callback when user changes the X-axis mode'
| def _x_mode_change(self, box):
| if (box == self._enable_range_x):
logger.info('Enable range x')
self._x_range = (float(self._range_x_min.text()), float(self._range_x_max.text()))
else:
self._range_x_min.setEnabled(False)
self._range_x_max.setEnabled(False)
|
'Callback when user changes the Y-axis mode'
| def _y_mode_change(self, box):
| if (box == self._enable_range_y):
self._range_y_min.setEnabled(True)
self._range_y_max.setEnabled(True)
y_range = (float(self._range_y_min.value()), float(self._range_y_max.value()))
self._plot_widget.getViewBox().setRange(yRange=y_range)
else:
self._range_y_min.setEnabled(False)
self._range_y_max.setEnabled(False)
if (box == self._enable_auto_y):
self._plot_widget.getViewBox().enableAutoRange(ViewBox.YAxis)
|
'Callback from pyqtplot when users changes the range of the plot using
the mouse'
| def _manual_range_change(self, obj):
| [[x_min, x_max], [y_min, y_max]] = self._plot_widget.getViewBox().viewRange()
self._range_y_min.setValue(y_min)
self._range_y_max.setValue(y_max)
self._range_y_min.setEnabled(True)
self._range_y_max.setEnabled(True)
self._enable_range_y.setChecked(True)
|
'Callback when user changes Y range manually'
| def _y_range_changed(self, val):
| _y_range = (float(self._range_y_min.value()), float(self._range_y_max.value()))
self._plot_widget.getViewBox().setRange(yRange=_y_range, padding=0)
|
'Callback when user changes the number of samples to be shown'
| def _nbr_samples_changed(self, val):
| self._nbr_samples = val
|
'Set the title of the plot.
title - the new title'
| def set_title(self, title):
| self._plot_widget.setTitle(title)
|
'Add a new curve to the plot.
title - the name of the data
pen - color of curve (using r for red and so on..)'
| def add_curve(self, title, pen='r'):
| self._items[title] = PlotItemWrapper(self._plot_widget.plot(name=title, pen=pen))
|
'Add new data to the plot.
data - dictionary sent from logging layer containing variable/value
pairs
ts - timestamp of the data in ms'
| def add_data(self, data, ts):
| if (not self._last_ts):
self._last_ts = ts
elif (not self._last_ts):
self._dtime = (ts - self._last_ts)
self._last_ts = ts
x_min_limit = 0
x_max_limit = 0
if self._enable_samples_x.isChecked():
x_min_limit = max(0, (self._last_item - self._nbr_samples))
x_max_limit = max(self._last_item, self._nbr_samples)
for name in self._items:
self._items[name].add_point(data[name], ts)
if (self._draw_graph and (time() > (self._ts + self._delay))):
[self._x_min, self._x_max] = self._items[name].show_data(x_min_limit, x_max_limit)
if (time() > (self._ts + self._delay)):
self._ts = time()
if (self._enable_samples_x.isChecked() and self._dtime and (self._last_item < self._nbr_samples)):
self._x_max = (self._x_min + (self._nbr_samples * self._dtime))
self._last_item = (self._last_item + 1)
self._plot_widget.getViewBox().setRange(xRange=(self._x_min, self._x_max))
|
'Reset the plot by removing all the datasets'
| def removeAllDatasets(self):
| for item in self._items:
self._plot_widget.removeItem(self._items[item])
self._clear_legend()
self._items = {}
self._last_item = 0
self._last_ts = None
self._dtime = None
self._plot_widget.clear()
|
'Callback when the Crazyflie has been connected'
| def _connected(self, link_uri):
| self._dumpSystemLoadButton.setEnabled(True)
|
'Callback for when the Crazyflie has been disconnected'
| def _disconnected(self, link_uri):
| self._dumpSystemLoadButton.setEnabled(False)
|
'Callback when the Crazyflie has been connected'
| def _connected(self, link_uri):
| logger.debug('Crazyflie connected to {}'.format(link_uri))
|
'Callback for when the Crazyflie has been disconnected'
| def _disconnected(self, link_uri):
| logger.debug('Crazyflie disconnected from {}'.format(link_uri))
|
'Callback when the registered parameter get\'s updated'
| def _param_updated(self, name, value):
| logger.debug('Updated {0} to {1}'.format(name, value))
|
'Callback when the log layer receives new data'
| def _log_data_received(self, timestamp, data, log_conf):
| logger.debug('{0}:{1}:{2}'.format(timestamp, log_conf.name, data))
|
'Callback from the log layer when an error occurs'
| def _logging_error(self, log_conf, msg):
| QMessageBox.about(self, 'Example error', 'Error when using log config [{0}]: {1}'.format(log_conf.name, msg))
|
'Re-implemented method to get the parent of the given index'
| def parent(self, index):
| return QModelIndex()
|
'Remove a block from the view'
| def remove_block(self, block):
| raise NotImplementedError()
|
'Re-implemented method to get the number of columns'
| def columnCount(self, parent):
| return 1
|
'Re-implemented method to get the number of rows for a given index'
| def rowCount(self, parent):
| parent_item = parent.internalPointer()
if parent.isValid():
parent_item = parent.internalPointer()
return 0
else:
return len(self._nodes)
|
'Re-implemented method to get the index for a specified
row/column/parent combination'
| def index(self, row, column, parent):
| if (not self._nodes):
return QModelIndex()
node = parent.internalPointer()
if (not node):
index = self.createIndex(row, column, self._nodes[row])
return index
else:
return self.createIndex(row, column, node.get_child(row))
|
'Re-implemented method to get the data for a given index and role'
| def data(self, index, role):
| node = index.internalPointer()
if ((not index.isValid()) or (not (0 <= index.row() < len(self._nodes)))):
return None
if (role == Qt.DisplayRole):
return self._nodes[index.row()].name
return None
|
'Reset the model'
| def reset(self):
| self._nodes = []
self.layoutChanged.emit()
|
'Callback when the Crazyflie has been connected'
| def _connected(self, link_uri):
| self._plot.removeAllDatasets()
self._plot.set_title('')
|
'Callback for when the Crazyflie has been disconnected'
| def _disconnected(self, link_uri):
| self._model.beginResetModel()
self._model.reset()
self._model.endResetModel()
self.dataSelector.setCurrentIndex((-1))
self._previous_config = None
self._started_previous = False
|
'Wrapper for signal'
| def _log_data_signal_wrapper(self, ts, data, logconf):
| self._log_data_signal.emit(ts, data, logconf)
|
'Wrapper for signal'
| def _log_error_signal_wrapper(self, config, msg):
| self._log_error_signal.emit(config, msg)
|
'Callback from ComboBox when a new item has been selected'
| def _selection_changed(self, i):
| if (i < 0):
return
if (self._started_previous and self._previous_config):
logger.debug('Should stop config [%s], stopping!', self._previous_config.name)
self._previous_config.delete()
if self._previous_config:
self._previous_config.data_received_cb.remove_callback(self._log_data_signal_wrapper)
self._previous_config.error_cb.remove_callback(self._log_error_signal_wrapper)
lg = self._model.get_config(i)
if (not lg.started):
logger.debug('Config [%s] not started, starting!', lg.name)
self._started_previous = True
lg.start()
else:
self._started_previous = False
self._plot.removeAllDatasets()
color_selector = 0
self._plot.set_title(lg.name)
for d in lg.variables:
self._plot.add_curve(d.name, self.colors[(color_selector % len(self.colors))])
color_selector += 1
lg.data_received_cb.add_callback(self._log_data_signal_wrapper)
lg.error_cb.add_callback(self._log_error_signal_wrapper)
self._previous_config = lg
|
'Callback from the log layer when a new config has been added'
| def _config_added(self, logconfig):
| logger.debug('Callback for new config [%s]', logconfig.name)
self._model.add_block(logconfig)
|
'Callback from the log layer when an error occurs'
| def _logging_error(self, log_conf, msg):
| QMessageBox.about(self, 'Plot error', ('Error when starting log config [%s]: %s' % (log_conf.name, msg)))
|
'Callback when the log layer receives new data'
| def _log_data_received(self, timestamp, data, logconf):
| if self._previous_config:
if (self._previous_config.name == logconf.name):
self._plot.add_data(data, timestamp)
|
'Sets the position.'
| def set_position(self, position):
| self.x = position[0]
self.y = position[1]
self.z = position[2]
|
'Returns the position as a vector'
| def get_position(self):
| return (self.x, self.y, self.z)
|
'Get the position from the UI elements'
| def get_position(self):
| return (self._x.value(), self._y.value(), self._z.value())
|
'Set the position in the UI elements'
| def set_position(self, position):
| self._x.setValue(position[0])
self._y.setValue(position[1])
self._z.setValue(position[2])
|
''
| def set_ref_position(self, position):
| self._ref_x = position[0]
self._ref_y = position[1]
self._ref_z = position[2]
self._has_ref_set = True
self._compare_all_ref_positions()
|
'Enable/disable all UI elements for the position'
| def enable(self, enabled):
| self._x.setEnabled(enabled)
self._y.setEnabled(enabled)
self._z.setEnabled(enabled)
if (not enabled):
self._has_ref_set = False
self._x.setStyleSheet(STYLE_NO_BACKGROUND)
self._y.setStyleSheet(STYLE_NO_BACKGROUND)
self._z.setStyleSheet(STYLE_NO_BACKGROUND)
|
'Callback when the Crazyflie has been connected'
| def _connected(self, link_uri):
| logger.debug('Crazyflie connected to {}'.format(link_uri))
if self._helper.cf.mem.ow_search(vid=188, pid=6):
try:
self._register_logblock('LoPoTab0', [('ranging', 'distance0', 'float'), ('ranging', 'distance1', 'float'), ('ranging', 'distance2', 'float'), ('ranging', 'distance3', 'float')], self._anchor_range_signal.emit, self._log_error_signal.emit)
(self._register_logblock('LoPoTab1', [('ranging', 'distance4', 'float'), ('ranging', 'distance5', 'float'), ('ranging', 'distance6', 'float'), ('ranging', 'distance7', 'float')], self._anchor_range_signal.emit, self._log_error_signal.emit),)
(self._register_logblock('LoPoTab2', [('kalman', 'stateX', 'float'), ('kalman', 'stateY', 'float'), ('kalman', 'stateZ', 'float'), ('ranging', 'state', 'uint8_t')], self._position_signal.emit, self._log_error_signal.emit),)
except KeyError as e:
logger.warning(str(e))
except AttributeError as e:
logger.warning(str(e))
self._start_polling_anchor_pos(self._helper.cf)
|
'Callback for when the Crazyflie has been disconnected'
| def _disconnected(self, link_uri):
| logger.debug('Crazyflie disconnected from {}'.format(link_uri))
self._stop_polling_anchor_pos()
self._clear_state()
self._update_graphics()
|
'Register log data to listen for. One logblock can contain a limited
number of parameters (6 for floats).'
| def _register_logblock(self, logblock_name, variables, data_cb, error_cb):
| lg = LogConfig(logblock_name, self.UPDATE_PERIOD_LOG)
for variable in variables:
if self._is_in_toc(variable):
lg.add_variable('{}.{}'.format(variable[0], variable[1]), variable[2])
self._helper.cf.log.add_config(lg)
lg.data_received_cb.add_callback(data_cb)
lg.error_cb.add_callback(error_cb)
lg.start()
return lg
|
'Callback from the logging system when a range is updated.'
| def _anchor_range_received(self, timestamp, data, logconf):
| for (name, value) in data.items():
(valid, anchor_number) = self._parse_range_param_name(name)
if valid:
self._get_anchor(anchor_number).distance = float(value)
|
'Callback from the logging system when the position is updated.'
| def _position_received(self, timestamp, data, logconf):
| for (name, value) in data.items():
(valid, axis) = self._parse_position_param_name(name)
if valid:
self._position[axis] = float(value)
self._update_ranging_status_indicators(data['ranging.state'])
|
'Callback from the log layer when an error occurs'
| def _logging_error(self, log_conf, msg):
| QMessageBox.about(self, 'LocoPositioningTab error', 'Error when using log config', ' [{0}]: {1}'.format(log_conf.name, msg))
|
'Set up a timer to poll anchor positions from the memory sub
system'
| def _start_polling_anchor_pos(self, crazyflie):
| self._anchor_pos_timer.start()
|
'Callback from the memory sub system when the anchor positions
are updated'
| def _anchor_positions_updated(self, mem):
| for (anchor_number, anchor_data) in enumerate(mem.anchor_data):
if anchor_data.is_valid:
anchor = self._get_anchor(anchor_number)
anchor.set_position(anchor_data.position)
self._anchor_pos_ui[anchor_number].set_ref_position(anchor_data.position)
|
'Parse a parameter name for a ranging distance and return the number
of the anchor. The name is on the format \'ranging.distance4\''
| def _parse_range_param_name(self, name):
| valid = False
anchor = 0
if name.startswith('ranging.distance'):
anchor = int(name[(-1)])
valid = True
return (valid, anchor)
|
'Parse a parameter name for a position and return the
axis (0=x, 1=y, 2=z).
The param name is on the format \'kalman.stateY\''
| def _parse_position_param_name(self, name):
| valid = False
axis = 0
if name.startswith('kalman.state'):
axis = {'X': 0, 'Y': 1, 'Z': 2}[name[(-1)]]
valid = True
return (valid, axis)
|
'Callback when the Crazyflie has been connected'
| def _connected(self, link_uri):
| mems = self._helper.cf.mem.get_mems(MemoryElement.TYPE_DRIVER_LED)
if (len(mems) > 0):
self._mem = mems[0]
logger.info(self._mem)
if self._mem:
for btn in self._btns:
btn.setEnabled(True)
btn.setStyleSheet('background-color: black')
self._intensity_slider.setEnabled(True)
self._intensity_spin.setEnabled(True)
|
'Callback for when the Crazyflie has been disconnected'
| def _disconnected(self, link_uri):
| for btn in self._btns:
btn.setEnabled(False)
btn.setStyleSheet('background-color: none')
self._intensity_slider.setEnabled(False)
self._intensity_spin.setEnabled(False)
self._intensity_slider.setValue(100)
|
'Initialize the node'
| def __init__(self, parent, name):
| self.parent = parent
self.name = name
|
'Return the number of children this node has'
| def child_count(self):
| return 0
|
'Initialize the parent node'
| def __init__(self, block, model, connected_ts):
| super(LogBlockItem, self).__init__()
self._block = block
self.parent = None
self.children = []
self.name = block.name
self.id = block.id
self.period = block.period_in_ms
self._model = model
self._log_file_writer = LogWriter(block, connected_ts)
self._block.started_cb.add_callback(self._set_started)
self._block.added_cb.add_callback(self._set_added)
self._block.error_cb.add_callback(self._log_error)
self._var_list = ''
for b in block.variables:
self.children.append(LogBlockChildItem(self, b.name))
self._var_list += ('%s/' % b.name)
self._var_list = self._var_list[:(-1)]
self._block_started = False
self._doing_transaction = False
|
'Callback when there\'s an error starting the block in the Crazyflie'
| def _log_error(self, logconfig, msg):
| self._doing_transaction = False
|
'Callback when a block has been started in the Crazyflie'
| def _set_started(self, conf, started):
| logger.debug('%s started: %s', self.name, started)
if started:
self._block_started = True
else:
self._block_started = False
self._doing_transaction = False
self._model.refresh()
|
'Return True if the block has been started, otherwise False'
| def logging_started(self):
| return self._block_started
|
'Return True if the block is being logged to file, otherwise False'
| def writing_to_file(self):
| return self._log_file_writer.writing()
|
'Start logging to file for this block'
| def start_writing_to_file(self):
| self._log_file_writer.start()
|
'Stop logging to file for this block'
| def stop_writing_to_file(self):
| self._log_file_writer.stop()
|
'Start the logging of this block'
| def start(self):
| self._doing_transaction = True
self._block.start()
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.