def get_date(id):
thread.allowsuspend(True)
global debug_date
global datebase
global namelist
global internet_date
global display_index
global start_flag
baseurl_1 = "http://fundgz.1234567.com.cn/js/"
baseurl_2 = ".js?rt=1463558676006"
while True:
if start_flag == 1:
utime.sleep(5)
debug_date.append('start get date')
url = baseurl_1 + datebase["info"][
namelist[display_index]] + baseurl_2
try:
temp = urequests.get(url).text
d = ujson.loads(temp[temp.find("(") + 1:temp.find(")")])
internet_date[namelist[display_index]] = d
del temp
except:
internet_date[namelist[display_index]] = None
debug_date.append('finish')
thread.notify(id, 1001)
gc.collect()
def rgbled(n=200, led=bled):
notif_exit = 4718
notif_replay = 2
notif_count = 3
x = 0
_thread.allowsuspend(True)
while True:
led.value(1)
time.sleep_ms(n)
led.value(0)
x = x + 1
t = 10
while t > 0:
notif = _thread.getnotification()
if notif == notif_exit:
_thread.sendmsg(_thread.getReplID(), "[%s] Exiting" % (_thread.getSelfName()))
return
elif notif == notif_replay:
_thread.sendmsg(_thread.getReplID(), "[%s] I've been notified" % (_thread.getSelfName()))
elif notif == notif_count:
_thread.sendmsg(_thread.getReplID(), "[%s] Run counter = %u" % (_thread.getSelfName(), x))
elif notif == 777:
_thread.sendmsg(_thread.getReplID(), "[%s] Forced EXCEPTION" % (_thread.getSelfName()))
time.sleep_ms(1000)
zz = 234 / 0
elif notif != 0:
_thread.sendmsg(_thread.getReplID(), "[%s] Got unknown notification: %u" % (_thread.getSelfName(), notif))
typ, sender, msg = _thread.getmsg()
if msg:
_thread.sendmsg(_thread.getReplID(), "[%s] Message from '%s'\n'%s'" % (_thread.getSelfName(), _thread.getThreadName(sender), msg))
time.sleep_ms(100)
t = t - 1
gc.collect()
def run_script_threaded(filename):
try:
thread.stack_size(5*1024)
thread.allowsuspend(True)
file = open(filename)
content = file.read()
file.close()
fix = '''while True:
ntf = thread.getnotification()
if ntf:
if ntf == thread.EXIT:
sys.exit()
elif ntf == thread.SUSPEND:
while thread.wait() != thread.RESUME:
pass'''
content = content.replace('while True:', fix)
content = content.replace('while 1:', fix)
exec(content)
while True:
ntf = thread.getnotification()
if ntf:
if ntf == thread.EXIT:
return
elif ntf == thread.SUSPEND:
while thread.wait() != thread.RESUME:
pass
except Exception as e:
print(red(thread.getSelfName() + str(e)))
return
def do_flashes(pin):
"""TODO: Docstring for do_flashes.
:returns: TODO
"""
_thread.allowsuspend(True)
while True:
pin.value(not pin.value())
utime.sleep_ms(250)
pin.value(1)
def mqtt_send_loop(self):
""" send mqtt loop """
# threading is different in lobo micropython
if sys.platform.startswith("esp32_LoBo"):
_thread.allowsuspend(True)
while True:
ntf = _thread.getnotification()
if ntf:
# some notification received
if ntf == _thread.EXIT:
return
self.send_one_message()
time.sleep(0.1)
else:
pass
def heartbeat(self, isReversed=False):
_thread.allowsuspend(True)
while True:
ntf = _thread.getnotification()
if ntf == _thread.EXIT:
# return from thread terminates the thread
#print("heartbeat: terminated")
return
elif ntf == _thread.SUSPEND:
while _thread.wait() != _thread.RESUME:
pass
else:
# default notification handling
pass
# regular application code
self._heartbeat(isReversed)
def __th_sd(self):
_thread.allowsuspend(True)
while True:
bufLen = len(self.dataBuffer)
if bufLen > self.SIZE_BUF and self.FLAG_SD == 0:
self.FLAG_SD = 1
strBuffer = ''
handle = self.dataBuffer[:bufLen]
del (self.dataBuffer[:bufLen])
for ds in handle:
strBuffer += ('%f,%f,%f,%f,%f,%f,%f\n' % ds)
with open('/sd/' + self.DNAME_ROOT + '/' + self.fname_save,
'a') as o:
o.write(strBuffer)
print('Write out. (%d)' % bufLen)
self.FLAG_SD = 0
else:
time.sleep(.2)
def video_thread_fn(data, clock, latch, buffer, mask, refresh_interval):
print("video_thread: started")
_thread.allowsuspend(True)
d = [
[1, 0, 0, 0, 0],
[0, 1, 0, 0, 0],
[0, 0, 1, 0, 0],
[0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]
]
r = [0, 1, 2, 3, 4, 5, 6]
row = 0
while True:
row %= 5
for x in r:
# (mask[1][row] >> x)
data.value(1 - ((buffer[1][row] >> x & 1) & (mask[1] >> row & 1)))
clock.value(1)
clock.value(0)
for j in d[row]:
data.value(j)
clock.value(1)
clock.value(0)
for x in r:
data.value(1 - ((buffer[0][row] >> x & 1) & (mask[0] >> row & 1)))
clock.value(1)
clock.value(0)
for j in d[row]:
data.value(j)
clock.value(1)
clock.value(0)
latch.value(0)
latch.value(1)
row += 1
_thread.wait(refresh_interval)
def bmerun(interval=60):
_thread.allowsuspend(True)
sendmsg = True
send_time = time.time() + interval
while True:
while time.time() < send_time:
notif = _thread.getnotification()
if notif == 10002:
_thread.sendmsg(_thread.getReplID(), bmevalues())
elif notif == 10004:
sendmsg = False
elif notif == 10006:
sendmsg = True
elif (notif <= 3600) and (notif >= 10):
interval = notif
send_time = time.time() + interval
_thread.sendmsg(_thread.getReplID(), "Interval set to {} seconds".format(interval))
time.sleep_ms(100)
send_time = send_time + interval
if sendmsg:
_thread.sendmsg(_thread.getReplID(), bmevalues())
def video_thread_fn(data, clock, latch, buffer, mask, refresh_interval):
print("video_thread: started")
_thread.allowsuspend(True)
d = [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0],
[0, 0, 0, 0, 1]]
r = [0, 1, 2, 3, 4, 5, 6]
row = 0
while True:
row %= 5
for x in r:
# (mask[1][row] >> x)
data.value(1 - ((buffer[1][row] >> x & 1) & (mask[1] >> row & 1)))
clock.value(1)
clock.value(0)
for j in d[row]:
data.value(j)
clock.value(1)
clock.value(0)
for x in r:
data.value(1 - ((buffer[0][row] >> x & 1) & (mask[0] >> row & 1)))
clock.value(1)
clock.value(0)
for j in d[row]:
data.value(j)
clock.value(1)
clock.value(0)
latch.value(0)
latch.value(1)
row += 1
_thread.wait(refresh_interval)
def main():
thread.allowsuspend(True)
gc_count = 0
if datebase is None:
pass
else:
ssid_text.update(datebase['wifi']['ssid'])
pwd_text.update(datebase['wifi']['pwd'])
del_name_list.updatelistdate(namelist)
while True:
if buttonA.wasPressed(callback=None):
window.event(1)
elif buttonB.wasPressed(callback=None):
window.event(2)
elif buttonC.wasPressed(callback=None):
window.event(3)
#temp = keyboard.read()
#if temp != b'\x00':
#window.event(temp)
#print(temp)
ntf = thread.getnotification()
if ntf:
if ntf == 1001: # 获取数据
# print(internet_date)
display()
gc_count += 1
# gc.collect()
# 将debug_date 数据显示到debug窗口
if len(debug_date) > 0:
de(debug_date[0])
del debug_date[0]
gc_count += 1
if gc_count > 20:
gc.collect()
gc_count = 0
def th_cam_to_motor(threads: dict, thctm_values: dict, m, config: dict):
_thread.allowsuspend(True)
cur_name = _thread.getSelfName()
cur_id = threads[cur_name]
print("{}: started with id {}".format(cur_name.upper(), cur_id))
while True:
"""Notification Handling"""
ntf = _thread.getnotification()
if ntf:
if ntf == _thread.EXIT:
print("{}: terminated".format(cur_name.upper()))
return
elif ntf == _thread.SUSPEND:
print("{}: suspended".format(cur_name.upper()))
m.stop()
# wait for RESUME notification indefinitely, some other thread must
# send the resume notification: _thread.notify(th_id, _thread.RESUME)
while _thread.wait() != _thread.RESUME:
pass
print("{}: resumed".format(cur_name.upper()))
else:
# Default notification handling
pass
# ---------------------------------------------------------------
# - Using sleep in thread function -
# ---------------------------------------------------------------
# 'utime.sleep(sec, True)' & 'utime.sleep_ms(ms, True)' functions returns the
# actual ellapsed sleep time. The sleep will be interrupted if
# a notification is received and the returned value will be less
# than the requested one
# ---------------------------------------------------------------
# Example:
# print("TH_FUNC: Loop started")
# for i in range(0, 5):
# print("TH_FUNC: Loop no:", i)
# sleep_time = utime.sleep_ms(10000, True)
# if sleep_time < 10000:
# # Notification received while sleeping
# print("TH_FUNC: Notification while sleeping", st)
# # Sleep for the remaining interval if needed
# utime.sleep_ms(10000 - sleep_time)
# print("TH_FUNC: Loop ended")
# ===================================================================================
# Handle inter thread message
# Sender thread ID, message type (string or integer) and message itself are available
# ===================================================================================
""
# <MAIN CODE>
"""Line Parsing and Motor controlling"""
line_angle = thctm_values["line"][1]
line_type = thctm_values["line"][0]
l_value = r_value = config["drive_speed"]
if line_type == CUART.ltype_straight:
x = line_angle
# l_value = constrain(maprange([-90, 0], [0, config["drive_speed"]], line_angle), 0, config["drive_speed"])
# r_value = constrain(maprange([0, 90], [config["drive_speed"], 0], line_angle), 0, config["drive_speed"])
l_value = int(0.0006911 * x * x * x - 0.011111 * x * x +
0.044657 * x + 20)
r_value = int(-0.0006911 * x * x * x - 0.011111 * x * x -
0.044657 * x + 20)
# print(l_value, r_value)
m.move(l_value, r_value)
# </MAIN CODE>
"""Message handling"""
typ, sender, msg = _thread.getmsg()
if msg:
if typ == 1 and msg == thr_msg.HEARTBEAT:
_thread.sendmsg(sender, thr_msg.HEARTBEAT)
# else:
# _thread.sendmsg(threads["log"], "[%s] Received message from '%s'\n'%s'" % (
# _thread.getSelfName(), _thread.getThreadName(sender), msg))
utime.sleep_ms(10) # Weird bug (was 10 before, trying to minimize)
def th_func(threads: dict):
# ------------------------------------------------------------
# Allow suspending this thread from other threads using
# _thread.suspend(th_id) / _thread.resume(th_id) functions.
# If not set, the thread connot be suspended.
# Still, "soft" suspend handling via notifications can be used
# ------------------------------------------------------------
_thread.allowsuspend(True)
cur_name = _thread.getSelfName()
cur_id = threads[cur_name]
print("{}: started with id {}".format(cur_name.upper(), cur_id))
# ---------------------------------------------
# Thread function usually runs in infinite loop
# ---------------------------------------------
while True:
# ================================================
# It is recommended to handle thread notifications
# ================================================
ntf = _thread.getnotification()
if ntf:
# some notification received
if ntf == _thread.EXIT:
# -------------------------------------------------
# Return from thread function terminates the thread
# -------------------------------------------------
print("{}: terminated".format(cur_name.upper()))
return
elif ntf == _thread.SUSPEND:
# -------------------------------------------------------------------
# The thread can be suspended using _thread.suspend(th_id) function,
# but sometimes it is more convenient to implement the "soft" suspend
# -------------------------------------------------------------------
print("{}: suspended".format(cur_name.upper()))
# wait for RESUME notification indefinitely, some other thread must
# send the resume notification: _thread.notify(th_id, _thread.RESUME)
while _thread.wait() != _thread.RESUME:
pass
print("{}: resumed".format(cur_name.upper()))
# ---------------------------------------------
# Handle the application specific notifications
# ---------------------------------------------
elif ntf == 1234:
# Your notification handling code
pass
else:
# -----------------------------
# Default notification handling
# -----------------------------
pass
# ----------------------------------
# Put your thread function code here
# ----------------------------------
# ---------------------------------------------------------------------------
# Thread function execution can be suspended until a notification is received
# Without argument '_thread.wait' will wait for notification indefinitely
# If the timeout argument is given, the function will return even if
# no notification is received after the timeout expires with result 'None'
# ---------------------------------------------------------------------------
# ntf = _thread.wait(30000)
# if ntf:
# # --------------------------------------------
# # Check if terminate notification was received
# # --------------------------------------------
# if ntf == _thread.EXIT:
# return
# #print("TH_FUNC: Notification received: ", ntf)
#
# # ---------------------------------------------
# # Execute some code based on notification value
# # ---------------------------------------------
# if ntf == 77:
# print("Notification 77 received")
# elif ntf == 8888:
# myvar += 100
# else:
# # ---------------------------------
# # Execute some code on wait timeout
# # ---------------------------------
# print("TH_FUNC: Wait notification timeout")
# ---------------------------------------------------------------
# - Using sleep in thread function -
# ---------------------------------------------------------------
# 'utime.sleep(sec, True)' & 'utime.sleep_ms(ms, True)' functions returns the
# actual ellapsed sleep time. The sleep will be interrupted if
# a notification is received and the returned value will be less
# than the requested one
# ---------------------------------------------------------------
# Example:
# print("TH_FUNC: Loop started")
# for i in range(0, 5):
# print("TH_FUNC: Loop no:", i)
# sleep_time = utime.sleep_ms(10000, True)
# if sleep_time < 10000:
# # Notification received while sleeping
# print("TH_FUNC: Notification while sleeping", st)
# # Sleep for the remaining interval if needed
# utime.sleep_ms(10000 - sleep_time)
# print("TH_FUNC: Loop ended")
# ===================================================================================
# Handle inter thread message
# Sender thread ID, message type (string or integer) and message itself are available
# ===================================================================================
typ, sender, msg = _thread.getmsg()
if msg:
# -------------------------------------
# message received from 'sender' thread
# -------------------------------------
if typ == 1 and msg == thr_msg.HEARTBEAT:
# Reply to sender, we can analyze the message first
_thread.sendmsg(sender, thr_msg.HEARTBEAT)
else:
# We can inform the main MicroPython thread (REPL) about received message
_thread.sendmsg(
threads["log"], "[%s] Received message from '%s'\n'%s'" %
(_thread.getSelfName(), _thread.getThreadName(sender),
msg))