class Button(): def __init__(self, hub): self.btn = Pin(BTN_GPIO, mode=Pin.IN) self.tmr = Timer(-1) def _tmr_cb(_): self._en = 1 self.btn.irq( handler=self._btn_cb, trigger=Pin.IRQ_FALLING | Pin.IRQ_RISING, ) def _sched_cb(_): self.tmr.init(period=3000, mode=Timer.ONE_SHOT, callback=_tmr_cb) hub.set(light=not (hub.light), light_cmd=True) def _btn_cb(_): self.btn.irq(trigger=0) if self._en: self._en = 0 schedule(_sched_cb, None) self._tmr_cb = _tmr_cb self._btn_cb = _btn_cb def start(self, hub): self._tmr_cb(None) def stop(self, hub): self.pin.irq(trigger=0) self.tmr.deinit()
class Deepsleep(): def __init__(self, hub): self.update_on = ['internet'] self.tmr = Timer(-1) def _set_tmr(self, hub): self.tmr.deinit() def cb(_): t = config.ALARM_SLEEP if hub.water and hub.enable else config.NORMAL_SLEEP print('deepsleep', t) try: hub.stop() except: pass sleep(5) deepsleep(t * 1000000) self.tmr.init(period=(60000 if hub.internet else 10000), mode=Timer.ONE_SHOT, callback=cb) def start(self, hub): self._set_tmr(hub) def update(self, hub, changed): self._set_tmr(hub) def stop(self, hub): self.tmr.deinit()
class DebouncedSwitch: def __init__(self, sw, cb, arg=None, delay=HALF_SECOND_DELAY, tid=4): self.sw = sw self._sw_cb = self.sw_cb self._tim_cb = self.tim_cb self._set_cb = getattr(self.sw, 'callback', None) or self.sw.irq self.delay = delay self.tim = Timer(tid) self.callback(cb, arg) def sw_cb(self, pin=None): self._set_cb(None) timer_init(self.tim, self.delay, self._tim_cb) def tim_cb(self, tim): tim.deinit() if self.sw(): micropython.schedule(self.cb, self.arg) self._set_cb(self._sw_cb if self.cb else None) def callback(self, cb, arg=None): self.tim.deinit() self.cb = cb self.arg = arg self._set_cb(self._sw_cb if cb else None)
class MinuteTimer: def __init__(self, func, mins=1): # The value passed in for period to the Timer init function. self.callback_period = 1000 self.counter_ticks = mins * 60 print('in minuteTimer. counter ticks: {}'.format(self.counter_ticks)) self.callback = func # used to call back code when timer stops. print('in minuteTimer. callback {}'.format(self.callback)) # number of times the timer has fired. self.counter_count = 0 self.timer = Timer(-1) def _timer_callback(self): self.counter_count += 1 print(self.counter_count) if self.counter_count == self.counter_ticks: self.stop_timer() def start_timer(self): self.timer.init(period=self.callback_period, mode=Timer.PERIODIC, callback=lambda t: self._timer_callback()) def stop_timer(self): # Reset the number of timer firings to 0. self.counter_count = 0 self.timer.deinit() self.callback()
class Fader(object): def __init__(self, np, NEOPIXEL_COUNT): super(Fader, self).__init__() self.step = 0 self.np = np self.NEOPIXEL_COUNT = NEOPIXEL_COUNT self.tim = Timer(-1) def start(self): self.tim.init(period=40, mode=Timer.PERIODIC, callback=self.tick) def stop(self): self.tim.deinit() def rainbow_cycle(self): for i in range(0, self.NEOPIXEL_COUNT): self.np[i] = brightness( wheel(int(i * 256 / self.NEOPIXEL_COUNT + self.step) & 255)) self.np.write() def tick(self, t): self.rainbow_cycle() self.step += 1 if self.step > 256 * 5: self.step = 0
class Counter(): def __init__(self, state): self.count = state.count = 0 self.pin = Pin(config.GPIO, mode=Pin.IN) self.led = Pin(config.LED, Pin.OUT) if config.LED else None self.timer = Timer(-1) def start(self, state): def increment(_): self.count += 1 if self.led: self.led.value(self.count % 2 == 0) self.pin.irq( trigger = Pin.IRQ_RISING if config.GPIO_VAL == 1 else Pin.IRQ_FALLING, handler = increment, ) def reset(_): c = self.count self.count = 0 state.set(count = c) def cb(_): schedule(reset, None) self.timer.init( period = config.FREQ * 1000, callback = cb, ) def stop(self, state): self.pin.irq(trigger=0) self.timer.deinit()
class DebouncedSwitchAnalog: def __init__(self, sw, threshold, cb, arg=None, delay=50, tid=4): # sw: Pin object that is switch input # cb: callback function self.sw = sw self.threshold = threshold # Create references to bound methods beforehand # http://docs.micropython.org/en/latest/pyboard/library/micropython.html#micropython.schedule self._sw_cb = self.sw_cb self._tim_cb = self.tim_cb self._set_cb = getattr(self.sw, 'callback', None) or self.sw.irq self.delay = delay self.tim = Timer(tid) self.callback(cb, arg) def sw_cb(self, pin=None): self._set_cb(None) timer_init(self.tim, self.delay, self._tim_cb) def tim_cb(self, tim): tim.deinit() if self.sw(): micropython.schedule(self.cb, self.arg) self._set_cb(self._sw_cb if self.cb else None) def callback(self, cb, arg=None): self.tim.deinit() self.cb = cb self.arg = arg self._set_cb(self._sw_cb if cb else None)
class DebouncedSwitch: def __init__(self, sw, cb, arg=None, delay=200, edge='RISING', tid=1): self.sw = sw # Create references to bound methods beforehand # http://docs.micropython.org/en/latest/pyboard/library/micropython.html#micropython.schedule self._sw_cb = self.sw_cb self._tim_cb = self.tim_cb self._set_cb = getattr(self.sw, 'callback', None) or self.sw.irq self.delay = delay # IRQ_RISING = 1 , IRQ_FALLING = 2 , IRQ_ANYEDGE = 3 if edge == 'RISING': self.edge = self.sw.IRQ_RISING elif edge == 'FALLING': self.edge = self.sw.IRQ_FALLING else: self.edge = self.sw.IRQ_ANYEDGE self.tim = Timer(tid) self.callback(cb, arg) def sw_cb(self, pin=None): self._set_cb(None) timer_init(self.tim, self.delay, self._tim_cb) def tim_cb(self, tim): tim.deinit() if self.sw(): micropython.schedule(self.cb, self.arg) self._set_cb(self._sw_cb if self.cb else None, trigger=self.edge) def callback(self, cb, arg=None): self.tim.deinit() self.cb = cb self.arg = arg self._set_cb(self._sw_cb if cb else None, trigger=self.edge)
class IR_RX(): # Result/error codes # Repeat button code REPEAT = -1 # Error codes BADSTART = -2 BADBLOCK = -3 BADREP = -4 OVERRUN = -5 BADDATA = -6 BADADDR = -7 def __init__(self, pin, nedges, tblock, callback, *args): # Optional args for callback self._pin = pin self._nedges = nedges self._tblock = tblock self.callback = callback self.args = args self._errf = lambda _: None self.verbose = False self._times = array('i', (0 for _ in range(nedges + 1))) # +1 for overrun self.tim0 = Timer(0, freq=1000000) self.tim0chan = self.tim0.channel(Timer.IC, pin=self._pin, polarity=Timer.RISING) self.tim0chan.callback(self._cb_pin) self.edge = 0 self.tim = Timer(1) # Hardware Timer 1 self.cb = self.decode # Pin interrupt. Save time of each edge for later decode. def _cb_pin(self, line): t = self.tim0chan.capture() # On overrun ignore pulses until software timer times out if self.edge <= self._nedges: # Allow 1 extra pulse to record overrun if not self.edge: # First edge received self.tim.init(freq=int(1 / self._tblock * 1000), mode=Timer.ONESHOT, callback=self.cb) self._times[self.edge] = t self.edge += 1 def do_callback(self, cmd, addr, ext, thresh=0): self.edge = 0 if cmd >= thresh: self.callback(cmd, addr, ext, *self.args) else: self._errf(cmd) def error_function(self, func): self._errf = func def close(self): self.tim0chan.callback(None) self.tim.deinit()
class IR_RX(): # Result/error codes # Repeat button code REPEAT = -1 # Error codes BADSTART = -2 BADBLOCK = -3 BADREP = -4 OVERRUN = -5 BADDATA = -6 BADADDR = -7 def __init__(self, pin, nedges, tblock, callback, *args): # Optional args for callback self._pin = pin self._nedges = nedges self._tblock = tblock self.callback = callback self.args = args self._errf = lambda _: None self.verbose = False self._times = array('i', (0 for _ in range(nedges + 1))) # +1 for overrun pin.irq(handler=self._cb_pin, trigger=(Pin.IRQ_FALLING | Pin.IRQ_RISING)) self.edge = 0 self.tim = Timer(-1) # Sofware timer self.cb = self.decode # Pin interrupt. Save time of each edge for later decode. def _cb_pin(self, line): t = ticks_us() # On overrun ignore pulses until software timer times out if self.edge <= self._nedges: # Allow 1 extra pulse to record overrun if not self.edge: # First edge received self.tim.init(period=self._tblock, mode=Timer.ONE_SHOT, callback=self.cb) self._times[self.edge] = t self.edge += 1 def do_callback(self, cmd, addr, ext, thresh=0): self.edge = 0 if cmd >= thresh: self.callback(cmd, addr, ext, *self.args) else: self._errf(cmd) def error_function(self, func): self._errf = func def close(self): self._pin.irq(handler=None) self.tim.deinit()
class LED: def __init__(self, pin): self.led = Pin(pin, Pin.OUT, value=0) self.led_timer = Timer(-1) self.blink_timer = Timer(-1) self.TIMEOUT = False self.blinking = False def blink(self, freq=1, timeout_ms=-1): Timer(-1).init( period=timeout_ms, mode=Timer.ONE_SHOT, callback=lambda t: self.blink_off(sleep=int(1000 / freq))) self.led_timer.init(period=int(1000 / freq), mode=Timer.PERIODIC, callback=lambda t: self.toggle()) def blink_multi(self, n=2, freq=1, timeout_ms=-1): t_single(timeout_ms, self.timeout) # Timer(-1).init(period = timeout_ms, mode = Timer.ONE_SHOT, callback = lambda t: self.timeout()) on_time = int(1000 / freq) blink_hz = int(freq * (n + 1)) self.TIMEOUT = False self.blinking = False self.blink_timer.init(period=on_time, mode=Timer.PERIODIC, callback=lambda t: self.toggle_blink( n=n, on_time=on_time, blink_hz=blink_hz)) def blink_off(self, sleep=0): self.led_timer.deinit() self.off() def timeout(self): self.TIMEOUT = True self.blink_off() self.blink_timer.deinit() def toggle(self): self.led.value(not self.led.value()) def toggle_blink(self, n, on_time, blink_hz): if self.blinking: self.blink_off() elif not self.TIMEOUT: self.blink(freq=blink_hz, timeout_ms=2 * n * int(on_time / (n + 1))) self.blinking = not self.blinking def on(self): self.led.on() def off(self): self.led.off()
class Target(servo.Servo): def __init__(self, pin, upTime=(3,6), downTime=(3,10)): super().__init__(pin) self.upTime = upTime self.downTime = downTime self.running = False self.rotate(0) self.state = 'down' self.tim = Timer(-1) def turn(self, t): if self.state == 'down': print('going up') self.rotate(90) time.sleep(0.15) self.state = 'up' else: print('going down') self.rotate(0) time.sleep(0.15) self.state = 'down' t.deinit() self.startTimer() def startTimer(self): if self.state == 'up': r = random.randint(self.upTime[0], self.upTime[1]) * 1000 else: r = random.randint(self.downTime[0], self.downTime[1]) * 1000 print("random time: " + str(r) + "ms") if self.tim == None: self.tim = Timer(-1) self.tim.init(period=r, mode=Timer.ONE_SHOT, callback=self.turn) def start(self): if self.running: return else: self.running = True self.startTimer() def stop(self): if not self.running: return else: self.running = False self.tim.deinit() self.tim = None self.rotate(0) self.state = 'down' print('target stopped')
def Try_Start(): try: tim = Timer(1) tim.init(period=500, mode=Timer.PERIODIC, callback=lambda t: Display_Time()) except: rtc.datetime(Get_Time()) tim.deinit() Try_Start()
def main(): tim = Timer(1) tim.init(mode=Timer.PERIODIC, period=TIME_LOOP, callback=print_callback) # tim.init(mode=Timer.ONE_SHOT, period=TIMEOUT_MS, callback=print_callback) led = Pin(2, Pin.OUT, 1) for i in range(60): now = time.time() print('{0} s : {1} - This is main loop.'.format(now - START, i)) led.value(not led.value()) time.sleep(1) tim.deinit() led.value(1)
def connect_wifi(): conn = network.WLAN(network.STA_IF) conn.active(True) conn.connect('Farinhaki', 'farinhaki2424527') t1 = Timer(-1) t1.init(period=100, mode=Timer.PERIODIC, callback=lambda t: toggle_led()) while (conn.isconnected() == False): print("Waiting connection...") utime.sleep_ms(500) t1.deinit() turnon_led() print("Connected!")
def main(): debug("starting main") controller = Controller() lambda1_signal = LambdaSignal(controller, 1, Configuration.LAMBDA1_FREQ_VALUE, Configuration.LAMBDA1_DUTY_VALUE, Configuration.LAMBDA1_PIN) adc_timer = Timer() adc_timer.init(freq=10, mode=Timer.PERIODIC, callback=controller.update) sleep(10) adc_timer.deinit()
class Clock: def __init__(self): """Set buttons callback, timer, colors and fonts.""" # rtc.set_date(2020, 3, 18, 3) # rtc.set_time(15, 36, 00) self.exit = False self.date = -1 lcd.clear() lcd.font("data/fonts/ariblk28.fon") # Time font. self.show_time_and_date() self.time = Timer(0) self.time.init(period=1000, mode=Timer.PERIODIC, callback=self.show_time_and_date) while not self.exit: if buttonA.was_pressed: # Deinit timer and exit. self.time.deinit() self.exit = True def show_time_and_date(self, t=None): """Display time, display date only when it change.""" current_time = rtc.get_time() current_date = rtc.get_date() lcd.text(lcd.CENTER, 20, "%02d:%02d:%02d" % current_time, color=lcd.WHITE) if current_date[2] != self.date: lcd.font("data/fonts/arial16.fon") lcd.textClear(lcd.CENTER, 55, "00-00-00") lcd.text( lcd.CENTER, 55, "%02d-%02d-%02d" % (current_date[2] + 1, current_date[1] + 1, current_date[0]), color=lcd.WHITE) lcd.font("data/fonts/ariblk28.fon") # Restore Time font. self.date = current_date[2]
def timers(tipe, arg): timer = Timer(-1) if tipe == 'sunrise': print('count to sunrise: ' + str(arg)) timer.init(period=arg, mode=Timer.ONE_SHOT, callback=lambda t: sunrise()) elif tipe == 'day_end': print('count to end of day is: ' + str(arg)) timer.init(period=arg + 18000000, mode=Timer.ONE_SHOT, callback=lambda t: light_mgmnt()) elif tipe == 'deinit': timer.deinit()
def start(): if not settings['device']['loop_async']: while True: loop() else: tim = Timer(-1) tim.init(period=10, mode=Timer.PERIODIC, callback=loop) #start webinterface try: webserver.run() except KeyboardInterrupt: tim.deinit() raise
class GReportPeriodically: def __init__(self, g, log, host='192.168.32.69'): self.tim = Timer(-1) self.reporter = Reporter(g, host, log) self.display = False def start(self): self.tim.init(period=2000, mode=Timer.PERIODIC, callback=self.report) def stop(self): self.tim.deinit() def report(self, t): self.reporter.send()
def connect(self): self.mqttClient.set_callback(self.sub_callback) self.mqttClient.connect() tim = Timer(-1) tim.init(period=30000, mode=Timer.PERIODIC, callback=self.ping) #Timer.PERIODIC Timer.ONE_SHOT self.mqttClient.subscribe(self.topic) # print("Connected to %s, subscribed to %s topic." % (self.server, self.topic)) try: while 1: msg = self.mqttClient.check_msg() print (msg) finally: self.mqttClient.disconnect() print('mqtt closed') tim.deinit()
def update_clock_string(args): #uuendab kella muutujat global clock_string clock = RTC().datetime() hours = str(clock[4]) minutes = str(clock[5]) # pane timer seisma, et alati muudetaks kellaaega screen_refresh = Timer(0) screen_refresh.deinit() #nulli kuvamiseks clock_string = (hours if len(hours) > 1 else '0' + hours) + (minutes if len(minutes) > 1 else '0' + minutes) # paneb uuesti timeri tööle et ekraanil numbreid näidata screen_refresh.init(period=10, mode=Timer.PERIODIC, callback=show_clock)
class timer: def __init__(self, t=500): self.tim = Timer(-1) self.t = t self.mode = self.tim.PERIODIC def timer(self, time): self.time = time self.tim.deinit() self.tim.init(period=self.t, mode=self.mode, callback=self._time_diff) def _time_diff(self, args): t = time.localtime() t = [t[3], t[4], t[5]] if t == self.time: lib.pin(12, 0)
class irqUART(): # uart: uart object # rx_pin: uart rxd pin # rx_irq: user rxd irq # frame_irq: user frame irq # CHR_TMO: rxd irq delay (ms) after rx_pin irq # FRAME_TMO: frame irq delay (ms) after last char def __init__(self, uart, rx_pin, rx_irq=None, frame_irq=None, CHR_TMO=3, FRAME_TMO=100): self._rxpin = rx_pin self._rxirq = rx_irq self._frameirq = frame_irq self._CHR_TMO = CHR_TMO self._FRAME_TMO = FRAME_TMO self._rxpin.init(Pin.IN) self._rxpin.irq(trigger=Pin.IRQ_FALLING, handler=self._RXPIN_IRQ) self._TMRX = Timer(-1) self._TMRX_sta = 0 self._mode = Timer.ONE_SHOT if sys.platform == 'pyboard' else Timer.PERIODIC self.uart = uart def _RXPIN_IRQ(self, t): if self._TMRX_sta == 0: self._TMRX_sta = 1 self._TMRX.deinit() self._TMRX.init(period=self._CHR_TMO, mode=self._mode, callback=self._TMRX_IRQ) def _TMRX_IRQ(self, t): if self._TMRX_sta != 0: if self._frameirq != None and self._FRAME_TMO > 0: self._TMRX.deinit() self._TMRX.init(period=self._FRAME_TMO, mode=Timer.ONE_SHOT, callback=self._TMRX_IRQ) if self._rxirq != None: self._rxirq(0) else: if self._frameirq != None: self._frameirq(0) self._TMRX_sta = 0
class DOUBLE_GPS(object): GGA_MESSAGE = b"$GPGGA,141623.523,2143.963,S,04111.493,W,1,12,1.0,0.0,M,0.0,M,,*65\n" RMC_MESSAGE = b"$GPRMC,141623.523,A,2143.963,S,04111.493,W,,,301019,000.0,W*7B\n" UPDATE_RATE_1S = 'PMTK220,1000' def __init__(self, TX, RX, uart): self.uart = UART(uart, baudrate=9600) self.uart.init(9600, bits=8, tx=TX, rx=RX) self.flag = False def make_data_available(self, NMEA_sentence): self.uart.write(NMEA_sentence) def received_command(self): command = self.uart.readline() if (command != None): command, received_check_sum = command.split(b'*') command = command.strip(b'$') received_check_sum = received_check_sum[0:2] generated_check_sum = self.generate_checksum(command) command = command.decode() if command == self.UPDATE_RATE_1S: self.continuous_mode() self.flag = True return command else: return None def generate_checksum(self, command): checksum = 0 for char in command: checksum ^= char return checksum def continuous_mode(self): self.my_timer = Timer(1) self.my_timer.init(period=1000, mode=self.my_timer.PERIODIC, callback=self.my_callback) def my_callback(self, timer): self.make_data_available(self.RMC_MESSAGE) def deinit(self): self.uart.deinit() if hasattr(self, 'my_timer'): self.my_timer.deinit()
class WDT: def __init__(self, _id=0, timeout=120, use_rtc_memory=True): self._timeout = timeout / 10 self._counter = 0 self._timer = Timer(_id) self._use_rtc_memory = use_rtc_memory self.init() try: with open("watchdog.txt", "r") as f: if f.read() == "True": print("Reset reason: Watchdog") except Exception as e: print(e) # file probably just does not exist try: with open("watchdog.txt", "w") as f: f.write("False") except Exception as e: print("Error saving to file: {!s}".format(e)) if use_rtc_memory and platform == "esp8266": rtc = machine.RTC() if rtc.memory() == b"WDT reset": print("Reset reason: Watchdog") rtc.memory(b"") def _wdt(self, t): self._counter += self._timeout if self._counter >= self._timeout * 10: try: with open("watchdog.txt", "w") as f: f.write("True") except Exception as e: print("Error saving to file: {!s}".format(e)) if self._use_rtc_memory and platform == "esp8266": rtc = machine.RTC() rtc.memory(b"WDT reset") machine.reset() def feed(self): self._counter = 0 def init(self, timeout=None): timeout = timeout or self._timeout self._timeout = timeout self._timer.init(period=int(self._timeout * 1000), mode=Timer.PERIODIC, callback=self._wdt) def deinit(self): # will not stop coroutine self._timer.deinit()
class Mimqtt: server = "broker.hivemq.com" # broker publico con el que podemos hacer pruebas # tiene un cliente web en http://www.hivemq.com/demos/websocket-client/ topic = b'curso_eoi' def __init__(self, registro_recibido_callback): self.registro_recibido_callback = registro_recibido_callback # El nombre con el que nos registremos en el broker tiene que ser unico # para eso podemos utilizar unique_id que nos devuelve la mac de nuestro dispositivo id_cliente = hexlify(unique_id()) self.client = MQTTClient( id_cliente, Mimqtt.server) # si no decimos nada usa el puerto por defecto 1883 self.client.set_callback( self.mqtt_callback ) # cuando entren mensajes por los topics a los que estamos suscritos, dispara el callback self.client.connect() self.client.subscribe( Mimqtt.topic) # nos suscribimos a los topics que nos interese # programamos un timer para que compruebe mensajes periodicamente, y cuando lleguen salte mqtt_callback self.timer = Timer(-1) self.timer.init(period=50, mode=Timer.PERIODIC, callback=lambda x: self.client.check_msg()) def enviar(self, nombre, tiempo): datos = {"nombre": nombre, "tiempo": tiempo} datos_serializados = json.dumps(datos) self.client.publish(Mimqtt.topic, datos_serializados) def mqtt_callback(self, topic, msg): #print("me llego por '{}' esto: {}".format(topic, msg)) try: datos = json.loads(msg.decode()) nombre = datos['nombre'] tiempo = int(datos['tiempo']) # nos aseguramos que sea un entero except: # si algo de lo anterior falta o falla, salta esta excepcion print("MQTT mensaje invalido") print(msg) return # una vez comprobado que este bien, el resto lo hacemos en la clase Juego self.registro_recibido_callback(nombre, tiempo) def disconnect(self): self.timer.deinit() self.client.disconnect()
def connect(self): self.mqttClient.set_callback(self.sub_callback) self.mqttClient.connect() tim = Timer(1) tim.init(period=3000, mode=Timer.PERIODIC, callback=self.putt) self.mqttClient.subscribe(self.topic) print("连接到 %s, 订阅 %s 主题." % (self.server, self.topic)) try: while 1: # self.mqttClient.wait_msg() self.mqttClient.check_msg() finally: # self.mqttClient.unsubscribe(self.topic) self.mqttClient.disconnect() print('mqtt closed') tim.deinit()
class DataLogger: def __init__(self, device_id, loc, tx, interval: int, topic: str, sensor: Sensor): self.timer = None self.topic = topic self.interval = 1 # defualt interval is 1000ms if interval.rstrip().endswith("m"): self.interval = int(interval[:-1]) * 60 elif interval.rstrip().endswith("h"): self.interval = int(interval[:-1]) * 3600 elif interval.rstrip().endswith("s"): self.interval = int(interval[:-1]) self.interval *= 1000 self.is_running = False self.sender = tx self.sensor = sensor self.device_id = device_id self.loc = loc def run(self): self.sender(self.topic, self.sensor._create_payload(self.device_id, self.loc)) log.info("Transmitting data...") def start(self): if not self.is_running: self.timer = Timer(-1) cb = lambda _: self.run() self.timer.init(period=self.interval, mode=Timer.PERIODIC, callback=cb) self.is_running = True log.info( "Started Data Logger for {} at an interval of {} ms, sending data to {}" .format(self.sensor.id, self.interval, self.topic)) def stop(self): self.timer.deinit() self.is_running = False @staticmethod def validate_topic(_type): if _type == "cmnd": # p = re.compile("(?=[^/].*)(\\S*)") return True if (p.match(topic) != None) else False
class Clock: def __init__(self): """Set buttons callback, timer, colors and fonts.""" # rtc.setDate(2019, 9, 28, 6) # rtc.setTime(15, 37, 00) self.date = -1 lcd.clear(0xFF8000) lcd.font("Libraries/Fonts/ariblk28.fon", transparent=False) # Time font. lcd.setTextColor(color=lcd.WHITE, bcolor=0xFF8000) buttonA.wasPressed(callback=self.exit) buttonB.wasPressed(callback=lambda: None) self.show_time_and_date() self.time = Timer(0) self.time.init(period=1000, mode=Timer.PERIODIC, callback=self.show_time_and_date) def show_time_and_date(self, t=None): """Display time, display date only when it change.""" current_time = rtc.getTime() lcd.print("%02d:%02d:%02d" % current_time, lcd.CENTER, 20) current_date = rtc.getDate() if current_date[2] != self.date: lcd.font("Libraries/Fonts/arial16.fon") lcd.print("%02d-%02d-%02d" % (current_date[2], current_date[1], current_date[0]), lcd.CENTER, 55) lcd.font("Libraries/Fonts/ariblk28.fon") # Restore Time font. self.date = current_date[2] def exit(self): """De-init timer and exit.""" self.time.deinit() # Return to menu return Data.Menu.Menu()
class Fader(object): def __init__(self, np, NEOPIXEL_COUNT): super(Fader, self).__init__() self.step = 0 self.np = np self.NEOPIXEL_COUNT = NEOPIXEL_COUNT self.tim = Timer(-1) def start(self): self.tim.init(period=40, mode=Timer.PERIODIC, callback=self.tick) def stop(self): self.tim.deinit() def rainbow_cycle(self): for i in range(0, self.NEOPIXEL_COUNT): self.np[i] = brightness(wheel(int(i * 256 / self.NEOPIXEL_COUNT + self.step) & 255)) self.np.write() def tick(self, t): self.rainbow_cycle() self.step += 1 if self.step > 256 * 5: self.step = 0
if not wlan.isconnected(): print('Attempting to connect to WiFi', end=' ') nets = wlan.scan() for net in nets: if net.ssid == 'Robotmad': KEY = 'mou3se43' break elif net.ssid == 'CoderDojo': KEY = 'coderdojo' break if KEY != '': print(net.ssid, end=" ") wlan.connect(net.ssid, auth=(net.sec, KEY), timeout=10000) if wlan.isconnected(): print('Connected') tim_a.freq(10) wlan.irq(trigger=WLAN.ANY_EVENT, wake=machine.SLEEP) else : wlan.init(WLAN.AP, ssid='wipy-wlan', auth=(WLAN.WPA2, 'www.wipy.io'), channel=5, antenna=WLAN.INT_ANT) print('Failed - setting up as AP wipy-wlan') tim.deinit() # Cancel timer that was flashing the LED led_out(True) # True = LED Off #print(wlan.ifconfig()) print('Done.') #machine.sleep()
tim = Timer(4) #1-14 exist; 3 is for internal use; avoid 5+6 (used for servo control or ADC/DAC) tim.init(mode=Timer.PERIODIC) #configure a timer 'channel' tim_a = tim.channel( tim.A, freq=5) #less than 5per sec did not work #add something useful to the running channel tim_a.irq(handler=blink) #blinks strangely rapidly #disable the timer 'channel' tim_a = None #still blinking #tim.deinit() #stopped, terminal froze. tim.channel( tim.A, freq=5) #stopped blinking #reinitialize, for a slower blink tim.deinit() #tim.init(mode=Timer.PERIODIC, width=32)#terminal froze. tim = Timer(4,mode=Timer.PERIODIC, width=32) tim_ab = tim.channel( Timer.A | Timer.B, freq=4) #does not work tim_ab.irq(handler=blink) #does not start blinking seconds = 2 * 1000 * 1000 tim_ab = tim.channel( Timer.A | Timer.B, period=seconds) tim_ab.irq(handler=blink) #does not start blinking tim.deinit() tim = Timer(1, mode=Timer.PERIODIC, width=32) tim_ab = tim.channel( Timer.A | Timer.B, period=seconds) #works! perhaps issue is with Timer 4? tim_ab.irq(handler=blink) seconds = 13 * 1000 * 1000