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 thrainbow(): pos = 0 np.brightness(25) while True: np.rainbow(pos, 3) notif = _thread.getnotification() if (notif > 0) and (notif <= 100): np.brightness(math.trunc(notif * 2.55)) elif notif == 1000: _thread.sendmsg(_thread.getReplID(), "[%s] Run counter = %u" % (_thread.getSelfName(), pos)) pos = pos + 1
def thrainbow_py(): pos = 0 bri = 0.02 while True: for i in range(0, num_np): dHue = 360.0/num_np * (pos+i); hue = dHue % 360; np.setHSB(i, hue, 1.0, bri, 1, False) np.show() notif = _thread.getnotification() if (notif > 0) and (notif <= 100): bri = notif / 100.0 elif notif == 1000: _thread.sendmsg(_thread.getReplID(), "[%s] Run counter = %u" % (_thread.getSelfName(), pos)) pos = pos + 1
def test(): i = 0 while i<10: i=i+1 print("Hello from thread") print(_thread.getSelfName()) mainID = _thread.getReplID() print(mainID) print(_thread.getmsg()) print(_thread.wait()) while _thread.wait() : #_thread.sendmsg(mainID, i) time.sleep(2) thrID = _thread.start_new_thread("test",test,()) _thread.sendmsg(thrID, 5) _thread.getmsg() _thread.list() _thread.notify(thrID, 1) #k=_thread.start_new_thread("testThr",testThread,(1,)) _thread.start_new_thread(testThread()) k=0 while k<15: k=k+1 time.sleep(1) print("Hello from main") pass
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 ThrReciveSocket(self): print("thrReciveSocket is RUN") #_thread.allowsuspend(True) # while True: i = 0 while i < 100: i = i + 1 print("Hello from thread") print(_thread.getSelfName()) # mainID = _thread.getReplID() # print(mainID) # print(_thread.getmsg()) if (self.isConnect()): # если есть соеденение то читаем из соккета isOk = False cntByte = 0 self.datafromserver = bytearray() while (isOk != True): try: bn = self.serversock.read(1) self.datafromserver.extend(chr(bn[0])) cntByte += 1 except OSError as e: if e.args[0] == 110: if cntByte > 0: isOk = True #print(e) #print("cntByte = ", cntByte) self.isDataFromServer = True print("read data size = ", cntByte) print("len data size = ", len(self.datafromserver)) print(self.datafromserver) """ try: print("self.isConnect()") bn = self.serversock.readinto(self.datafromserver) if(bn >0): self.isDataFromServer = True else: self.err_thr_read = ERR_READ_DATA_FROM_SERVER print("read data size = ",bn) print("len data size = ", len(self.datafromserver)) print(self.datafromserver) except OSError as e: print("!!!!!!!! except OSError in ThrReciveSocket") # выставляем флаг того что была ошибка """ notification = _thread.wait() print("notification = ", notification) if (notification == _thread.EXIT): print("_thread.EXIT") break #if (notification == 10): #print("SEND_DATA_TO_SERBER == 1") #if (self.isConnect()): # try: # self.serversock.send(self.datatoserver) # except OSError as e: # print("!!!!!!!! except OSError in ThrReciveSocket") # выставляем флаг того что была ошибка #continue print("Stop thrReciveSocket")
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))