def start_match(team1, team2):
"""Start a match between team1 and team2. Return which team won (1 or 2) or
0 if there was a draw.
"""
global rnames
print
print rnames[team1], "vs", rnames[team2]
print
args = CMD_STUB.split()
args.extend([team1, team2])
print "Starting", " ".join(args)
stdout, stderr = Popen(args, stdout=PIPE, stderr=PIPE).communicate()
tmp = reversed(stdout.splitlines())
lastline = None
# get the real names of the teams.
# pelitagame will output two lines of the following form:
# Using factory 'RandomPlayer' -> 'The RandomPlayers'
for line in stdout.splitlines():
if line.startswith("Using factory '"):
split = line.split("'")
tname, rname = split[1], split[3]
rnames[tname] = rname
for line in tmp:
if line.startswith("Finished."):
lastline = line
break
if not lastline:
print "*** ERROR: Apparently the game crashed. At least I could not find the outcome of the game."
print "*** Maybe stderr helps you to debug the problem"
print stderr
print "***"
return 0
print "***", lastline
if lastline.find("had a draw.") >= 0:
print "Draw!"
return 0
else:
tmp = lastline.split("'")
winner = tmp[1]
loser = tmp[3]
if winner == rnames[team1]:
print team1, "wins."
return 1
elif winner == rnames[team2]:
print team2, "wins."
return 2
else:
print "Unable to parse winning result :("
return 0
def test_rename_combo():
comm = "vk rename --prefix PREFIX_ --suffix _SUFFIX --subst N2:TEST --subst WN2001,TEST2 --subst AB1=TEST3 test_data/test.vcf.gz | bcftools query --list-samples"
rename.main(["rename","--prefix","PREFIX_","--suffix","_SUFFIX","--subst","N2:TEST","--subst","WN2001,TEST2","--subst","AB1=TEST3","test_data/test.vcf.gz"])
out, err = Popen(comm, stdout=PIPE, stderr=PIPE, shell=True).communicate()
assert all([x.startswith("PREFIX_") for x in out.splitlines()])
assert sum(["TEST" in x for x in out.splitlines()]) == 3
assert all([x.endswith("_SUFFIX") for x in out.splitlines()])
def main():
branch = is_repo()
res, err = Popen(['git','diff','--name-status'], stdout=PIPE, stderr=PIPE).communicate()
err_string = err.decode('utf-8')
if 'fatal' in err_string:
sys.exit(0)
changed_files = [namestat[0] for namestat in res.splitlines()]
staged_files = [namestat[0] for namestat in Popen(['git','diff', '--staged','--name-status'], stdout=PIPE).communicate()[0].splitlines()]
nb_changed = len(changed_files) - changed_files.count('U')
nb_U = staged_files.count('U')
nb_staged = len(staged_files) - nb_U
staged = str(nb_staged)
conflicts = str(nb_U)
changed = str(nb_changed)
nb_untracked = len(Popen(['git','ls-files','--others','--exclude-standard'],stdout=PIPE).communicate()[0].splitlines())
untracked = str(nb_untracked)
if not nb_changed and not nb_staged and not nb_U and not nb_untracked:
clean = '1'
else:
clean = '0'
remote = ''
if not branch: # not on any branch
branch = symbols['prehash']+ Popen(['git','rev-parse','--short','HEAD'], stdout=PIPE).communicate()[0][:-1]
else:
remote_name = Popen(['git','config','branch.%s.remote' % branch], stdout=PIPE).communicate()[0].strip()
if remote_name:
merge_name = Popen(['git','config','branch.%s.merge' % branch], stdout=PIPE).communicate()[0].strip()
if remote_name == '.': # local
remote_ref = merge_name
else:
remote_ref = 'refs/remotes/%s/%s' % (remote_name, merge_name[11:])
revgit = Popen(['git', 'rev-list', '--left-right', '%s...HEAD' % remote_ref],stdout=PIPE, stderr=PIPE)
revlist = revgit.communicate()[0]
if revgit.poll(): # fallback to local
revlist = Popen(['git', 'rev-list', '--left-right', '%s...HEAD' % merge_name],stdout=PIPE, stderr=PIPE).communicate()[0]
behead = revlist.splitlines()
ahead = len([x for x in behead if x[0]=='>'])
behind = len(behead) - ahead
if behind:
remote += '%s%s' % (symbols['behind'], behind)
if ahead:
remote += '%s%s' % (symbols['ahead of'], ahead)
out = '\n'.join([
branch,
remote,
staged,
conflicts,
changed,
untracked,
clean])
print(out)
def disk_usage(path):
"""Return disk usage statistics about the given path."""
output = Popen(['df', '-k', path], stdout=PIPE).communicate()[0]
try:
df = output.splitlines()[2].split()
device = output.splitlines()[1]
(size, used, free, percent, mountpoint) = df
except IndexError:
df = output.splitlines()[1].split()
(device, size, used, free, percent, mountpoint) = df
return (device, int(size), int(used), int(free), percent, mountpoint)
def monitor(p):
def cputimestring2secs(str):
m = cputime_RE.match(str)
secs = 60 * int(m.group(2)) + float(m.group(3))
if m.group(1) is not None:
secs += 3600 * int(m.group(1))
return secs
rsz = vsz = cpu = -1
while p.poll() is None:
try:
r = Popen(("ps", "-p", str(p.pid), "-o" "rsz,vsz,cputime"),
stdout=PIPE,
env=os.environ).communicate()[0]
ps = r.splitlines()[1].split()
rsz = max(rsz, int(ps[0]) * 1024)
vsz = max(vsz, int(ps[1]) * 1024)
cpu = max(cpu, cputimestring2secs(ps[2]))
except:
break
return rsz, vsz, cpu
def execute(*command): out, err = Popen(stdout=PIPE, stderr=PIPE, *command).communicate() if not err: nb = len(out.splitlines()) else: nb = '?' return nb
def diff(old,new):
"""
Do a diff of two src trees, parse out file names, returns a dict
with lists
{ new: [...], differ: [...], removed: [...] }
"""
#do a diff of old and new
cmd = 'LC_ALL=C diff -rq %s %s | grep -v .svn' % (old,new)
res = Popen(cmd,shell=True,stdout=PIPE).communicate()[0]
differ = []
new = []
removed = []
for l in res.splitlines():
if l.endswith('differ'):
differ.append(l.split()[3])
elif l.startswith('Only'):
s = l.split()
fpth = path.join(s[2][:-1],s[3])
if 'alfresco-enterprise-3.4.4' in l:
new.append(fpth)
else:
removed.append(fpth)
return { 'differ': differ, 'removed':removed, 'new':new }
def _generate_mountpoint_topology(cls):
"""
Gets the information about disks, partitions and mountpoints. Stores information about used filesystem and
creates a list of all underlying devices (in case of LVM) for each mountpoint.
"""
mountpoint_topology = {}
current_disk = None
stdout, stderr = Popen(["/usr/bin/lsblk", "-rno", "TYPE,RM,KNAME,FSTYPE,MOUNTPOINT"], stdout=PIPE, stderr=PIPE, close_fds=True).communicate()
for columns in map(lambda line: line.split(), stdout.splitlines()):
if len(columns) < 3:
continue
device_type, device_removable, device_name = columns[:3]
filesystem = columns[3] if len(columns) > 3 else None
mountpoint = columns[4] if len(columns) > 4 else None
if device_type == "disk":
current_disk = device_name
continue
# skip removable, skip nonpartitions
if device_removable == "1" or device_type not in ["part", "lvm"]:
continue
if mountpoint is None or mountpoint == "[SWAP]":
continue
mountpoint_topology.setdefault(mountpoint, {"disks": set(), "device_name": device_name, "filesystem": filesystem})
mountpoint_topology[mountpoint]["disks"].add(current_disk)
cls._mountpoint_topology = mountpoint_topology
def __queueCheck (self):
"""This method runs over each hop in a route and checks the latency
of all hops"""
print "Going for a quick run using one packetsize, to check the queue delay"
roundTimeStamp = time.time()
for packetCount in range (self.maxHopReps):
sleep (0.5)
for hop in range (1,self.hopsRequired+1):
output = Popen (["traceroute", "-n", "-q", "1", "-T", "-f", str (hop), "-m", str (hop), self.targetHost, "1042"], stdout=PIPE).communicate()[0]
print output
for line in output.splitlines()[1:]:
traceroute = line.split()
self.packetsSent += 1
# If the packet timed out
if len (traceroute) < 3:
self.packetsLost += 1
continue
# interperating the stuff we got back from traceroute
tracerouteHop = traceroute[0].strip()
tracerouteIP = traceroute[1].strip().lstrip("(").rstrip(")")
tracerouteRTT = traceroute[2].strip() # this is still a string, not a float
tracerouteRTT = float (tracerouteRTT) / 1000.0
self.resultset.add (tracerouteHop, 1098, tracerouteRTT, roundTimeStamp)
print "Queuecheck done"
print "Send {0} packets, lost {1}".format(self.packetsSent,self.packetsLost)
def __init__(self):
self.logger = logging.getLogger(__name__)
self.logger.debug('Initializing notify object')
if sys.platform == 'linux2':
self.user = ''
who = Popen(['/usr/bin/who'], stdout=PIPE).stdout.read()
for line in who.splitlines():
if 'tty7' in line:
self.user = line.split()[0]
if '(' in line.split()[-1]:
self.display = line.split()[-1].replace('(','').replace(')','')
else:
self.display = ':0'
break
if not self.user:
self.logger.error('User not found in tty7. Probably no one logged in or in other terminal')
raise Exception('No user found.')
self.logger.debug('Set user : {0}'.format(self.user))
self.logger.debug('Set display : {0}'.format(self.display))
self.logger.debug('Initializing pynotify')
pynotify.init('Summary')
self.__notifier = pynotify.Notification
self.message = self.__message
if sys.platform == 'win32':
self.logger.debug('Initializing WindowsBalloonTip')
self.__notifier = WindowsBalloonTip()
self.message = self.__message
def add_new_apps(apps):
""" Add new applications to apps' dict
"""
curr_apps = Popen(DMENU_PATH, stdout=PIPE).communicate()[0]
for app in curr_apps.splitlines():
apps.setdefault(app, 0)
return apps
def git_status():
"""
Get git status.
"""
git_cmd = ['git', 'status', '-b', '--porcelain']
result, __ = Popen(git_cmd, stdout=PIPE).communicate()
branch = remote_branch = ''
staged = changed = untracked = unmerged = ahead = behind = 0
commit = ''
for line in result.splitlines():
line = line.decode('utf-8')
prefix = line[0:2]
line = line[3:]
if prefix == '##': # branch name + ahead & behind info
branch, remote_branch, ahead, behind, commit = parse_git_branch(line)
elif prefix == '??': # untracked file
untracked += 1
elif prefix in ('DD', 'AU', 'UD', 'UA', 'DU', 'AA', 'UU'): # unmerged
unmerged += 1
else:
if prefix[0] in ('M', 'A', 'D', 'R', 'C'): # changes in index
staged += 1
if prefix[1] in ('M', 'D'): # changes in work tree
changed += 1
return (branch, remote_branch, staged, changed, untracked, unmerged,
ahead, behind, commit)
def nslookup(addr):
result = Popen(['nslookup', addr], stdout=PIPE, stderr=PIPE)\
.communicate()[0].decode('utf8')
for line in result.splitlines():
if 'name = ' in line:
return line.rsplit('name = ')[-1]
return None
def runcmd(cmd, *args):
"helper function to grab output of a shell command."
if args:
cmd = cmd + ' ' + ' '.join(args)
output = Popen(shlex.split(cmd), stdout=PIPE).communicate()[0]
return output.splitlines()
def test_flake8(self):
"""Test if the code is Flake8 compliant."""
if os.environ.get('ON_TRAVIS', False):
root = '../'
command = ['flake8']
output = Popen(command, stdout=PIPE, cwd=root).communicate()[0]
default_number_lines = 0
elif sys.platform.startswith('win'):
# ET I don't know on windows.
pass
else:
# OSX and linux just delegate to make
root = '../../'
command = ['make', 'flake8']
output = Popen(command, stdout=PIPE, cwd=root).communicate()[0]
default_number_lines = 0
# make pep8 produces some extra lines by default.
lines = len(output.splitlines()) - default_number_lines
print output
message = (
'Hey mate, go back to your keyboard :) (expected %s, got %s '
'lines from PEP8.)' % (default_number_lines, lines))
self.assertEquals(lines, 0, message)
def updatevalues(self):
variable = Popen("sensors -A", stdout=PIPE, shell=True).stdout.read()
splitvar = variable.splitlines()
if variable == "":
print("no sensors")
return False
self.titlelist = []
self.fanarray = {}
self.temperaturearray = {}
for x in range(0, len(splitvar)):
if not(splitvar[x] == ""):
#sensors output means only titles lack a colon
if (splitvar[x].find(':') == -1):
self.titlelist.append(splitvar[x])
currentsection = splitvar[x]
#find all the fan lines
elif not(splitvar[x].find('fan') == -1):
splitline = splitvar[x].split()
data = [(currentsection, splitline[0], splitline[1])]
for busdevice, sensor, value in data:
self.fanarray.setdefault(busdevice, {})[sensor] = value
#find all the lines with a degree sign in
elif not(splitvar[x].find('\xc2') == -1):
splitline = splitvar[x].split(':')
data = [(currentsection,splitline[0],splitline[1].split()[0])]
for busdevice, sensor, value in data:
self.temperaturearray.setdefault(busdevice, {})[sensor] = value
def main():
args = parse_args()
redis_info = Popen(('redis-cli', '-a', redis_pwd(), 'info'),
stdout=PIPE).stdout.read()
redis_info = redis_info.splitlines()
redis_stats = {}
for x in redis_info:
if x.find(':') != -1:
key, value = x.split(':')
redis_stats[key] = value
template = args.prefix + '.{} {} ' + str(int(time()))
headers = (
'total_connections_received',
'total_commands_processed',
'keyspace_hits',
'keyspace_misses',
'used_memory',
'used_cpu_sys',
'used_cpu_user',
'used_cpu_sys_children',
'used_cpu_user_children',
)
for metric in headers:
print(template.format(metric, redis_stats[metric]))
def dosetup(**kwargs):
if 'enabled' not in kwargs:
kwargs['enabled'] = False
kwargs['server']=kwargs['server'][:-1] # take out extra /
for set in ['hash_id', 'server', 'password', 'enabled',
'cron_minute', 'cron_hour', 'cron_dom', 'cron_month', 'cron_dow']:
setSetting(set, kwargs[set])
old_crontab=Popen(['crontab', '-l'], stdout=PIPE).communicate()[0]
print old_crontab
filename = tempfile.mkstemp('crontab')[1]
new_crontab=file(filename, 'w')
for line in old_crontab.splitlines():
if line.find('pushrecords')==-1:
new_crontab.write('%s\n' % line)
if kwargs['enabled']:
line = '%(cron_minute)s %(cron_hour)s %(cron_dom)s %(cron_month)s %(cron_dow)s' % kwargs
line = '%s cd /opt/openproximity2; /bin/bash manager.sh egg_command pushrecords >> /tmp/pushrecords.log' % line
new_crontab.write('%s\n' % line)
new_crontab.close()
call(['crontab', filename])
print Popen(['crontab', '-l'], stdout=PIPE).communicate()[0]
os.unlink(filename)
def getContentInformation(self):
"""Returns the information about the PDF document with pdfinfo.
"""
if not self.hasData():
return dict()
try:
return self._content_information.copy()
except AttributeError:
pass
tmp = tempfile.NamedTemporaryFile()
tmp.write(self.getData())
tmp.seek(0)
command_result = None
try:
# First, we use pdfinfo to get standard metadata
command = ['pdfinfo', '-meta', '-box', tmp.name]
try:
command_result = Popen(command, stdout=PIPE).communicate()[0]
except OSError, e:
if e.errno == errno.ENOENT:
raise ConversionError('pdfinfo was not found')
raise
result = {}
for line in command_result.splitlines():
item_list = line.split(':')
key = item_list[0].strip()
value = ':'.join(item_list[1:]).strip()
result[key] = value
# Then we use PyPDF2 to get extra metadata
try:
from PyPDF2 import PdfFileReader
from PyPDF2.utils import PdfReadError
except ImportError:
# if PyPDF2 not found, pass
pass
else:
try:
pdf_file = PdfFileReader(tmp)
for info_key, info_value in (pdf_file.getDocumentInfo() or {}).iteritems():
info_key = info_key.lstrip("/")
if isinstance(info_value, unicode):
info_value = info_value.encode("utf-8")
# Ignore values that cannot be pickled ( such as AAPL:Keywords )
try:
pickle.dumps(info_value)
except pickle.PicklingError:
LOG("PDFDocument.getContentInformation", INFO,
"Ignoring non picklable document info on %s: %s (%r)" % (
self.getRelativeUrl(), info_key, info_value))
else:
result.setdefault(info_key, info_value)
except PdfReadError:
LOG("PDFDocument.getContentInformation", PROBLEM,
"PyPDF2 is Unable to read PDF, probably corrupted PDF here : %s" % \
(self.getRelativeUrl(),))
def run_command(command):
version = sys.version.split()[0].split(".")
if map(int, version) >= [2, 4]:
from subprocess import Popen, PIPE
if type(command) == type(""):
stdout = Popen([command], stdout=PIPE).communicate()[0]
return [l.strip() for l in stdout.splitlines()]
else:
stdout = Popen(command, stdout=PIPE).communicate()[0]
return [l.strip() for l in stdout.splitlines()]
else:
if type(command) == type(""):
return [l.strip() for l in os.popen2(command)[1].readlines()]
else:
return [l.strip() for l in os.popen2(" ".join(command))[1].readlines()]
def read_content():
output = Popen(["nm", "--demangle", get_kernel_bin_path()], stdout=PIPE).communicate()[0]
lines = output.splitlines()
global _split_records
_split_records = [ i.split(' ', 3) for i in lines ]
_split_records = [ (int(i[0], 16), i[1], i[2]) for i in _split_records ]
_split_records.sort(lambda x, y: cmp(y[0], x[0]))
def run(self):
command = sh_split(' '.join(self.arguments[0:]))
stdout = Popen(command, stdout=PIPE, stdin=open(os.devnull)
).communicate()[0]
node = nodes.section()
node.document = self.state.document
nested_parse_with_titles(self.state, ViewList(stdout.splitlines()),
node)
return node.children
def execute(*command):
out, err = Popen(*command, stdout=PIPE, stderr=PIPE).communicate()
out = out.decode("utf-8")
err = err.decode("utf-8")
if not err:
nb = len(out.splitlines())
else:
nb = '?'
return nb
def current_branch(self):
'''
Return the name of the current branch
'''
out, _ = Popen(self.git_cmd + ['branch'],
stdout=PIPE, stderr=PIPE).communicate()
for line in out.splitlines():
if line.startswith('*'):
return line[1:].strip()
return None
def get_prog_version(prog):
if prog == "libdiscid":
version = discid.LIBDISCID_VERSION_STRING
elif prog == "cdrdao":
outdata = Popen([prog], stderr=PIPE).communicate()[1]
version = b" ".join(outdata.splitlines()[0].split()[::2][0:2])
else:
version = prog
return decode(version)
def get_version():
"""Get the last git tag and call that our version"""
# Probably not such a great idea
cmd = "git tag -l | tail -n 1"
try:
v = Popen(cmd, stdout=PIPE, shell=True).communicate()[0]
v = v.splitlines()[0]
except:
v = 'unknown'
return v
def get_data(self):
d1 = {}
r1 = re.compile("(.*?)\s=>\s(.*)")
output = Popen(["facter"], stdout=PIPE, shell=True).communicate()[0]
for line in output.splitlines():
match = r1.match(line)
if match:
d1[match.group(1)] = match.group(2)
return d1
def get_sockinfo(pid):
sockinfo = []
nulldev = open(os.devnull, "w")
# netstat -plan 2>/dev/null | awk '/[tcp|udp].*pid\/node/{print $4}'
netstat_process = Popen(['netstat', '-plan'], stdout=PIPE, stderr=nulldev.fileno())
awk_process_output = Popen([r"awk", "/^[tcp|udp].*\s*" + pid + "\s*\/node/{print $4}"], stdin=netstat_process.stdout, stdout=PIPE, stderr=PIPE).communicate()[0]
netstat_process.stdout.close()
if awk_process_output:
for line in awk_process_output.splitlines():
sockinfo.append(line)
return sockinfo
def disk_usage(path):
"""Return disk usage statistics about the given path.
Found at: http://stackoverflow.com/a/7285509/940204
Returned valus is a named tuple with attributes 'total', 'used' and
'free', which are the amount of total, used and free space, in bytes.
"""
output = Popen(['df', '-k', path], stdout=PIPE).communicate()[0]
df = output.splitlines()[1].split()
(device, size, used, free, percent, mountpoint) = df
return (device, int(size), int(used), int(free), percent, mountpoint)
def fetch_ntp_state():
offset = 0
try:
raw_data = Popen(['ntpq', '-pn'], stdout=PIPE, stderr=PIPE).communicate()[0]
for line in raw_data.splitlines():
if line.startswith('*'):
offset = line.split()[8]
except OSError:
pass
create_record(offset)
def getContentInformation(self):
"""Returns the information about the PDF document with pdfinfo.
"""
if not self.hasData():
return {}
try:
return self._content_information.copy() # pylint: disable=access-member-before-definition
except AttributeError:
pass
tmp = tempfile.NamedTemporaryFile()
tmp.write(self.getData())
tmp.seek(0)
command_result = None
try:
# First, we use pdfinfo to get standard metadata
command = ['pdfinfo', '-meta', '-box', tmp.name]
try:
command_result = Popen(command, stdout=PIPE).communicate()[0]
except OSError, e:
if e.errno == errno.ENOENT:
raise ConversionError('pdfinfo was not found')
raise
result = {}
for line in command_result.splitlines():
item_list = line.split(':')
key = item_list[0].strip()
value = ':'.join(item_list[1:]).strip()
result[key] = value
# Then we use PyPDF2 to get extra metadata
try:
from PyPDF2 import PdfFileReader
from PyPDF2.utils import PdfReadError
except ImportError:
# if PyPDF2 not found, pass
pass
else:
try:
pdf_file = PdfFileReader(tmp)
for info_key, info_value in (pdf_file.getDocumentInfo()
or {}).iteritems():
info_key = info_key.lstrip("/")
if isinstance(info_value, unicode):
info_value = info_value.encode("utf-8")
# Ignore values that cannot be pickled ( such as AAPL:Keywords )
try:
pickle.dumps(info_value)
except pickle.PicklingError:
LOG(
"PDFDocument.getContentInformation", INFO,
"Ignoring non picklable document info on %s: %s (%r)"
%
(self.getRelativeUrl(), info_key, info_value))
else:
result.setdefault(info_key, info_value)
except (PdfReadError, AssertionError):
LOG("PDFDocument.getContentInformation", PROBLEM,
"PyPDF2 is Unable to read PDF, probably corrupted PDF here : %s" % \
(self.getRelativeUrl(),))
except Exception:
# an exception of Exception class will be raised when the
# document is encrypted.
pass
]
# search for dependencies only
extra_include_dirs = [
'%s/include/python%s' %
(SAGE_LOCAL, platform.python_version().rsplit('.', 1)[0]),
# finally, standard C/C++ include dirs
'/usr/local/include/',
'/usr/include'
]
try:
from subprocess import Popen, PIPE
gccinclude = Popen(['gcc', '--print-file-name=include'],
stdout=PIPE).communicate()[0]
extra_include_dirs.extend(gccinclude.splitlines())
except OSError:
pass
extra_compile_args = []
extra_link_args = []
# comment these four lines out to turn on warnings from gcc
import distutils.sysconfig
NO_WARN = True
if NO_WARN and distutils.sysconfig.get_config_var('CC').startswith("gcc"):
extra_compile_args.append('-w')
DEVEL = False
if DEVEL:
extra_compile_args.append('-ggdb')
def evaluate(self,
score_functions,
on_dev=True,
output=None,
remove_unk=False,
max_dev_size=None,
raw_output=False,
fix_edits=True,
max_test_size=None,
post_process_script=None,
unk_replace=False,
**kwargs):
"""
Decode a dev or test set, and perform evaluation with respect to gold standard, using the provided
scoring function. If `output` is defined, also save the decoding output to this file.
When evaluating development data (`on_dev` to True), several dev sets can be specified (`dev_prefix` parameter
in configuration files), and a score is computed for each of them.
:param score_function: name of the scoring function used to score and rank models (typically 'bleu_score')
:param on_dev: if True, evaluate the dev corpus, otherwise evaluate the test corpus
:param output: save the hypotheses to this file
:param remove_unk: remove the UNK symbols from the output
:param max_dev_size: maximum number of lines to read from dev files
:param max_test_size: maximum number of lines to read from test files
:param raw_output: save raw decoder output (don't do post-processing like UNK deletion or subword
concatenation). The evaluation is still done with the post-processed output.
:param fix_edits: when predicting edit operations, pad shorter hypotheses with KEEP symbols.
:return: scores of each corpus to evaluate
"""
utils.log('starting evaluation')
if on_dev:
filenames = self.filenames.dev
else:
filenames = [self.filenames.test]
# convert `output` into a list, for zip
if isinstance(output, str):
output = [output]
elif output is None:
output = [None] * len(filenames)
scores = []
# evaluation on multiple corpora
for dev_id, (filenames_, output_, prefix) in enumerate(
zip(filenames, output, self.dev_prefix)):
if self.ref_ext is not None:
filenames_ = filenames_[:len(self.src_ext)] + filenames_[-1:]
if self.dev_batches:
dev_batches = self.dev_batches[dev_id]
dev_loss = sum(
self.seq2seq_model.step(batch, update_model=False).loss *
len(batch) for batch in dev_batches)
dev_loss /= sum(map(len, dev_batches))
else: # TODO
dev_loss = 0
src_lines = list(
utils.read_lines(filenames_[:len(self.src_ext)],
binary=self.binary[:len(self.src_ext)]))
trg_lines = list(utils.read_lines([filenames_[len(self.src_ext)]]))
assert len(trg_lines) % len(src_lines) == 0
references = []
ref_count = len(trg_lines) // len(src_lines)
for i in range(len(src_lines)):
ref = trg_lines[i * ref_count:(i + 1) * ref_count]
ref = [
ref_[0].strip().replace('@@ ', '').replace('@@', '')
for ref_ in ref
]
references.append(ref)
if on_dev and max_dev_size:
max_size = max_dev_size
elif not on_dev and max_test_size:
max_size = max_test_size
else:
max_size = len(src_lines)
src_lines = src_lines[:max_size]
references = references[:max_size]
hypotheses = []
output_file = None
try:
if output_ is not None:
output_file = open(output_, 'w', encoding='utf8')
hypothesis_iter = self.decode_batch(src_lines,
self.batch_size,
remove_unk=remove_unk,
fix_edits=fix_edits,
unk_replace=unk_replace)
if post_process_script is not None:
hypotheses, raw = zip(*hypothesis_iter)
data = '\n'.join(hypotheses).encode()
data = Popen(
[post_process_script], stdout=PIPE,
stdin=PIPE).communicate(input=data)[0].decode()
hypotheses = data.splitlines()
hypothesis_iter = zip(hypotheses, raw)
for i, hypothesis in enumerate(hypothesis_iter):
hypothesis, raw = hypothesis
hypotheses.append(hypothesis)
if output_file is not None:
if raw_output:
hypothesis = raw
output_file.write(hypothesis + '\n')
output_file.flush()
finally:
if output_file is not None:
output_file.close()
scores_ = []
summary = None
for score_function in score_functions:
try:
if score_function != 'bleu':
references_ = [ref[0] for ref in references]
else:
references_ = references
if score_function == 'loss':
score = dev_loss
reversed_ = True
else:
fun = getattr(evaluation, 'corpus_' + score_function)
try:
reversed_ = fun.reversed
except AttributeError:
reversed_ = False
score, score_summary = fun(hypotheses, references_)
summary = summary or score_summary
scores_.append((score_function, score, reversed_))
except:
pass
score_info = [
'{}={:.2f}'.format(key, value) for key, value, _ in scores_
]
score_info.insert(0, prefix)
if summary:
score_info.append(summary)
if self.name is not None:
score_info.insert(0, self.name)
utils.log(' '.join(map(str, score_info)))
# main score
_, score, reversed_ = scores_[0]
scores.append(-score if reversed_ else score)
return scores
import sys
gitsym = Popen(['git', 'symbolic-ref', 'HEAD'], stdout=PIPE, stderr=PIPE)
branch, error = gitsym.communicate()
error_string = error.decode('utf-8')
if 'fatal: not a git repository (or any of the parent directories): .git' in error_string:
sys.exit(0)
branch = branch.strip()[11:]
res, err = Popen(['git','diff','--name-status'], stdout=PIPE, stderr=PIPE).communicate()
err_string = err.decode('utf-8')
if 'fatal' in err_string:
sys.exit(0)
changed_files = [namestat[0] for namestat in res.splitlines()]
staged_files = [namestat[0] for namestat in Popen(['git','diff', '--staged','--name-status'], stdout=PIPE).communicate()[0].splitlines()]
nb_changed = len(changed_files) - changed_files.count('U')
nb_U = staged_files.count('U')
nb_staged = len(staged_files) - nb_U
staged = str(nb_staged)
conflicts = str(nb_U)
changed = str(nb_changed)
nb_untracked = len(Popen(['git','ls-files','--others','--exclude-standard'],stdout=PIPE).communicate()[0].splitlines())
untracked = str(nb_untracked)
if not nb_changed and not nb_staged and not nb_U and not nb_untracked:
clean = '1'
else:
clean = '0'
remote = ''
def sensores_ipmi(tela_leds):
#executa o pyimpi criado na versão py
tela_leds.ui.progressBar.setValue(0)
tela_leds.repaint()
QApplication.processEvents()
local = "cd IPMI_PY27/criado_pyinstaller_py27/dist/ipmi_py27\n"
comando = "./ipmi_py27"
command_stdout = Popen(local + comando,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
print(command_stdout)
tela_leds.ui.progressBar.setValue(90)
tela_leds.repaint()
QApplication.processEvents()
if (len(command_stdout) < 1):
sensores_ipmi_aprovacao = "FAIL"
sensores_ipmi_result = "SENSORES IPMI - RESULTADO DO TESTE: FAIL"
else:
sensores_ipmi_aprovacao = "OK"
sensores_ipmi_result = "SENSORES IPMI - RESULTADO DO TESTE: OK"
i = 0
cont = 0
outputs = []
while (i < len(command_stdout)):
if (str(command_stdout[i].decode("utf-8")) != ""):
outputs.append(command_stdout[i].decode("utf-8"))
cont = cont + 1
i = i + 1
sensores_ipmi_data_type = []
sensores_ipmi_data_value = []
sensores_ipmi_data_units = []
sensores_ipmi_medicao = []
text_reading_type_aux = "Reading Type: "
text_reading_value_aux = "Reading Value: "
text_reading_units_aux = "Reading Units: "
i = 0
for i in range(0, len(outputs) - 2, 3):
sensores_ipmi_data_type.append(outputs[i].replace(
text_reading_type_aux, ""))
sensores_ipmi_data_value.append(outputs[i + 1].replace(
text_reading_value_aux, ""))
sensores_ipmi_data_units.append(outputs[i + 2].replace(
text_reading_units_aux, ""))
i = 0
for i in range(0, len(sensores_ipmi_data_type)):
sensores_ipmi_medicao.append(i + 1)
tela_leds.ui.progressBar.setValue(100)
if (sensores_ipmi_aprovacao == "OK"):
tela_leds.ui.kled_SENSORES_IPMI.setState(1)
tela_leds.ui.kled_SENSORES_IPMI.setColor(QtGui.QColor(0, 255, 0))
tela_leds.repaint()
QApplication.processEvents()
print("Led SENSORES_IPMI", tela_leds.repaint())
print("Led SENSORES_IPMI", QApplication.processEvents())
else:
tela_leds.ui.kled_SENSORES_IPMI.setState(1)
tela_leds.ui.kled_SENSORES_IPMI.setColor(QtGui.QColor(255, 0, 0))
tela_leds.repaint()
QApplication.processEvents()
print("Led SENSORES_IPMI", tela_leds.repaint())
print("Led SENSORES_IPMI", QApplication.processEvents())
return (sensores_ipmi_data_type, sensores_ipmi_data_value,
sensores_ipmi_data_units, sensores_ipmi_medicao,
sensores_ipmi_aprovacao, sensores_ipmi_result)
def evaluate(self,
score_function,
on_dev=True,
output=None,
remove_unk=False,
max_dev_size=None,
raw_output=False,
fix_edits=True,
max_test_size=None,
post_process_script=None,
**kwargs):
"""
Decode a dev or test set, and perform evaluation with respect to gold standard, using the provided
scoring function. If `output` is defined, also save the decoding output to this file.
When evaluating development data (`on_dev` to True), several dev sets can be specified (`dev_prefix` parameter
in configuration files), and a score is computed for each of them.
:param score_function: name of the scoring function used to score and rank models (typically 'bleu_score')
:param on_dev: if True, evaluate the dev corpus, otherwise evaluate the test corpus
:param output: save the hypotheses to this file
:param remove_unk: remove the UNK symbols from the output
:param max_dev_size: maximum number of lines to read from dev files
:param max_test_size: maximum number of lines to read from test files
:param raw_output: save raw decoder output (don't do post-processing like UNK deletion or subword
concatenation). The evaluation is still done with the post-processed output.
:param fix_edits: when predicting edit operations, pad shorter hypotheses with KEEP symbols.
:return: scores of each corpus to evaluate
"""
utils.log('starting decoding')
if on_dev:
filenames = self.filenames.dev
else:
filenames = [self.filenames.test]
print(filenames)
# convert `output` into a list, for zip
if isinstance(output, str):
output = [output]
elif output is None:
output = [None] * len(filenames)
scores = []
new_lines = []
for filenames_, output_, prefix in zip(
filenames, output,
self.dev_prefix): # evaluation on multiple corpora
extensions = list(self.extensions)
if self.ref_ext is not None:
extensions.append(self.ref_ext)
lines = list(utils.read_lines(filenames_, binary=self.binary))
if on_dev and max_dev_size:
lines = lines[:max_dev_size]
elif not on_dev and max_test_size:
lines = lines[:max_test_size]
hypotheses = []
references = []
output_file = None
try:
if output_ is not None:
output_file = open(output_, 'w')
lines_ = list(zip(*lines))
src_sentences = list(zip(*lines_[:len(self.src_ext)]))
trg_sentences = list(zip(*lines_[len(self.src_ext):]))
hypothesis_iter = self.decode_batch(lines,
self.batch_size,
remove_unk=remove_unk,
fix_edits=fix_edits)
#ref_file_path = '../data/valid/ref.out'
#ref_file = open(ref_file_path, 'w')
for i, (sources, hypothesis, reference) in enumerate(
zip(src_sentences, hypothesis_iter, trg_sentences)):
if self.ref_ext is not None and on_dev:
reference = reference[-1]
else:
reference = reference[0] # single output for now
hypothesis, raw = hypothesis
hypotheses.append(hypothesis)
# FIXME: c.f. utils.py:174 for reasons
# reference = reference.strip().split('\t')[1]
reference = reference.strip()
references.append(reference)
if output_file is not None:
if raw_output:
hypothesis = raw
output_file.write(hypothesis + '\n')
output_file.flush()
#ref_file.write(reference + '\n')
finally:
if output_file is not None:
output_file.close()
#ref_file.close()
if post_process_script is not None:
data = '\n'.join(hypotheses).encode()
data = Popen([post_process_script], stdout=PIPE,
stdin=PIPE).communicate(input=data)[0].decode()
hypotheses = data.splitlines()
print("hypotheses:%d, references: %d" %
(len(hypotheses), len(references)))
print(hypotheses[:2])
print(references[:2])
# default scoring function is utils.bleu_score
# score, avg_score = getattr(evaluation, score_function)(hypotheses, references)
score = getattr(evaluation, score_function)(hypotheses, references)
# print scoring information
# score_info = [prefix, 'score={:.4f} avg_score={:.4f}'.format(score, avg_score)]
score_info = [prefix, 'score={:.4f}'.format(score)]
# if score_summary:
# score_info.append(score_summary)
if self.name is not None:
score_info.insert(0, self.name)
utils.log(' '.join(map(str, score_info)))
scores.append(score)
return scores
#!/usr/bin/python
import sys
from subprocess import call, Popen, PIPE
call(["adb", "devices"])
adbStdout, err = Popen(["adb", "devices"], stdout=PIPE).communicate()
print(adbStdout)
adbStdoutList = adbStdout.splitlines()
print(adbStdoutList)
adbDevices = []
for item in adbStdoutList:
temp = item.split('\t')
if len(temp) == 2 and temp[1] == "device":
print(temp[0])
adbDevices.append(temp[0])
if len(adbDevices) > 1:
while (1):
for device in adbDevices:
print(adbDevices.index(device), ")", device)
deviceInput = sys.stdin.readline()
if int(deviceInput) < len(adbDevices) and int(deviceInput) >= 0:
break
serial = adbDevices[int(deviceInput)]
elif len(adbDevices) == 1:
serial = adbDevices[0]
else:
def fpga(gravar_fpga_check, IP_CRATE, USERNAME, PASSWORD, POSITION_CRATE,
tela_leds):
if (gravar_fpga_check == True):
print("Iniciou a Gravação da FPGA")
local = "cd Fpga/impact_fpga\n"
comando1 = "impact -batch gravar_arquivo_svf_script"
comando2 = "impact -batch gravar_arquivo_bit_script"
tela_leds.ui.progressBar.setValue(0)
tela_leds.repaint()
QApplication.processEvents()
command_stdout = Popen(local + comando1,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
fpga_str = 'Cable connection established'
check_fpga = fpga_str in str(command_stdout)
if (check_fpga == True):
print("Fase 1 de 2 da Gravação da FPGA: Completa")
tela_leds.ui.progressBar.setValue(10)
tela_leds.repaint()
QApplication.processEvents()
else:
print("Fase 1 de 2 da Gravação da FPGA: FAIL")
print(command_stdout)
print("Encerrando o Programa...")
tela_leds.ui.kled_fpga.setState(1)
tela_leds.ui.kled_fpga.setColor(QtGui.QColor(255, 0, 0))
tela_leds.repaint()
QApplication.processEvents()
print(tela_leds.repaint())
print(QApplication.processEvents())
time.sleep(SLEEP_TIME)
sys.exit()
sys.exit()
command_stdout = Popen(local + comando2,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
fpga_str = 'Programmed successfully'
check_fpga = fpga_str in str(command_stdout)
if (check_fpga == True):
print("Fase 2 de 2 da Gravação da FPGA: Completa")
print("FPGA Gravada com Sucesso!")
tela_leds.ui.progressBar.setValue(70)
tela_leds.repaint()
QApplication.processEvents()
#FIXME: Isto ocorre pois algumas vezes ao gravarmos a FPGA o CRATE não reconhece a fpga...
print("Verificando se a FPGA foi reconhecida no CRATE...")
ssh = paramiko.SSHClient()
ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
ssh.connect(IP_CRATE,
username=str(USERNAME),
password=str(PASSWORD))
stdin, stdout, stderr = ssh.exec_command('cd /dev/;ls')
stdin.flush()
fpga_line = stdout.readlines()
fgpa_str = 'fpga\n'
fpga_check = fgpa_str in fpga_line
if (fpga_check == True):
print("FPGA reconhecida!")
tela_leds.ui.progressBar.setValue(100)
tela_leds.repaint()
QApplication.processEvents()
else:
print("FPGA nao reconhecida!")
print("Encerrando o programa...")
tela_leds.ui.kled_fpga.setState(1)
tela_leds.ui.kled_fpga.setColor(QtGui.QColor(255, 0, 0))
tela_leds.repaint()
QApplication.processEvents()
print(tela_leds.repaint())
print(QApplication.processEvents())
time.sleep(SLEEP_TIME)
sys.exit()
else:
print("Fase 2 de 2 da Gravação da FPGA: FAIL")
print(command_stdout)
print("Encerrando o Programa...")
tela_leds.ui.kled_fpga.setState(1)
tela_leds.ui.kled_fpga.setColor(QtGui.QColor(255, 0, 0))
tela_leds.repaint()
QApplication.processEvents()
print(tela_leds.repaint())
print(QApplication.processEvents())
time.sleep(SLEEP_TIME)
sys.exit()
fpga_str_result = "FPGA: Gravacao realizada com sucesso"
return (fpga_str_result)
def cis_configuration(
ad9510_pll_function_config, ad9510_pll_clock_sel_config,
ad9510_pll_clock_sel_ref_config, ad9510_a_divider_config,
ad9510_b_divider_config, ad9510_r_divider_config,
ad9510_prescaler_config, ad9510_pll_powerdown_config,
ad9510_current_config, ad9510_outputs_config, si571_freq_config,
si571_output_config, ad9510_a_divider_config_check,
ad9510_b_divider_config_check, ad9510_current_config_check,
ad9510_outputs_config_check, ad9510_pll_clock_sel_config_check,
ad9510_pll_clock_sel_ref_config_check, ad9510_prescaler_config_check,
ad9510_pll_function_config_check, ad9510_pll_powerdown_config_check,
ad9510_r_divider_config_check, si571_freq_config_check,
si571_output_config_check, all_config_check, IP_CRATE, POSITION_ADC,
POSITION_CRATE, tela_principal):
ping_crate = Popen(['ping', str(IP_CRATE), '-c', '1', "-W", "2"])
ping_crate.wait()
ping_result = ping_crate.poll()
if (ping_result == 0):
crate_str_result_msg = "CRATE - COMUNICAÇÃO: OK"
crate_str_IP = "CRATE - IP: " + str(IP_CRATE)
print(crate_str_result_msg)
tela_principal.ui.communication_config.setText("OK")
tela_principal.repaint()
QApplication.processEvents()
communication_config_str = "OK"
else:
crate_str_result_msg = "CRATE - COMUNICAÇÃO: FAIL"
crate_str_IP = "CRATE IP - " + str(IP_CRATE)
print(crate_str_result_msg)
print("Encerrando conexão")
tela_principal.ui.communication_config.setText("FAIL")
tela_principal.repaint()
QApplication.processEvents()
communication_config_str = "FAIL"
time.sleep(SLEEP_TIME)
sys.exit()
if (communication_config_str == "OK"):
fail_general = 0
local = "cd CRATE_ACESSO/bpm-app/.halcs-libs/examples\n"
tela_principal.ui.progressBar_config.setValue(0)
tela_principal.repaint()
QApplication.processEvents()
print("Iniciou a Configuração dos CIs - AD9510 & Si571")
start_time = datetime.datetime.now()
start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_write_time:", start_time_str)
cis_configuration_log = []
write_text = "WRITTEN VALUE: "
read_text = "READ VALUE: "
write_verification_text = "WRITE CHECK: "
read_verification_text = "READ CHECK: "
if (all_config_check == True):
ad9510_pll_function_config_check = True
ad9510_pll_clock_sel_config_check = True
ad9510_pll_clock_sel_ref_config_check = True
ad9510_a_divider_config_check = True
ad9510_b_divider_config_check = True
ad9510_r_divider_config_check = True
ad9510_prescaler_config_check = True
ad9510_pll_powerdown_config_check = True
ad9510_current_config_check = True
ad9510_outputs_config_check = True
si571_freq_config_check = True
si571_output_config_check = True
if (ad9510_pll_function_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -fmc_pll_function " + str(
ad9510_pll_function_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
cis_configuration_log.append("PLL_FUNCTION CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("PLL_FUNCTION TEST: OK")
cis_configuration_log.append("PLL_FUNCTION TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("PLL_FUNCTION TEST: FAIL")
cis_configuration_log.append("PLL_FUNCTION TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("PLL_FUNCTION CONFIG: Não Realizado")
if (ad9510_pll_clock_sel_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -pll_clk_sel " + str(
ad9510_pll_clock_sel_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("PLL_CLOCK_SEL CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("PLL_CLOCK_SEL: OK")
cis_configuration_log.append("PLL_CLOCK_SEL TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("PLL_CLOCK_SEL TEST: FAIL")
cis_configuration_log.append("PLL_CLOCK_SEL TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("PLL_CLOCK_SEL CONFIG: Não Realizado")
if (ad9510_pll_clock_sel_ref_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -pll_clk_sel_ref " + str(
ad9510_pll_clock_sel_ref_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("PLL_CLOCK_SEL_REF CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("PLL_CLOCK_SEL_REF: OK")
cis_configuration_log.append("PLL_CLOCK_SEL_REF TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("PLL_CLOCK_SEL_REF TEST: FAIL")
cis_configuration_log.append("PLL_CLOCK_SEL_REF TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append(
"PLL_CLOCK_SEL_REF CONFIG: Não Realizado")
if (ad9510_a_divider_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -a_div " + str(ad9510_a_divider_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("A_DIVIDER CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("A_DIVIDER: OK")
cis_configuration_log.append("A_DIVIDER TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("A_DIVIDER TEST: FAIL")
cis_configuration_log.append("A_DIVIDER TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("A_DIVIDER CONFIG: Não Realizado")
if (ad9510_b_divider_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -b_div " + str(ad9510_b_divider_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("B_DIVIDER CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("B_DIVIDER: OK")
cis_configuration_log.append("B_DIVIDER TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("B_DIVIDER: FAIL")
cis_configuration_log.append("B_DIVIDER TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("B_DIVIDER CONFIG: Não Realizado")
tela_principal.ui.progressBar_config.setValue(50)
tela_principal.repaint()
QApplication.processEvents()
if (ad9510_r_divider_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -r_div " + str(ad9510_r_divider_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("R_DIVIDER CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("R_DIVIDER TEST: OK")
cis_configuration_log.append("R_DIVIDER TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("R_DIVIDER TEST: FAIL")
cis_configuration_log.append("R_DIVIDER TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("R_DIVIDER CONFIG: Não Realizado")
if (ad9510_prescaler_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -prescaler_div " + str(
ad9510_prescaler_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("PRESCALER CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("PRESCALER: OK")
cis_configuration_log.append("PRESCALER TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("PRESCALER TEST: FAIL")
cis_configuration_log.append("PRESCALER TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("PRESCALER CONFIG: Não Realizado")
if (ad9510_pll_powerdown_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -pll_pdown " + str(
ad9510_pll_powerdown_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("PLL_PDOWN CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("PLL_PDOWN: OK")
cis_configuration_log.append("PLL_PDOWN TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("PLL_PDOWN TEST: FAIL")
cis_configuration_log.append("PLL_PDOWN TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("PLL_PDOWN CONFIG: Não Realizado")
if (ad9510_current_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -cp_current " + str(ad9510_current_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("CURRENT CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("CURRENT: OK")
cis_configuration_log.append("CURRENT TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("CURRENT TEST: FAIL")
cis_configuration_log.append("CURRENT TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("CURRENT CONFIG: Não Realizado")
if (ad9510_outputs_config_check == True):
command = "./THALES_ad9510_ctl_CONFIG -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -outputs " + str(ad9510_outputs_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
cis_configuration_log.append("OUTPUTS CONFIG")
ad9510_write_check = 0
ad9510_read_check = 0
check_function = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
if (write_aux != read_aux):
cis_configuration_log.append(
"Fail Detected - Valor Escrito: " + str(write_aux) +
" Valor lido: " + str(read_aux))
print("Fail Detected - Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
check_function = check_function + 1
if (check_function == 0):
print("OUTPUTS: OK")
cis_configuration_log.append("OUTPUTS TEST: OK")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
else:
print("OUTPUTS TEST: FAIL")
cis_configuration_log.append("OUTPUTS TEST: FAIL")
cis_configuration_log.append("Valor Escrito: ", write_aux,
" Valor lido: ", read_aux)
fail_general = fail_general + 1
else:
cis_configuration_log.append("OUTPUTS CONFIG: Não Realizado")
'''################################################################'''
if (si571_freq_config_check == True):
command = "./THALES_si571_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -freq " + str(si571_freq_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
si571_freq_write_check = 0
si571_freq_read_check = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
si571_freq_write_check = si571_freq_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
si571_freq_read_check = si571_freq_read_check + 1
print("Verificação...")
si571_freq_check = 0
if (read_value != write_value
or read_value != str(format(si571_freq_config, '.6f'))):
print("Valor Enviado pelo Comando: ", si571_freq_config)
print("Valor Escrito :", write_value)
print("Valor Lido: ", read_value)
si571_freq_check = si571_freq_check + 1
if (si571_freq_check == 0):
print("Si571 Test: OK")
si571_freq_result = "OK"
else:
print("Si571 Test: FAIL")
si571_freq_result = "FAIL"
fail_general = fail_general + 1
if (si571_freq_write_check != 0):
si571_freq_write_check_result = "FAIL"
print("Utilizacao do método de Escrita: ",
si571_freq_write_check_result)
fail_general = fail_general + 1
else:
si571_freq_write_check_result = "OK"
print("Utilizacao do método de Escrita: ",
si571_freq_write_check_result)
if (si571_freq_read_check != 0):
si571_freq_read_check_result = "FAIL"
fail_general = fail_general + 1
print("Utilizacao do método de Leitura: ",
si571_freq_read_check_result)
else:
si571_freq_read_check_result = "OK"
print("Utilizacao do método de Leitura: ",
si571_freq_read_check_result)
cis_configuration_log.append(
"Configuração para o Parâmetro: Si571 - Frequência")
cis_configuration_log.append("Valor Enviado pelo Comando [Hz]: " +
str(si571_freq_config))
cis_configuration_log.append("Valor Escrito [Hz]: " +
str(write_value))
cis_configuration_log.append("Valor Lido [Hz]: " + str(read_value))
cis_configuration_log.append("Utilizacao do método de Escrita: " +
str(si571_freq_write_check_result))
cis_configuration_log.append("Utilizacao do método de Leitura: " +
str(si571_freq_read_check_result))
cis_configuration_log.append("FINAL RESULT: " +
str(si571_freq_result))
else:
cis_configuration_log.append("Si571 Freq CONFIG: Não Realizado")
'''################################################################'''
if (si571_output_config_check == True):
command = "./THALES_si571_output_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -output " + str(si571_output_config)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
si571_output_write_check = 0
si571_output_read_check = 0
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
si571_output_write_check = si571_output_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
si571_output_read_check = si571_output_read_check + 1
print("Verificação...")
si571_output_check = 0
if (read_value != write_value
or read_value != str(format(si571_output_config))):
print("Valor Enviado pelo Comando: ", si571_output_config)
print("Valor Escrito :", write_value)
print("Valor Lido: ", read_value)
si571_output_check = si571_output_check + 1
if (si571_output_check == 0):
print("Si571 Test: OK")
si571_output_result = "OK"
else:
print("Si571 Test: FAIL")
si571_output_result = "FAIL"
fail_general = fail_general + 1
if (si571_output_write_check != 0):
si571_output_write_check_result = "FAIL"
fail_general = fail_general + 1
print("Utilizacao do método de Escrita: ",
si571_output_write_check_result)
else:
si571_output_write_check_result = "OK"
print("Utilizacao do método de Escrita: ",
si571_output_write_check_result)
if (si571_output_read_check != 0):
si571_output_read_check_result = "FAIL"
fail_general = fail_general + 1
print("Utilizacao do método de Leitura: ",
si571_output_read_check_result)
else:
si571_output_read_check_result = "OK"
print("Utilizacao do método de Leitura: ",
si571_output_read_check_result)
cis_configuration_log.append(
"Configuração para o Parâmetro: Si571 - Ouput")
cis_configuration_log.append("Valor Enviado pelo Comando: " +
str(si571_output_config))
cis_configuration_log.append("Valor Escrito: " + str(write_value))
cis_configuration_log.append("Valor Lido: " + str(read_value))
cis_configuration_log.append("Utilizacao do método de Escrita: " +
str(si571_output_write_check_result))
cis_configuration_log.append("Utilizacao do método de Leitura: " +
str(si571_output_read_check_result))
cis_configuration_log.append("FINAL RESULT: " +
str(si571_output_result))
else:
cis_configuration_log.append("Si571 Output CONFIG: Não Realizado")
tela_principal.ui.progressBar_config.setValue(100)
tela_principal.repaint()
QApplication.processEvents()
if (fail_general == 0):
tela_principal.ui.result_config.setText("OK")
tela_principal.repaint()
QApplication.processEvents()
else:
tela_principal.ui.result_config.setText("FAIL")
tela_principal.repaint()
QApplication.processEvents()
#ad9510_pll_status_config = "Teste2"
return (cis_configuration_log)
'changed': '‣',
'untracked': '…',
'clean': '⚡',
'unmerged': '≠',
'sha1': ':'
}
output, error = Popen(['git', 'status'],
stdout=PIPE,
stderr=PIPE,
universal_newlines=True).communicate()
if error:
import sys
sys.exit(0)
lines = output.splitlines()
behead_re = re.compile(
r"^# Your branch is (ahead of|behind) '(.*)' by (\d+) commit")
diverge_re = re.compile(r"^# and have (\d+) and (\d+) different")
status = ''
staged = re.compile(r'^# Changes to be committed:$', re.MULTILINE)
changed = re.compile(r'^# Changed but not updated:$', re.MULTILINE)
untracked = re.compile(r'^# Untracked files:$', re.MULTILINE)
unmerged = re.compile(r'^# Unmerged paths:$', re.MULTILINE)
def execute(*command):
out, err = Popen(stdout=PIPE, stderr=PIPE, *command).communicate()
if not err:
def eeprom(IP_CRATE, POSITION_CRATE, POSITION_ADC, tela_leds):
local = "cd CRATE_ACESSO/bpm-app/.halcs-libs/examples\n"
#Para escrever todos os valores possíveis em 2 Bytes [00 - FF]
j = 0
eeprom_all_values_hex = []
eeprom_all_values_dec = []
#Máximo de posições na memória que devo escrever/ler na eeprom é a posição 8191
#Os valors all_values_hex são os valores que serão mostrados como escritos pelo crate
#pois o código do LNLS mostra o valor que foi escrito em hexadecimal
#convertendo o valor de decimal (entrada do usuário) para um valor em hexadecimal (saída no terminal)
while (j < 8192):
i = 0
while (i < 256):
eeprom_all_values_hex.append(format(i, '02x').upper())
eeprom_all_values_dec.append(i)
i = i + 1
j = j + i
#Posições na memória em hexadecimal
eeprom_memory_position_standard_hex = []
i = 0
while (i < 8192):
eeprom_memory_position_standard_hex.append(format(i, '02x').upper())
i = i + 1
print("Iniciou a ESCRITA na EEPROM do ADC")
start_write_time = datetime.datetime.now()
start_write_time_str = start_write_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_write_time:", start_write_time_str)
memory_text = "MEMORY ADDRESS: 0x"
write_text = "WRITTEN VALUE: 0x"
write_verification_text = "WRITE CHECK: "
read_verification_text = "READ CHECK: "
memory_position_write = []
eeprom_value_write = []
write_verification = []
address = 0
eeprom_memory_position_standard_dec = []
while (address < len(eeprom_all_values_dec)):
command_write = "./THALES_fmc130m_eeprom_ctl -b tcp://" + str(
IP_CRATE
) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -rw 1 -addr " + str(address) + " -data " + str(
eeprom_all_values_dec[address])
command_stdout_write = Popen(local + command_write,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout_write = command_stdout_write.splitlines()
memory_position_aux = command_stdout_write[len(command_stdout_write) -
2].decode("utf-8")
memory_position_aux = memory_position_aux.replace(memory_text, "")
value_aux = command_stdout_write[len(command_stdout_write) -
1].decode("utf-8")
value_aux = value_aux.replace(write_text, "")
memory_position_write.append(memory_position_aux)
eeprom_value_write.append(value_aux)
eeprom_memory_position_standard_dec.append(address)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout_write[len(command_stdout_write)
- 3].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
write_verification.append(write_verification_aux)
tela_leds.ui.progressBar.setValue(
(address * 50) / len(eeprom_all_values_dec))
tela_leds.repaint()
QApplication.processEvents()
address = address + 1
end_write_time = datetime.datetime.now()
end_write_time_str = end_write_time.strftime("%Y-%m-%d %H:%M:%S")
print("Fim da ESCRITA na EEPROM do ADC")
print("End_write_time:", end_write_time_str)
print("Iniciou a LEITURA na EEPROM do ADC")
start_read_time = datetime.datetime.now()
start_read_time_str = start_read_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_read_time:", start_read_time_str)
read_text = "VALUE READ: 0x"
memory_position_read = []
eeprom_value_read = []
read_verification = []
address = 0
while (address < len(eeprom_all_values_dec)):
command_read = "./THALES_fmc130m_eeprom_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -rw 0 -addr " + str(address)
command_stdout_read = Popen(local + command_read,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout_read = command_stdout_read.splitlines()
memory_position_aux = command_stdout_read[len(command_stdout_read) -
2].decode("utf-8")
memory_position_aux = memory_position_aux.replace(memory_text, "")
value_aux = command_stdout_read[len(command_stdout_read) -
1].decode("utf-8")
value_aux = value_aux.replace(read_text, "")
memory_position_read.append(memory_position_aux)
eeprom_value_read.append(value_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
read_verification_aux = command_stdout_read[len(command_stdout_read) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
read_verification.append(read_verification_aux)
tela_leds.ui.progressBar.setValue((address * 50) /
len(eeprom_all_values_dec) + 50)
tela_leds.repaint()
QApplication.processEvents()
address = address + 1
end_read_time = datetime.datetime.now()
end_read_time_str = end_read_time.strftime("%Y-%m-%d %H:%M:%S")
print("Fim da LEITURA na EEPROM do ADC")
print("End_read_time:", end_read_time_str)
print("Verificação das memórias da eeprom...")
start_check_time = datetime.datetime.now()
start_check_time_str = start_check_time.strftime("%Y-%m-%d %H:%M:%S")
memory_test_check = 0
for i in range(0, len(eeprom_all_values_dec)):
if (memory_position_read[i] != memory_position_write[i]
or memory_position_read[i] !=
eeprom_memory_position_standard_hex[i]):
#if (memory_position_read[i]!=memory_position_standard_hex[i]):
print("Memória Acessada Escrita/Leitura Diferem - Posição: ", i)
print(memory_position_read[i], memory_position_write[i],
eeprom_memory_position_standard_hex[i])
memory_test_check = memory_test_check + 1
value_test_check = 0
for i in range(0, len(eeprom_all_values_dec)):
if (eeprom_value_read[i] != eeprom_value_write[i]
or eeprom_value_read[i] != eeprom_all_values_hex[i]):
#if (value_read[i]!=all_values_hex[i]):
print("Valor Escrito/Lido com Diferem - Posição: ", i)
print(eeprom_value_read[i], eeprom_value_write[i],
eeprom_all_values_hex[i])
value_test_check = value_test_check + 1
end_check_time = datetime.datetime.now()
end_check_time_str = end_check_time.strftime("%Y-%m-%d %H:%M:%S")
print("Fim da Teste da EEPROM do ADC")
print("Start_check_time:", start_check_time_str)
print("End_check_time:", end_check_time_str)
duration_write = ((end_write_time - start_write_time).total_seconds()) / 60
duration_read = ((end_read_time - start_read_time).total_seconds()) / 60
duration_check = ((end_check_time - start_check_time).total_seconds()) / 60
duration_global = (
(end_check_time - start_write_time).total_seconds()) / 60
print("Duracao do Teste de ESCRITA:", round(duration_write, 4))
print("Duracao do Teste de LEITURA:", round(duration_read, 4))
print("Duracao do Teste de CHECK:", round(duration_check, 4))
print("Duracao do Teste TOTAL:", round(duration_global, 4))
if (memory_test_check == 0):
print("Memórias Acessadas: OK")
else:
print("Memórias Acessadas: FAIL")
if (value_test_check == 0):
print("Valores Escritos/Lidos: OK")
else:
print("Valores Escritos/Lidos: FAIL")
eeprom_write_check = 0
eeprom_read_check = 0
i = 0
for i in range(0, len(eeprom_value_write)):
if (write_verification[i] != str(0)):
eeprom_write_check = eeprom_write_check + 1
if (read_verification[i] != str(0)):
eeprom_read_check = eeprom_read_check + 1
if (eeprom_write_check == 0):
print("Utilizacao do método de Escrita: OK")
eeprom_write_check_result = "OK"
else:
print("Utilizacao do método de Escrita: FAIL")
print(eeprom_write_check)
eeprom_write_check_result = "FAIL"
if (eeprom_read_check == 0):
print("Utilizacao do método de Leitura: OK")
eeprom_read_check_result = "OK"
else:
print("Utilizacao do método de Leitura: FAIL")
print(eeprom_read_check)
eeprom_read_check_result = "FAIL"
if (value_test_check == 0 and memory_test_check == 0):
eeprom_result = "OK"
print("EEPROM: OK")
else:
eeprom_result = "FAIL"
print("EEPROM: FAIL")
tela_leds.ui.progressBar.setValue(100)
tela_leds.repaint()
QApplication.processEvents()
return (eeprom_result, eeprom_write_check_result, eeprom_read_check_result,
eeprom_all_values_dec, eeprom_all_values_hex,
eeprom_memory_position_standard_dec,
eeprom_memory_position_standard_hex, eeprom_value_write,
eeprom_value_read)
def getsystemdlog(name=None):
if name is None:
return ''
out = Popen(JOURNALCTL + name, shell=True, stdout=PIPE).stdout.read()
lines = out.splitlines()
return lines
def ad9510(IP_CRATE, POSITION_CRATE, POSITION_ADC, tela_leds):
local = "cd CRATE_ACESSO/bpm-app/.halcs-libs/examples\n"
tela_leds.ui.progressBar.setValue(0)
tela_leds.repaint()
QApplication.processEvents()
print("Iniciou o Teste do AD9510")
start_time = datetime.datetime.now()
start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_write_time:", start_time_str)
ad9510_log = []
write_text = "WRITTEN VALUE: "
read_text = "READ VALUE: "
write_verification_text = "WRITE CHECK: "
read_verification_text = "READ CHECK: "
ad9510_write_check = 0
ad9510_read_check = 0
#Teste do PLL_CLK_SEL
if (PLL_CLK_SEL_RUN == "yes"):
print("Iniciou o Teste do PLL_CLK_SEL")
ad9510_log.append("Iniciou o Teste do PLL_CLK_SEL")
start_pll_clk_sel_time = datetime.datetime.now()
start_pll_clk_sel_time_str = start_pll_clk_sel_time.strftime(
"%Y-%m-%d %H:%M:%S")
print("start_pll_clk_sel: ", start_pll_clk_sel_time_str)
i = PLL_CLK_SEL_MIN
read_text = "READ VALUE OF PLL_CLK_SEL: "
write_text = "WRITTEN VALUE OF PLL_CLK_SEL: "
pll_clk_sel_write = []
pll_clk_sel_read = []
#Realiza a escrita e leitura no mesmo loop, pois a funcao ./THALES_ad9510_ctl realiza ambos os processos automaticamente
while (i < PLL_CLK_SEL_MAX + 1):
command = "./THALES_ad9510_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -pll_clk_sel " + str(i)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
pll_clk_sel_write.append(write_aux)
pll_clk_sel_read.append(read_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
i = i + 1
#Teste de verificação
print("Verificando resultado...")
i = 0
check_pll_clk_sel = 0
while (i < PLL_CLK_SEL_MAX - PLL_CLK_SEL_MIN + 1):
ad9510_log.append("Valor Escrito: " + str(pll_clk_sel_write[i]) +
" - Valor lido: " + str(pll_clk_sel_read[i]))
if (pll_clk_sel_write[i] != pll_clk_sel_read[i]):
ad9510_log.append("Fail Detected - Valor Escrito: " +
str(pll_clk_sel_write[i]) + " Valor lido: " +
str(pll_clk_sel_read[i]))
print("Fail Detected - Valor Escrito: ", pll_clk_sel_write[i],
" Valor lido: ", pll_clk_sel_read[i])
check_pll_clk_sel = check_pll_clk_sel + 1
i = i + 1
if (check_pll_clk_sel == 0):
print("PLL_CLK_SEL TEST: OK")
ad9510_log.append("PLL_CLK_SEL TEST: OK")
else:
print("PLL_CLK_SEL TEST: FAIL")
ad9510_log.append("PLL_CLK_SEL TEST: FAIL")
print("Fim do Teste do PLL_CLK_SEL")
ad9510_log.append("Fim do Teste do PLL_CLK_SEL\n")
end_pll_clk_sel_time = datetime.datetime.now()
end_pll_clk_sel_time_str = end_pll_clk_sel_time.strftime(
"%Y-%m-%d %H:%M:%S")
print("end_pll_clk_sel_time: ", end_pll_clk_sel_time_str)
duration_pll_clk_sel = (
(end_pll_clk_sel_time -
start_pll_clk_sel_time).total_seconds()) / 60 #desprezível
print("Duração do Teste PLL_CLK_SEL [min]: ",
round(duration_pll_clk_sel, 4))
else:
print("PLL_CLK_SEL WILL NOT BE PERFORMED")
ad9510_log.append("PLL_CLK_SEL WILL NOT BE PERFORMED\n")
#FIXME: ESTA PARTE SÓ SERVE PARA DEBUG
check_pll_clk_sel = 0
ad9510_write_check = 0
ad9510_read_check = 0
#Teste do A_DIV
if (A_DIV_RUN == "yes"):
print("Iniciou o Teste do A_DIV")
ad9510_log.append("Iniciou o Teste do A_DIV")
start_a_div_time = datetime.datetime.now()
start_a_div_time_str = start_a_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("start_a_div_time: ", start_a_div_time_str)
i = A_DIV_MIN
read_text = "READ VALUE OF A_DIV: "
write_text = "WRITTEN VALUE OF A_DIV: "
a_div_write = []
a_div_read = []
#Realiza a escrita e leitura no mesmo loop, pois a funcao ./THALES_ad9510_ctl realiza ambos os processos automaticamente
while (i < A_DIV_MAX + 1):
command = "./THALES_ad9510_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -a_div " + str(i)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
a_div_write.append(write_aux)
a_div_read.append(read_aux)
#print(write_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
i = i + 1
#Teste de verificação
print("Verificando resultado...")
i = 0
check_a_div = 0
while (i < A_DIV_MAX - A_DIV_MIN + 1):
ad9510_log.append("Valor Escrito: " + str(a_div_write[i]) +
" - Valor lido: " + str(a_div_read[i]))
if (a_div_write[i] != a_div_read[i]):
ad9510_log.append("Fail Detected - Valor Escrito: " +
str(a_div_write[i]) + " - Valor lido: " +
str(a_div_read[i]))
print("Fail Detected - Valor Escrito: ", a_div_write[i],
" Valor lido: ", a_div_read[i])
check_a_div = check_a_div + 1
i = i + 1
if (check_a_div == 0):
print("A_DIV TEST: OK")
ad9510_log.append("A_DIV TEST: OK")
else:
print("A_DIV TEST: FAIL")
ad9510_log.append("A_DIV TEST: FAIL")
print("Fim do Teste do A_DIV")
ad9510_log.append("Fim do Teste do A_DIV\n")
end_a_div_time = datetime.datetime.now()
end_a_div_time_str = end_a_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("end_a_div_time: ", end_a_div_time_str)
duration_a_div = (
(end_a_div_time -
start_a_div_time).total_seconds()) / 60 #desprezível
print("Duração do Teste A_DIV [min]: ", round(duration_a_div, 4))
else:
print("A_DIV WILL NOT BE PERFORMED")
ad9510_log.append("A_DIV WILL NOT BE PERFORMED\n")
#FIXME: ESTA PARTE SÓ SERVE PARA DEBUG
check_a_div = 0
ad9510_write_check = 0
ad9510_read_check = 0
#Teste do B_DIV
if (B_DIV_RUN == "yes"):
print("Iniciou o Teste do B_DIV")
ad9510_log.append("Iniciou o Teste do B_DIV")
start_b_div_time = datetime.datetime.now()
start_b_div_time_str = start_b_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("start_b_div_time: ", start_b_div_time_str)
i = B_DIV_MIN
read_text = "READ VALUE OF B_DIV: "
write_text = "WRITTEN VALUE OF B_DIV: "
b_div_write = []
b_div_read = []
#Realiza a escrita e leitura no mesmo loop, pois a funcao ./THALES_ad9510_ctl realiza ambos os processos automaticamente
while (i < B_DIV_MAX + 1):
command = "./THALES_ad9510_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -b_div " + str(i)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
b_div_write.append(write_aux)
b_div_read.append(read_aux)
#print(write_aux)
#print(read_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
tela_leds.ui.progressBar.setValue((i + B_DIV_MIN) * 40 / B_DIV_MAX)
tela_leds.repaint()
QApplication.processEvents()
i = i + 1
#Teste de verificação
print("Verificando resultado...")
i = 0
check_b_div = 0
while (i < B_DIV_MAX - B_DIV_MIN + 1):
ad9510_log.append("Valor Escrito: " + str(b_div_write[i]) +
" - Valor lido: " + str(b_div_read[i]))
if (b_div_write[i] != b_div_read[i]):
print("Fail Detected - Valor Escrito: ", b_div_write[i],
" Valor lido: ", b_div_read[i])
ad9510_log.append("Fail Detected - Valor Escrito: " +
str(b_div_write[i]) + " - Valor lido: " +
str(b_div_read[i]))
check_b_div = check_b_div + 1
i = i + 1
if (check_b_div == 0):
print("B_DIV TEST: OK")
ad9510_log.append("B_DIV TEST: OK")
else:
print("B_DIV TEST: FAIL")
ad9510_log.append("B_DIV TEST: FAIL")
print("Fim do Teste do B_DIV")
ad9510_log.append("Fim do Teste do B_DIV\n")
end_b_div_time = datetime.datetime.now()
end_b_div_time_str = end_b_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("end_b_div_time: ", end_b_div_time_str)
duration_b_div = (
(end_b_div_time -
start_b_div_time).total_seconds()) / 60 #demora 4.5 minutos
print("Duração do Teste B_DIV [min]: ", round(duration_b_div, 4))
else:
print("B_DIV WILL NOT BE PERFORMED")
ad9510_log.append("B_DIV WILL NOT BE PERFORMED\n")
#FIXME: ESTA PARTE SÓ SERVE PARA DEBUG
check_b_div = 0
ad9510_write_check = 0
ad9510_read_check = 0
tela_leds.ui.progressBar.setValue(40)
tela_leds.repaint()
QApplication.processEvents()
#Teste do R_DIV
if (R_DIV_RUN == "yes"):
print("Iniciou o Teste do R_DIV")
ad9510_log.append("Iniciou o Teste do R_DIV")
start_r_div_time = datetime.datetime.now()
start_r_div_time_str = start_r_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("start_r_div_time: ", start_r_div_time_str)
i = R_DIV_MIN
read_text = "READ VALUE OF R_DIV: "
write_text = "WRITTEN VALUE OF R_DIV: "
r_div_write = []
r_div_read = []
#Realiza a escrita e leitura no mesmo loop, pois a funcao ./THALES_ad9510_ctl realiza ambos os processos automaticamente
while (i < R_DIV_MAX + 1):
command = "./THALES_ad9510_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -r_div " + str(i)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
r_div_write.append(write_aux)
r_div_read.append(read_aux)
#print(write_aux)
#print(read_aux)
#print(i+1," de ", R_DIV_MAX," ",read_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
tela_leds.ui.progressBar.setValue((i + R_DIV_MIN) * 60 /
R_DIV_MAX + 40)
tela_leds.repaint()
QApplication.processEvents()
i = i + 1
#Teste de verificação
print("Verificando resultado...")
i = 0
check_r_div = 0
while (i < R_DIV_MAX - R_DIV_MIN + 1):
ad9510_log.append("Valor Escrito: " + str(r_div_write[i]) +
" - Valor lido: " + str(r_div_read[i]))
if (r_div_write[i] != r_div_read[i]):
ad9510_log.append("Fail Detected - Valor Escrito: " +
str(r_div_write[i]) + " - Valor lido: " +
str(r_div_read[i]))
print("Fail Detected - Valor Escrito: " + str(r_div_write[i]) +
" - Valor lido: " + str(r_div_read[i]))
check_r_div = check_r_div + 1
i = i + 1
if (check_r_div == 0):
print("R_DIV TEST: OK")
ad9510_log.append("R_DIV TEST: OK")
else:
print("R_DIV TEST: FAIL")
ad9510_log.append("R_DIV TEST: FAIL")
print("Fim do Teste do R_DIV")
ad9510_log.append("Fim do Teste do R_DIV\n")
end_r_div_time = datetime.datetime.now()
end_r_div_time_str = end_r_div_time.strftime("%Y-%m-%d %H:%M:%S")
print("end_r_div_time: ", end_r_div_time_str)
duration_r_div = (
(end_r_div_time - start_r_div_time).total_seconds()) / 60
print("Duração do Teste R_DIV [min]: ", round(duration_r_div,
4)) #8.7 minutos
else:
print("R_DIV WILL NOT BE PERFORMED")
ad9510_log.append("R_DIV WILL NOT BE PERFORMED\n")
#FIXME: ESTA PARTE SÓ SERVE PARA DEBUG
check_r_div = 0
ad9510_write_check = 0
ad9510_read_check = 0
#Teste do PRESCALER_DIV
if (PRESCALER_DIV_RUN == "yes"):
print("Iniciou o Teste do PRESCALER_DIV")
ad9510_log.append("Iniciou o Teste do PRESCALER_DIV")
start_prescaler_div_time = datetime.datetime.now()
start_prescaler_div_time_str = start_prescaler_div_time.strftime(
"%Y-%m-%d %H:%M:%S")
print("start_prescaler_div_time: ", start_prescaler_div_time_str)
i = PRESCALER_DIV_MIN
read_text = "READ VALUE OF PRESCALER_DIV: "
write_text = "WRITTEN VALUE OF PRESCALER_DIV: "
prescaler_div_write = []
prescaler_div_read = []
#Realiza a escrita e leitura no mesmo loop, pois a funcao ./THALES_ad9510_ctl realiza ambos os processos automaticamente
while (i < PRESCALER_DIV_MAX + 1):
command = "./THALES_ad9510_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(
POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -prescaler_div " + str(i)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_value = command_stdout[len(command_stdout) -
2].decode("utf-8")
read_value = command_stdout[len(command_stdout) -
1].decode("utf-8")
write_aux = str(write_value).replace(write_text, "")
read_aux = str(read_value).replace(read_text, "")
prescaler_div_write.append(write_aux)
prescaler_div_read.append(read_aux)
#print(write_aux)
#print(read_aux)
#print(i+1," de ", R_DIV_MAX," ",read_aux)
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ad9510_write_check = ad9510_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ad9510_read_check = ad9510_read_check + 1
i = i + 1
#Teste de verificação
print("Verificando resultado...")
i = 0
check_prescaler_div = 0
while (i < PRESCALER_DIV_MAX - PRESCALER_DIV_MIN + 1):
ad9510_log.append("Valor Escrito: " + str(prescaler_div_write[i]) +
" - Valor lido: " + str(prescaler_div_read[i]))
if (prescaler_div_write[i] != prescaler_div_read[i]):
ad9510_log.append("Fail Detected -Valor Escrito: " +
str(prescaler_div_write[i]) +
" - Valor lido: " +
str(prescaler_div_read[i]))
print("Fail Detected - Valor Escrito: ",
prescaler_div_write[i], " Valor lido: ",
prescaler_div_read[i])
check_prescaler_div = check_prescaler_div + 1
i = i + 1
if (check_prescaler_div == 0):
print("PRESCALER_DIV TEST: OK")
ad9510_log.append("PRESCALER_DIV TEST: OK")
else:
print("PRESCALER_DIV TEST: FAIL")
ad9510_log.append("PRESCALER_DIV TEST: FAIL")
print("Fim do Teste do PRESCALER_DIV")
ad9510_log.append("Fim do Teste do PRESCALER_DIV\n")
end_prescaler_div_time = datetime.datetime.now()
end_prescaler_div_time_str = end_prescaler_div_time.strftime(
"%Y-%m-%d %H:%M:%S")
print("end_prescaler_div_time: ", end_prescaler_div_time_str)
duration_prescaler_div = (
(end_prescaler_div_time -
start_prescaler_div_time).total_seconds()) / 60
print("Duração do Teste PRESCALER_DIV [min]: ",
round(duration_prescaler_div, 4)) #desprezível
else:
print("PRESCALER_DIV WILL NOT BE PERFORMED")
ad9510_log.append("PRESCALER_DIV WILL NOT BE PERFORMED\n")
#FIXME: ESTA PARTE SÓ SERVE PARA DEBUG
check_prescaler_div = 0
ad9510_write_check = 0
ad9510_read_check = 0
if (check_pll_clk_sel == 0 and check_a_div == 0 and check_b_div == 0
and check_prescaler_div == 0 and check_r_div == 0):
ad9510_result = "OK"
print("AD9510 OK")
else:
ad9510_result = "FAIL"
print("AD9510 FAIL")
if (ad9510_write_check != 0):
ad9510_write_check_result = "FAIL"
print("Utilizacao do método de Escrita: ", ad9510_write_check_result)
else:
ad9510_write_check_result = "OK"
print("Utilizacao do método de Escrita: ", ad9510_write_check_result)
if (ad9510_read_check != 0):
ad9510_read_check_result = "FAIL"
print("Utilizacao do método de Leitura: ", ad9510_read_check_result)
else:
ad9510_read_check_result = "OK"
print("Utilizacao do método de Leitura: ", ad9510_read_check_result)
ad9510_log.append("Utilizacao do método de Escrita: " +
str(ad9510_write_check_result))
ad9510_log.append("Utilizacao do método de Leitura: " +
str(ad9510_read_check_result))
ad9510_log.append("FINAL RESULT: " + str(ad9510_result))
end_time = datetime.datetime.now()
duracao = ((end_time - start_time).total_seconds()) / 60
print("Duração do Teste: ", round(duracao, 4))
tela_leds.ui.progressBar.setValue(100)
tela_leds.repaint()
QApplication.processEvents()
return (ad9510_result, ad9510_write_check_result, ad9510_read_check_result,
ad9510_log)
def test_rename_prefix():
comm = "vk rename --prefix prefix_ data/test.vcf.gz | bcftools query --list-samples"
# Run 2x for testing
rename.main(["rename","--prefix","prefix_","test_data/test.vcf.gz"])
out, err = Popen(comm, stdout=PIPE, stderr=PIPE, shell=True).communicate()
assert all([x.startswith("prefix") for x in out.splitlines()])
def evaluate(self, score_functions, on_dev=True, output=None, remove_unk=False, max_dev_size=None,
raw_output=False, fix_edits=True, max_test_size=None, post_process_script=None,
unk_replace=False, **kwargs):
"""
Decode a dev or test set, and perform evaluation with respect to gold standard, using the provided
scoring function. If `output` is defined, also save the decoding output to this file.
When evaluating development data (`on_dev` to True), several dev sets can be specified (`dev_prefix` parameter
in configuration files), and a score is computed for each of them.
:param score_function: name of the scoring function used to score and rank models (typically 'bleu_score')
:param on_dev: if True, evaluate the dev corpus, otherwise evaluate the test corpus
:param output: save the hypotheses to this file
:param remove_unk: remove the UNK symbols from the output
:param max_dev_size: maximum number of lines to read from dev files
:param max_test_size: maximum number of lines to read from test files
:param raw_output: save raw decoder output (don't do post-processing like UNK deletion or subword
concatenation). The evaluation is still done with the post-processed output.
:param fix_edits: when predicting edit operations, pad shorter hypotheses with KEEP symbols.
:return: scores of each corpus to evaluate
"""
utils.log('starting evaluation')
if on_dev:
filenames = self.filenames.dev
else:
filenames = [self.filenames.test]
# convert `output` into a list, for zip
if isinstance(output, str):
output = [output]
elif output is None:
output = [None] * len(filenames)
scores = []
utils.log('show output')
utils.log(output)
# evaluation on multiple corpora
for dev_id, (filenames_, output_, prefix) in enumerate(zip(filenames, output, self.dev_prefix)):
utils.log('filenames, output, self.dev_prefix')
utils.log(filenames)
utils.log(output)
if self.dev_batches:
dev_batches = self.dev_batches[dev_id]
dev_loss = sum(self.seq2seq_model.step(batch, update_model=False).loss * len(batch)
for batch in dev_batches)
dev_loss /= sum(map(len, dev_batches))
else: # TODO
dev_loss = 0
extensions = list(self.extensions)
if self.ref_ext is not None:
extensions.append(self.ref_ext)
lines = list(utils.read_lines(filenames_, binary=self.binary))
if on_dev and max_dev_size:
lines = lines[:max_dev_size]
elif not on_dev and max_test_size:
lines = lines[:max_test_size]
hypotheses = []
references = []
utils.log("making hypotheses")
output_file = None
try:
if output_ is not None:
output_file = open(output_, 'w', encoding='utf-8')
lines_ = list(zip(*lines))
src_sentences = list(zip(*lines_[:len(self.src_ext)]))
trg_sentences = list(zip(*lines_[len(self.src_ext):]))
utils.log("making decode_batch")
hypothesis_iter = self.decode_batch(lines, self.batch_size, remove_unk=remove_unk,
fix_edits=fix_edits, unk_replace=unk_replace)
for i, (sources, hypothesis, reference) in enumerate(zip(src_sentences, hypothesis_iter,
trg_sentences)):
if self.ref_ext is not None and on_dev:
reference = reference[-1]
else:
reference = reference[0] # single output for now
hypothesis, raw = hypothesis
# hypothesis: [10items],each item is a "token sequence"
hypotheses.append(hypothesis)
references.append(reference.strip().replace('@@ ', ''))
if output_file is not None:
if raw_output:
hypothesis = raw
line = "source:\t" + str(sources) + "\nref:\t" + str(reference) + "\n"
for item in hypothesis:
line += str(item) + '\n'
line += "\n"
# line = hypothesis + '\n'
output_file.write(line)
output_file.flush()
finally:
if output_file is not None:
output_file.close()
if post_process_script is not None:
data = '\n'.join(hypotheses).encode()
data = Popen([post_process_script], stdout=PIPE, stdin=PIPE).communicate(input=data)[0].decode()
hypotheses = data.splitlines()
scores_ = []
summary = None
for score_function in score_functions:
try:
if score_function == 'loss':
score = dev_loss
reversed_ = True
else:
fun = getattr(evaluation, 'corpus_' + score_function)
try:
reversed_ = fun.reversed
except AttributeError:
reversed_ = False
func_arg = []
for item in hypotheses:
func_arg.append(item[0])
score, score_summary = fun(func_arg, references)
summary = summary or score_summary
scores_.append((score_function, score, reversed_))
except:
pass
score_info = ['{}={:.2f}'.format(key, value) for key, value, _ in scores_]
score_info.insert(0, prefix)
if summary:
score_info.append(summary)
if self.name is not None:
score_info.insert(0, self.name)
utils.log(' '.join(map(str, score_info)))
# main score
_, score, reversed_ = scores_[0]
scores.append(-score if reversed_ else score)
return scores
'''
Create and format a dependency graph for the project.
'''
from subprocess import Popen, PIPE
# create the graph file
result_1 = Popen(['sfood', 'quicknxs'], stdout=PIPE).communicate()[0]
dot = Popen(['sfood-graph'], stdout=PIPE, stdin=PIPE).communicate(result_1)[0]
# process result dot file data
out_dot = []
ext_packages = []
first_add = True
for line in dot.splitlines():
if line.startswith('"quicknxs"') or 'version' in line or '"logging"' in line or \
'sip' in line or 'figureoptions' in line or 'types' in line or 'nxutils.so' in line or\
'output_templates' in line or 'os' in line or 'sys' in line:
continue
elif line.startswith('"quicknxs/'):
line = line.replace(
'style=filled',
'style=filled, color="#00aa00" shape=box, fontsize=24').replace(
'quicknxs/', '')
if 'PyQt4' in line or 'email' in line or 'scipy' in line or 'matplotlib/' in line or \
'IPython' in line:
line = line.split('/')[0] + '";'
if first_add:
first_add = False
out_dot.append(
if remote_name:
merge_name = Popen(
['git', 'config', 'branch.%s.merge' % branch],
stdout=PIPE).communicate()[0].strip()
if remote_name == '.': # local
remote_ref = merge_name
else:
remote_ref = 'refs/remotes/%s/%s' % (remote_name, merge_name[11:])
revgit = Popen(
['git', 'rev-list', '--left-right',
'%s...HEAD' % remote_ref],
stdout=PIPE,
stderr=PIPE)
revlist = revgit.communicate()[0]
if revgit.poll(): # fallback to local
revlist = Popen(
['git', 'rev-list', '--left-right',
'%s...HEAD' % merge_name],
stdout=PIPE,
stderr=PIPE).communicate()[0]
behead = revlist.splitlines()
ahead = len([x for x in behead if x[0] == '>'])
behind = len(behead) - ahead
if behind:
remote += '%s%s' % (symbols['behind'], behind)
if ahead:
remote += '%s%s' % (symbols['ahead of'], ahead)
out = '\n'.join([branch, remote, staged, conflicts, changed, untracked, clean])
print out
def getPIDsOfProcess(processName):
# print >> stderr, "=> APPEL a la fonction getPIDsOfProcess !"
selfPID = str(os.getpid())
myProcessNamePattern = re.compile(processName, re.I)
PIDs = []
if os.name == "posix":
if platform.system() == "Linux":
proc = Popen('pgrep ' + " ".join(args.patternList), stdout=PIPE)
for line in proc.stdout:
print "line = " + line
else:
interpreter = "ksh"
if checkPythonVersion(2.7):
from subprocess import check_output
outPut = check_output("ps -elf | grep " + processName,
shell=True)
for line in outPut:
print "line = " + line
else:
proc1 = Popen('ps -elf', stdout=PIPE)
proc = Popen('grep ' + processName,
stdin=proc1.stdout,
stdout=PIPE)
for line in proc.stdout:
print "line = " + line
print >> stderr, "TO BE DONE !"
elif platform.system() == "Windows":
interpreter = "cmd"
regExp2 = "Prompt \- "
tasklistPrompt = re.compile(regExp2)
separator = ","
if isAdmin():
wmicProcessProcStdout, wmicProcessProcStderr = Popen(
"wmic process where \"name = '" + processName +
"'\" get caption,commandline,processid -format:csv",
stdout=PIPE,
stderr=PIPE).communicate()
if not wmicProcessProcStderr:
for line in wmicProcessProcStdout.splitlines():
line = line.strip()
wmicLineColumns = line.split(separator)
if not line or wmicLineColumns[0] == "Node": continue
if myProcessNamePattern.search(line):
pid = wmicLineColumns[-1]
if pid != selfPID:
PIDs.append(pid)
else:
tasklistProc = Popen('tasklist -fo:csv', stdout=PIPE)
for line in tasklistProc.stdout:
line = line.strip()
tlistLineColumns = line.split(separator)
if not line or tlistLineColumns[0] == '"Image Name"': continue
if myProcessNamePattern.search(
line) and not tasklistPrompt.search(line):
pid = tlistLineColumns[1].split('"')[1]
if pid != selfPID:
PIDs.append(pid)
return PIDs
def test_rename_subst():
comm = "vk rename --subst N2:TEST --subst WN2001,TEST2 --subst AB1=TEST3 test_data/test.vcf.gz | bcftools query --list-samples"
rename.main(["rename","--subst","N2:TEST","--subst","WN2001,TEST2","--subst","AB1=TEST3", "test_data/test.vcf.gz"])
out, err = Popen(comm, stdout=PIPE, stderr=PIPE, shell=True).communicate()
assert sum([x.startswith("TEST") for x in out.splitlines()]) == 3
def test_rename_suffix():
comm = "vk rename --suffix _suffix data/test.vcf.gz | bcftools query --list-samples"
rename.main(["rename","--suffix","_suffix","test_data/test.vcf.gz"])
out, err = Popen(comm, stdout=PIPE, stderr=PIPE, shell=True).communicate()
assert all([x.endswith("_suffix") for x in out.splitlines()])
def is_present(name):
"""Checks if the given locale is currently installed."""
output = Popen(["locale", "-a"], stdout=PIPE).communicate()[0]
return any(
fix_case(name) == fix_case(line) for line in output.splitlines())
import smtplib
# Settings to send emails with SMTP with gmail.
server = "smtp.gmail.com"
port = 587
user = '******'
pw = 'ENTER_PW' # Please use an application-specific password for security!
email_to = 'ENTER_TO_EMAIL'
email_from = 'ENTER_FROM_EMAIL'
root_url = 'ENTER_URL'
cmd = ["linkchecker", "--no-warnings", "--no-status", "--external", root_url]
output = Popen(cmd, stdout=PIPE).communicate()[0].decode("UTF-8")
bad_urls = []
for line in output.splitlines():
if line.startswith("URL"):
current_url = line
if line.startswith("Parent URL"):
parent_url = line
elif line.startswith("Result"):
current_result = line
toks = line.split()
if toks[1] != "Valid:":
bad_urls.append((current_url, parent_url, current_result))
if bad_urls:
message_contents = "Error checking links for " + root_url + "\n\n"
for url in bad_urls:
message_contents += "\n".join(url) + "\n\n"
nargs='?',
type=str,
default='2',
help='Specify the outgoing subnet')
parser.add_argument(
'--st',
'--secondary-table',
dest='stable',
action='store_const',
const=True,
default=False,
help='Configure a secondary routing table for multihomed enclaves')
args = parser.parse_args()
output, _ = Popen(["ip", "route"], stdout=PIPE, stderr=PIPE).communicate()
out = output.splitlines()
lines_to_remove = []
ifaces = {}
subnet = args.subnet
# pylint: disable=too-many-boolean-expressions
for line in out:
tokens = line.strip("\n").split()
if (len(tokens) >= 5 and tokens[1] == "via" and tokens[0] != 'default' and
(tokens[0] != '192.168.0.0/22' and tokens[0] != '172.16.0.0/12'
and tokens[0] != '192.168.0.0/16' and tokens[0] != '224.0.0.0/4'
and tokens[0] != '172.17.0.0/16')):
lines_to_remove.append(line)
else:
def si571(IP_CRATE,POSITION_CRATE,POSITION_ADC,tela_leds):
local = "cd CRATE_ACESSO/bpm-app/.halcs-libs/examples\n"
tela_leds.ui.progressBar.setValue(0)
tela_leds.repaint()
QApplication.processEvents()
print("Iniciou o Teste do Si571")
start_time=datetime.datetime.now()
start_time_str=start_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_write_time:",start_time_str)
si571_log=[]
write_text="WRITTEN VALUE: "
read_text="READ VALUE: "
write_verification_text="WRITE CHECK: "
read_verification_text="READ CHECK: "
si571_write_check=0
si571_read_check=0
#Este valor ainda precisa ser melhor definido - 130000000 Hz
freq_value=120000000
command= "./THALES_si571_ctl -b tcp://"+str(IP_CRATE)+":8978 -board "+str(POSITION_CRATE)+" -halcs "+str(POSITION_ADC)+" -freq "+str(freq_value)
command_stdout = Popen(local+command,shell=True,stdin=PIPE,stdout=PIPE,stderr=PIPE).communicate()[0]
command_stdout=command_stdout.splitlines()
write_aux=command_stdout[len(command_stdout)-2].decode("utf-8")
write_value=write_aux.replace(write_text,"")
read_aux=command_stdout[len(command_stdout)-1].decode("utf-8")
read_value=read_aux.replace(read_text,"")
tela_leds.ui.progressBar.setValue(50)
tela_leds.repaint()
QApplication.processEvents()
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux=command_stdout[len(command_stdout)-4].decode("utf-8")
write_verification_aux=write_verification_aux.replace(write_verification_text,"")
if (write_verification_aux!=str(0)):
si571_write_check=si571_write_check+1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux=command_stdout[len(command_stdout)-3].decode("utf-8")
read_verification_aux=read_verification_aux.replace(read_verification_text,"")
if (read_verification_aux!=str(0)):
si571_read_check=si571_read_check+1
print("Verificação...")
si571_check=0
if(read_value!=write_value or read_value!=str(format(freq_value, '.6f'))):
print("Valor Enviado pelo Comando: ",freq_value)
print("Valor Escrito :",write_value)
print("Valor Lido: ",read_value)
si571_check=si571_check+1
if(si571_check==0):
print("Si571 Test: OK")
si571_result="OK"
else:
print("Si571 Test: FAIL")
si571_result="FAIL"
if(si571_write_check!=0):
si571_write_check_result = "FAIL"
print("Utilizacao do método de Escrita: ",si571_write_check_result)
else:
si571_write_check_result = "OK"
print("Utilizacao do método de Escrita: ",si571_write_check_result)
if(si571_read_check!=0):
si571_read_check_result = "FAIL"
print("Utilizacao do método de Leitura: ",si571_read_check_result)
else:
si571_read_check_result = "OK"
print("Utilizacao do método de Leitura: ",si571_read_check_result)
tela_leds.ui.progressBar.setValue(100)
tela_leds.repaint()
QApplication.processEvents()
end_time=datetime.datetime.now()
end_time_str=end_time.strftime("%Y-%m-%d %H:%M:%S")
print("Fim da ESCRITA na EEPROM do ADC")
print("End_write_time:",end_time_str)
duracao=((end_time - start_time).total_seconds())/60
print("Duração do Teste: ",round(duracao,4))
si571_log.append("Valor Enviado pelo Comando: "+str(freq_value))
si571_log.append("Valor Escrito: "+str(write_value))
si571_log.append("Valor Lido: "+str(read_value))
si571_log.append("Utilizacao do método de Escrita: "+str(si571_write_check_result))
si571_log.append("Utilizacao do método de Leitura: "+str(si571_read_check_result))
si571_log.append("FINAL RESULT: "+str(si571_result))
return (si571_result,si571_write_check_result,si571_read_check_result,si571_log)
def ics854s01i(IP_CRATE, POSITION_CRATE, POSITION_ADC, tela_leds):
local = "cd CRATE_ACESSO/bpm-app/.halcs-libs/examples\n"
tela_leds.ui.progressBar.setValue(0)
tela_leds.repaint()
QApplication.processEvents()
print("Iniciou o teste do ICS854S01I")
start_time = datetime.datetime.now()
start_time_str = start_time.strftime("%Y-%m-%d %H:%M:%S")
print("Start_write_time:", start_time_str)
write_text = "WRITTEN VALUE: "
read_text = "READ VALUE: "
write_verification_text = "WRITE CHECK: "
read_verification_text = "READ CHECK: "
ics854s01i_write_check = 0
ics854s01i_read_check = 0
ics854s01i_log = []
#pll_clk_sel = 0 Clock from external source (MMCX J4) function mode
ics854s01i_log.append(
"Teste do PLL_CLK_SEL FROM EXTERNAL SOURCE - MMCX J4: 0")
print("Teste do PLL_CLK_SEL FROM EXTERNAL SOURCE - MMCX J4: 0")
pll_clk_sel = 0
command = "./THALES_ics854s01i_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -fmc_pll_function " + str(pll_clk_sel)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ics854s01i_write_check = ics854s01i_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ics854s01i_read_check = ics854s01i_read_check + 1
print("Verificação...")
tela_leds.ui.progressBar.setValue(50)
tela_leds.repaint()
QApplication.processEvents()
pll_clk_sel_check_mmcx = 0
if (read_value != write_value or read_value != str(pll_clk_sel)):
print("PLL_CLK_SEL: FAIL")
print("Valor Enviado pelo Comando: ", pll_clk_sel)
print("Valor Escrito : ", write_value)
print("Valor Lido: ", read_value)
pll_clk_sel_check_mmcx = pll_clk_sel_check_mmcx + 1
if (pll_clk_sel_check_mmcx == 0):
print("PLL_CLK_SEL FROM EXTERNAL SOURCE - MMCX J4: OK")
pll_clk_sel_mmcx_result = "OK"
else:
print("PLL_CLK_SEL FROM EXTERNAL SOURCE - MMCX J4: FAIL")
pll_clk_sel_mmcx_result = "FAIL"
ics854s01i_log.append("Valor Enviado pelo Comando: " + str(pll_clk_sel))
ics854s01i_log.append("Valor Escrito : " + str(write_value))
ics854s01i_log.append("Valor Lido : " + str(read_value))
#pll_clk_sel = 1 Clock from FMC PIN (FMC_CLK line) function mode
ics854s01i_log.append(
"Teste do PLL_CLK_SEL FROM FMC PIN (FMC_CLK LINE): 1")
print("Teste do PLL_CLK_SEL FROM FMC PIN (FMC_CLK LINE): 1")
pll_clk_sel = 1
command = "./THALES_ics854s01i_ctl -b tcp://" + str(
IP_CRATE) + ":8978 -board " + str(POSITION_CRATE) + " -halcs " + str(
POSITION_ADC) + " -fmc_pll_function " + str(pll_clk_sel)
command_stdout = Popen(local + command,
shell=True,
stdin=PIPE,
stdout=PIPE,
stderr=PIPE).communicate()[0]
command_stdout = command_stdout.splitlines()
write_aux = command_stdout[len(command_stdout) - 2].decode("utf-8")
write_value = write_aux.replace(write_text, "")
read_aux = command_stdout[len(command_stdout) - 1].decode("utf-8")
read_value = read_aux.replace(read_text, "")
#Verifica se foi capaz de enviar comandos através do método de escrita
write_verification_aux = command_stdout[len(command_stdout) -
4].decode("utf-8")
write_verification_aux = write_verification_aux.replace(
write_verification_text, "")
if (write_verification_aux != str(0)):
ics854s01i_write_check = ics854s01i_write_check + 1
#Verifica se foi capaz de enviar comandos através do método de leitura
read_verification_aux = command_stdout[len(command_stdout) -
3].decode("utf-8")
read_verification_aux = read_verification_aux.replace(
read_verification_text, "")
if (read_verification_aux != str(0)):
ics854s01i_read_check = ics854s01i_read_check + 1
tela_leds.ui.progressBar.setValue(100)
tela_leds.repaint()
QApplication.processEvents()
print("Verificação...")
pll_clk_sel_check_fmc_pin = 0
if (read_value != write_value or read_value != str(pll_clk_sel)):
print("PLL_CLK_SEL : FAIL")
print("Valor Enviado pelo Comando: ", pll_clk_sel)
print("Valor Escrito :", write_value)
print("Valor Lido: ", read_value)
pll_clk_sel_check_fmc_pin = pll_clk_sel_check_fmc_pin + 1
if (pll_clk_sel_check_fmc_pin == 0):
print("PLL_CLK_SEL FROM FMC PIN (FMC_CLK LINE): OK")
pll_clk_sel_fmc_pin_result = "OK"
else:
print("PLL_CLK_SEL FROM FMC PIN (FMC_CLK LINE): FAIL")
pll_clk_sel_fmc_pin_result = "FAIL"
if (pll_clk_sel_mmcx_result != "OK" or pll_clk_sel_fmc_pin_result != "OK"):
ics854s01i_result = "FAIL"
print("Teste do ICS854S01I: FAIL")
else:
ics854s01i_result = "OK"
print("Teste do ICS854S01I: OK")
if (ics854s01i_write_check != 0):
ics854s01i_write_check_result = "FAIL"
print("Utilizacao do método de Escrita: ",
ics854s01i_write_check_result)
else:
ics854s01i_write_check_result = "OK"
print("Utilizacao do método de Escrita: ",
ics854s01i_write_check_result)
if (ics854s01i_read_check != 0):
ics854s01i_read_check_result = "FAIL"
print("Utilizacao do método de Leitura: ",
ics854s01i_read_check_result)
else:
ics854s01i_read_check_result = "OK"
print("Utilizacao do método de Leitura: ",
ics854s01i_read_check_result)
ics854s01i_log.append("Valor Enviado pelo Comando: " + str(pll_clk_sel))
ics854s01i_log.append("Valor Escrito : " + str(write_value))
ics854s01i_log.append("Valor Lido : " + str(read_value))
ics854s01i_log.append("Utilizacao do metodo de Escrita: " +
str(ics854s01i_write_check_result))
ics854s01i_log.append("Utilizacao do metodo de Leitura: " +
str(ics854s01i_read_check_result))
ics854s01i_log.append("FINAL RESULT: " + str(ics854s01i_result))
end_time = datetime.datetime.now()
end_time_str = end_time.strftime("%Y-%m-%d %H:%M:%S")
print("Fim do Teste do ICS854S01I")
print("End_write_time:", end_time_str)
duracao = ((end_time - start_time).total_seconds()) / 60
print("Duração do Teste: ", round(duracao, 4))
return (ics854s01i_result, ics854s01i_write_check_result,
ics854s01i_read_check_result, ics854s01i_log)
def main():
branch = str(get_branch().decode('utf-8'))
name_status = get_name_status()
changed, nb_conflicts, nb_staged, nb_untracked = get_numbers(name_status)
if changed or nb_staged or nb_conflicts or nb_untracked:
clean = '0'
else:
clean = '1'
remote = ''
branch = branch.strip()[11:]
if not branch:
branch = str(
Popen(['git', 'rev-parse', '--short', 'HEAD'],
stdout=PIPE).communicate()[0][:-1].decode('utf-8'))
else:
remote_name = str(
Popen(['git', 'config', 'branch.{}.remote'.format(branch)],
stdout=PIPE).communicate()[0].decode('utf-8').strip())
if remote_name:
merge_name = str(
Popen(['git', 'config', 'branch.{}.merge'.format(branch)],
stdout=PIPE).communicate()[0].strip().decode('utf-8'))
if remote_name == '.': # local
remote_ref = merge_name
else:
remote_ref = 'refs/remotes/{}/{}'.format(
remote_name, merge_name[11:])
revgit = Popen([
'git', 'rev-list', '--left-right',
'{}...HEAD'.format(remote_ref)
],
stdout=PIPE,
stderr=PIPE)
revlist = revgit.communicate()[0]
if revgit.poll(): # fallback to local
revlist = Popen([
'git', 'rev-list', '--left-right',
'%s...HEAD' % merge_name
],
stdout=PIPE,
stderr=PIPE).communicate()[0]
behead = revlist.splitlines()
ahead = len([x for x in behead if x[0] == '>'])
behind = len(behead) - ahead
if behind:
remote += '{}{}'.format(SYMBOLS['behind'], behind)
if ahead:
remote += '{}{}'.format(SYMBOLS['ahead'], ahead)
out = ', '.join([
str(branch), remote,
str(nb_staged),
str(nb_conflicts),
str(changed),
str(nb_untracked), clean
])
print(out)
def create_release(plugin_name=None):
"""Verify the plugin name and create the current release."""
# Was no plugin name provided?
if plugin_name not in plugin_list:
print(
'Invalid plugin name "{plugin_name}"'.format(
plugin_name=plugin_name,
)
)
return
# Get the plugin's base path
plugin_path = START_DIR / plugin_name
plugin_path.chdir()
output = Popen(
'git ls-tree --full-tree -r HEAD'.split(),
stdout=PIPE,
).communicate()[0]
START_DIR.chdir()
repo_files = [
'{sep}{path}'.format(
sep=sep,
path=str(x).split('\\t')[1].replace('/', sep)[:~0],
) for x in output.splitlines()
]
# Does the plugin not exist?
if not plugin_path.isdir():
print(
'Plugin "{plugin_name}" not found.'.format(plugin_name=plugin_name)
)
return
# Get the plugin's current version
info_file = plugin_path.joinpath(
'addons', 'source-python', 'plugins', plugin_name, 'info.ini'
)
config_obj = ConfigObj(info_file)
version = config_obj['version']
# Was no version information found?
if version is None:
print('No version found.')
return
# Get the directory to save the release in
save_path = RELEASE_DIR / plugin_name
# Create the directory if it doesn't exist
if not save_path.isdir():
save_path.makedirs()
# Get the zip file location
zip_path = save_path / '{plugin_name} - v{version}.zip'.format(
plugin_name=plugin_name,
version=version,
)
# Does the release already exist?
if zip_path.isfile():
print('Release already exists for current version.')
return
# Create the zip file
with ZipFile(zip_path, 'w', ZIP_DEFLATED) as zip_file:
# Loop through all allowed directories
for allowed_path in allowed_filetypes:
# Get the full path to the directory
check_path = plugin_path.joinpath(*allowed_path.split('/'))
# Does the directory exist?
if not check_path.isdir():
continue
# Loop through all files with the plugin's name
for full_file_path in _find_files(
check_path.files(
'{plugin_name}.*'.format(
plugin_name=plugin_name,
)
),
allowed_path,
allowed_filetypes,
):
relative_file_path = full_file_path.replace(plugin_path, '')
if relative_file_path in repo_files:
# Add the file to the zip
_add_file(
zip_file, full_file_path, relative_file_path,
plugin_path,
)
# Loop through all files within the plugin's directory
for full_file_path in _find_files(
check_path.joinpath(
plugin_name,
).walkfiles(),
allowed_path,
allowed_filetypes,
):
relative_file_path = full_file_path.replace(plugin_path, '')
if relative_file_path in repo_files:
# Add the file to the zip
_add_file(
zip_file, full_file_path, relative_file_path,
plugin_path,
)
# Loop through all other allowed directories
for allowed_path in other_filetypes:
# Get the full path to the directory
check_path = plugin_path.joinpath(*allowed_path.split('/'))
# Does the directory exist?
if not check_path.isdir():
continue
# Loop through all files in the directory
for full_file_path in _find_files(
check_path.walkfiles(), allowed_path, other_filetypes
):
relative_file_path = full_file_path.replace(plugin_path, '')
if relative_file_path in repo_files:
# Add the file to the zip
_add_file(
zip_file, full_file_path, relative_file_path,
plugin_path,
)
# Print a message that everything was successful
print(
'Successfully created {plugin_name} version {version} release:'.format(
plugin_name=plugin_name,
version=version,
)
)
print('\t"{zip_path}"\n\n'.format(zip_path=zip_path))
def get_size(path):
out = Popen([SIZE, path], stdout=PIPE).communicate()[0]
return map(int, out.splitlines()[1].split()[:4])
t = 0
for x in IPandMAC:
if routerIP in x[1]:
routerMAC = x[0]
t = 1
break
if t == 0:
sys.exit('Router MAC not found')
#Do nbtscan for windows netbios names
print '[+] Running nbtscan'
try:
nbt = Popen(['nbtscan', IPprefix + '0/24'], stdout=PIPE, stderr=DN)
nbt = nbt.communicate()[0]
nbt = nbt.splitlines()
except:
print '[-] nbtscan error, are you sure it is installed?'
if len(nbt) < 5:
print '[-] nbtscan failed'
for l in nbt:
if l.startswith(IPprefix):
ip_name = re.search('(\d{2,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})\s+(\w+)', l)
try:
nbtip = ip_name.group(1)
except:
continue
try:
netbios = ip_name.group(2)
except:
continue
from subprocess import Popen,PIPE
a = False
#b = True
#print("Escolha o teste de loopback a ser feito:\n")
#print("1- Pinos de alta velocidade\n")
#print("2- Pinos RTM\n")
if (a==True):
comando2 = "sudo /opt/Xilinx/Vivado/2016.2/bin/vivado -source /home/engenharia/Project_Test/GTP.tcl\n"
command_stdout = Popen(comando2,shell=True,stdin=PIPE,stdout=PIPE,stderr=PIPE).communicate()[0]
command_stdout=command_stdout.splitlines()
if (a==False):
comando2 = "sudo /opt/Xilinx/Vivado/2016.2/bin/vivado -source /home/engenharia/Project_Test/RTM_IO.tcl\n"
command_stdout = Popen(comando2,shell=True,stdin=PIPE,stdout=PIPE,stderr=PIPE).communicate()[0]
command_stdout=command_stdout.splitlines()
