def read_stest_count():
if (get_ser().isOpen() == False):
get_log_cm().error("serial not available")
return -1
# send UART request
input = '/opt/maxim-ic/basic/examples/ucl_example'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(1)
out = get_ser().readlines()
#generator: creates "matches list" only if parsed TMP info present.
#print "Out is %s" % out
valid = [v for v in out if "DES" in v]
passed = [x for x in out if "PASSED" in x]
fails = [z for z in out if "FAILED" in z]
#if not matches:
if not valid:
get_log_cm().error("\t\t\t(read_stest_count)Possible reset")
return -1
elif not fails:
#Passes
count = 0
else:
count = 0
#Count each Failure detected
for y in fails:
count += 1
return count
def read_smart_card(card_id):
x = isCardPresent(card_id)
time.sleep(1)
if(x < 0):
#Card failed to read
get_log_cm().error("\t\tcard %d failed to read" % (card_id))
run = handle_failed_card_read()
if run == False:
return -1
return 1
elif x == 0:
get_log_cm().error("\t\t\tcard %d is Missing" % (card_id))
return 1
elif x == 1:
#Get ATR
set_fail_count(0)
if x > 0:
if x == True:
emv_data = getEnvData(card_id)
get_log_cm().debug("Card %d ATR %s" % (card_id, emv_data))
if "No EMV Support" not in str(emv_data):
characters = emv_data.replace(' ', '')
get_log_cm().debug("Card %d ATR string %s" % (card_id, characters.decode('hex')))
return 0
else:
get_log_cm().error("x is %d UNKNOWN") % (x)
return 1
def card_bay_open():
power_on()
pull_off()
time.sleep(1)
power_off()
#print "card_bay_open -Plunger pushed forward, locked by magnet"
get_log_cm().debug(" ---card_bay_open---")
def read_stest_count():
if (get_ser().isOpen()==False):
get_log_cm().error("serial not available")
return -1
# send UART request
input = '/opt/maxim-ic/basic/examples/ucl_example'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(1)
out = get_ser().readlines()
#generator: creates "matches list" only if parsed TMP info present.
#print "Out is %s" % out
valid = [v for v in out if "DES" in v]
passed = [x for x in out if "PASSED" in x]
fails = [z for z in out if "FAILED" in z]
#if not matches:
if not valid:
get_log_cm().error("\t\t\t(read_stest_count)Possible reset")
return -1
elif not fails:
#Passes
count = 0
else:
count = 0
#Count each Failure detected
for y in fails:
count += 1
return count
def read_secdiag_val_old():
if (get_ser().isOpen() == False):
get_log_cm().info("\t\t\t(read_secdiag_val)serial not available")
return -1
print "read_secdiag_val Here"
input = '/opt/maxim-ic/hcr4/apps/secmon /dev/secmon0 5 ffe0200c'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(1)
out = get_ser().readlines()
print out
count = -1
if not out:
get_log_cm().error("\t\t\t(read_secdiag_val)Possible reset")
elif len(out) < 15:
get_log_cm().error("\t\t\t(read_secdiag_val)Possible reset, too short")
elif 'Error reading' in out:
get_log_cm().error("\t\t\t(read_secdiag_val)secdiag read error")
elif 'fee0200c =' in out[15]:
# Brute force index values
print out[15][11:]
count = int(out[15][11:], 16)
else:
get_log_cm().error("Tamper secdiag return not found.")
return count
def card_bay_locked():
power_on()
pull_on()
time.sleep(1)
power_off()
#print "card_bay_locked -Plunger pulled back"
get_log_cm().debug(" ---card_bay_lock---")
def card_bay_open():
power_on()
pull_off()
time.sleep(1)
power_off()
#print "card_bay_open -Plunger pushed forward, locked by magnet"
get_log_cm().debug(" ---card_bay_open---")
def read_smart_card(card_id):
x = isCardPresent(card_id)
time.sleep(1)
if (x < 0):
#Card failed to read
get_log_cm().error("\t\tcard %d failed to read" % (card_id))
run = handle_failed_card_read()
if run == False:
return -1
return 1
elif x == 0:
get_log_cm().error("\t\t\tcard %d is Missing" % (card_id))
return 1
elif x == 1:
#Get ATR
set_fail_count(0)
if x > 0:
if x == True:
emv_data = getEnvData(card_id)
get_log_cm().debug("Card %d ATR %s" % (card_id, emv_data))
if "No EMV Support" not in str(emv_data):
characters = emv_data.replace(' ', '')
get_log_cm().debug("Card %d ATR string %s" %
(card_id, characters.decode('hex')))
return 0
else:
get_log_cm().error("x is %d UNKNOWN") % (x)
return 1
def card_bay_locked():
power_on()
pull_on()
time.sleep(1)
power_off()
#print "card_bay_locked -Plunger pulled back"
get_log_cm().debug(" ---card_bay_lock---")
def set_tamper_trigger(num):
input = 'secmon /dev/secmon0 4 ' + str(num)
if (get_ser().isOpen() == False):
get_log_cm().info("\t\t\tserial not available")
return
#get_ser().write(input.encode('ascii')+'\n')
#time.sleep(1)
#out = get_ser().readlines()
out = Hcr4SendCMD(input)
if 'Error Getting SEC_GET_STATUS' in out:
get_log_cm().info("\t\t\tsecmon read error")
def handle_failed_card_read():
count=get_fail_count()
set_fail_count(count+1)
ret = True
get_log_cm().error("\t\t\tFailed %d for Card", count)
#if 5 failed reads in a row, the system may have reset.
if get_fail_count() > MAX_COM_RETRY:
get_log_cm().error("\t\t\tReading stopped, Reboot restarting script.\n\n\n")
serial_close()
ret = False
return ret
def handle_failed_card_read():
count = get_fail_count()
set_fail_count(count + 1)
ret = True
get_log_cm().error("\t\t\tFailed %d for Card", count)
#if 5 failed reads in a row, the system may have reset.
if get_fail_count() > MAX_COM_RETRY:
get_log_cm().error(
"\t\t\tReading stopped, Reboot restarting script.\n\n\n")
serial_close()
ret = False
return ret
def read_secdiag_val_obsolete():
if (get_ser().isOpen() == False):
get_log_cm().info("\t\t\t(read_secdiag_val)serial not available")
return -1
input = '/opt/maxim-ic/hcr4/apps/secmon /dev/secmon0 5 ffe0200c'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(1)
out = get_ser().readlines()
#Filter all out for ifstatement
matches = [x for x in out if "fee0200c" in x]
if not matches: #out:
get_log_cm().error("\t\t\t(read_secdiag_val)Possible reset")
val = -1
else:
conv = matches[0][12:]
val = int(conv, 16)
return val
def can_addr_ping(addr):
response = os.system('ping -n 1 %s > temp.txt' % addr)
time.sleep(1)
ret = False
if response != 0:
get_log_cm().info("Ping to %s Failed" % (addr))
return ret
txt = open("temp.txt")
out = txt.readlines()
if "Destination host unreachable" in str(out):
get_log_cm().error("Ping Dest Unreachable")
return ret
elif "Lost = 0" not in str(out):
print 'Ping Lost'
return ret
else:
ret = True
txt.close()
response = os.remove('temp.txt')
return ret
def read_tamper_count():
if (get_ser().isOpen() == False):
get_log_cm().error("serial not available")
return -1
# send UART request
input = '/opt/maxim-ic/hcr4/apps/secmon /dev/secmon0 3'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(1)
out = get_ser().readlines()
#generator: creates "matches list" only if parsed TMP info present.
matches = [x for x in out if "TMP" in x]
if not matches:
get_log_cm().error("\t\t\t(read_tamper_count)Possible reset")
return -1
else:
count = 0
for y in matches:
count += int(y[7:])
return count
def read_rtc_count():
if (get_ser().isOpen() == False):
get_log_cm().error("serial not available")
return -1
# send UART request
input = '/opt/maxim-ic/hcr4/apps/secmon /dev/secmon0 3'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(1)
out = (get_ser().readlines())
#generator: creates "matches list" only if parsed TMP info present.
lRtc = [x for x in out if "RTC:" in x]
#s_index = 5 #smatch.find('RTC:\\t\\t')+8
#print("lRtc is %s\n" % lRtc)
#print("lRtc[s_index:] is %s\n" % lRtc[0][5:])
count = -1
try:
if not lRtc:
get_log_cm().error("\t\t\t(read_rtc_count)Possible reset")
else:
count = int(lRtc[0][5:])
except ValueError:
get_log_cm().error("\t\t\t(read_rtc_count)Possible reset error")
return count
def become_root ():
# check list for NOK or OK
rootDone = False
check = True
while check:
state = await_boot_complete()
if "Pending" in state:
rootDone = False
check = True
elif "BootDone" in state:
rootDone = False
check = False
else:
rootDone = True
check = False
if rootDone == False:
out = str(get_ser().readlines())
get_log_cm().info("Out is %s", out)
get_log_cm().info("Send Password")
input = 'root'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(1)
get_ser().write(input.encode('ascii')+'\n')
#Make all passes go through this (move out of if)
time.sleep(3)
input = 'cd /opt/maxim-ic/hcr4/apps'
get_ser().write(input.encode('ascii')+'\n')
# end
time.sleep(1)
#Check if in the correct directory
input = 'ls'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(2)
out = get_ser().readlines()
if "sci" in str(out):
return True
else:
get_log_cm().debug("FAIL to find SCIBASIC")
input = 'pwd'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(1)
get_log_cm().info("%s" % str(get_ser().readlines()))
return False
def setCardFacilitator():
#This statys running until completes
ser = get_ser()
input = '/opt/maxim-ic/basic/examples/card_facilitator'
ser.write(input.encode('ascii') + '\n')
#Wait 2 seconds for Sam card
get_log_cm().info("Pull out MSR read within 10 seconds")
out = str(ser.readlines())
get_log_cm().info(out)
time.sleep(10)
#Control-C
input = '\x03'
ser.write(input.encode('ascii')) #+'\n')
get_log_cm().info("DONE")
def setCardFacilitator ():
#This statys running until completes
ser = get_ser()
input = '/opt/maxim-ic/basic/examples/card_facilitator'
ser.write(input.encode('ascii')+'\n')
#Wait 2 seconds for Sam card
get_log_cm().info("Pull out MSR read within 10 seconds")
out = str(ser.readlines())
get_log_cm().info(out)
time.sleep(10)
#Control-C
input = '\x03'
ser.write(input.encode('ascii')) #+'\n')
get_log_cm().info("DONE")
def find_dev_secmon_name():
if (get_ser().isOpen() == False):
get_log_cm().info("\t\t\tserial not available")
return -1
input = 'ls /dev/secm*'
get_ser().write(input.encode('ascii') + '\n')
time.sleep(2)
out = get_ser().readlines()
if not out:
get_log_cm().error("\t\t\t(find_dev_secmon_name)Possible Reset")
elif "ls" is out:
get_log_cm().error("\t\t\t/dev/secmon not found")
else:
print out
s_index = out[1].find('dev') + 4
e_index = out[1].find(r"\x1b", s_index)
print out[1][s_index:e_index]
def isCardPresent(num):
# check list for NOK or OK
ser = get_ser()
input = '/opt/maxim-ic/hcr4/apps/sci /dev/sc 3'
index = input.find(' 3')
input2 = input[:index] + str(num) + input[index:]
ser.write(input2.encode('ascii') + '\n')
out = ser.readlines()
if "NOK" in str(out):
get_log_cm().error("Card Missing")
return False
elif " OK" in str(out):
get_log_cm().debug("Card Present")
return True
else:
get_log_cm().error("Failed to read")
return -1
def isCardPresent (num):
# check list for NOK or OK
ser = get_ser()
input = '/opt/maxim-ic/hcr4/apps/sci /dev/sc 3'
index = input.find(' 3')
input2 = input[:index] + str(num) + input[index:]
ser.write(input2.encode('ascii')+'\n')
out = ser.readlines()
if "NOK" in str(out):
get_log_cm().error("Card Missing")
return False
elif " OK" in str(out):
get_log_cm().debug("Card Present")
return True
else:
get_log_cm().error("Failed to read")
return -1
def _ser_init():
wait4ser=True
while wait4ser:
try:
set_ser(serial.Serial(port, baud, timeout=1))
get_ser().close()
get_ser().open()
wait4ser=False
except serial.SerialException:
get_log_cm().info("Oops! waiting 15 seconds. Is the serial port %s available" % port)
wait4ser=True
set_ser(0)
time.sleep(15)
if get_ser().isOpen():
get_log_cm().info(get_ser().name + ' is open...')
else:
get_log_cm().error('Another UART blocking '+get_ser().name)
print ("Reading stopped, Reboot suspected")
get_ser().close()
run = 0
break
else:
#Get Transition Change
count = 0
if isCardP[i] != x:
isCardP[i] = x
ts = time.time()
st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')
if isCardP[i] == True:
if i == 1:
card_bay_locked() #plunger is pulled
print "%s Card %d Present & Locked" % (st, i)
get_log_cm().info("%s Card %d Present & Locked" % (st, i))
else:
print "%s Card %d Present" % (st, i)
get_log_cm().info("%s Card %d Present" % (st, i))
emv_data = getEnvData(i)
print ("%s Card %d ATR %s" % (st, i, emv_data))
get_log_cm().info("%s Card %d ATR %s" % (st, i, emv_data))
#Print ASCII, if data is available
if "No EMV Support" not in str(emv_data):
characters = emv_data.replace(' ', '')
print "%s Card %d ATR string %s" % (st, i, characters.decode('hex'))
if i == 1:
card_bay_open() #Plunger goes forward
print "%s Card %d Bay opened, Remove Card Quickly!!" % (st, i)
get_log_cm().info("%s Card %d Bay opened, Remove Card Quickly!!" % (st, i))
else:
def power_off():
latch_config(POWER_DOWN)
get_log_cm().debug("power_off")
return True
def pull_off():
latch_config(PULL_OFF)
get_log_cm().debug("pull_off")
return True
def latched_close():
latch_config(LATCHED_CLOSE)
get_log_cm().debug("\n latched_close\n")
return True
if __name__ == '__main__':
##############USER DEFINED##################################################################################
##Overwrite Log location
my_path = '..\\solenoid_log\\'
my_name = 'solendoid_test'
test_count = 10
##############USER DEFINED##################################################################################
##One time setup
while True:
test_count = 0
########Passing Counters########
total_count = 0
run = 1
################################
##############INIT #################
set_log_info(my_path, my_name)
ser_Init()
#card_bay_init()
##############INIT END##############
get_log_cm().info('Start %s Test', my_name)
get_log_cm().info('Test :\n Solenoid')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count += 1
get_log_cm().debug("Total Test Cycles = %d", total_count)
time.sleep(1)
def get_fail_count():
global fail_count
if 'fail_count' not in globals():
get_log_cm().error("Error: fail_count not init")
fail_count=0
return fail_count
##One time setup
while True:
test_count = 0
########Passing Counters########
total_count = 0
smart_card_count = 0
MAX_COM_RETRY = 5
################################
##############INIT #################
ser_Init()
run = 1
#card_bay_init()
##############INIT END##############
get_log_cm().info('Start %s Test', my_name)
get_log_cm().info('Test: Smart Card')
while run:
total_count+=1
get_log_cm().debug( "Total Test Cycles = %d", total_count)
#SMARTCARD Test:##########################################################
for i in range(1,2):
val = read_smart_card(i)
if val == -1:
run = 0
break
if val == 0:
smart_card_count+=1
#SMARTCARD Test:##########################################################
smart_card_count = 0
tamper_count = 0
rtc_stamp = 0
total_count = 0
MAX_COM_RETRY = 5
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
hostname = find_ip_addr('eth0')
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start FCC Test')
get_log_cm().info('Test :\n UART, Ethernet, USB, SmartCard')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count+=1
get_log_cm().debug( "Total Test Cycles = %d", total_count)
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count+=1
def await_boot_complete():
input = 'root'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(3)
out = str(get_ser().readlines())
if "jibe-eek login" in out:
get_log_cm().info("Boot up Complete")
return "BootDone"
elif "root@jibe-eek examples" in out:
get_log_cm().info("Root up Complete")
return "RootDone"
elif "SecureBoot/disabled (EvKit-revC-B5)>" in out:
get_log_cm().info("U-Boot detected, reset u-boot and wait 40 seconds")
input = 'reset'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(40)
get_log_cm().info("Go Back to listening")
return "Pending"
elif "root@jibe" in out:
get_log_cm().info("Root Log Complete")
return "RootDone"
elif "#" in out:
get_log_cm().info("Root Log Complete")
return "RootDone"
elif "Password" in out:
input = 'ls'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(5)
get_log_cm().info("Boot up Complete:PW")
return "BootDone"
else:
get_log_cm().info("%s: Awaiting Bootup", port )
input = 'cd /root'
get_ser().write(input.encode('ascii')+'\n')
time.sleep(2)
get_log_cm().info("Awaiting2 Bootup")
get_log_cm().info("%s" % out)
return "Pending"
smart_card_count = 0
tamper_count = 0
rtc_stamp = 0
cdc_count = 0
total_count = 0
MAX_COM_RETRY = 5
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
hostname = find_ip_addr('eth0')
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start FCC Test')
get_log_cm().info('Test :\n UART, Ethernet, USB, SmartCard')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count += 1
get_log_cm().debug("Total Test Cycles = %d", total_count)
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count += 1
SLEEP_DURATION = 2
CUSTOMER_DELAY = 5
while True:
########Passing Counters########
total_count = 0
smart_card_count = 0
run = 1
################################
##############INIT #################
ser_Init()
card_bay_init()
##############INIT END##############
get_log_cm().info('Start %s Test', my_name)
while run:
total_count += 1
if total_count >= test_count:
card_bay_init() #
run = 0
get_log_cm().info("Total Test Cycles = %d Sleep for %d seconds!",
total_count, CUSTOMER_DELAY)
time.sleep(CUSTOMER_DELAY)
#card_bay_locked()
latched_close()
#SMARTCARD Test:##########################################################
for i in range(1, 2):
val = read_smart_card(i)
if val == -1:
def latched_open():
latch_config(LATCHED_OPEN)
get_log_cm().debug("\n latched_open\n")
return True
known_val = "Hexadecimal VendorID=0x525 & ProductID=0xa4ac"
usb_count = 0;
while (1):
dev = usb.core.find(find_all=True)
time.sleep(1)
if prev_dev == "Not Init":
for cfg in dev:
sys.stdout.write("idVendor %s\n\n" % cfg.idVendor)
if cfg.idVendor == 0x0525:
prev_dev = cfg
usb_count += 1
elif prev_dev != "Not Init":
for cfg in dev:
if cfg is None:
get_log_cm().error('\t\t\tUSB Device not found')
elif cfg is 'NoneType':
get_log_cm().error('\t\t\tUSB Device noneType found')
else:
sys.stdout.write( "PREV VENDOR %s\n" % prev_dev.idVendor)
sys.stdout.write("cfg VENDOR %s\n" % cfg.idVendor)
if prev_dev.idVendor == cfg.idVendor and prev_dev.idProduct == cfg.idProduct:
usb_count += 1
sys.stdout.write("count %d\n\n" % usb_count)
def pull_on():
latch_config(PULL_ON)
get_log_cm().debug("pull_on")
return True
def latched_open ():
latch_config(LATCHED_OPEN)
get_log_cm().debug("\n latched_open\n")
return True
def power_on():
latch_config(POWER_ON)
get_log_cm().debug("power_on")
return True
def pull_on ():
latch_config(PULL_ON)
get_log_cm().debug("pull_on")
return True
########Passing Counters########
uart_count = 0
tamper_count = 0
rtc_stamp = 0
total_count = 0
MAX_COM_RETRY = 5
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start TAMPER Monitor Test')
while run:
total_count+=1
get_log_cm().debug( "Total Test Cycles = %d", total_count)
#UART:####################################################################
ret = uart_self_test()
if ret == False:
uart_count += 1
get_log_cm().info( "UART Count = \t\t\t%d of %d", uart_count, total_count)
#UART end:################################################################
#TAMPER:####################################################################
if tamper_flag != 0:
def power_on ():
latch_config(POWER_ON)
get_log_cm().debug("power_on")
return True
crypto_count = 0
total_count = 0
MAX_COM_RETRY = 5
SECONDS_PMIN = 60
MINUTES_DELAY = (SECONDS_PMIN * DELAY_PER_CYCLE)
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
hostname = find_ip_addr('eth0')
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start FCC Test')
get_log_cm().info('Test :\n UART, Ethernet, USB, SmartCard')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count+=1
get_log_cm().debug( "Total Test Cycles = %d", total_count)
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count+=1
def get_fail_count():
global fail_count
if 'fail_count' not in globals():
get_log_cm().error("Error: fail_count not init")
fail_count = 0
return fail_count
test_count = 10
##############USER DEFINED##################################################################################
##One time setup
while True:
test_count = 0
########Passing Counters########
total_count = 0
run = 1
################################
##############INIT #################
set_log_info(my_path, my_name, 1)
ser_Init()
#card_bay_init()
##############INIT END##############
get_log_cm().info('Start %s Test', my_name)
get_log_cm().info('Test :\n Solenoid')
card_bay_init()
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count+=1
pull_off()
get_log_cm().debug( "Total Test Cycles = %d", total_count)
time.sleep(5)
pull_on()
get_log_cm().debug( "Total Test Cycles = %d", total_count)
CUSTOMER_DELAY = 5
while True:
########Passing Counters########
total_count = 0
smart_card_count = 0
run = 1
################################
##############INIT #################
ser_Init()
card_bay_init()
##############INIT END##############
get_log_cm().info('Start %s Test', my_name)
while run:
total_count+=1
if total_count >= test_count:
card_bay_init() #
run = 0
get_log_cm().info( "Total Test Cycles = %d Sleep for %d seconds!", total_count, CUSTOMER_DELAY)
time.sleep(CUSTOMER_DELAY)
#card_bay_locked()
latched_close()
#SMARTCARD Test:##########################################################
for i in range(1,2):
val = read_smart_card(i)
if val == -1:
run = 0
def latched_close ():
latch_config(LATCHED_CLOSE)
get_log_cm().debug("\n latched_close\n")
return True
rtc_stamp = 0
crypto_count = 0
total_count = 0
MAX_COM_RETRY = 5
SECONDS_PMIN = 60
MINUTES_DELAY = (SECONDS_PMIN * DELAY_PER_CYCLE)
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
hostname = find_ip_addr('eth0')
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start FCC Test')
get_log_cm().info('Test :\n UART, Ethernet, USB, SmartCard')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count += 1
get_log_cm().debug("Total Test Cycles = %d", total_count)
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count += 1
def pull_off ():
latch_config(PULL_OFF)
get_log_cm().debug("pull_off")
return True
##################################################
#Main Code Here
##################################################
if __name__=='__main__':
while True:
run = 1
ethernet_count = 0
total_count = 0
my_path = '..\\ping_log\\'
my_name = 'ping_test'
set_log_info(my_path, my_name, 0)
ser_Init()
while run:
#Total Test Cycles
get_log_cm().info("\n")
total_count+=1
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
hostname = find_ip_addr('eth0')
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count+=1
get_log_cm().info( "Ethernet Count = \t\t%d of %d", ethernet_count, total_count)
#Ethernet Test end:#######################################################
def power_off ():
latch_config(POWER_DOWN)
get_log_cm().debug("power_off")
return True
smart_card_count = 0
tamper_count = 0
rtc_stamp = 0
total_count = 0
MAX_COM_RETRY = 5
################################
##############INIT #################
prev_dev = "Not Init"
ser_Init()
#Requires Serial init
hostname = find_ip_addr('eth0')
set_tamper_trigger(tamper_flag)
##############INIT END##############
get_log_cm().info('Start FCC Test')
get_log_cm().info('Test :\n UART, Ethernet, USB, SmartCard')
while run:
#Total Test Cycles
#get_log_cm().info( "\n")
total_count+=1
get_log_cm().debug( "Total Test Cycles = %d", total_count)
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if hostname != -1:
ret = can_addr_ping(hostname)
if ret == True:
ethernet_count+=1
#print e_index - s_index
return out[s_index:e_index]
else:
return -1
##################################################
#Main Code Here
##################################################
if __name__=='__main__':
while True:
run = 1
cdc_count = 0
total_count = 0
my_path = '..\\ping_log\\'
my_name = 'ping_test'
set_log_info(my_path, my_name, 0)
ser_Init()
while run:
#Total Test Cycles
get_log_cm().info("\n")
total_count+=1
#Ethernet Test:###########################################################
###Find HCR-4 IP Address####
if find_cdc_rsp_data() != -1:
cdc_count = cdc_count+1
get_log_cm().info( "CDC Count = \t\t%d of %d", cdc_count, total_count)
#Ethernet Test end:#######################################################
def ser_Init():
_ser_init()
while become_root() == False:
get_log_cm().debug("\t\t\t\tChecking for ROOT\n")
get_log_cm().info("\tROOT Detected!!")
