/* new version */

from messageTesting import *

from comandBone import command_M
from boardDefines import installedDevices, connectionSettings, testDevice
import os
import time
from PyQt4.Qt import pyqtSignal, QObject,pyqtSlot
from screenClass import pyScreenClass,pyScreenModes
from wireless import Wireless
from PyQt4 import QtCore
import serial
import datetime
import subprocess
import struct
from threading import Timer
from sip import voidptr
from TestEngine.config import VC_external_configuration
def cmdWin(cmd):
return subprocess.Popen(
cmd, shell=True,
stdout=subprocess.PIPE
).stdout.read()
class protoTesting(QtCore.QThread,QObject):
""" ************************ SIGNAL DEFINITIONS*************************
*********** """
# Signals of finish or complete function
finish_checkRAM
= pyqtSignal(int)
finish_checkFLASH
= pyqtSignal(int)
finish_checkRTC
= pyqtSignal(int)
finish_checkETH
= pyqtSignal(int)
finish_checkWIFI
= pyqtSignal(int)
finish_checkCAM
= pyqtSignal(int)
finish_checkINPUTS
= pyqtSignal(int)
finish_checkMUX
= pyqtSignal(int)
finish_checkuC
= pyqtSignal(int)
# Passing Camera
pass_camera

= pyqtSignal(int)

# Alert or dialog navigation signals

sig_wait_SD
= pyqtSignal(str)
# Remote delete of dialog (or remote deletion)
sig_close_alert
= pyqtSignal()
# Signal to nav Modal dialog
sig_nav_dialog
= pyqtSignal(str)
# Out logger signal
sig_console

= pyqtSignal(str)

# Signal clear console

sig_clear_console
= pyqtSignal()
""" ************************CLASS DEFINITIONS***************************
*********** """

#STATE NUMBER----------------------------------------------------------__STATE_CHECK_TSM
= 0
__STATE_CHECK_RAM
= 1
__STATE_CHECK_FLASH
= 2
__STATE_CHECK_RTC
= 3
__STATE_CHECK_ETHERNET = 4
__STATE_CHECK_WIFI
= 5
#SIGNAL NUMBER---------------------------------------------------------__SIGNAL_S
= 0
__SIGNAL_E
= 1
__SIGNAL_I
= 2
__SIGNAL_R
= 3
__SIGNAL_X
= 4
__SIGNAL_A
= 5
__SIGNAL_B
= 6
__SIGNAL_C
= 7
__SIGNAL_D
= 8
__SIGNAL_P
= 9
__SIGNAL_Z
= 10
__SIGNAL_F
= 11
__SIGNAL_IDLE
= 255
# MAX ATTEMPS --------------------------------------------------------__MAXATTEMPS

= 1000

# EMITING TEST --------------------------------------------------------__SIGNAL_OK

= 0
__SIGNAL_FAIL = 2
__SIGNAL_ND
= 1
# TESTING CODES--------------------------------------------------------__TESTING_ALL = 0x1F
""" *****************************PUBLIC DEFINITIONS*********************
*********** """
def __init__(self,serial_ins = None,part = None,screen = None):
super(protoTesting,self).__init__()
#Imprime los puertos COM disponibles
self.__list_COM = self.__searchCOMS()
print self.__list_COM
#seria class container
self.__serial = serial_ins
self.__forceStop = 0
#self.__serial.close()
self.__buffer = ""
self.__state_m = {
0:self.__stateStartCom,
1:self.__stateCheckRAM,
2:self.__stateCheckFLASH
,
3:self.__stateCheckRTC,
4:self.__stateCheckETHER
NET,
5:self.__stateCheckWIFI
}
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")

#
#

while not self.__forceStop :

bufferh = bytearray(512);
num = self.__serial.readinto(bufferh)
#bufferh = self.__serial.readline()
#bufferh = bytearray(bufferh);
#num = len(bufferh)
if num > 6:
print "RAW:" + bufferh
countFail = 0
self.__eventGenerator(num, bufferh)
else:
#nothing received
countFail += 1
if countFail == protoTesting.__MAXATTEMPS:
self.__forceStop = 1
self.__forceStop = 0
print "Received data"
""" Connecting end process signals on remote slots """
@pyqtSlot()
def linkEndSig (self,arraySlots):
for i in range(0,len(self.endSignals)):
self.endSignals[i].connect(arraySlots[i])
""" Connecting signal to remote slot """
def linkSDDialog (self,rmtslt):
self.sig_wait_SD.connect(rmtslt)
""" Connecting signal to close remote"""
def linkCloseDialog (self,rmtslt):
self.sig_close_alert.connect(rmtslt)
""" Connecting signal to navigation dialog"""
def linkNavDialog(self,rmtslt):
self.sig_nav_dialog.connect(rmtslt)
""" Connecting signal to console """
def linkMainConsole(self,fcn,fcn2):
self.sig_console.connect(fcn)
self.sig_clear_console.connect(fcn2)

""" ************************PRIVATE DEFINITIONS*************************

************* """
""" Complete connection serial routine"""
def __connectionSerial(self):
# Ensure serial is closed
if self.__serial == None:
# Checking for answers of listed comports
if len(self.__list_COM)>0:

self.__serial = self.__searchDevices()
if self.__serial == None:
print "not working device in any port"
return 0
else:
if (self.__serial.isOpen()==False):
self.__serial.open()
print "CORRECTLY OPEN SERIAL"
else:
raise Exception("FAILED TO OPEN
SERIAL")
return 0
else:
print "There no exists any COM port"
""" Looking for avaliable COM ports """
def __searchCOMS(self):
__MAX_COMPORTS = 256
#generating all posible ports IMPORTANTE CHANGE OR AVOID IF IS L
INUX
ports = ["COM%s"%(i+1) for i in range(__MAX_COMPORTS)]
list_ports = []
for port in ports:
try:
s = serial.Serial(port)
s.close()
list_ports.append(port)
except (OSError,serial.SerialException):
pass
return list_ports
""" Looking for active device in avaliable COM ports """
def __searchDevices(self):
for port in self.__list_COM:
# Trying to search a device in any avaliable port so run
over __list_COM
try:
prv = serial.Serial(port = "\\..\\"+port,baudrat
e=460800,parity=serial.PARITY_NONE,stopbits=serial.STOPBITS_ONE,bytesize=serial.
EIGHTBITS,timeout = 0.001,inter_byte_timeout = 0.002)
prv.close()
except serial.SerialException:
print "Exception: %s" %serial.SerialException
else:
prv.open()
# Send a command and wait response
cmd_M = command_M()
msage = cmd_M.retCommand()
tm = testMessage(0,self.__SIGNAL_P,msage.complet
e)
prv.write(tm.comlist)
time.sleep(0.2)
# wait response
bufferh = bytearray(512);
num = prv.readinto(bufferh)
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
if self.__countersig >= (sec*1000)/msptick :

return (self.__countersig*100)/1000
else:
return 0
""" Emiting signal CAM from remote slot """
@pyqtSlot(int)
def
__rcvSignalCAM(self,s_emit):
print "received cam"
self.control_testing.updateTestControl(testDevice.C_CAM, bool(s_
emit))
""" Emiting signal MUX from remote slot """
@pyqtSlot(int)
def
__rcvSignalMUX(self,s_emit):
print "received mux"
self.control_testing.updateTestControl(testDevice.C_MUX, bool(s_
emit))
""" Emiting signal MUX from remote slot """
@pyqtSlot(int)
def
__rcvSignalPassCamera(self,s_emit):
print "received pass camera"
self.scr.stopScreen()
tm = testMessage(self.__actual_state,self.__SIGNAL_D,"NEXT STATE
")
self.__serial.write(tm.comlist)
self.__emitOK()
self.control_testing.updateTestControl(self.__actual_state-1, Tr
ue)
""" Modifing bytes bitewise"""
def __set_bit(self,origin,index,value):
mask = 1 << index
origin &= ~mask
if value:
origin |= mask
return origin
"""Return Next program state Following stablished order """
def __follow_order(self):
ret = 0
# Run over the vector
for j in range(self.__actual_state,6):
if self.__actual_state == self.__STATE_CHECK_WIFI:
return self.__STATE_CHECK_WIFI
break
# if I found a next enable state return it
elif self.__test_order & (1<<j):
ret = j
break
return (ret+1)
""" List of recheck state need"""
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