def generate_accessor(accessor, instr, reg): accfmt = instr[accessor['access_type']] if accfmt['type'] == 'read': templ = RS_REG_READ elif accfmt['type'] == 'write': templ = RS_REG_WRITE elif accfmt['type'] == 'modify': logwarn("modify is not handled yet!") return "" else: logerr("unknown access format type '{}'".format(accfmt['type'])) if reg['use_encoding']: encstr = "S{}_{}_C{}_C{}_{}".format( int(accessor['encoding']['op0'], base=2), int(accessor['encoding']['op1'], base=2), int(accessor['encoding']['crn'], base=2), int(accessor['encoding']['crm'], base=2), int(accessor['encoding']['op2'], base=2), ) else: encstr = reg['id'] encoding = accfmt['fmt'][0] + " " + ", ".join( accfmt['fmt'][1:]).format(encstr) return templ.format(name=reg['name'], id=reg['id'], length=reg['length'], access=accessor['access_instruction'], enc=encoding)
def generate_system_instr(reg, instr): systeminstr = RS_SECTION.format(header=reg['name']) for accessor in reg['access']: accfmt = instr[accessor['access_type']] opinstr = accessor['access_instruction'] if accfmt['type'] != None: logerr("expected none, was {}".format(accfmt['type'])) encstr = reg['id'].split('_')[1] # this is an optional argument if '{, <Xt>}' in opinstr: # template = RS_SYSINSTR_ARG + RS_SYSINSTR template = RS_SYSINSTR instrfmt = accfmt['fmt'][0] + " " + ", ".join(accfmt['fmt'][1:-1]) else: if '$0' in accfmt['fmt']: template = RS_SYSINSTR_ARG instrfmt = accfmt['fmt'][0] + " " + ", ".join( accfmt['fmt'][1:]) else: template = RS_SYSINSTR instrfmt = accfmt['fmt'][0] + " " + ", ".join( accfmt['fmt'][1:-1]) systeminstr = systeminstr + template.format( fn=reg['id'], desc=reg['name'], length=reg['length'], instr=instrfmt.format(encstr)) return systeminstr
def _bad_sql(sql): bad_sql_words = ['create', 'drop', 'delete', 'update', 'alter', 'grant'] if any(x in sql.lower() for x in bad_sql_words): logerr("You wrote some destructive SQL. Exiting.") sys.exit(0) else: pass
def Interrupt_Flight(lander_channel, controller_channel): #Interrupt flight, disable controller and enable lander rate = rospy.Rate(30) utils.logerr('Flight interrupted, landing mode active') while not rospy.is_shutdown(): lander_channel.publish(True) controller_channel.publish(False) rate.sleep()
def generate(sysreg, outdir): generate_register_access_module(sysreg, outdir / "registers") generate_sysinstr(sysreg, outdir / "instructions") try: cargo("fmt") except ProcessExecutionError as e: logerr("Could not format. {}".format(e.retcode))
def Interrupt_Flight(lander_channel,controller_channel): #Interrupt flight, disable controller and enable lander rate=rospy.Rate(30) utils.logerr('Flight interrupted, landing mode active') while not rospy.is_shutdown(): lander_channel.publish(True) controller_channel.publish(False) rate.sleep()
def extract_tar(tarfile, outdir): try: with local.cwd(outdir): log("Extracting archive...") tarargs = ["-xf", tarfile] logcmd("tar", tarargs) tar(*tarargs) except ProcessExecutionError as e: logerr("Could not extract file: {}".format(e.retcode))
def build(self, buildflags=['-Cdf'], recursive=False): if recursive: for d in self.deps: succeeded = d.build(buildflags=buildflags, recursive=True) if not succeeded: return False # one dep fails, the entire branch fails immediately, software will not be runnable if self.in_repos or (self.installed and not self.in_aur): return True if self.installed and self.in_aur and self.version_installed == self.version_latest: return True pkgs = pkg_in_cache(self) if len(pkgs) > 0: self.built_pkgs.append( pkgs[0] ) # we only need one of them, not all, if multiple ones with different extensions have been built return True utils.logmsg(self.ctx.v, 3, "building sources of {}".format(self.name)) if self.srcpkg.built: return self.srcpkg.build_success succeeded = self.srcpkg.build(buildflags=buildflags) if not succeeded: utils.logerr( None, "Building sources of package {} failed, aborting this subtree". format(self.name)) return False pkgext = os.environ.get('PKGEXT') or 'tar.xz' fullpkgname_x86_64 = "{}-{}-x86_64.pkg.{}".format( self.name, self.version_latest, pkgext) fullpkgname_any = "{}-{}-any.pkg.{}".format(self.name, self.version_latest, pkgext) if fullpkgname_x86_64 in os.listdir(self.srcpkg.srcdir): self.built_pkgs.append(fullpkgname_x86_64) shutil.move(os.path.join(self.srcpkg.srcdir, fullpkgname_x86_64), self.ctx.cachedir) elif fullpkgname_any in os.listdir(self.srcpkg.srcdir): self.built_pkgs.append(fullpkgname_any) shutil.move(os.path.join(self.srcpkg.srcdir, fullpkgname_any), self.ctx.cachedir) else: utils.logerr( None, "Package file {}-{}-{}.pkg.{} was not found in builddir, aborting this subtree" .format(self.name, self.version_latest, "{x86_64,any}", pkgext)) return False return True
def download_file(url, outfile): if outfile.is_file(): log("Skipping download, as file already exists") try: log("Downloading file...") wgetargs = ["-O", outfile, url] logcmd("wget", wgetargs) wget(*wgetargs) except ProcessExecutionError as e: logerr("Could not download file: {}".format(e.errno))
def Connect_To_Mocap(NODE_NAME): #Connect to the Motion Capture System, flag an error if it is unavailable try: utils.loginfo('Connecting to the mocap system...') rospy.wait_for_service('mocap_get_data',10) except: utils.logerr('No connection to the mocap system') sys.exit() utils.loginfo('Connected to Mocap') return rospy.ServiceProxy('mocap_get_data',BodyData)
def Set_Flight_Mode(MODE): """This function sets the flight mode of the drone to MODE.""" return_value=True #Change the flight mode on the Pixhawk flight controller try: rospy.wait_for_service('mavros/set_mode',10) except: utils.logerr('Mavros is not available') return_value=False utils.loginfo('Changing flight mode to '+MODE+' ...') rospy.sleep(2) try: change_param=rospy.ServiceProxy('mavros/set_mode',SetMode) param=change_param(0,MODE) while param.success==False: param=change_param(0,MODE) if param.success==False: utils.logerr('Cannot change flight mode') if param.success: utils.loginfo('Flight mode changed to '+MODE) else: utils.logerr('Cannot change flight mode') return_value=False except: utils.logerr('Cannot change flight mode') return_value=False return return_value
def Set_Flight_Mode(MODE): """This function sets the flight mode of the drone to MODE.""" return_value = True #Change the flight mode on the Pixhawk flight controller try: rospy.wait_for_service('mavros/set_mode', 10) except: utils.logerr('Mavros is not available') return_value = False utils.loginfo('Changing flight mode to ' + MODE + ' ...') rospy.sleep(2) try: change_param = rospy.ServiceProxy('mavros/set_mode', SetMode) param = change_param(0, MODE) while param.success == False: param = change_param(0, MODE) if param.success == False: utils.logerr('Cannot change flight mode') if param.success: utils.loginfo('Flight mode changed to ' + MODE) else: utils.logerr('Cannot change flight mode') return_value = False except: utils.logerr('Cannot change flight mode') return_value = False return return_value
def getConfig(): import sys import commentjson as cj from constants import CONFIGFILE from utils import loginfo, logerr try: config = cj.load(open(CONFIGFILE)) except Exception as e: logerr("Error while reading config file.") logerr(e) sys.exit() return config
def cleanup(self): def errhandler(func, path, excinfo): os.chmod(path, stat.S_IWUSR | stat.S_IRUSR | stat.S_IXUSR) if os.path.isdir(path): os.rmdir(path) else: os.remove(path) if self.srcdir: try: shutil.rmtree(self.srcdir, onerror=errhandler) except PermissionError: utils.logerr( None, "Cannot remove {}: Permission denied".format(self.srcdir)) self.srcdir = None # if we couldn't remove it, we can't next time, so we ignore the exception and continue
def main(): # load the configuration file cfg = None try: with open(FILE_CONFIG) as cfgfile: cfg = json.load(cfgfile) except: logerr("Failed to load configuraton file.") # setting up argsparse parser = argparse.ArgumentParser( description='Building Enzian ThunderX firmware images.') parser.add_argument('command', metavar='cmd', choices=commands.keys(), help='The command to be executed {}'.format( [s for s in commands.keys()])) versions = [str(v) for v in cfg["versions"].keys()] parser.add_argument('--version', metavar='version', choices=versions, default=cfg["default"], help='The version to build for {}'.format(versions)) parser.add_argument('--target', metavar='target', choices=CODEGENS, default=CODEGENS[0], help='The version to build for {}'.format(CODEGENS)) parser.add_argument('--verbose', default=False, action='store_true', help='print commands before executing them') args = parser.parse_args() # set the global VERBOSE argument logsetverbose(args.verbose) # run the command commands[args.command](cfg, args)
def parse_field_node(field_node, length): # <field ..> # <field_msb>63</field_msb> # <field_lsb>32</field_lsb> # <field_description order="before"> # ... # </field_description> # </field> if field_node is None: logerr(" - expected a field node, but was None!") return None field_msb = int(field_node.find('field_msb').text) field_lsb = int(field_node.find('field_lsb').text) field_size = field_msb - field_lsb + 1 field_name_node = field_node.find('field_name') field_id = filterident(field_node.attrib['id']) if field_id == "none_{}_0".format(length - 1): field_id = 'val' if field_name_node is None: field_name = field_id else: field_name = field_name_node.text is_reserved = False desc = field_node.find('field_description/para') if desc is not None: if desc.text is not None: is_reserved = desc.text.startswith("Reserved") logverbose(" - {} [{}..{}] ({} bits)".format(field_id, field_lsb, field_msb, field_size)) return { "id": field_id, "name": field_name, "msb": field_msb, "lsb": field_lsb, "size": field_size, "reserved": is_reserved }
def parse_reg_purpose_node(reg_purpose_node): # layout of the reg_purpose node # # <reg_purpose> # <purpose_text> # <para>...</para> # </purpose_text> # </reg_purpose> if reg_purpose_node == None: logerr(" - expected a reg_purpose node, but was None!") return None para_node = reg_purpose_node.find("purpose_text/para") if para_node is None: logerr( ' - expected a `reg_purpose` node in the register description. found none.' ) return para_node.text
def Wait_For_ID(id_int): return_value = False # Wait for Mavros connection and wait until the parameter SYSID_MYGCS is available utils.loginfo('Connecting to Mavros ...') try: rospy.wait_for_service('mavros/param/set', 10) except: utils.logerr( 'Mavros is not available (fail to contact service mavros/param/set).' ) return_value = False utils.loginfo('Connected to Mavros') set_param = rospy.ServiceProxy('mavros/param/set', ParamSet) while return_value == False: try: param = set_param('SYSID_MYGCS', id_int, 0.0) if param.success: utils.loginfo('System ID changed') return_value = True else: utils.logerr('Cannot change system ID') return_value = False except: utils.logerr( 'Cannot connect to the service "mavros/param/set" to change system ID' ) return_value = False rospy.sleep(5) utils.loginfo('Iris initialised...') return return_value
def Set_System_ID(id_int): return_value = True """This function sets the system ID and checks if it is possible to connect to mavros. The system ID should be 1 to be able to use the rc/override topic.""" utils.loginfo('Connecting to Mavros ...') try: rospy.wait_for_service('mavros/param/set', 10) except: utils.logerr( 'Mavros is not available (fail to contact service mavros/param/set).' ) return_value = False utils.loginfo('Connected to Mavros') utils.loginfo('Changing system ID ...') rospy.sleep(2) try: change_param = rospy.ServiceProxy('mavros/param/set', ParamSet) param = change_param('SYSID_MYGCS', id_int, 0.0) if param.success: utils.loginfo('System ID changed') else: utils.logerr('Cannot change system ID') return_value = False except: utils.logerr('Cannot change system ID') return_value = False return return_value
def Set_System_ID(NODE_NAME,id_int): return_value=True #Necesary to allow RCOverride #Also checks if there is a connection to Mavros, and shuts down if there isn't utils.loginfo('Connecting to Mavros ...') try: rospy.wait_for_service('mavros/param/set',10) except: utils.logerr('Mavros is not available') return_value=False utils.loginfo('Connected to Mavros') utils.loginfo('Changing system ID ...') rospy.sleep(2) try: change_param=rospy.ServiceProxy('mavros/param/set',ParamSet) param=change_param('SYSID_MYGCS',id_int,0.0) except: utils.logerr('Cannot change system ID') return_value=False if param.success: utils.loginfo('System ID changed') else: utils.logerr('Cannot change system ID') return_value=False return return_value
def Set_Flight_Mode(NODE_NAME,MODE): return_value=True #Change the flight mode on the Pixhawk flight controller try: rospy.wait_for_service('/mavros/set_mode',10) except: utils.logerr('Mavros is not available') return_value=False utils.loginfo('Changing flight mode to '+MODE+' ...') rospy.sleep(2) try: change_param=rospy.ServiceProxy('/mavros/set_mode',SetMode) param=change_param(0,MODE) except: utils.logerr('Cannot change flight mode') return_value=False if param.success: utils.loginfo('Flight mode changed to '+MODE) else: utils.logerr('Cannot change flight mode') return_value=False return return_value
def Set_System_ID(id_int): return_value=True """This function sets the system ID and checks if it is possible to connect to mavros. The system ID should be 1 to be able to use the rc/override topic.""" utils.loginfo('Connecting to Mavros ...') try: rospy.wait_for_service('mavros/param/set',10) except: utils.logerr('Mavros is not available (fail to contact service mavros/param/set).') return_value=False utils.loginfo('Connected to Mavros') utils.loginfo('Changing system ID ...') rospy.sleep(2) try: change_param=rospy.ServiceProxy('mavros/param/set',ParamSet) param=change_param('SYSID_MYGCS',id_int,0.0) if param.success: utils.loginfo('System ID changed') else: utils.logerr('Cannot change system ID') return_value=False except: utils.logerr('Cannot change system ID') return_value=False return return_value
def Wait_For_ID(id_int): return_value=False # Wait for Mavros connection and wait until the parameter SYSID_MYGCS is available utils.loginfo('Connecting to Mavros ...') try: rospy.wait_for_service('mavros/param/set',10) except: utils.logerr('Mavros is not available (fail to contact service mavros/param/set).') return_value=False utils.loginfo('Connected to Mavros') set_param=rospy.ServiceProxy('mavros/param/set',ParamSet) while return_value==False: try: param=set_param('SYSID_MYGCS',id_int,0.0) if param.success: utils.loginfo('System ID changed') return_value=True else: utils.logerr('Cannot change system ID') return_value=False except: utils.logerr('Cannot change system ID') return_value=False rospy.sleep(5) utils.loginfo('Iris initialised...') return return_value
def generate(cfg, args): logtitle("Generating AArch64 register bindings for {}".format(args.target)) jsonfile = DIR_DATA / args.version / "sysreg.json" if not jsonfile.is_file(): logwarn("json file is not present, trying to generated") do_parse(cfg, args) # load the json file sysregdata = None try: with open(jsonfile) as sysregjson: sysregdata = json.load(sysregjson) except: logerr("Failed to load configuraton file.") if args.target == 'rust': rustcode.generate(sysregdata, DIR_OUTPUT) else: logerr("unknown target {}".format(args.target)) logok("Generated access code for {}".format(args.target))
def parse_reg_groups_node(reg_groups_node): # layout of the reg_groups node # <reg_groups> # <reg_group>...</reg_group> # ... # </reg_groups> if reg_groups_node == None: logerr("expected a reg_groups node, but was None!") return None reg_groups = [] for reg_group in reg_groups_node.findall("reg_group"): reg_groups.append(reg_group.text) if len(reg_groups) == 1: return reg_groups[0] if len(reg_groups) == 0: logerr(" - expected at least one reg group!") reg_groups_filtered = [] reg_groups_discarded = [] for reg_group in reg_groups: if reg_group in ['IMPLEMENTATION DEFINED', 'Virtualization registers']: reg_groups_discarded.append(reg_group) else: reg_groups_filtered.append(reg_group) if len(reg_groups_filtered) == 1: return reg_groups_filtered[0] if len(reg_groups_filtered) > 2: print("filtered", reg_groups_filtered) print("discarded", reg_groups_discarded) return reg_groups_filtered[0] return 'Virtualization registers'
def Arming_Quad(base_name=""): """This function is used to arm the quad.""" return_value = True #Arming the Quad srv_path = 'mavros/cmd/arming' if base_name != "": srv_path = "/%s/%s" % (base_name, srv_path) try: utils.loginfo('Arming Quad ...') rospy.wait_for_service(srv_path, 10) except: utils.logerr('No connection to Mavros') return_value = False try: arming = rospy.ServiceProxy(srv_path, CommandBool) arming_result = arming(True) except: utils.logerr('Cannot arm quad') return_value = False rospy.sleep(1) #Arming has to be done twice sometimes... try: arming = rospy.ServiceProxy(srv_path, CommandBool) arming_result = arming(True) except: utils.logerr('Cannot arm quad') return_value = False rospy.sleep(1) if arming_result.success: utils.loginfo('Quad is now armed') else: utils.logerr('Cannot arm quad') return_value = False return return_value
def Arming_Quad(base_name=""): """This function is used to arm the quad.""" return_value=True #Arming the Quad srv_path = 'mavros/cmd/arming' if base_name!="": srv_path = "/%s/%s"%(base_name,srv_path) try: utils.loginfo('Arming Quad ...') rospy.wait_for_service(srv_path,10) except: utils.logerr('No connection to Mavros') return_value=False try: arming=rospy.ServiceProxy(srv_path,CommandBool) arming_result=arming(True) except: utils.logerr('Cannot arm quad') return_value=False rospy.sleep(1) #Arming has to be done twice sometimes... try: arming=rospy.ServiceProxy(srv_path,CommandBool) arming_result=arming(True) except: utils.logerr('Cannot arm quad') return_value=False rospy.sleep(1) if arming_result.success: utils.loginfo('Quad is now armed') else: utils.logerr('Cannot arm quad') return_value=False return return_value
def Wait_For_Arming(): return_value=False #Arming the Quad try: utils.loginfo('Arming Quad ...') rospy.wait_for_service('mavros/cmd/arming',10) except: utils.logerr('No connection to Mavros') return_value=False try: arming=rospy.ServiceProxy('mavros/cmd/arming',CommandBool) arming_result=arming(True) except: utils.logerr('Cannot arm quad') return_value=False rospy.sleep(1) set_param=rospy.ServiceProxy('mavros/param/set',ParamSet) while return_value==False: #Arming has to be done twice sometimes... try: arming=rospy.ServiceProxy('mavros/cmd/arming',CommandBool) arming_result=arming(True) if arming_result.success: utils.loginfo('Quad is now armed') else: utils.logerr('Cannot arm quad') return_value=False except: utils.logerr('Cannot arm quad') return_value=False rospy.sleep(20) return return_value
def Wait_For_Arming(): return_value = False #Arming the Quad try: utils.loginfo('Arming Quad ...') rospy.wait_for_service('mavros/cmd/arming', 10) except: utils.logerr('No connection to Mavros') return_value = False try: arming = rospy.ServiceProxy('mavros/cmd/arming', CommandBool) arming_result = arming(True) except: utils.logerr('Cannot arm quad') return_value = False rospy.sleep(1) set_param = rospy.ServiceProxy('mavros/param/set', ParamSet) while return_value == False: #Arming has to be done twice sometimes... try: arming = rospy.ServiceProxy('mavros/cmd/arming', CommandBool) arming_result = arming(True) if arming_result.success: utils.loginfo('Quad is now armed') else: utils.logerr('Cannot arm quad') return_value = False except: utils.logerr('Cannot arm quad') return_value = False rospy.sleep(20) return return_value
def Security_Check(current_point): keep_controller=False if current_point.get_time()<0.5: if current_point.found_body: if Within_Boundaries(current_point.x,current_point.y,current_point.z): keep_controller=True else: utils.logerr('Out of boundaries.') keep_controller=False return keep_controller else: utils.logerr('Body not found.') keep_controller=False return keep_controller else: utils.logerr('Lost mocap signal (no signal during more than 0.5 seconds).') keep_controller=False return keep_controller return keep_controller
def Security_Check(current_point): keep_controller = False if current_point.get_time() < 0.5: if current_point.found_body: if Within_Boundaries(current_point.x, current_point.y, current_point.z): keep_controller = True else: utils.logerr('Out of boundaries.') keep_controller = False return keep_controller else: utils.logerr('Body not found.') keep_controller = False return keep_controller else: utils.logerr( 'Lost mocap signal (no signal during more than 0.5 seconds).') keep_controller = False return keep_controller return keep_controller
#Prepare the Iris for flight (set system ID and arm) #ready_to_fly=Prepare_For_Flight() #if not ready_to_fly: # Interrupt_Flight(lander_channel,controller_channel) while not rospy.is_shutdown(): controller_on = Security_Check(current_point) if trajectory_done.is_done: controller_on = False if controller_on: lander_permission.permission = False controller_permission.permission = True else: utils.logerr('Initiate landing mode') lander_permission.permission = True controller_permission.permission = False while not rospy.is_shutdown(): lander_channel.publish(lander_permission) controller_channel.publish(controller_permission) loop_rate.sleep() lander_channel.publish(lander_permission) controller_channel.publish(controller_permission) if controller_on: quad_state = Get_Quad_State(current_point) data_forward.publish(quad_state) loop_rate.sleep()
def build_packages_from_aur(package_candidates, install_as_dep=False): aurpkgs, repopkgs, notfoundpkgs = utils.check_in_aur(package_candidates) if repopkgs: utils.logmsg( ctx.v, 1, "Skipping: {}: packaged in repos".format(", ".join(repopkgs))) if notfoundpkgs: utils.logmsg( ctx.v, 1, "Skipping: {}: neither in repos nor AUR".format( ", ".join(notfoundpkgs))) packages = [] skipped_packages = [] utils.logmsg( ctx.v, 0, "Fetching information and files for dependency-graph for {} package{}". format(len(aurpkgs), '' if len(aurpkgs) == 1 else 's')) async def gen_package_obj(pkgnamelist, ctx): pkgobj = [] loop = asyncio.get_event_loop() futures = [ loop.run_in_executor(None, Package, p, ctx) for p in pkgnamelist ] for p in await asyncio.gather(*futures): pkgobj.append(p) return pkgobj loop = asyncio.get_event_loop() packages = loop.run_until_complete(gen_package_obj(aurpkgs, ctx)) for p in packages: if not p.review(): utils.logmsg(ctx.v, 0, "Skipping: {}: Did not pass review".format(p.name)) skipped_packages.append(p) # drop all packages that did not pass review for p in skipped_packages: packages.remove(p) uninstalled_makedeps = set() skipped_due_to_missing_makedeps = [] for p in packages: md = p.get_makedeps() md_not_found = [ p for p in md if not p.installed and not p.in_repos and not p.in_aur ] if len(md_not_found) > 0: utils.logerr( None, "{}: cannot satisfy makedeps from either repos, AUR or local installed packages, skipping" .format(p.name)) skipped_packages.append(p) skipped_due_to_missing_makedeps.append(p) md_available = set( [p for p in md if not p.installed and (p.in_repos or p.in_aur)]) uninstalled_makedeps = uninstalled_makedeps.union(md_available) # drop all packages whose makedeps cannot be satisfied for p in skipped_due_to_missing_makedeps: packages.remove(p) md_aur = [p for p in uninstalled_makedeps if p.in_aur] if len(md_aur) > 0: utils.logmsg( ctx.v, 0, "Building makedeps from aur: {}".format(", ".join( p.name for p in md_aur))) build_packages_from_aur(md_aur, install_as_dep=True) repodeps = set() for p in packages: repodeps = repodeps.union(p.get_repodeps()) md_repos = [p.name for p in uninstalled_makedeps if p.in_repos] repodeps_uninstalled = [p.name for p in repodeps if not p.installed] to_be_installed = set(repodeps_uninstalled).union(md_repos) if to_be_installed: utils.logmsg(ctx.v, 0, "Installing dependencies and makedeps from repos") if not pacman.install_repo_packages(to_be_installed, asdeps=True): utils.logerr(0, "Could not install deps and makedeps from repos") for p in packages: success = p.build(buildflags=['-Cfd'], recursive=True) if success: od = p.get_optdeps() for name, optdeplist in od: print(" :: Package {} has optional dependencies:") for odname in optdeplist: print(" - {}".format(odname)) built_pkgs = set() built_deps = set() for p in packages: built_pkgs = built_pkgs.union(set(p.built_pkgs)) for d in p.deps: built_deps = built_deps.union(d.get_built_pkgs()) os.chdir(ctx.cachedir) if args.buildonly: utils.logmsg(ctx.v, 1, "Packages have been built:") utils.logmsg(ctx.v, 1, ", ", join(built_deps + built_pkgs) or "None") else: if built_deps: utils.logmsg(ctx.v, 0, "Installing package dependencies") if not pacman.install_package_files(built_deps, asdeps=True): utils.logerr(2, "Failed to install built package dependencies") if built_pkgs: utils.logmsg(ctx.v, 0, "Installing built packages") if not pacman.install_package_files(built_pkgs, asdeps=install_as_dep): utils.logerr(2, "Failed to install built packages") else: utils.logmsg(ctx.v, 0, "No packages built, nothing to install") if uninstalled_makedeps: utils.logmsg(ctx.v, 0, "Removing previously uninstalled makedeps") if not pacman.remove_packages( [p for p in uninstalled_makedeps if pacman.is_installed(p.name)]): utils.logerr(None, "Failed to remove previously uninstalled makedeps") if not args.keep_sources == "all": for p in packages: p.remove_sources() if not args.keep_sources in ["all", "skipped"]: for p in skipped_packages: p.remove_sources()
#ready_to_fly=Prepare_For_Flight() #if not ready_to_fly: # Interrupt_Flight(lander_channel,controller_channel) while not rospy.is_shutdown(): controller_on=Security_Check(current_point) if trajectory_done.is_done: controller_on=False if controller_on: lander_permission.permission=False controller_permission.permission=True else: utils.logerr('Initiate landing mode') lander_permission.permission=True controller_permission.permission=False while not rospy.is_shutdown(): lander_channel.publish(lander_permission) controller_channel.publish(controller_permission) loop_rate.sleep() lander_channel.publish(lander_permission) controller_channel.publish(controller_permission) if controller_on: quad_state=Get_Quad_State(current_point) data_forward.publish(quad_state) loop_rate.sleep()
def parse_access_mechanisms_node(regname, access_mechanisms_node, instr): # <access_mechanisms> # <access_mechanism accessor="..."> # <encoding> # <access_instruction>...</access_instruction> # <enc n=".." v=".."/> # <enc n=".." v=".."/> # <enc n=".." v=".."/> # <enc n=".." v=".."/> # <enc n=".." v=".."/> # </encoding> # ... # </access_mechanism> # ... # </access_mechanisms> if access_mechanisms_node == None: logerr("expected a access_mechanisms_node node, but was None!") return None is_writable = False is_readable = False access_mechanisms = [] for access_machism in access_mechanisms_node.findall("access_mechanism"): # getting the encoding node encoding_node = access_machism.find("encoding") if encoding_node is None: logerr("expected finding an encoding node, but was none") # get the accessor node and extract the accessor type accessor = access_machism.attrib["accessor"] accesstype = accessor_type(accessor) # the accessor type should be in the known instructions if (accesstype not in instr): logerr("accessor type '{}' not found in {}".format( accesstype, instr.keys())) # check if the register is writable or readable access_instr = instr[accesstype] if access_instr["type"] == "write": is_writable = True if access_instr["type"] == "read": is_readable = True # get the access_instruction node within access_instruction = encoding_node.find("access_instruction") if access_instruction is None: logerr("expected finding an access_instruction node, but was none") # skip those accessors with two execution levels access_ident = filterident(access_instruction.text) if "_el12" in access_ident: continue if "_el02" in access_ident: continue # skipping the nxs variants of those accesses if "tlbi" in access_ident and "nxs" in access_ident: continue regname = regname.replace("icv", 'icc') if "_el" in regname and regname not in access_ident: #logwarn("XXX {} {}".format(regname, access_ident)) continue encodings = {} for enc in encoding_node.findall("enc"): n = enc.attrib["n"] v = enc.attrib["v"] encodings[n.lower()] = v access_mechanisms.append({ "access_instruction": access_instruction.text, "access_type": accesstype, "encoding": encodings }) if len(access_mechanisms) == 0: logerr("no access mechanisms present") return (is_writable, is_readable, access_mechanisms)
def parse_reg_fieldsets_node(reg_fieldsets_node, is_register): # <reg_fieldsets> # ... # <fields length="64"> # <field ..> # <field_msb>63</field_msb> # <field_lsb>32</field_lsb> # <field_description order="before"> # ... # </field_description> # </field> # </fields> # ... # <reg_fieldset length="64"> # <fieldat id="0_63_32" lsb="32" msb="63"/> # ... # </reg_fieldset> # ... # </reg_fieldsets> if reg_fieldsets_node == None: logerr(" - expected a reg_fieldsets node, but was None!") return None # here there can be multiple fields/fieldset definitions. we take the one for aarc64 fields_nodes = [] for fields_node in reg_fieldsets_node.findall("fields"): fields_condition = fields_node.find("fields_condition") if fields_condition is None: fields_nodes.append(fields_node) continue if fields_condition.text is None: fields_nodes.append(fields_node) continue # do not take anything from AAarch32 if "from AArch32" in fields_condition.text or \ "to AArch32" in fields_condition.text or \ "using AArch32" in fields_condition.text: continue if fields_condition.text.endswith("== 0"): continue if "AArch32" in fields_condition.text: logwarn(' - had aarch32') fields_nodes.append(fields_node) # we have no fields, probably this is a cache if len(fields_nodes) == 0: if not is_register: return (0, None) else: logerr( " - expected fields_nodes to have exactly one element, had 0" ) if len(fields_nodes) != 1: logwarn( " - expected fields_nodes to have exactly one element, had {}". format(len(fields_nodes))) fields_node = fields_nodes[0] length = int(fields_node.attrib["length"]) fields = [] for field_node in fields_node.findall("field"): field = parse_field_node(field_node, length) fields.append(field) return (length, fields)
def do_parse(cfg, args): version = cfg["versions"][args.version] log("Version: {}".format(args.version)) # check if the data directory exists, if not download files xmldir = DIR_DATA / args.version if not xmldir.is_dir(): logwarn("xml files are not present, trying to download...") do_download(cfg, args) # get the instructions instrxmlfile = DIR_DATA / args.version / version["instructions"] instr = parse_xml_instructions(cfg, args, instrxmlfile) registers = [] sysinstr = [] xmldir = xmlfilepath = DIR_DATA / args.version for f in os.listdir(xmldir): # skip non xml files if not f.endswith(".xml"): continue # skip the instructions file if f == version["instructions"]: continue # dskip ignored files if f in version['filemap']['ignored']: continue # skip use_encoding = False if f in version["filemap"]['useencoding']: use_encoding = True xmlfilepath = xmldir / f (parsed_registers, parsed_others) = parse_xml_file(cfg, args, instr, xmlfilepath) for pr in parsed_registers: pr['use_encoding'] = use_encoding registers.append(pr) for po in parsed_others: po['use_encoding'] = use_encoding sysinstr.append(po) registers.sort(key=lambda x: x['id']) sysinstr.sort(key=lambda x: x['id']) # the json file for the parsed output jsonfile = DIR_DATA / args.version / "sysreg.json" with open(jsonfile, "w") as write_file: jsondata = { 'instrfmt': instr, 'version': args.version, 'url': version['url'], 'registers': registers, 'instructions': sysinstr } try: json.dump(jsondata, write_file, indent=2) except: logerr("could not store the sysregs json file")
def parse_register_node(cfg, args, instr, reg_node): # the structure of the register node is as follows: # # <register execution_state="AArch64" is_register="True" is_internal="True" is_banked="False" is_stub_entry="False"> # <reg_short_name>SPSR_EL1</reg_short_name> # <reg_long_name>Saved Program Status Register (EL1)</reg_long_name> # <reg_reset_value></reg_reset_value> # <reg_mappings> .. </reg_mappings> # <reg_purpose> .. </reg_purpose> # <reg_groups> .. </reg_groups> # <reg_configuration></reg_configuration> # <reg_attributes> .. </reg_attributes> # <reg_fieldsets> .. </reg_fieldsets> # <access_mechanisms> .. </access_mechanisms> # <arch_variants> .. </arch_variants> # </register> # extract the `reg_short_name` node text, remove all non-identifier-compatible args reg_id = filterident(reg_node.find("reg_short_name").text) # extract the long name from the register node reg_name = reg_node.find("reg_long_name").text if "execution_state" not in reg_node.attrib: logerr(" @ Register: {} ({}) has no execution state, skipping.".format( reg_name, reg_id)) return None if reg_node.attrib["execution_state"] != "AArch64": logerr(" @ Register: {} ({}) is not AArch64, skipping.".format( reg_name, reg_id)) return None # is this a register description or an instruction? is_register = (reg_node.attrib["is_register"] == "True") if is_register: log(" @ Parsing register description: {} ({})".format( reg_name, reg_id)) else: log(" @ Parsing instruction description: {} ({})".format( reg_name, reg_id)) # reg_reset_value seems to be never set, skipping it #if len (reg_node.find("reg_reset_value").getchildren()) > 0 : # logerr("reg_reset_value was not empty") # reg_mappings won't be used later on as they describe mapping onto AArch32 # if len (reg_node.find("reg_mappings").getchildren()) > 0 : # logerr("reg_mappings was not empty") # extract the purpose of this register reg_purpose = parse_reg_purpose_node(reg_node.find("reg_purpose")) # get the register groups reg_group = parse_reg_groups_node(reg_node.find("reg_groups")) # reg_configuration won't be used # if len (reg_node.find("reg_configuration").getchildren()) > 0 : # logerr("reg_configuration was not empty") # reg_attributes won't be used # if len (reg_node.find("reg_attributes").getchildren()) > 0 : # logwarn("reg_attributes was not empty") # extract the reg_fieldsets length, reg_fieldsets = parse_reg_fieldsets_node( reg_node.find("reg_fieldsets"), is_register) # extract the access_mechanisms parsed_access_mechanisms = parse_access_mechanisms_node( reg_id, reg_node.find("access_mechanisms"), instr) reg_writable = parsed_access_mechanisms[0] reg_readable = parsed_access_mechanisms[1] access_mechanisms = parsed_access_mechanisms[2] # arch_variants won't be used they describe which architecture version e.g. 8.7a supports it # if len (reg_node.find("arch_variants").getchildren()) > 0 : # logerr("arch_variants was not empty") log(" + Length: {}".format(length)) log(" + Access: Writable: {}, Readable: {}".format( reg_writable, reg_readable)) log(" + Register: {}".format("yes" if is_register else "no")) log(" + Group: {}".format(reg_group)) # the parsed register data. regdata = { "id": reg_id, "name": reg_name, "length": length, "is_register": is_register, "is_writable": reg_writable, "is_readable": reg_readable, "purpose": reg_purpose, "group": reg_group, "access": access_mechanisms, "fields": reg_fieldsets, } return regdata