def run_deepsleep(self): if not self.run(): # RTC wasn't set, try to sleep forever self.rtc.alarm(time=2000000000) # Set the wakeup (why do it earlier?) rtc_i = self.rtc.irq(trigger=RTC.ALARM0, wake=DEEPSLEEP) self.log("Going to sleep, waking in %dms" % self.rtc.alarm_left()) # Close files on the SD card if self.sd: self.logfile.close() self.logfile = None unmount('/sd') self.sd.deinit() # Turn the screen off self.epd.disable() if not self.wifi_pin(): # Basically turn off deepsleep() else: self.log("DEBUG MODE: Staying awake") pass
def main(): btn = machine.Pin(5, machine.Pin.IN, machine.Pin.PULL_UP) led = machine.Pin(2, machine.Pin.OUT) #D4 if btn.value(): led.value(1) sta_if = network.WLAN(network.STA_IF) if not sta_if.isconnected(): sta_if.active(True) sta_if.connect('ESL_Lab1', 'wifi@esl') while not sta_if.isconnected(): pass led.value(0) dhtValue = dht.DHT22(machine.Pin(4)) dhtValue.measure() led.value(1) c = MQTTClient(CLIENT_ID, SERVER) c.connect() DHTbuff = "%.2f,%.2f" % (dhtValue.humidity(), dhtValue.temperature()) c.publish(TOPIC, DHTbuff) led.value(0) time.sleep(3) # print ("Data temp : "+str(dhtValue.temperature())+" humidity : "+str(dhtValue.humidity())) rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) rtc.alarm(rtc.ALARM0, 2000) machine.deepsleep()
def deep_sleep(msecs) : # configure RTC.ALARM0 to be able to wake the device rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # set RTC.ALARM0 to fire after X milliseconds (waking the device) rtc.alarm(rtc.ALARM0, msecs) # put the device to sleep machine.deepsleep()
def sleep(duration=0, status=False): # Not working for Disobey 2020 as the pins are not in the RTC domain machine.RTC().wake_on_ext0(pin=machine.Pin(25), level=0) #machine.RTC().wake_on_ext1([machine.Pin(5, machine.Pin.IN, machine.Pin.PULL_UP)], 0) #--- if (duration >= 86400000): #One day duration = 0 if status: if duration < 1: term.header(True, "Sleeping until touch button is pressed!") else: term.header(True, "Sleeping for " + str(duration) + "ms...") time.sleep(0.05) machine.deepsleep(duration)
def run(self): helper = TinyIPFIX_Helper_Functions() template_rec_set = self.create_template_record_set() template_i = self.variable_dict["template_i"] data_i = self.variable_dict["data_i"] set_list = self.variable_dict["data_records_set_list"] self.data_records_set_list = [] for s in set_list: self.data_records_set_list.append(bytes(s, 'utf-8')) # to correct timing (actually data and template are sent less ofthen than sleep time): # -> t = time.time() # -> elapsed = time.time() - t # alternative method would be to calculate sleeptime every time instead of using gcd while True: if template_i == 0: template_i = self.template_measure_interval template_to_send = self.create_template_message( template_rec_set) self.send(template_to_send) print('sent template message: {}\n'.format(template_to_send)) if data_i == 0: data_i = self.data_measure_interval data_bytes = self.create_data_records_set( ).data_records_set_to_byte() self.data_records_set_list.append(data_bytes) print('created data record: {}\n'.format(data_bytes)) if len(self.data_records_set_list ) >= self.data_sets_per_message: data_message_bytes = helper.aggregate_bytes( 0, 0, self.receive_sequence_number(0), *self.data_records_set_list) self.send(data_message_bytes) print('sent data message: {}\n'.format(data_message_bytes)) self.data_records_set_list = [] sleep_time = min(data_i, template_i) template_i -= sleep_time data_i -= sleep_time self.variable_dict["template_i"] = template_i self.variable_dict["data_i"] = data_i self.variable_dict[ "data_records_set_list"] = self.data_records_set_list self.variable_dict["sequence_number"] = self.sequence_number f = open("variables.json", "w") f.write(ujson.dumps(self.variable_dict)) f.close() print(self.sequence_number) machine.deepsleep(sleep_time * 1000)
def enter_deep_sleep(secs): # For some weird reason, my Wemos D1 does not wake up from deepsleep """ Ensure that pin RST & D0 are connected! """ # configure RTC.ALARM0 to be able to wake the device rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # set RTC.ALARM0 to fire after Xseconds, waking the device sleep_timeout = secs * 1000 rtc.alarm(rtc.ALARM0, sleep_timeout) print("Sleep for %d sec" % sleep_timeout) # put the device to sleep machine.deepsleep()
def sleep(duration=0, status=False): if not device.configureWakeupSource(): print("No wakeup source available, rebooting...") reboot() return if (duration >= 86400000): #One day duration = 0 if status: if duration < 1: term.header(True, "Sleeping until a touch button is pressed!") else: term.header(True, "Sleeping for " + str(duration) + "ms...") device.prepareForSleep() machine.deepsleep(duration)
def sleep(duration=0, status=False): import time, os, badge #machine.RTC().wake_on_ext0(pin = machine.Pin(34), level = 0) # MPR121 interrupt #machine.RTC().wake_on_ext1([machine.Pin(5, machine.Pin.IN, machine.Pin.PULL_UP)], 0) if (duration >= 86400000): #One day duration = 0 if status: import term if duration < 1: term.header(True, "Sleeping until a touch button is pressed!") else: term.header(True, "Sleeping for "+str(duration)+"ms...") time.sleep(0.05) machine.deepsleep(duration)
def run(): global tstump (t, h, p, v, vs, msg) = measure() vbat = v if FAKE_SLEEP: print("No watchdog") else: wdt = machine.WDT(timeout=int(DEEP_SLEEP + DEEP_SLEEP / 2) * 1000) while True: tstump = '%s-%.2d-%.2d %.2d:%.2d:%.2d' % time.localtime()[0:6] if POSITIONING != 'NO': position() (t, h, p, v, vs, msg) = measure() print("TZ: %s LONGITUDE: %s" % (cfg['tz'], cfg['longitude'])) dat = update_data([ t, h, p, v, vs, paz.duty(), palt.duty(), machine.wake_reason(), msg ]) try: config = { "sleep": DEEP_SLEEP, "fake_sleep": FAKE_SLEEP, "ts_cfg": tstump, "Vsun": LVL_SUNPIN } print("Publish config: %s %s" % (MY_ID, config)) me.send_publish('weather/%s/config' % MY_ID, json.dumps(config)) dat.reverse() print("Publish id: %s Length:%s" % (MY_ID, len(dat))) for line in dat: me.send_publish('weather/' + MY_ID, json.dumps(to_dict(line))) except Exception as e: print("Publish exception: %s" % e) stime = DEEP_SLEEP - (time.time() - lib.boot_time) if stime < 0: stime = 1 elif stime > DEEP_SLEEP: stime = DEEP_SLEEP if FAKE_SLEEP: stime = stime / 20 print("Fake sleep for %s sec" % stime) time.sleep(stime) lib.boot_time = time.time() else: print('Deepsleep for %s sec.' % stime) wdt.feed() machine.deepsleep(stime * 1000) print()
def hibernate(self, interval, lightsleep=False, deepsleep=False): """ :param interval: :param lightsleep: (Default value = False) :param deepsleep: (Default value = False) """ #logging.enable_logging() if deepsleep: # Prepare and invoke deep sleep. # https://docs.micropython.org/en/latest/library/machine.html#machine.deepsleep log.info('Preparing deep sleep') # Set wake up mode. self.set_wakeup_mode() # Invoke deep sleep. log.info('Entering deep sleep for {} seconds'.format(interval)) #self.terminal.stop() machine.deepsleep(int(interval * 1000)) else: # Adjust watchdog for interval. self.watchdog.adjust_for_interval(interval) # Invoke light sleep. # https://docs.micropython.org/en/latest/library/machine.html#machine.sleep # https://docs.micropython.org/en/latest/library/machine.html#machine.lightsleep # # As "machine.sleep" seems to be a noop on Pycom MicroPython, # we will just use the regular "time.sleep" here. # machine.sleep(int(interval * 1000)) machine.idle() if lightsleep: log.info( 'Entering light sleep for {} seconds'.format(interval)) machine.sleep(int(interval * 1000)) else: # Normal wait. log.info('Waiting for {} seconds'.format(interval)) time.sleep(interval)
def main(): global wl_net # Initialize wireless network if not wl_net: wl_net = init_wifi() # Initialize DHT sensor = dht.DHT22(machine.Pin(4)) # Main loop to read temp and send it # Read the temperature sensor.measure() temp = sensor.temperature() * 9.0 / 5.0 + 32.0 humid = sensor.humidity() print('v1.2: Temp / Humid = {:2} / {:2}'.format(temp, humid)) # Send it through MQTT mqtt_c = MQTTClient(MQ_CLIENT, MQ_BROKER_IP, user=MQ_USER, password=MQ_PASSWORD) mqtt_c.connect() json_array = { "temp": "{}".format(temp), "hum": "{}".format(humid), } import ujson # {"source":"TV (0)","pvr_status":"NONE","powerstate":"Normal","tv_mode":"Cable (1)","volume":"7","channel_number":"45","channel_name":"Nat Geo HD","program_name":"Personaje ale nazismului","resolution":"1920x1080","error":false} mqtt_c.publish(MQ_TOPIC.encode('utf-8'), ujson.dumps(json_array), retain=True) mqtt_c.disconnect() # configure RTC.ALARM0 to be able to wake the device rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # set RTC.ALARM0 to fire after 10 seconds (waking the device) rtc.alarm(rtc.ALARM0, 10000) # For debugging, 10 seconds # rtc.alarm(rtc.ALARM0, 1000 * DELAY_MLOOP) # Default: 60 seconds # Make sure that the Node MCU has pin D0 (L15) wired to RST (R3) # put the device to sleep machine.deepsleep()
def subscription_callback(self, topic, message): if (type(topic) is bytes): topic = topic.decode("utf-8") self.paused = False self.last_update = ticks_ms() s = topic.split("/") if "color" in topic: logger.log("Color update") data = json.loads(message) self.renderer.update_animation(data) self.ping() elif "sync" in topic: logger.log("sync request") pass elif "poke" in topic: logger.log("Poke request") self.connect() elif "update" in topic: if len(s) == 1 or (len(s) > 1 and s[1] == self.id): logger.log("Firmware Update") self.view.off() self.broker.disconnect() self.updater.check_for_update_to_install_during_next_reboot() logger.log("checked") reset() elif "config" in topic: if len(s) == 1 or (len(s) > 1 and s[1] == self.id): logger.log("config update") provider.update_config(message) elif "sleep" in topic: if len(s) == 1 or (len(s) > 1 and s[1] == self.id): logger.log("sleeping") self.view.off() data = json.loads(message) deepsleep(data["seconds"] * 1000) elif "restart" in topic: if len(s) == 1 or (len(s) > 1 and s[1] == self.id): self.view.off() logger.log("restarting") reset() else: logger.log("unknown command")
def start_sleeping(sleepTime=0): term.header(True, "Going to sleep...") rgb.clear() rgb.scrolltext('ZzZz') time.sleep(3) if (sleepTime >= 86400000): # One day sleepTime = 0 if (sleepTime < 1): print("Sleeping until A-button is pressed...") else: print("Sleeping for " + str(sleepTime) + "ms...") time.sleep(0.1) machine.deepsleep(sleepTime)
def go_to_sleep(event: MainControllerEvent) -> None: """ Go to deep sleep. """ # Resets flag before sleep config.cfg.printed_time = False config.cfg.got_sensor_data = False config.cfg.published_to_cloud = False config.cfg.save() logging.debug("sleep({})".format(event.data)) ms = int(event.data['ms']) if ms <= 0: ms = 10 machine.deepsleep(ms)
def init(milliseconds): import machine """ # If this is deployed on ESP8266, uncomment this block # to enable real time clock & interrupts for the ESP8266 # configure RTC.ALARM0 to be able to wake the device rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # set RTC.ALARM0 to fire after X seconds (waking the device) rtc.alarm(rtc.ALARM0, milliseconds) """ # put the device to sleep # we'll also need to power off the sensors at some point too. machine.deepsleep(milliseconds)
def finito(): print("Exiting...") # configure RTC.ALARM0 to be able to wake the device rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # check if the device woke from a deep sleep if machine.reset_cause() == machine.DEEPSLEEP_RESET: print('Woke from a deep sleep') # set RTC.ALARM0 to fire after some milliseconds (waking the device) rtc.alarm(rtc.ALARM0, 140000) #148000 (4min 48 sek: 297000 time.sleep(2) # put the device to sleep machine.deepsleep()
def deepsleep(): """Go into deep sleep mode. GPIO16 (D0) must be connected to RST (RST).""" # wait some time before going into deesleep mode - otherwise no # intervention possible when problems occur. time.sleep(5) rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # set alarm time (in ms) print("setting alarm for RTC", config.DEEPSLEEP_TIME) rtc.alarm(rtc.ALARM0, config.DEEPSLEEP_TIME) # sleep print("starting deep sleep...") machine.deepsleep()
def deep_sleep_esp(msecs): try: # configure RTC.ALARM0 to be able to wake the device timer = machine.Timer(-1) timer.init(period=15000, mode=machine.Timer.ONE_SHOT, callback=lambda t: esp.deepsleep(10000000)) # set RTC.ALARM0 to fire after X milliseconds (waking the device) rtc = machine.RTC() rtc.alarm(rtc.ALARM0, msecs) # put the device to sleep machine.deepsleep() except Exception as e: print(e)
def PowerFailCb(logger): power_fail = Pin(POWER_FAIL_PIN) if debouncedPFSignal(power_fail) == 1: #stopTasksButLora() # save power by leaving all non essential tasks ASAP pycom.nvs_set(POWER_FAIL_STATE, MODE_POWER_FAIL) unixLocalTime= time.time() + time.timezone() pycom.nvs_set(POWER_FAIL_TS, unixLocalTime) currentAlarmLoraMessageToSend = buildPFAlarmMessage(unixLocalTime) lora_queue_immediate_semaphore.acquire(0) rand=int(getRandom() * 2000) # 0-2000 value time.sleep_ms(rand) # just randow m wait of 3s LoraQueueImmediate.put(currentAlarmLoraMessageToSend) lora_queue_immediate_semaphore.acquire(1,2) # wait 2s max for msg to be sent by the Lora task time.sleep_ms(WAIT_TIME_BEFORE_SLEEP) # time for the LoRA MAC layer to send that message rand=int(getRandom() * 20) # 0-20 value machine.deepsleep((WAKEUP_DELAY+rand)*1000) # GO TO SLEEP NOW AND PRESERVE POWER
def seconds_handler(alarm): global connection_time global timeFlag file = open('/flash/sleepTimes.json', 'r') parsedx = ujson.load(file) file.close() timeFlag = parsedx['timers']['timeFlag'] connection_time = parsedx['timers']['connection_time'] sleep_time = parsedx['timers']['sleep_time'] if timeFlag == False: print("Alarma desactivada") alarm.cancel() elif timeFlag == True: print("Pasaron: " +str(connection_time)+" segundos") machine.deepsleep(sleep_time*1000)
def main(): do_connect_mqtt(server, client_id) # do_publish(topic2, msg) flags_modem_isOn = True global start while True: b.tick() if b.isPress(): start = time.ticks_ms() elif flags_modem_isOn and time.ticks_diff(time.ticks_ms(), start) > timeout: flags_modem_isOn = machine.deepsleep() if b.isDouble(): print("Button pressed double ") if not flags_modem_isOn: do_connect() do_connect_mqtt(server, client_id) flags_modem_isOn = True do_publish(topic2, msg) if b.isSingle(): print("Button pressed Single ") if not flags_modem_isOn: do_connect() do_connect_mqtt(server, client_id) flags_modem_isOn = True do_publish(topic1, msg) c.disconnect()
def main(): mode_sw = Pin(MODE_SW_PIN, Pin.IN) service_mode = mode_sw.value() == 0 if service_mode: return station = init_wlan_station() open_networks = find_open_networks(station) station.active(False) if open_networks: print("Open wifi networks:") for network in open_networks: print(network) blink_user_led(1, len(open_networks)) else: print("No open wifi networks found.") deepsleep()
def deepsleep(): print('Going into deepsleep for {seconds} seconds...'.format( seconds=config.LOG_INTERVAL)) # RTC = Real Time Clock rtc = machine.RTC() # Setup the machine to wake up from a deep sleep mode when the alarm goes off rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # Set the alarm to go off within the setup interval rtc.alarm(rtc.ALARM0, config.LOG_INTERVAL * 1000) # Enters deep sleep mode machine.deepsleep()
async def sleep(): """ pushes the device into a deep sleep mode """ from machine import RTC, DEEPSLEEP, deepsleep await asyncio.sleep(3) print('.... in deep sleep zzZz') # configure RTC.ALARM0 to be able to wake the device rtc = RTC() rtc.irq(trigger=rtc.ALARM0, wake=DEEPSLEEP) # set RTC.ALARM0 to fire after 10 seconds (waking the device) rtc.alarm(rtc.ALARM0, 10000) # put the device to sleep deepsleep()
def initialize(self, notify=True): ''' Initialize App. ''' self.connect_to_network(notify=notify) if not self.connected: return self.device_auth = DeviceAuth.from_file(SAVED_LOCATION) if not self.device_auth or self.device_auth.authorized == False: # Initialize auth self.device_auth = DeviceAuth( client_id=CLIENT_ID, client_secret=CLIENT_SECRET, discovery_endpoint=DISCOVERY_ENDPOINT, scopes=SCOPES, saved_location=SAVED_LOCATION) self.device_auth.discover() self.authorizing = True self.device_auth.authorize() user_code = self.device_auth.user_code verification_url = self.device_auth.verification_url current_attempt = 0 max_attempts = 20 while not self.device_auth.authorized and current_attempt < max_attempts: messages = [ '%s to continue' % (verification_url), 'Attempt %s of %s' % (current_attempt + 1, max_attempts) ] self._notify(user_code, messages=messages) self.device_auth.check_authorization_complete(max_attempts=1) time.sleep(5) # Sleep duration in seconds. current_attempt += 1 if not self.device_auth.authorized: message = 'Unable to authorize the application.' self._error(message=message) return if notify: self._notify('Syncing', messages=['Updating calendar events']) self.build_calendar_ui() print('Entering deep sleep.') machine.deepsleep(REFRESH_INTERVAL * 60 * 1000)
def process(line): try: words = line.split() command = words[0][0] if command == "s": set_speed(int(words[1])) elif command == "r": reverse() elif command == "c": set_color(bytes(map(int, words[1:4]))) elif command == "p": machine.deepsleep() else: # `repr` converts non-printing characters to hex escapes or '\n' etc. print("Ignoring: {}".format(repr(line))) except Exception as e: sys.print_exception(e)
def sleep(sleep_type, sleep_time=60000): if sleep_type == "deepsleep": print("Putting device into {0} for {1} seconds".format( sleep_type, sleep_time / 1000)) if sleep_time: rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=getattr(machine, sleep_type.upper())) rtc.alarm(rtc.ALARM0, sleep_time) machine.deepsleep() if sleep_type == "idle": machine.idle() if sleep_type == "sleep": machine.sleep() if sleep_type == "wait": time.sleep(sleep_time / 1000)
def run(self, no_except=True): """Run the system manager synchronously. This allows all watch management activities to handle in the normal execution context meaning any exceptions and other problems can be observed interactively via the console. """ global free if self._scheduling: print('Watch already running in the background') return if not self.app: self.switch(self.quick_ring[0]) if watch.free: gc.collect() free = gc.mem_free() # Reminder: wasptool uses this string to confirm the device has # been set running again. print('Watch is running, use Ctrl-C to stop') if not no_except: # This is a simplified (uncommented) version of the loop # below while True: self._tick() machine.deepsleep() while True: try: self._tick() except KeyboardInterrupt: raise except Exception as e: # Only print the exception if the watch provides a way to do so! if 'print_exception' in dir(watch): watch.print_exception(e) self.switch(CrashApp(e)) # Currently there is no code to control how fast the system # ticks. In other words this code will break if we improve the # power management... we are currently relying on not being able # to stay in the low-power state for very long. machine.deepsleep()
def now(self): """Rotina a ser chamada no boot.py. 0 - coleta temperatura e publica 1 - fica em loop ate que seja publicado que pode dormir 2 - faz a rotina de dormir. Dorme no intervalo definido em self.SLEEP_TIME 3 - quando der o timeout, acorda, coleta, envia e repete. """ size = 0 print("Estabelecendo conexao de rede...") while size < 11: try: size = len(self.sta_if.ifconfig()[0]) time.sleep_ms(80) except: size = 0 print("setting callback...") self.myMQTT.set_callback(self.sub_cb) print("connecting for...") self.myMQTT.connect() print("Subscribe for sleep...") self.myMQTT.subscribe(b'freezer/sleep') print("Publishing termometer status") self.myMQTT.publish(b'freezer/termometro', b'ON') # coleta e publica temperatura... print("Coletando temperatura e publicando...") t = self.tasks() # ...aguarda por ordem de dormir... print("Aguardando ordem para dormir...") self.waiting() if self.DO_SLEEP: self.myMQTT.publish("freezer/termometro", "OFF") print("Dormindo. Ate logo.") # ...inicia processo de deepsleep. self.DO_SLEEP = False rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # wake up after... rtc.alarm(rtc.ALARM0, self.SLEEP_TIME) # sleep machine.deepsleep()
def timer_and_scale(write_to_google_sheet=0, sleep=0): oled_i2c = init_spi_oled() hx711 = init_weight() sheet = initialize_google_sheets() ntptime.settime() polling_interval = 0.1 # how often to check if magnet is on sleep_after_seconds = 600 # time after which esp32 goes to sleep if not used idle_time = 0 write_to_oled_with_font(oled_i2c, 'Espresso32', freesans20) while 1: time.sleep(polling_interval) idle_time += polling_interval # hx711.tare() if (idle_time > sleep_after_seconds) and (sleep): write_to_oled_with_font(oled_i2c, 'Going to sleep...', freesans20) time.sleep(5) t = init_sleep() # machine.lightsleep() machine.deepsleep() if start_timer_external_hall(): print("Starting timer") start_time = get_localtime_as_string() num_seconds = 0 start_weight_reading = round(get_weight(hx711), 2) time_weight_pairs = [] time_weight_pairs.append([start_time, 0, 0]) while not stop_timer_external_hall(): time.sleep(1) num_seconds += 1 weight = round(get_weight(hx711) - start_weight_reading, 2) time_weight_pairs.append([start_time, num_seconds, weight]) print(num_seconds) print(weight) # write_to_oled(oled_i2c, str(num_seconds)+ 'sec') write_to_oled_with_font( oled_i2c, str(num_seconds) + 'sec\n' + str(weight) + 'g', arial28) print("timer stopped") if write_to_google_sheet and (num_seconds > 5): sheet.append_values(time_weight_pairs) idle_time = 0
async def watcher(self): while True: now = time.ticks_ms() diff = time.ticks_diff(now, self.last_activity_ms) #print("Diff {}".format(time.ticks_diff(self.last_activity_ms, now))) if self.keypad_service.command and diff > env.CANCEL_COMMAND_SEC * 1000: self.keypad_service.clear_command() if diff > env.DEEP_SLEEP_SEC * 1000: print("Preparing deep sleep...") self.keypad_service.prepare_deep_sleep() self.led_service.prepare_deep_sleep() machine.Pin(env.PIN_NO_BEEP, machine.Pin.IN, machine.Pin.PULL_DOWN) await logger.adebug("Entering deep sleep...") print("Entering deep sleep...") machine.deepsleep() await asyncio.sleep(1) print("Tick " + str(diff / 1000))
def __exit__(self, exc_type, exc_val, exc_tb): if exc_type == KeyboardInterrupt: _logger.info( "KeyboardInterrupt detected. Extending WDT (%d ms) and exiting to REPL.", REPL_WDT_MS) global wdt wdt.init(REPL_WDT_MS) sys.exit() return False if exc_val: _logger.exc(exc_val, "Uncaught exception at MainWrapper top level") _logger.warning( "MainWrapper last resort. Don't know what else to do. Going to sleep for a while (%d ms).", LAST_RESORT_DEEPSLEEP_MS) machine.deepsleep(LAST_RESORT_DEEPSLEEP_MS) return False
def _update(self, state_machine): try: if state_machine.lastError: log.error("Last error: {}".format(state_machine.lastError)) # try to send the error message event = ({ 'properties.variables.lastError': { 'value': state_machine.lastError if state_machine.lastError is not None else "unknown", 'sentAt': formated_time()} }) state_machine.system.send_emergency_event(event) state_machine.system.sim.deinit() state_machine.system.lte.deinit(detach=True, reset=True) finally: time.sleep(3) machine.deepsleep(1) # this will wakeup with reset in the main again
def main(server=SERVER): #c = MQTTClient(CLIENT_ID, server) # Subscribed messages will be delivered to this callback c.set_callback(sub_cb) #c.connect() mqttconnect() c.subscribe(TOPIC) print("Connected to {}, subscribed to {} topic".format(server, TOPIC)) try: while 1: #micropython.mem_info() c.check_msg() sleep(5) if state == 1: print('going to deepsleep') deepsleep(10000) finally: c.disconnect()
def set_deepSleep(millisec): rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) rtc.alarm(rtc.ALARM0, millisec) machine.deepsleep()
def lo_power(): from machine import Pin, deepsleep for pin in dir(Pin.board): p = Pin(pin) p.init(Pin.IN, pull=Pin.PULL_DOWN, alt=-1) deepsleep()
# configure it as uplink only s.setsockopt(socket.SOL_SIGFOX, socket.SO_RX, False) pycom.heartbeat(False) ow = OneWire(Pin('G17')) temp = DS18X20(ow) temp.start_convertion() time.sleep(1) result = temp.read_temp_async() wlan = WLAN(mode=WLAN.STA) nets = wlan.scan() nets = sorted(nets, key=lambda x:x.rssi, reverse=True) wifi = [] print(str(result)) pycom.rgbled(0x003300) s.send(str(result)) pycom.rgbled(0x000000) if len(nets) >= 2: wifi = nets[0].bssid + nets[1].bssid print(wifi) pycom.rgbled(0x003300) s.send(wifi.decode()) pycom.rgbled(0x000000) machine.deepsleep(60*1000*10)
def sleep(seconds): rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) rtc.alarm(rtc.ALARM0, seconds * 1000) machine.deepsleep()
import machine, micropython # configure RTC.ALARM0 to be able to wake the device micropython.alloc_emergency_exception_buf(100) rtc = machine.RTC() rtc.irq(trigger=rtc.ALARM0, wake=machine.DEEPSLEEP) # check if the device woke from a deep sleep if machine.reset_cause() == machine.DEEPSLEEP_RESET: print('woke from a deep sleep') # set RTC.ALARM0 to fire after 10 seconds (waking the device) rtc.alarm(rtc.ALARM0, 5000) # put the device to sleep machine.deepsleep()