Documenti di Didattica
Documenti di Professioni
Documenti di Cultura
= pyqtSignal(int)
= pyqtSignal(str)
= 1000
self.__actual_state = 0
self.__trans_state = 0
self.setParent(part)
self.label = screen
# Screen instance
self.scr = pyScreenClass(mode = pyScreenModes.MODE_REMOTE,screen
= self.label)
# Wirelees sheduler instance
self.__wirelessshed = Wireless(profile_name = "wifinetwork.xml")
# List of signals
self.endSignals =
self.finish_checkRAM,
self.finish_chec
kFLASH,
self.finish_chec
kRTC,
self.finish_chec
kETH,
self.finish_chec
kWIFI,
self.finish_chec
kCAM,
self.finish_chec
kINPUTS,
self.finish_chec
kMUX,
self.finish_chec
kuC]
# Counter signals
self.__countersig = 0
# Control testing
self.control_testing = testDevice()
# Signal MUX and CAM asociation
self.finish_checkMUX.connect(self.__rcvSignalMUX)
self.finish_checkCAM.connect(self.__rcvSignalCAM)
self.pass_camera.connect(self.__rcvSignalPassCamera)
# Error list
self.error_list = []
# TEst order
self.__test_order = 0x05#self.__TESTING_ALL
# Test recheck
self.__recheck = 0
#slot to receive start machine (from a button or something similar)
""" Start SLOT function"""
@pyqtSlot()
def startTest(self):
# ERase logger
self.sig_clear_console.emit()
# TEst order
self.__test_order = self.__TESTING_ALL
# Test recheck
self.__recheck = 0
self.__actual_state = 0
self.__trans_state = 0
self.forceStop = 1
#try connection
self.__connectionSerial()
if not self.__forceStop:
self.__forceStop = 1
self.wait()
self.start()
""" Checking Solution Button Handler"""
@pyqtSlot()
def startCheck(self):
print "Rechecking solutions"
# ERase logger
self.sig_clear_console.emit()
# TEst order
self.__test_order = self.__recheck
self.__actual_state = 0
self.__trans_state = 0
self.forceStop = 1
# try connection
self.__connectionSerial()
if not self.__forceStop:
self.__forceStop = 1
self.wait()
self.start()
""" Stop SLOT function """
@pyqtSlot()
def stopTest(self):
self.__serialSend(self.__SIGNAL_E,"EMERGENCY STOP")
""" Event dispatch SLOT """
@pyqtSlot()
def emitStateInternalSig(self):
self.__eventDispatch(protoTesting.__SIGNAL_I)
"""generating event receiver"""
def run(self):
print "_________________________________________________________
__"
countFail = 0
self.__actual_state = 0
self.__trans_state = 0
self.__forceStop = 0
#Ensure start
self.__serialSend(self.__SIGNAL_F,"HARD RESET")
#
#
prv.close()
if num <= 0:
continue
else:
return prv
return None
""" EMIT IF OK"""
def __emitOK(self):
self.endSignals[self.__actual_state -1].emit(self.__SIGNAL_OK)
""" EMIT IF FAILS"""
def __emitFAIL(self):
self.endSignals[self.__actual_state -1].emit(self.__SIGNAL_FAIL)
"""STATE START COM-----------------------------------------------------------"""
def __stateStartCom(self,evt):
#event error
if (evt == protoTesting.__SIGNAL_R):
cmd_M = command_M()
msage = cmd_M.retCommand()
self.__serialSend(self.__SIGNAL_P,msage.complete)
elif (evt == protoTesting.__SIGNAL_P):
# Complete test used
self.__trans_state = self.__follow_order()
self.__serialSend(self.__SIGNAL_S,struct.pack('>B',self.
__test_order)+"START")
time.sleep(0.5)
print 'START STATE MACHINE'
"""STATE CHECK RAM-----------------------------------------------------------"""
def __stateCheckRAM(self,evt):
#event error
if (evt == protoTesting.__SIGNAL_E):
self.__serialSend(self.__SIGNAL_E,"ERROR ACK")
self.__sendLogger('error RAM')
elif(evt == protoTesting.__SIGNAL_B):
self.__sendLogger('START CHECKING RAM INFORMED...')
self.finish_checkuC.emit(self.__SIGNAL_OK)
self.__serialSend(self.__SIGNAL_B,"ACK OK")
elif(evt == protoTesting.__SIGNAL_A):
self.__sendLogger('...correct CHECKING RAM')
self.__serialSend(self.__SIGNAL_A,"RESPONSE TO A")
self.control_testing.updateTestControl(testDevice.C_RAM,
True)
"""STATE CHECK FLASH---------------------------------------------------------"""
def __stateCheckFLASH(self,evt):
#event error
if (evt == protoTesting.__SIGNAL_E):
self.__serialSend(self.__SIGNAL_E,"ERROR ACK")
self.__sendLogger('error FLASH')
elif(evt == protoTesting.__SIGNAL_B):
self.__sendLogger('START CHECKING FLASH INFORMED...')
self.__serialSend(self.__SIGNAL_B,"ACK OK")
elif(evt == protoTesting.__SIGNAL_A):
self.__sendLogger('...correct CHECKING FLASH')
self.__serialSend(self.__SIGNAL_A,"RESPONSE TO A")
self.control_testing.updateTestControl(testDevice.C_FLAS
H, True)
"""STATE CHECK RTC-----------------------------------------------------------"""
def __stateCheckRTC(self,evt):
if (evt == protoTesting.__SIGNAL_E):
self.__serialSend(self.__SIGNAL_E,"ERROR ACK")
self.sig_close_alert.emit()
self.__sendLogger('error RTC')
elif(evt == protoTesting.__SIGNAL_B):
self.__serialSend(self.__SIGNAL_B,"ACK OK")
self.__sendLogger('START CHECKING RTC INFORMED...')
elif(evt == protoTesting.__SIGNAL_A):
self.__serialSend(self.__SIGNAL_A,"RESPONSE TO A")
self.control_testing.updateTestControl(testDevice.C_RTC,
True)
self.__sendLogger('...correct CHECKING RTC')
elif(evt == protoTesting.__SIGNAL_C):
self.__sendLogger("Sending time",True)
hour = datetime.datetime.now()
hour = hour.strftime("%H%M%S%f")
self.__serialSend(self.__SIGNAL_C,hour)
self.sig_close_alert.emit()
elif(evt == protoTesting.__SIGNAL_D):
self.__sendLogger("Wait for shutdown",True)
self.sig_wait_SD.emit("WAITING FOR SHUTDOWN DEVICE...")
"""STATE CHECK ETHERNET------------------------------------------------------"""
def __stateCheckETHERNET (self,evt):
if (evt == protoTesting.__SIGNAL_E):
self.__serialSend(self.__SIGNAL_E,"ERROR ACK")
self.scr.stopScreen()
self.__sendLogger('error ETHERNET')
elif(evt == protoTesting.__SIGNAL_B):
self.__sendLogger('START CHECKING ETHERNET INFORMED...')
self.__countersig = 0
self.__serialSend(self.__SIGNAL_B,"ACK OK")
#Testing if ping looks ok
if self.__testingPing(mode=self.__STATE_CHECK_ETHERNET,t
imes= 50) == True :
self.__serialSend(self.__SIGNAL_B,"PING OK")
self.scr.startScreen()
self.sig_nav_dialog.emit("Is the cam viewing pro
perly?")
else :
self.__serialSend(self.__SIGNAL_E,"ERROR PINGING
")
elif(evt == protoTesting.__SIGNAL_A):
self.__sendLogger('...correct CHECKING ETH')
self.__serialSend(self.__SIGNAL_A,"RESPONSE TO A")
self.scr.stopScreen()
self.control_testing.updateTestControl(testDevice.C_ETH,
True)
elif(evt == protoTesting.__SIGNAL_C):
self.__countersig += 1
"""STATE CHECK WIFI----------------------------------------------------------"""
def __stateCheckWIFI (self,evt):
if (evt == protoTesting.__SIGNAL_E):
self.__serialSend(self.__SIGNAL_E,"ERROR ACK")
self.scr.stopScreen()
self.__wirelessshed.disconnect(connectionSettings.wifi_S
SID)
self.__sendLogger('error WIFI')
elif(evt == protoTesting.__SIGNAL_B):
self.__sendLogger('START CHECKING WIFI INFORMED...')
self.__serialSend(self.__SIGNAL_B,"ACK OK")
time.sleep(0.5)
if self.__look4SSID(connectionSettings.wifi_SSID):
self.__wirelessshed.disconnect(connectionSetting
s.wifi_SSID)
resp = self.__wirelessshed.connect(connectionSet
tings.wifi_SSID)
# trying to connect wifi SSID
if not resp:
self.__sendLogger("Error connecting WiFi
")
self.__serialSend(self.__SIGNAL_E,"ERROR
CONNECTING WIFI")
else:
self.__sendLogger("Pinging Start...")
time.sleep(15)
if self.__testingPing(mode=self.__STATE_
CHECK_WIFI,times=80) == True :
self.__serialSend(self.__SIGNAL_
B,"PING OK")
self.scr.startScreen(ip=connecti
onSettings.wifi_IP)
self.sig_nav_dialog.emit("Is the
cam viewing properly?")
else :
self.__serialSend(self.__SIGNAL_
E,"ERROR PINGING")
else:
self.__sendLogger("Not Found WiFi SSID")
self.__serialSend(self.__SIGNAL_E,"ERROR CONNECT
ING WIFI")
elif(evt == protoTesting.__SIGNAL_A):
self.__sendLogger('...correct CHECKING WiFi')
self.__serialSend(self.__SIGNAL_A,"RESPONSE TO A")
self.control_testing.updateTestControl(testDevice.C_WIFI
, True)
elif(evt == protoTesting.__SIGNAL_C):
self.__countersig += 1
"""DISPATCHER----------------------------------------------------------------"""
def __eventDispatch(self,evt):
self.__state_m[self.__actual_state](evt)
self.__actual_state = self.__trans_state
return 1
"""EVENT GENERATOR-----------------------------------------------------------"""
def __eventGenerator(self,num,bufferh):
evt = protoTesting.__SIGNAL_IDLE
if (num == 0):
evt = 1
return 0
index_flag = bufferh.find("@")
if (index_flag != -1):
strr = bufferh[index_flag:len(bufferh)]
try:
msg = testMessage(strnstrng = strr)
except :
self.__sendLogger('format failed',True)
self.__sendLogger("FAIL:" +strr,True)
return 0
if msg.getState()!=protoTesting.__STATE_CHECK_TSM :
print "PROCESSED:" + msg.getComheader()+msg.getT
ype()+msg.getMsg()
print "_________________________________________
__________________"
if msg.getType() == 'S':
evt = protoTesting.__SIGNAL_S
elif msg.getType() == 'F':
evt = protoTesting.__SIGNAL_F
elif msg.getType() == 'I':
evt = protoTesting.__SIGNAL_I
elif msg.getType() == 'E':
evt = protoTesting.__SIGNAL_E
self.error_list.append(msg.getMsg())
elif msg.getType() == 'A':
evt = protoTesting.__SIGNAL_A
elif msg.getType() == 'B':
evt = protoTesting.__SIGNAL_B
elif msg.getType() == 'C':
evt = protoTesting.__SIGNAL_C
elif msg.getType() == 'D':
evt = protoTesting.__SIGNAL_D
elif msg.getType() == 'R':
evt = protoTesting.__SIGNAL_R
#if is a TSM control message translate
elif msg.getType() == 'Z':
self.finish_checkINPUTS.emit(self.__SIGNAL_OK)
self.control_testing.updateTestControl(testDevic
e.C_IN, True)
#if a Parameter VC received ignore state and process
if msg.getType() == 'P':
evt = protoTesting.__SIGNAL_P
cmd_M = command_M()
cmd_M.recCommand(msg.getMsg())
# if is the first or not errors reprogram
if self.__recheck == 0:
self.__test_order = self.__checkOrderFil
l(VC_external_configuration)
else:
self.__recheck = 0
#once message is tested
return self.__eventDispatch(evt)
""" Testing Ping routine"""
def __testingPing(self,mode,times):
if mode < 4 :
return False
response = 0
# we send pings to the selected IP
array_IP = {0:connectionSettings.eth_IP,1:connectionSettings.wif
i_IP}
fails_IP = {0:5,1:20}
timeouts = {0:"10",1:"50"}
# try ping
for _ in range(0,times):
response += os.system ("ping " + array_IP[mode - 4] +" f -n 1 -w " + timeouts[mode - 4])
self.__sendLogger("fallos detectados " + str(response),True)
if response > fails_IP[mode - 4] :
response = False
else :
response = True
return response
""" Searching WiFi SSID"""
def __look4SSID(self,ssid):
res=self.__wirelessshed.interfaces()
for element in res:
if element == connectionSettings.wifi_SSID:
return True
return False
""" Counting Seconds from waiting counter """
def __countingSeconds(self,sec):
msptick = 100
self.__countersig += 1
def __recheck_add(self,state):
self.__recheck |= 1<<(state-1)
""" Send By Serial"""
def __serialSend(self,signal,text):
#first send error
tm = testMessage(self.__actual_state,signal,text)
self.__serial.write(tm.comlist)
if signal == self.__SIGNAL_A:
self.__emitOK()
self.__trans_state = self.__follow_order()
elif signal == self.__SIGNAL_E:
self.__emitFAIL()
self.__recheck_add(self.__actual_state)
self.__trans_state = self.__follow_order()
""" Fill the start order of checking """
def __checkOrderFill (self,config):
#Always test RTC
temp = 0
temp |= 1<<(self.__STATE_CHECK_RTC - 1)
#Fill each one following config
if config.eth_phy_installed:
temp |= 1 <<(self.__STATE_CHECK_ETHERNET - 1)
if config.wifi_ready:
temp |= 1 <<(self.__STATE_CHECK_WIFI - 1)
if config.flash_ready:
temp |= 1 <<(self.__STATE_CHECK_FLASH - 1)
if config.ext_ram_ready:
temp |= 1 << (self.__STATE_CHECK_RAM - 1)
return temp
""" Send some text by the logger """
def __sendLogger(self,strng,onlyPrint=False):
if not onlyPrint:
self.sig_console.emit(str(strng)+'\n\r')
print strng