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
