def checkinstructionlist(instructionlist,
startpositions=[
shimon.arm.positiontable[0],
shimon.arm.positiontable[2],
shimon.arm.positiontable[-4],
shimon.arm.positiontable[-2]
],
strikercommands=None,
midifilename=None,
infofilename='info.log',
warningfilename='warning.log'):
# Open log output
log.open(infofilename, warningfilename)
# Arm initialization
instructionlist = sorted(instructionlist, key=lambda x: x[0])
totaltime = instructionlist[-1][0] + 2000
arms = [
shimon.arm.Arm(1, startpositions[0]),
shimon.arm.Arm(2, startpositions[1]),
shimon.arm.Arm(3, startpositions[2]),
shimon.arm.Arm(4, startpositions[3])
]
for instruction in instructionlist:
arms[instruction[1] - 1].instructionqueue.append(instruction)
# Striker initialization
strikers = []
numberofnotes = 0
notelist = []
offset = 0
if strikercommands is not None and len(strikercommands) > 0:
strikercommands = sorted(strikercommands, key=lambda x: x[0])
for i in range(8):
strikers.append(shimon.striker.Striker(i + 1))
strikermaxtime = int(strikercommands[-1][0]) + 2000
if totaltime < strikermaxtime:
totaltime = strikermaxtime
for strikercommand in strikercommands:
for i in range(8):
if strikercommand[i + 1] == 1:
strikers[i].instructionqueue.append(strikercommand[0])
if midifilename is not None:
numberofnotes, notelist = checkmidi.readnotes(midifilename)
offset = checkmidi.findstaticoffset(strikercommands[0][0] + 85,
notelist)
log.info(f'Static offset: {offset}')
success, hitnotes = cycle.run(arms, strikers, strikercommands, 0,
totaltime, numberofnotes, notelist, offset,
midifilename)
if success:
log.info('Simulation successful')
log.close()
def initialize(instructionlist,
startpositions=[
shimon.arm.positiontable[0], shimon.arm.positiontable[2],
shimon.arm.positiontable[-4], shimon.arm.positiontable[-2]
],
strikercommands=None,
midifilename=None,
infofilename='guiinfo.log',
warningfilename='guiwarning.log'):
# Open log output
log.open(infofilename, warningfilename)
# Arm initialization
instructionlist = sorted(instructionlist, key=lambda x: x[0])
gui.totaltime = instructionlist[-1][0] + 2000
gui.arms = [
shimon.arm.Arm(1, startpositions[0]),
shimon.arm.Arm(2, startpositions[1]),
shimon.arm.Arm(3, startpositions[2]),
shimon.arm.Arm(4, startpositions[3])
]
for instruction in instructionlist:
gui.arms[instruction[1] - 1].instructionqueue.append(instruction)
# Striker initialization
for i in range(8):
gui.strikers.append(shimon.striker.Striker(i + 1))
if strikercommands is not None and len(strikercommands) > 0:
strikercommands = sorted(strikercommands, key=lambda x: x[0])
gui.strikercommands = strikercommands
strikermaxtime = int(strikercommands[-1][0]) + 2000
if gui.totaltime < strikermaxtime:
gui.totaltime = strikermaxtime
for strikercommand in strikercommands:
for i in range(8):
if strikercommand[i + 1] == 1:
gui.strikers[i].instructionqueue.append(strikercommand[0])
if midifilename is not None:
gui.numberofnotes, gui.notelist = checkmidi.readnotes(midifilename)
gui.offset = checkmidi.findstaticoffset(strikercommands[0][0] + 85,
gui.notelist)
print('Static offset:', gui.offset, file=sys.stderr)
gui.midifilename = midifilename
def runCaseFromGroup(case, nodesList, logPath):
caseName, connParameters, variables = case
variables = misc.cdicts(env.getVariables(), variables)
logName = '%s.txt' % caseName
nodeNames = [node.getName() for nPar, node in nodesList]
nodes.setStatus(nodeNames, '%s: running %s' % (misc.testSuiteName, caseName))
nodeList = []
taken = [False] * len(nodesList)
for conn, cPar in connParameters.iteritems():
for i in range(len(nodesList)):
nPar, node = nodesList[i]
if cPar == nPar and not taken[i]:
taken[i] = True
variables[conn] = node.getConnection()
nodeList += [node]
time.sleep(0.5)
variables[conn].clear()
break
if len(nodeList) != len(connParameters):
log.error('%s: not executed due to upload failure' % caseName, log = 'suite')
return False
nodes.restart(nodeList)
#time.sleep(5)
#LogFactory.dropPrefix('system')
caseLogName = os.path.join(logPath, logName)
log.open(caseLogName, enableConsole = False)
# Write case parameters to log
try:
info = scriptInfo.getScriptInfo(misc.expandPath(caseName))
descr = info['description'][0]
except scriptInfo.GetScriptInfoError, exception:
descr = '*** no description available ***'
def __init__(self, session, feid):
self.session = session
Screen.__init__(self, session)
self.feid = feid
self.oldref = None
log.open(self.LOG_SIZE)
if config.Nims[self.feid].configMode.value == 'advanced':
self.advanced = True
self.advancedconfig = config.Nims[self.feid].advanced
self.advancedsats = self.advancedconfig.sat
self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid))
else:
self.advanced = False
cur = { }
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
service = session.nav.getCurrentService()
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
service = self.session.pip.pipservice
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
if hasattr(self, 'raw_channel'):
del self.raw_channel
self.frontendStatus = { }
self.diseqc = Diseqc(self.frontend)
# True means we dont like that the normal sec stuff sends commands to the rotor!
self.tuner = Tuner(self.frontend, ignore_rotor = True)
tp = ( cur.get("frequency", 0) / 1000,
cur.get("symbol_rate", 0) / 1000,
cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal),
cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown),
cur.get("orbital_position", 0),
cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
self.tuner.tune(tp)
self.isMoving = False
self.stopOnLock = False
self.red = Button("")
self["key_red"] = self.red
self.green = Button("")
self["key_green"] = self.green
self.yellow = Button("")
self["key_yellow"] = self.yellow
self.blue = Button("")
self["key_blue"] = self.blue
self.list = []
self["list"] = ConfigList(self.list)
self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus)
self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)
self["frequency_value"] = Label("")
self["symbolrate_value"] = Label("")
self["fec_value"] = Label("")
self["polarisation"] = Label("")
self["status_bar"] = Label("")
self.statusMsgTimeoutTicks = 0
self.statusMsgBlinking = False
self.statusMsgBlinkCount = 0
self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds
self.tuningChangedTo(tp)
self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"],
{
"ok": self.keyOK,
"cancel": self.keyCancel,
"up": self.keyUp,
"down": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
"red": self.redKey,
"green": self.greenKey,
"yellow": self.yellowKey,
"blue": self.blueKey,
"log": self.showLog,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
self.updateColors("tune")
self.statusTimer = eTimer()
self.statusTimer.callback.append(self.updateStatus)
self.collectingStatistics = False
self.statusTimer.start(self.UPDATE_INTERVAL, True)
self.dataAvailable = Event()
self.onClose.append(self.__onClose)
self.createConfig()
self.createSetup()
def __init__(self, session, feid):
self.session = session
Screen.__init__(self, session)
self.feid = feid
self.oldref = None
log.open(self.LOG_SIZE)
if config.Nims[self.feid].configMode.value == 'advanced':
self.advanced = True
self.advancedconfig = config.Nims[self.feid].advanced
self.advancedsats = self.advancedconfig.sat
self.availablesats = map(lambda x: x[0], nimmanager.getRotorSatListForNim(self.feid))
else:
self.advanced = False
cur = { }
if not self.openFrontend():
self.oldref = session.nav.getCurrentlyPlayingServiceReference()
service = session.nav.getCurrentService()
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
session.nav.stopService() # try to disable foreground service
if not self.openFrontend():
if session.pipshown: # try to disable pip
service = self.session.pip.pipservice
feInfo = service and service.frontendInfo()
if feInfo:
cur = feInfo.getTransponderData(True)
del feInfo
del service
from Screens.InfoBar import InfoBar
InfoBar.instance and hasattr(InfoBar.instance, "showPiP") and InfoBar.instance.showPiP()
if not self.openFrontend():
self.frontend = None # in normal case this should not happen
if hasattr(self, 'raw_channel'):
del self.raw_channel
self.frontendStatus = { }
self.diseqc = Diseqc(self.frontend)
# True means we dont like that the normal sec stuff sends commands to the rotor!
self.tuner = Tuner(self.frontend, ignore_rotor = True)
tp = ( cur.get("frequency", 0) / 1000,
cur.get("symbol_rate", 0) / 1000,
cur.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal),
cur.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto),
cur.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown),
cur.get("orbital_position", 0),
cur.get("system", eDVBFrontendParametersSatellite.System_DVB_S),
cur.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK),
cur.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35),
cur.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown))
self.tuner.tune(tp)
self.isMoving = False
self.stopOnLock = False
self.red = Button("")
self["key_red"] = self.red
self.green = Button("")
self["key_green"] = self.green
self.yellow = Button("")
self["key_yellow"] = self.yellow
self.blue = Button("")
self["key_blue"] = self.blue
self.list = []
self["list"] = ConfigList(self.list)
self["snr_db"] = TunerInfo(TunerInfo.SNR_DB, statusDict = self.frontendStatus)
self["snr_percentage"] = TunerInfo(TunerInfo.SNR_PERCENTAGE, statusDict = self.frontendStatus)
self["ber_value"] = TunerInfo(TunerInfo.BER_VALUE, statusDict = self.frontendStatus)
self["snr_bar"] = TunerInfo(TunerInfo.SNR_BAR, statusDict = self.frontendStatus)
self["ber_bar"] = TunerInfo(TunerInfo.BER_BAR, statusDict = self.frontendStatus)
self["lock_state"] = TunerInfo(TunerInfo.LOCK_STATE, statusDict = self.frontendStatus)
self["frequency_value"] = Label("")
self["symbolrate_value"] = Label("")
self["fec_value"] = Label("")
self["polarisation"] = Label("")
self["status_bar"] = Label("")
self.statusMsgTimeoutTicks = 0
self.statusMsgBlinking = False
self.statusMsgBlinkCount = 0
self.statusMsgBlinkRate = 500 / self.UPDATE_INTERVAL # milliseconds
self.tuningChangedTo(tp)
self["actions"] = NumberActionMap(["DirectionActions", "OkCancelActions", "ColorActions", "TimerEditActions", "InputActions"],
{
"ok": self.keyOK,
"cancel": self.keyCancel,
"up": self.keyUp,
"down": self.keyDown,
"left": self.keyLeft,
"right": self.keyRight,
"red": self.redKey,
"green": self.greenKey,
"yellow": self.yellowKey,
"blue": self.blueKey,
"log": self.showLog,
"1": self.keyNumberGlobal,
"2": self.keyNumberGlobal,
"3": self.keyNumberGlobal,
"4": self.keyNumberGlobal,
"5": self.keyNumberGlobal,
"6": self.keyNumberGlobal,
"7": self.keyNumberGlobal,
"8": self.keyNumberGlobal,
"9": self.keyNumberGlobal,
"0": self.keyNumberGlobal
}, -1)
self.updateColors("tune")
self.statusTimer = eTimer()
self.statusTimer.callback.append(self.updateStatus)
self.collectingStatistics = False
self.statusTimer.start(self.UPDATE_INTERVAL, True)
self.dataAvailable = Event()
self.onClose.append(self.__onClose)
self.createConfig()
self.createSetup()
def runTestScript(name):
# Open the system logger explicitely to prevent direct console messages
log.open(None, log = 'system', enableConsole = False)
# Open the tester and test case loggers
log.open(None, log = 'tester', enableConsole = False)
log.open(None, log = 'testcase', enableConsole = False)
log.write("Running test script " + name, log = 'tester')
misc.__stateManager=__stateManager
misc.__nodeFactory=__nodeFactory
server = env.getValue('resourceManagerServer')
if server:
factory=WSNServicesFactories.get('com.atmel.wsnrunner.testwsn.TestWSNClientFactory')
WSNClientObj = factory.create()
misc.__client = WSNClientObj.create(server)
if not misc.__client:
log.error('Can not connect to resource manager server', log = 'tester')
return
else:
misc.__client = None
if misc.__client:
misc.__user = env.getValue('user')
if not misc.__user:
log.error('Can not determine user name to use', log = 'tester')
misc.__client.close()
return
misc.__password = env.getValue('password')
if not misc.__password:
misc.__password=misc.__user
misc.__sessionId = env.getValue('sessionId')
if not misc.__sessionId:
misc.__sessionId=-1
misc.__client.authenticate(misc.__user,misc.__password,misc.__sessionId)
commandMode = name == '-i'
while True:
if commandMode:
name = raw_input('\n> ')
if name == '':
break
fullName = misc.expandPath(name)
if fullName is None:
log.error('File not found: %s' % name, log = 'tester')
if commandMode:
continue
else:
break
try:
h = {
'sampleapptest': handlers.h_sampleapptest,
'sampleapp' : handlers.h_sampleapp,
'testcase' : handlers.h_testcase,
'testsuite' : handlers.h_testsuite,
'function' : handlers.h_function,
'rawfile' : handlers.h_rawfile,
}
info = scriptInfo.getScriptInfo(fullName)
h[info['type']](name, info)
except scriptInfo.GetScriptInfoError, exception:
log.error(str(exception), log = 'tester')
except exc.TestFailed, exception:
logName = exception.getLogger()
if logName is None:
logName = 'tester'
if exception.getMessage() is None:
tb = traceback.extract_tb(sys.exc_info()[2])
log.error(misc.formatFailMsg(tb[-2]), log = logName)
else:
log.error(str(exception), log = logName)
def openLog(fileName, logName = 'testcase', enableConsole=False): log.open(fileName, logName, enableConsole)
def runTestCases(caseList):
t0 = time.time()
logPath = env.getValue('logPath')
if logPath is None:
logPath = '.'
logName = env.getValue('logName')
if logName:
logName = os.path.join(logPath, logName)
else:
logName = os.path.join(logPath, '%s_%s' % (misc.testSuiteName, misc.getTimeStr()))
if not misc.makeDirs(logName):
return
misc.removeFile(logName + '.txt')
log.open(logName + '.txt', log = 'suite', enableConsole = False)
nodeList = env.getNodeList(10000, respectLimit = True) # Get as many as we can
nodesAvail = len(nodeList)
nodes.setStatus(nodeList, '%s: preparing' % misc.testSuiteName)
result = {True: 0, False: 0}
# Extract all required info from cases and build all images
extList = expandCaseList(caseList, nodesAvail)
cache.init()
t1 = time.time()
# buildImagesForTestSuite(extList)
buildTime = time.time() - t1
cache.sync()
# Remove cases without all required images built
workList = []
fullSet = []
for caseName, connParameters, variables in extList:
workList += [(caseName, connParameters, variables)]
fullSet = misc.clists([fullSet, [par for conn, par in connParameters.iteritems()]])
nodesNeeded = len(fullSet)
if nodesAvail < nodesNeeded:
log.write('Info: for maximum performance %d nodes required (%d nodes available)' %
(nodesNeeded, nodesAvail), log = 'suite')
else:
log.write('Info: %d nodes will be used' % nodesNeeded, log = 'suite')
nodesAvail = nodesNeeded
# Group all scripts to optimize upload strategy
groups = groupCases(workList, nodesAvail)
log.write('Info: %d uploads will be performed' % len(groups), log = 'suite')
# Upload and execute scripts
nodeList = nodeList[:nodesAvail]
allNodes = []
log.write('Test will use next nodes:', log = 'suite')
for node in nodeList:
log.write(' %s' % node, log = 'suite')
allNodes += [misc.__nodeFactory.create(node)]
#for node in allNodes:
# node.getConnection().setTesterMode(misc.runOn['tester'])
testCaseExecTimes = []
uploadTimes = []
nodes.restart(allNodes, leaveOff = True)
groupNo = 1
for group in groups:
log.write('Running group %d of %d' % (groupNo, len(groups)), log = 'suite')
t2 = time.time()
usedNodes = uploadNodesFromGroup(allNodes, workList, group)
uploadTimes.append(time.time() - t2)
time.sleep(1)
for index in group:
t3 = time.time()
ret = runCaseFromGroup(workList[index], usedNodes, logName)
testCaseExecTimes.append(time.time() - t3)
result[ret] += 1
groupNo += 1
if len(uploadTimes):
meanUploadTime = sum(uploadTimes) / len(uploadTimes)
else:
meanUploadTime = 0
if len(testCaseExecTimes):
meanTestcaseExecTime = sum(testCaseExecTimes) / len(testCaseExecTimes)
else:
meanTestcaseExecTime = 0
totalTime = time.time() - t0
log.write('Test finished: %d passed, %d failed' % (result[True], result[False]), log = 'suite')
log.write('Execution time statistics', log = 'suite')
log.write('Build images time: %d sec' % buildTime, log = 'suite')
log.write('Total upload time: %d sec' % sum(uploadTimes), log = 'suite')
log.write('Mean group upload time: %d sec' % meanUploadTime, log = 'suite')
log.write('Testcases execution time: %d sec' % sum(testCaseExecTimes), log = 'suite')
log.write('Mean testcase execution time: %d sec' % meanTestcaseExecTime, log = 'suite')
log.write('Total execution time: %d sec' % totalTime, log = 'suite')
# Remove all temporary files, save cache
cache.cleanup()