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))