_id stringlengths 2 7 | title stringlengths 1 88 | partition stringclasses 3
values | text stringlengths 75 19.8k | language stringclasses 1
value | meta_information dict |
|---|---|---|---|---|---|
q230600 | mavfile.recv_match | train | def recv_match(self, condition=None, type=None, blocking=False, timeout=None):
'''recv the next MAVLink message that matches the given condition
type can be a string or a list of strings'''
if type is not None and not isinstance(type, list):
type = [type]
start_time = time.ti... | python | {
"resource": ""
} |
q230601 | mavfile.setup_logfile | train | def setup_logfile(self, logfile, mode='w'):
'''start logging to the given logfile, with timestamps'''
self.logfile = open(logfile, mode=mode) | python | {
"resource": ""
} |
q230602 | mavfile.setup_logfile_raw | train | def setup_logfile_raw(self, logfile, mode='w'):
'''start logging raw bytes to the given logfile, without timestamps'''
self.logfile_raw = open(logfile, mode=mode) | python | {
"resource": ""
} |
q230603 | mavfile.param_fetch_all | train | def param_fetch_all(self):
'''initiate fetch of all parameters'''
if time.time() - getattr(self, 'param_fetch_start', 0) < 2.0:
# don't fetch too often
return
self.param_fetch_start = time.time()
self.param_fetch_in_progress = True
self.mav.param_request_l... | python | {
"resource": ""
} |
q230604 | mavfile.param_fetch_one | train | def param_fetch_one(self, name):
'''initiate fetch of one parameter'''
try:
idx = int(name)
self.mav.param_request_read_send(self.target_system, self.target_component, "", idx)
except Exception:
self.mav.param_request_read_send(self.target_system, self.target_... | python | {
"resource": ""
} |
q230605 | mavfile.time_since | train | def time_since(self, mtype):
'''return the time since the last message of type mtype was received'''
if not mtype in self.messages:
return time.time() - self.start_time
return time.time() - self.messages[mtype]._timestamp | python | {
"resource": ""
} |
q230606 | mavfile.param_set_send | train | def param_set_send(self, parm_name, parm_value, parm_type=None):
'''wrapper for parameter set'''
if self.mavlink10():
if parm_type == None:
parm_type = mavlink.MAVLINK_TYPE_FLOAT
self.mav.param_set_send(self.target_system, self.target_component,
... | python | {
"resource": ""
} |
q230607 | mavfile.waypoint_request_list_send | train | def waypoint_request_list_send(self):
'''wrapper for waypoint_request_list_send'''
if self.mavlink10():
self.mav.mission_request_list_send(self.target_system, self.target_component)
else:
self.mav.waypoint_request_list_send(self.target_system, self.target_component) | python | {
"resource": ""
} |
q230608 | mavfile.waypoint_clear_all_send | train | def waypoint_clear_all_send(self):
'''wrapper for waypoint_clear_all_send'''
if self.mavlink10():
self.mav.mission_clear_all_send(self.target_system, self.target_component)
else:
self.mav.waypoint_clear_all_send(self.target_system, self.target_component) | python | {
"resource": ""
} |
q230609 | mavfile.waypoint_request_send | train | def waypoint_request_send(self, seq):
'''wrapper for waypoint_request_send'''
if self.mavlink10():
self.mav.mission_request_send(self.target_system, self.target_component, seq)
else:
self.mav.waypoint_request_send(self.target_system, self.target_component, seq) | python | {
"resource": ""
} |
q230610 | mavfile.waypoint_set_current_send | train | def waypoint_set_current_send(self, seq):
'''wrapper for waypoint_set_current_send'''
if self.mavlink10():
self.mav.mission_set_current_send(self.target_system, self.target_component, seq)
else:
self.mav.waypoint_set_current_send(self.target_system, self.target_component,... | python | {
"resource": ""
} |
q230611 | mavfile.waypoint_current | train | def waypoint_current(self):
'''return current waypoint'''
if self.mavlink10():
m = self.recv_match(type='MISSION_CURRENT', blocking=True)
else:
m = self.recv_match(type='WAYPOINT_CURRENT', blocking=True)
return m.seq | python | {
"resource": ""
} |
q230612 | mavfile.waypoint_count_send | train | def waypoint_count_send(self, seq):
'''wrapper for waypoint_count_send'''
if self.mavlink10():
self.mav.mission_count_send(self.target_system, self.target_component, seq)
else:
self.mav.waypoint_count_send(self.target_system, self.target_component, seq) | python | {
"resource": ""
} |
q230613 | mavfile.set_mode_auto | train | def set_mode_auto(self):
'''enter auto mode'''
if self.mavlink10():
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_MISSION_START, 0, 0, 0, 0, 0, 0, 0, 0)
else:
MAV_ACTION_SET_AUTO = 13
... | python | {
"resource": ""
} |
q230614 | mavfile.set_mode | train | def set_mode(self, mode, custom_mode = 0, custom_sub_mode = 0):
'''set arbitrary flight mode'''
mav_autopilot = self.field('HEARTBEAT', 'autopilot', None)
if mav_autopilot == mavlink.MAV_AUTOPILOT_PX4:
self.set_mode_px4(mode, custom_mode, custom_sub_mode)
else:
se... | python | {
"resource": ""
} |
q230615 | mavfile.set_mode_rtl | train | def set_mode_rtl(self):
'''enter RTL mode'''
if self.mavlink10():
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_NAV_RETURN_TO_LAUNCH, 0, 0, 0, 0, 0, 0, 0, 0)
else:
MAV_ACTION_RETURN = 3
... | python | {
"resource": ""
} |
q230616 | mavfile.set_mode_manual | train | def set_mode_manual(self):
'''enter MANUAL mode'''
if self.mavlink10():
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_DO_SET_MODE, 0,
mavlink.MAV_MODE_MANUAL_ARMED,
... | python | {
"resource": ""
} |
q230617 | mavfile.set_mode_fbwa | train | def set_mode_fbwa(self):
'''enter FBWA mode'''
if self.mavlink10():
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_DO_SET_MODE, 0,
mavlink.MAV_MODE_STABILIZE_ARMED,
... | python | {
"resource": ""
} |
q230618 | mavfile.set_mode_loiter | train | def set_mode_loiter(self):
'''enter LOITER mode'''
if self.mavlink10():
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_NAV_LOITER_UNLIM, 0, 0, 0, 0, 0, 0, 0, 0)
else:
MAV_ACTION_LOITER = 27
... | python | {
"resource": ""
} |
q230619 | mavfile.set_servo | train | def set_servo(self, channel, pwm):
'''set a servo value'''
self.mav.command_long_send(self.target_system, self.target_component,
mavlink.MAV_CMD_DO_SET_SERVO, 0,
channel, pwm,
0, 0, 0, 0, 0) | python | {
"resource": ""
} |
q230620 | mavfile.set_relay | train | def set_relay(self, relay_pin=0, state=True):
'''Set relay_pin to value of state'''
if self.mavlink10():
self.mav.command_long_send(
self.target_system, # target_system
self.target_component, # target_component
mavlink.MAV_CMD_DO_SET_RELAY, # ... | python | {
"resource": ""
} |
q230621 | mavfile.reboot_autopilot | train | def reboot_autopilot(self, hold_in_bootloader=False):
'''reboot the autopilot'''
if self.mavlink10():
if hold_in_bootloader:
param1 = 3
else:
param1 = 1
self.mav.command_long_send(self.target_system, self.target_component,
... | python | {
"resource": ""
} |
q230622 | mavfile.location | train | def location(self, relative_alt=False):
'''return current location'''
self.wait_gps_fix()
# wait for another VFR_HUD, to ensure we have correct altitude
self.recv_match(type='VFR_HUD', blocking=True)
self.recv_match(type='GLOBAL_POSITION_INT', blocking=True)
if relative_a... | python | {
"resource": ""
} |
q230623 | mavfile.motors_armed | train | def motors_armed(self):
'''return true if motors armed'''
if not 'HEARTBEAT' in self.messages:
return False
m = self.messages['HEARTBEAT']
return (m.base_mode & mavlink.MAV_MODE_FLAG_SAFETY_ARMED) != 0 | python | {
"resource": ""
} |
q230624 | mavfile.field | train | def field(self, type, field, default=None):
'''convenient function for returning an arbitrary MAVLink
field with a default'''
if not type in self.messages:
return default
return getattr(self.messages[type], field, default) | python | {
"resource": ""
} |
q230625 | mavfile.setup_signing | train | def setup_signing(self, secret_key, sign_outgoing=True, allow_unsigned_callback=None, initial_timestamp=None, link_id=None):
'''setup for MAVLink2 signing'''
self.mav.signing.secret_key = secret_key
self.mav.signing.sign_outgoing = sign_outgoing
self.mav.signing.allow_unsigned_callback =... | python | {
"resource": ""
} |
q230626 | mavfile.disable_signing | train | def disable_signing(self):
'''disable MAVLink2 signing'''
self.mav.signing.secret_key = None
self.mav.signing.sign_outgoing = False
self.mav.signing.allow_unsigned_callback = None
self.mav.signing.link_id = 0
self.mav.signing.timestamp = 0 | python | {
"resource": ""
} |
q230627 | mavlogfile.scan_timestamp | train | def scan_timestamp(self, tbuf):
'''scan forward looking in a tlog for a timestamp in a reasonable range'''
while True:
(tusec,) = struct.unpack('>Q', tbuf)
t = tusec * 1.0e-6
if abs(t - self._last_timestamp) <= 3*24*60*60:
break
c = self.f.... | python | {
"resource": ""
} |
q230628 | mavlogfile.pre_message | train | def pre_message(self):
'''read timestamp if needed'''
# read the timestamp
if self.filesize != 0:
self.percent = (100.0 * self.f.tell()) / self.filesize
if self.notimestamps:
return
if self.planner_format:
tbuf = self.f.read(21)
if ... | python | {
"resource": ""
} |
q230629 | mavlogfile.post_message | train | def post_message(self, msg):
'''add timestamp to message'''
# read the timestamp
super(mavlogfile, self).post_message(msg)
if self.planner_format:
self.f.read(1) # trailing newline
self.timestamp = msg._timestamp
self._last_message = msg
if msg.get_typ... | python | {
"resource": ""
} |
q230630 | periodic_event.trigger | train | def trigger(self):
'''return True if we should trigger now'''
tnow = time.time()
if tnow < self.last_time:
print("Warning, time moved backwards. Restarting timer.")
self.last_time = tnow
if self.last_time + (1.0/self.frequency) <= tnow:
self.last_tim... | python | {
"resource": ""
} |
q230631 | MavlinkSerialPort.write | train | def write(self, b):
'''write some bytes'''
from . import mavutil
self.debug("sending '%s' (0x%02x) of len %u\n" % (b, ord(b[0]), len(b)), 2)
while len(b) > 0:
n = len(b)
if n > 70:
... | python | {
"resource": ""
} |
q230632 | MavlinkSerialPort._recv | train | def _recv(self):
'''read some bytes into self.buf'''
from . import mavutil
start_time = time.time()
while time.time() < start_time + self.timeout:
m = self.mav.recv_match(condition='SERIAL_CONTROL.count!=0',
... | python | {
"resource": ""
} |
q230633 | MavlinkSerialPort.read | train | def read(self, n):
'''read some bytes'''
if len(self.buf) == 0:
self._recv()
if len(self.buf) > 0:
if n > len(self.buf):
n = len(self.buf)
ret = self.buf[:n]
... | python | {
"resource": ""
} |
q230634 | MavlinkSerialPort.flushInput | train | def flushInput(self):
'''flush any pending input'''
self.buf = ''
saved_timeout = self.timeout
self.timeout = 0.5
self._recv()
self.timeout = saved_timeout
self.buf = ''
self.debug("flushInput... | python | {
"resource": ""
} |
q230635 | NSHModule.stop | train | def stop(self):
'''stop nsh input'''
self.mpstate.rl.set_prompt(self.status.flightmode + "> ")
self.mpstate.functions.input_handler = None
self.started = False
# unlock the port
mav = self.master.mav
mav.serial_control_send(self.serial_settings.port,
... | python | {
"resource": ""
} |
q230636 | NSHModule.cmd_nsh | train | def cmd_nsh(self, args):
'''nsh shell commands'''
usage = "Usage: nsh <start|stop|set>"
if len(args) < 1:
print(usage)
return
if args[0] == "start":
self.mpstate.functions.input_handler = self.send
self.started = True
self.mpsta... | python | {
"resource": ""
} |
q230637 | WPModule.process_waypoint_request | train | def process_waypoint_request(self, m, master):
'''process a waypoint request from the master'''
if (not self.loading_waypoints or
time.time() > self.loading_waypoint_lasttime + 10.0):
self.loading_waypoints = False
self.console.error("not loading waypoints")
... | python | {
"resource": ""
} |
q230638 | WPModule.send_all_waypoints | train | def send_all_waypoints(self):
'''send all waypoints to vehicle'''
self.master.waypoint_clear_all_send()
if self.wploader.count() == 0:
return
self.loading_waypoints = True
self.loading_waypoint_lasttime = time.time()
self.master.waypoint_count_send(self.wpload... | python | {
"resource": ""
} |
q230639 | WPModule.load_waypoints | train | def load_waypoints(self, filename):
'''load waypoints from a file'''
self.wploader.target_system = self.target_system
self.wploader.target_component = self.target_component
try:
self.wploader.load(filename)
except Exception as msg:
print("Unable to load %s... | python | {
"resource": ""
} |
q230640 | WPModule.update_waypoints | train | def update_waypoints(self, filename, wpnum):
'''update waypoints from a file'''
self.wploader.target_system = self.target_system
self.wploader.target_component = self.target_component
try:
self.wploader.load(filename)
except Exception as msg:
print("Unable... | python | {
"resource": ""
} |
q230641 | WPModule.get_default_frame | train | def get_default_frame(self):
'''default frame for waypoints'''
if self.settings.terrainalt == 'Auto':
if self.get_mav_param('TERRAIN_FOLLOW',0) == 1:
return mavutil.mavlink.MAV_FRAME_GLOBAL_TERRAIN_ALT
return mavutil.mavlink.MAV_FRAME_GLOBAL_RELATIVE_ALT
i... | python | {
"resource": ""
} |
q230642 | WPModule.wp_draw_callback | train | def wp_draw_callback(self, points):
'''callback from drawing waypoints'''
if len(points) < 3:
return
from MAVProxy.modules.lib import mp_util
home = self.wploader.wp(0)
self.wploader.clear()
self.wploader.target_system = self.target_system
self.wploade... | python | {
"resource": ""
} |
q230643 | WPModule.wp_loop | train | def wp_loop(self):
'''close the loop on a mission'''
loader = self.wploader
if loader.count() < 2:
print("Not enough waypoints (%u)" % loader.count())
return
wp = loader.wp(loader.count()-2)
if wp.command == mavutil.mavlink.MAV_CMD_DO_JUMP:
pri... | python | {
"resource": ""
} |
q230644 | WPModule.set_home_location | train | def set_home_location(self):
'''set home location from last map click'''
try:
latlon = self.module('map').click_position
except Exception:
print("No map available")
return
lat = float(latlon[0])
lon = float(latlon[1])
if self.wploader.c... | python | {
"resource": ""
} |
q230645 | WPModule.cmd_wp_move | train | def cmd_wp_move(self, args):
'''handle wp move'''
if len(args) != 1:
print("usage: wp move WPNUM")
return
idx = int(args[0])
if idx < 1 or idx > self.wploader.count():
print("Invalid wp number %u" % idx)
return
try:
latl... | python | {
"resource": ""
} |
q230646 | WPModule.cmd_wp_param | train | def cmd_wp_param(self, args):
'''handle wp parameter change'''
if len(args) < 2:
print("usage: wp param WPNUM PNUM <VALUE>")
return
idx = int(args[0])
if idx < 1 or idx > self.wploader.count():
print("Invalid wp number %u" % idx)
return
... | python | {
"resource": ""
} |
q230647 | depthToRGB8 | train | def depthToRGB8(float_img_buff, encoding):
'''
Translates from Distance Image format to RGB. Inf values are represented by NaN, when converting to RGB, NaN passed to 0
@param float_img_buff: ROS Image to translate
@type img: ros image
@return a Opencv RGB image
'''
gray_image = None
... | python | {
"resource": ""
} |
q230648 | ListenerCamera.__callback | train | def __callback (self, img):
'''
Callback function to receive and save Images.
@param img: ROS Image received
@type img: sensor_msgs.msg.Image
'''
image = imageMsg2Image(img, self.bridge)
self.lock.acquire()
self.data = image
self.lock.... | python | {
"resource": ""
} |
q230649 | noise | train | def noise():
'''a noise vector'''
from random import gauss
v = Vector3(gauss(0, 1), gauss(0, 1), gauss(0, 1))
v.normalize()
return v * args.noise | python | {
"resource": ""
} |
q230650 | find_offsets | train | def find_offsets(data, ofs):
'''find mag offsets by applying Bills "offsets revisited" algorithm
on the data
This is an implementation of the algorithm from:
http://gentlenav.googlecode.com/files/MagnetometerOffsetNullingRevisited.pdf
'''
# a limit on the maximum change in each ... | python | {
"resource": ""
} |
q230651 | MPImage.set_menu | train | def set_menu(self, menu):
'''set a MPTopMenu on the frame'''
self.menu = menu
self.in_queue.put(MPImageMenu(menu)) | python | {
"resource": ""
} |
q230652 | MPImage.set_popup_menu | train | def set_popup_menu(self, menu):
'''set a popup menu on the frame'''
self.popup_menu = menu
self.in_queue.put(MPImagePopupMenu(menu)) | python | {
"resource": ""
} |
q230653 | MPImagePanel.image_coordinates | train | def image_coordinates(self, point):
'''given a point in window coordinates, calculate image coordinates'''
# the dragpos is the top left position in image coordinates
ret = wx.Point(int(self.dragpos.x + point.x/self.zoom),
int(self.dragpos.y + point.y/self.zoom))
r... | python | {
"resource": ""
} |
q230654 | MPImagePanel.redraw | train | def redraw(self):
'''redraw the image with current settings'''
state = self.state
if self.img is None:
self.mainSizer.Fit(self)
self.Refresh()
state.frame.Refresh()
self.SetFocus()
return
# get the current size of the containi... | python | {
"resource": ""
} |
q230655 | MPImagePanel.limit_dragpos | train | def limit_dragpos(self):
'''limit dragpos to sane values'''
if self.dragpos.x < 0:
self.dragpos.x = 0
if self.dragpos.y < 0:
self.dragpos.y = 0
if self.img is None:
return
if self.dragpos.x >= self.img.GetWidth():
self.dragpos.x = s... | python | {
"resource": ""
} |
q230656 | MPImagePanel.on_drag_event | train | def on_drag_event(self, event):
'''handle mouse drags'''
state = self.state
if not state.can_drag:
return
newpos = self.image_coordinates(event.GetPosition())
dx = -(newpos.x - self.mouse_down.x)
dy = -(newpos.y - self.mouse_down.y)
self.dragpos = wx.P... | python | {
"resource": ""
} |
q230657 | MPImagePanel.show_popup_menu | train | def show_popup_menu(self, pos):
'''show a popup menu'''
self.popup_pos = self.image_coordinates(pos)
self.frame.PopupMenu(self.wx_popup_menu, pos) | python | {
"resource": ""
} |
q230658 | MPImagePanel.on_key_event | train | def on_key_event(self, event):
'''handle key events'''
keycode = event.GetKeyCode()
if keycode == wx.WXK_HOME:
self.zoom = 1.0
self.dragpos = wx.Point(0, 0)
self.need_redraw = True | python | {
"resource": ""
} |
q230659 | MPImagePanel.on_event | train | def on_event(self, event):
'''pass events to the parent'''
state = self.state
if isinstance(event, wx.MouseEvent):
self.on_mouse_event(event)
if isinstance(event, wx.KeyEvent):
self.on_key_event(event)
if (isinstance(event, wx.MouseEvent) and
n... | python | {
"resource": ""
} |
q230660 | MPImagePanel.on_menu | train | def on_menu(self, event):
'''called on menu event'''
state = self.state
if self.popup_menu is not None:
ret = self.popup_menu.find_selected(event)
if ret is not None:
ret.popup_pos = self.popup_pos
if ret.returnkey == 'fitWindow':
... | python | {
"resource": ""
} |
q230661 | MPImagePanel.set_menu | train | def set_menu(self, menu):
'''add a menu from the parent'''
self.menu = menu
wx_menu = menu.wx_menu()
self.frame.SetMenuBar(wx_menu)
self.frame.Bind(wx.EVT_MENU, self.on_menu) | python | {
"resource": ""
} |
q230662 | MPImagePanel.set_popup_menu | train | def set_popup_menu(self, menu):
'''add a popup menu from the parent'''
self.popup_menu = menu
if menu is None:
self.wx_popup_menu = None
else:
self.wx_popup_menu = menu.wx_menu()
self.frame.Bind(wx.EVT_MENU, self.on_menu) | python | {
"resource": ""
} |
q230663 | MPImagePanel.fit_to_window | train | def fit_to_window(self):
'''fit image to window'''
state = self.state
self.dragpos = wx.Point(0, 0)
client_area = state.frame.GetClientSize()
self.zoom = min(float(client_area.x) / self.img.GetWidth(),
float(client_area.y) / self.img.GetHeight())
s... | python | {
"resource": ""
} |
q230664 | MPImagePanel.full_size | train | def full_size(self):
'''show image at full size'''
self.dragpos = wx.Point(0, 0)
self.zoom = 1.0
self.need_redraw = True | python | {
"resource": ""
} |
q230665 | mavmission | train | def mavmission(logfile):
'''extract mavlink mission'''
mlog = mavutil.mavlink_connection(filename)
wp = mavwp.MAVWPLoader()
while True:
m = mlog.recv_match(type=['MISSION_ITEM','CMD','WAYPOINT'])
if m is None:
break
if m.get_type() == 'CMD':
m = mavutil.... | python | {
"resource": ""
} |
q230666 | message_checksum | train | def message_checksum(msg):
'''calculate a 8-bit checksum of the key fields of a message, so we
can detect incompatible XML changes'''
from .mavcrc import x25crc
crc = x25crc()
crc.accumulate_str(msg.name + ' ')
# in order to allow for extensions the crc does not include
# any field extens... | python | {
"resource": ""
} |
q230667 | merge_enums | train | def merge_enums(xml):
'''merge enums between XML files'''
emap = {}
for x in xml:
newenums = []
for enum in x.enum:
if enum.name in emap:
emapitem = emap[enum.name]
# check for possible conflicting auto-assigned values after merge
i... | python | {
"resource": ""
} |
q230668 | check_duplicates | train | def check_duplicates(xml):
'''check for duplicate message IDs'''
merge_enums(xml)
msgmap = {}
enummap = {}
for x in xml:
for m in x.message:
key = m.id
if key in msgmap:
print("ERROR: Duplicate message id %u for %s (%s:%u) also used by %s" % (
... | python | {
"resource": ""
} |
q230669 | total_msgs | train | def total_msgs(xml):
'''count total number of msgs'''
count = 0
for x in xml:
count += len(x.message)
return count | python | {
"resource": ""
} |
q230670 | MAVType.base_fields | train | def base_fields(self):
'''return number of non-extended fields'''
if self.extensions_start is None:
return len(self.fields)
return len(self.fields[:self.extensions_start]) | python | {
"resource": ""
} |
q230671 | dataflash_logger._dataflash_dir | train | def _dataflash_dir(self, mpstate):
'''returns directory path to store DF logs in. May be relative'''
if mpstate.settings.state_basedir is None:
ret = 'dataflash'
else:
ret = os.path.join(mpstate.settings.state_basedir,'dataflash')
try:
os.makedirs(re... | python | {
"resource": ""
} |
q230672 | dataflash_logger.new_log_filepath | train | def new_log_filepath(self):
'''returns a filepath to a log which does not currently exist and is suitable for DF logging'''
lastlog_filename = os.path.join(self.dataflash_dir,'LASTLOG.TXT')
if os.path.exists(lastlog_filename) and os.stat(lastlog_filename).st_size != 0:
fh = open(last... | python | {
"resource": ""
} |
q230673 | dataflash_logger.start_new_log | train | def start_new_log(self):
'''open a new dataflash log, reset state'''
filename = self.new_log_filepath()
self.block_cnt = 0
self.logfile = open(filename, 'w+b')
print("DFLogger: logging started (%s)" % (filename))
self.prev_cnt = 0
self.download = 0
self.p... | python | {
"resource": ""
} |
q230674 | dataflash_logger.mavlink_packet | train | def mavlink_packet(self, m):
'''handle REMOTE_LOG_DATA_BLOCK packets'''
now = time.time()
if m.get_type() == 'REMOTE_LOG_DATA_BLOCK':
if self.stopped:
# send a stop packet every second until the other end gets the idea:
if now - self.time_last_stop_pac... | python | {
"resource": ""
} |
q230675 | MAVLink.meminfo_send | train | def meminfo_send(self, brkval, freemem, force_mavlink1=False):
'''
state of APM memory
brkval : heap top (uint16_t)
freemem : free memory (uint16_t)
'''
return self.send(self.meminfo_en... | python | {
"resource": ""
} |
q230676 | older_message | train | def older_message(m, lastm):
'''return true if m is older than lastm by timestamp'''
atts = {'time_boot_ms' : 1.0e-3,
'time_unix_usec' : 1.0e-6,
'time_usec' : 1.0e-6}
for a in atts.keys():
if hasattr(m, a):
mul = atts[a]
t1 = m.getattr(a) * mul
... | python | {
"resource": ""
} |
q230677 | process | train | def process(filename):
'''process one logfile'''
print("Processing %s" % filename)
mlog = mavutil.mavlink_connection(filename, notimestamps=args.notimestamps,
robust_parsing=args.robust)
ext = os.path.splitext(filename)[1]
isbin = ext in ['.bin', '.BIN']
i... | python | {
"resource": ""
} |
q230678 | LogModule.handle_log_entry | train | def handle_log_entry(self, m):
'''handling incoming log entry'''
if m.time_utc == 0:
tstring = ''
else:
tstring = time.ctime(m.time_utc)
self.entries[m.id] = m
print("Log %u numLogs %u lastLog %u size %u %s" % (m.id, m.num_logs, m.last_log_num, m.size, ts... | python | {
"resource": ""
} |
q230679 | LogModule.handle_log_data_missing | train | def handle_log_data_missing(self):
'''handling missing incoming log data'''
if len(self.download_set) == 0:
return
highest = max(self.download_set)
diff = set(range(highest)).difference(self.download_set)
if len(diff) == 0:
self.master.mav.log_request_data... | python | {
"resource": ""
} |
q230680 | LogModule.log_status | train | def log_status(self):
'''show download status'''
if self.download_filename is None:
print("No download")
return
dt = time.time() - self.download_start
speed = os.path.getsize(self.download_filename) / (1000.0 * dt)
m = self.entries.get(self.download_lognum... | python | {
"resource": ""
} |
q230681 | LogModule.log_download | train | def log_download(self, log_num, filename):
'''download a log file'''
print("Downloading log %u as %s" % (log_num, filename))
self.download_lognum = log_num
self.download_file = open(filename, "wb")
self.master.mav.log_request_data_send(self.target_system,
... | python | {
"resource": ""
} |
q230682 | LogModule.idle_task | train | def idle_task(self):
'''handle missing log data'''
if self.download_last_timestamp is not None and time.time() - self.download_last_timestamp > 0.7:
self.download_last_timestamp = time.time()
self.handle_log_data_missing() | python | {
"resource": ""
} |
q230683 | complete_modules | train | def complete_modules(text):
'''complete mavproxy module names'''
import MAVProxy.modules, pkgutil
modlist = [x[1] for x in pkgutil.iter_modules(MAVProxy.modules.__path__)]
ret = []
loaded = set(complete_loadedmodules(''))
for m in modlist:
if not m.startswith("mavproxy_"):
co... | python | {
"resource": ""
} |
q230684 | complete_filename | train | def complete_filename(text):
'''complete a filename'''
#ensure directories have trailing slashes:
list = glob.glob(text+'*')
for idx, val in enumerate(list):
if os.path.isdir(val):
list[idx] = (val + os.path.sep)
return list | python | {
"resource": ""
} |
q230685 | complete_variable | train | def complete_variable(text):
'''complete a MAVLink variable'''
if text.find('.') != -1:
var = text.split('.')[0]
if var in rline_mpstate.status.msgs:
ret = []
for f in rline_mpstate.status.msgs[var].get_fieldnames():
ret.append(var + '.' + f)
r... | python | {
"resource": ""
} |
q230686 | rule_expand | train | def rule_expand(component, text):
'''expand one rule component'''
global rline_mpstate
if component[0] == '<' and component[-1] == '>':
return component[1:-1].split('|')
if component in rline_mpstate.completion_functions:
return rline_mpstate.completion_functions[component](text)
ret... | python | {
"resource": ""
} |
q230687 | rule_match | train | def rule_match(component, cmd):
'''see if one rule component matches'''
if component == cmd:
return True
expanded = rule_expand(component, cmd)
if cmd in expanded:
return True
return False | python | {
"resource": ""
} |
q230688 | complete_rules | train | def complete_rules(rules, cmd):
'''complete using a list of completion rules'''
if not isinstance(rules, list):
rules = [rules]
ret = []
for r in rules:
ret += complete_rule(r, cmd)
return ret | python | {
"resource": ""
} |
q230689 | complete | train | def complete(text, state):
'''completion routine for when user presses tab'''
global last_clist
global rline_mpstate
if state != 0 and last_clist is not None:
return last_clist[state]
# split the command so far
cmd = readline.get_line_buffer().split()
if len(cmd) == 1:
# if... | python | {
"resource": ""
} |
q230690 | laserScan2LaserData | train | def laserScan2LaserData(scan):
'''
Translates from ROS LaserScan to JderobotTypes LaserData.
@param scan: ROS LaserScan to translate
@type scan: LaserScan
@return a LaserData translated from scan
'''
laser = LaserData()
laser.values = scan.ranges
'''
ROS Angle Map ... | python | {
"resource": ""
} |
q230691 | ListenerLaser.__callback | train | def __callback (self, scan):
'''
Callback function to receive and save Laser Scans.
@param scan: ROS LaserScan received
@type scan: LaserScan
'''
laser = laserScan2LaserData(scan)
self.lock.acquire()
self.data = laser
self.lock.release... | python | {
"resource": ""
} |
q230692 | add_to_linestring | train | def add_to_linestring(position_data, kml_linestring):
'''add a point to the kml file'''
global kml
# add altitude offset
position_data[2] += float(args.aoff)
kml_linestring.coords.addcoordinates([position_data]) | python | {
"resource": ""
} |
q230693 | sniff_field_spelling | train | def sniff_field_spelling(mlog, source):
'''attempt to detect whether APM or PX4 attributes names are in use'''
position_field_type_default = position_field_types[0] # Default to PX4 spelling
msg = mlog.recv_match(source)
mlog._rewind() # Unfortunately it's either call this or return a mutated objec... | python | {
"resource": ""
} |
q230694 | LinkModule.cmd_link_ports | train | def cmd_link_ports(self):
'''show available ports'''
ports = mavutil.auto_detect_serial(preferred_list=['*FTDI*',"*Arduino_Mega_2560*", "*3D_Robotics*", "*USB_to_UART*", '*PX4*', '*FMU*'])
for p in ports:
print("%s : %s : %s" % (p.device, p.description, p.hwid)) | python | {
"resource": ""
} |
q230695 | SimpleConsole.writeln | train | def writeln(self, text, fg='black', bg='white'):
'''write to the console with linefeed'''
if not isinstance(text, str):
text = str(text)
self.write(text + '\n', fg=fg, bg=bg) | python | {
"resource": ""
} |
q230696 | match_extension | train | def match_extension(f):
'''see if the path matches a extension'''
(root,ext) = os.path.splitext(f)
return ext.lower() in extensions | python | {
"resource": ""
} |
q230697 | TileInfo.path | train | def path(self):
'''return relative path of tile image'''
(x, y) = self.tile
return os.path.join('%u' % self.zoom,
'%u' % y,
'%u.img' % x) | python | {
"resource": ""
} |
q230698 | TileInfo.url | train | def url(self, service):
'''return URL for a tile'''
if service not in TILE_SERVICES:
raise TileException('unknown tile service %s' % service)
url = string.Template(TILE_SERVICES[service])
(x,y) = self.tile
tile_info = TileServiceInfo(x, y, self.zoom)
return url.substitute(tile_info) | python | {
"resource": ""
} |
q230699 | MPTile.tile_to_path | train | def tile_to_path(self, tile):
'''return full path to a tile'''
return os.path.join(self.cache_path, self.service, tile.path()) | python | {
"resource": ""
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.