561 lines
25 KiB
Python
Executable file
561 lines
25 KiB
Python
Executable file
import random
|
|
import os
|
|
import time
|
|
import string
|
|
import re
|
|
import threading
|
|
|
|
from TCAction import TCActionBase, PerformanceTCBase
|
|
from NativeLog import NativeLog
|
|
from Utility import MakeFolder
|
|
from Utility import MultimeterUtil
|
|
from Utility import ShellCmd
|
|
|
|
LOG_PATH = os.path.join("AT_LOG", "SLEEP")
|
|
|
|
SLEEP_MODE_LIST = ["none_sleep", "light_sleep", "modem_sleep"]
|
|
SLEEP_MODE = dict(zip(SLEEP_MODE_LIST, range(len(SLEEP_MODE_LIST))))
|
|
|
|
SAMPLE_RATE_SLEEP_MODE_CHANGE = 0.002
|
|
SAMPLE_NUM_SLEEP_MODE_CHANGE = 256
|
|
|
|
SAMPLE_RATE = 0.002
|
|
SAMPLE_NUM = 512
|
|
MAX_VALUE = 1
|
|
Y_AXIS_LABEL = "Current (mA)"
|
|
GPIO_EDGE_DELAY = 120 # 20 ms
|
|
|
|
NONE_SLEEP_MIN_CUR = 30
|
|
LIGHT_SLEEP_MIN_CUR = 1.5
|
|
MODEM_SLEEP_MIN_CUR = 20
|
|
|
|
GPIO_WAKE_UP = 15
|
|
GPIO_CHIP_RESET = 14
|
|
|
|
SLEEP_WAKEUP_DELAY = 0.01
|
|
|
|
|
|
class AutoSleep(PerformanceTCBase.PerformanceTCBase):
|
|
|
|
def __init__(self, name, test_env, cmd_set, timeout=30, log_path=TCActionBase.LOG_PATH):
|
|
PerformanceTCBase.PerformanceTCBase.__init__(self, name, test_env, cmd_set=cmd_set,
|
|
timeout=timeout, log_path=log_path)
|
|
self.test_mode = "mode_change"
|
|
self.test_count = 100
|
|
self.sleep_mode = SLEEP_MODE_LIST
|
|
# load param from excel
|
|
for i in range(1, len(cmd_set)):
|
|
if cmd_set[i][0] != "dummy":
|
|
cmd_string = "self." + cmd_set[i][0]
|
|
exec cmd_string
|
|
self.log_folder = MakeFolder.make_folder(os.path.join(LOG_PATH,
|
|
"AUTO_SLEEP_%s_%s" % (self.test_mode,
|
|
time.strftime("%d%H%M%S",
|
|
time.localtime()))))
|
|
self.multimeter = MultimeterUtil.MultimeterUtil(self.log_folder)
|
|
|
|
@staticmethod
|
|
def find_min_items(item_list, count):
|
|
assert count < len(item_list)
|
|
min_items = []
|
|
for i in range(count):
|
|
min_val = min(item_list)
|
|
min_items.append(min_val)
|
|
item_list.remove(min_val)
|
|
return min_items
|
|
|
|
def sleep_mode_change(self, sleep_mode):
|
|
result = True
|
|
NativeLog.add_prompt_trace("[AutoSleep][ModeChange] %s start" % sleep_mode)
|
|
# choose sleep mode
|
|
sleep_mode_enum = SLEEP_MODE[sleep_mode]
|
|
# change GPIO to make sure target exit sleep mode, so it can process SSC commands
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
# set sleep mode
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % sleep_mode_enum)
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][ModeChange] mode set")
|
|
time.sleep(6)
|
|
# measure current
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE_SLEEP_MODE_CHANGE,
|
|
sample_num=SAMPLE_NUM_SLEEP_MODE_CHANGE,
|
|
max_value=MAX_VALUE)
|
|
# do check measure
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][ModeChange] measure done, average min current %f" % average_val)
|
|
|
|
if sleep_mode == "none_sleep":
|
|
if average_val < NONE_SLEEP_MIN_CUR:
|
|
result = False
|
|
elif sleep_mode == "light_sleep":
|
|
if average_val > LIGHT_SLEEP_MIN_CUR:
|
|
result = False
|
|
elif sleep_mode == "modem_sleep":
|
|
if average_val > MODEM_SLEEP_MIN_CUR or average_val < LIGHT_SLEEP_MIN_CUR:
|
|
result = False
|
|
if result is False:
|
|
NativeLog.add_trace_critical("[AutoSleep][ModeChange] %s failed" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE, "%s_fail" % sleep_mode, Y_AXIS_LABEL)
|
|
|
|
time.sleep(5)
|
|
return result
|
|
|
|
def sleep_current_measure(self, sleep_mode):
|
|
result = True
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][CurrentMeasure] %s start" % sleep_mode)
|
|
# choose sleep mode
|
|
sleep_mode_enum = SLEEP_MODE[sleep_mode]
|
|
# change GPIO to make sure target exit sleep mode, so it can process SSC commands
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
# set sleep mode
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % sleep_mode_enum)
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][CurrentMeasure] set mode done")
|
|
time.sleep(10)
|
|
# measure current
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE, sleep_mode, Y_AXIS_LABEL)
|
|
NativeLog.add_prompt_trace("[AutoSleep][CurrentMeasure] measure done")
|
|
return result
|
|
|
|
def light_sleep_wakeup(self):
|
|
result = True
|
|
NativeLog.add_prompt_trace("[AutoSleep][LightSleepWakeup] start")
|
|
|
|
time.sleep(1)
|
|
self.serial_write_line("SSC1", "")
|
|
time.sleep(1)
|
|
# check if respond to uart
|
|
self.flush_data("SSC1")
|
|
for i in range(60):
|
|
self.serial_write("SSC1", "a")
|
|
time.sleep(0.043)
|
|
time.sleep(0.1)
|
|
respond_data = self.serial_read_data("SSC1")
|
|
if len(respond_data) >= 60:
|
|
NativeLog.add_trace_critical("[AutoSleep][light sleep wakeup] "
|
|
"Failed when recving data during sleep, %d" % len(respond_data))
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][LightSleepWakeup] check on sleep mode done")
|
|
|
|
self.serial_write_line("SSC1", "")
|
|
time.sleep(1)
|
|
|
|
# change GPIO to make target wakeup
|
|
self.serial_write_line("SSC2", "gpio -L -p %d -t 0" % GPIO_WAKE_UP)
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
self.serial_write_line("SSC1", "")
|
|
time.sleep(1)
|
|
self.flush_data("SSC1")
|
|
for i in range(60):
|
|
self.serial_write("SSC1", "a")
|
|
time.sleep(0.043)
|
|
time.sleep(0.1)
|
|
respond_data = self.serial_read_data("SSC1")
|
|
if len(respond_data) < 60:
|
|
NativeLog.add_trace_critical("[AutoSleep][light sleep wakeup] "
|
|
"Failed when recving data during wakeup, %d" % len(respond_data))
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][LightSleepWakeup] check on wakeup mode done")
|
|
self.serial_write_line("SSC1", "")
|
|
# restore GPIO level
|
|
self.serial_write_line("SSC2", "gpio -L -p %d -t 1" % GPIO_WAKE_UP)
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_CHIP_RESET, GPIO_EDGE_DELAY))
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
time.sleep(2)
|
|
return result
|
|
|
|
def sleep_exit_enter(self, sleep_mode, ssid, password):
|
|
result = True
|
|
if sleep_mode == "modem_sleep":
|
|
max_current_for_sleep = 20
|
|
elif sleep_mode == "light_sleep":
|
|
max_current_for_sleep = 5
|
|
else:
|
|
raise StandardError("Not supported mode %s" % sleep_mode)
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] %s start" % sleep_mode)
|
|
|
|
ap_ssid = self.get_parameter("ap_ssid")
|
|
ap_password = self.get_parameter("ap_password")
|
|
|
|
# step A: no STA connect to SoftAP, enter modem sleep mode
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "op -S -o 1")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sta -C -s %s -p %s" % (ap_ssid, ap_password))
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
self.check_response("SSC1", "+JAP:CONNECTED")
|
|
self.check_response("SSC1", "pm open")
|
|
|
|
self.serial_write_line("SSC2", "sta -D")
|
|
self.check_response("SSC2", "+QAP")
|
|
|
|
time.sleep(5)
|
|
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val > max_current_for_sleep:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] "
|
|
"did not enter %s sleep, %d" % (sleep_mode, average_val))
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_A" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step A done")
|
|
# step B: STA connect to SoftAP, exit modem sleep mode
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "op -S -o 3")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
time.sleep(1)
|
|
self.serial_write_line("SSC2", "sta -C -s %s -p %s" % (ssid, password))
|
|
self.check_response("SSC2", "+JAP:CONNECTED")
|
|
# self.check_response("SSC1", "pm close")
|
|
time.sleep(10)
|
|
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val < 30:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] did not exit %s sleep" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_B" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step B done")
|
|
# step C: target set to STA mode, enter modem sleep
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "op -S -o 1")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
# self.check_response("SSC1", "pm open")
|
|
time.sleep(15)
|
|
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val > max_current_for_sleep:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] did not enter %s sleep" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_C" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step C done")
|
|
# step D: target disconnect, exit modem sleep
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sta -D")
|
|
self.check_response("SSC1", "+QAP")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
# self.check_response("SSC1", "pm close")
|
|
time.sleep(5)
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val < 30:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] did not exit %s sleep" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_D" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step D done")
|
|
# step E: target connect to AP, enter modem sleep
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sta -C -s %s -p %s" % (ap_ssid, ap_password))
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
self.check_response("SSC1", "+JAP:CONNECTED")
|
|
self.check_response("SSC1", "pm open")
|
|
time.sleep(3)
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val > max_current_for_sleep:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] did not enter %s sleep" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_E" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step E done")
|
|
# step F: target set to AP mode, exit modem sleep
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "op -S -o 2")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
# self.check_response("SSC1", "pm close")
|
|
time.sleep(5)
|
|
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val < 30:
|
|
NativeLog.add_trace_critical("[AutoSleep][SleepExitEnter] did not exit %s sleep" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_sleep_exit_enter_fail_F" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][EnterExitSleep] step F done")
|
|
return result
|
|
|
|
def ping_test(self, sleep_mode):
|
|
result = True
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] %s start" % sleep_mode)
|
|
# choose sleep mode
|
|
sleep_mode_enum = SLEEP_MODE[sleep_mode]
|
|
if sleep_mode == "modem_sleep":
|
|
max_current_for_sleep = MODEM_SLEEP_MIN_CUR
|
|
elif sleep_mode == "light_sleep":
|
|
max_current_for_sleep = LIGHT_SLEEP_MIN_CUR
|
|
else:
|
|
raise StandardError("Not supported mode %s" % sleep_mode)
|
|
|
|
self.serial_write_line("SSC1", "op -S -o 1")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
|
|
# set sleep mode
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % sleep_mode_enum)
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] set mode done")
|
|
|
|
# connect to AP
|
|
ap_ssid = self.get_parameter("ap_ssid")
|
|
ap_password = self.get_parameter("ap_password")
|
|
target_ip = self.get_parameter("target_ip")
|
|
|
|
self.serial_write_line("SSC1", "sta -C -s %s -p %s" % (ap_ssid, ap_password))
|
|
self.check_response("SSC1", "+JAP:CONNECTED")
|
|
|
|
time.sleep(10)
|
|
# measure current, should be in sleep mode
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
|
|
if average_val > max_current_for_sleep:
|
|
NativeLog.add_trace_critical("[AutoSleep][PingTest] step A did not enter %s sleep, %f"
|
|
% (sleep_mode, average_val))
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_ping_test_fail_not_enter_sleep" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
else:
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] step A enter %s sleep, %f"
|
|
% (sleep_mode, average_val))
|
|
|
|
class PingThread(threading.Thread):
|
|
def __init__(self, ping_ip):
|
|
threading.Thread.__init__(self)
|
|
self.setDaemon(True)
|
|
self.target_ip = ping_ip
|
|
self.exit_event = threading.Event()
|
|
|
|
def run(self):
|
|
while self.exit_event.isSet() is False:
|
|
ShellCmd.shell_check_output("ping %s -w 500" % self.target_ip)
|
|
time.sleep(0.1)
|
|
pass
|
|
|
|
def exit(self):
|
|
self.exit_event.set()
|
|
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] ping start")
|
|
ping_thread = PingThread(target_ip)
|
|
ping_thread.start()
|
|
time.sleep(5)
|
|
|
|
# measure current, should not be in sleep mode
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val < 30:
|
|
NativeLog.add_trace_critical("[AutoSleep][PingTest] step B did not exit %s sleep, %f"
|
|
% (sleep_mode, average_val))
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_ping_test_fail_not_exit_sleep" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
else:
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] step B exit %s sleep, %f"
|
|
% (sleep_mode, average_val))
|
|
|
|
ping_thread.exit()
|
|
ping_thread.join(20)
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] ping stop")
|
|
time.sleep(10)
|
|
|
|
# measure current, should not be in sleep mode
|
|
current_line = self.multimeter.measure_current(sample_rate=SAMPLE_RATE,
|
|
sample_num=SAMPLE_NUM,
|
|
max_value=MAX_VALUE)
|
|
min_items = self.find_min_items(current_line, 10)
|
|
average_val = float(0)
|
|
for val in min_items:
|
|
average_val += val
|
|
average_val /= 10
|
|
if average_val > max_current_for_sleep:
|
|
NativeLog.add_trace_critical("[AutoSleep][PingTest] step C did not enter %s" % sleep_mode)
|
|
self.multimeter.draw_graph(current_line, SAMPLE_RATE,
|
|
"%s_ping_test_fail_not_enter_sleep" % sleep_mode, Y_AXIS_LABEL)
|
|
result = False
|
|
else:
|
|
NativeLog.add_prompt_trace("[AutoSleep][PingTest] step C enter %s sleep" % sleep_mode)
|
|
|
|
return result
|
|
|
|
def cleanup(self):
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % SLEEP_MODE["modem_sleep"])
|
|
self.check_response("SSC1", "OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
def execute(self):
|
|
TCActionBase.TCActionBase.execute(self)
|
|
|
|
try:
|
|
test_mode = self.test_mode
|
|
test_count = self.test_count
|
|
sleep_mode = self.sleep_mode
|
|
except StandardError, e:
|
|
return
|
|
|
|
# make sure enter modem sleep mode before start test
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % SLEEP_MODE["modem_sleep"])
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
self.check_response("SSC1", "pm open", timeout=10)
|
|
|
|
self.serial_write_line("SSC1", "gpio -G -p %d" % GPIO_WAKE_UP)
|
|
self.check_response("SSC1", "+GPIO_GET")
|
|
self.serial_write_line("SSC1", "gpio -G -p %d" % GPIO_CHIP_RESET)
|
|
self.check_response("SSC1", "+GPIO_GET")
|
|
|
|
# start test
|
|
if "mode_change" in test_mode:
|
|
for i in range(test_count):
|
|
result = self.sleep_mode_change(random.choice(SLEEP_MODE_LIST))
|
|
|
|
elif "measure_current" in test_mode:
|
|
for i in range(test_count):
|
|
for mode in sleep_mode:
|
|
result = self.sleep_current_measure(mode)
|
|
pass
|
|
elif "gpio_wakeup" in test_mode:
|
|
# change GPIO to make sure target exit sleep mode, so it can process SSC commands
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
# set sleep mode
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % SLEEP_MODE["light_sleep"])
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
for i in range(test_count):
|
|
result = self.light_sleep_wakeup()
|
|
pass
|
|
elif "sleep_exit_enter" in test_mode:
|
|
ssid = "".join([random.choice(string.lowercase) for i in range(10)])
|
|
password = "".join([random.choice(string.lowercase) for i in range(10)])
|
|
self.serial_write_line("SSC2", "sta -D")
|
|
self.check_response("SSC2", "+QAP")
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "op -S -o 3")
|
|
self.check_response("SSC1", "+MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
self.serial_write_line("SSC1", "ap -S -s %s -p %s -t 3" % (ssid, password))
|
|
self.check_response("SSC1", "+SAP:OK")
|
|
self.serial_write_line("SSC2", "op -S -o 1")
|
|
self.check_response("SSC2", "+MODE:OK")
|
|
|
|
for mode in sleep_mode:
|
|
self.serial_write_line("SSC2", "gpio -E -p %d -t 0 -d %d" % (GPIO_WAKE_UP, GPIO_EDGE_DELAY))
|
|
time.sleep(SLEEP_WAKEUP_DELAY)
|
|
self.serial_write_line("SSC1", "sleep -S -t %d" % SLEEP_MODE[mode])
|
|
self.check_response("SSC1", "+SLEEP_MODE:OK")
|
|
self.check_response("SSC2", "+GPIO_SET:OK")
|
|
|
|
for i in range(test_count):
|
|
result = self.sleep_exit_enter(mode, ssid, password)
|
|
elif "ping" in test_mode:
|
|
for mode in sleep_mode:
|
|
for i in range(test_count):
|
|
result = self.ping_test(mode)
|
|
pass
|
|
|
|
|
|
def main():
|
|
pass
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|