def start_webrepl(self, force=False): if self.wlan.isconnected(): if force or self.webrepl_cfg['enable']: # noinspection PyUnresolvedReferences esp.sleep_type(esp.SLEEP_NONE) import webrepl # noinspection PyUnresolvedReferences webrepl.start(password=self.webrepl_cfg['password'])
def __init__(self, config): super().__init__(config) self._isconnected = False # Current connection state keepalive = 1000 * self._keepalive # ms self._ping_interval = keepalive // 4 if keepalive else 20000 p_i = config['ping_interval'] * 1000 # Can specify shorter e.g. for subscribe-only if p_i and p_i < self._ping_interval: self._ping_interval = p_i self._in_connect = False self._has_connected = False # Define 'Clean Session' value to use. import esp esp.sleep_type(0) # Improve connection integrity at cost of power consumption.
async def main(): global mqtt_client # Wi-Fi connection try: await uasyncio.wait_for(wifi_connect(WIFI_AP_SSID, WIFI_AP_PSW), 20) esp.sleep_type(2) except uasyncio.TimeoutError: print("wifi connected timeout!") # MQTT connection try: await uasyncio.wait_for(mqtt_connect(), 20) except uasyncio.TimeoutError: print("mqtt connected timeout!") await uasyncio.gather(light_loop())
def runtime_setup(self): self.ensure_adc_mode() self.lowpower_phase = machine.reset_cause() in ( machine.DEEPSLEEP_RESET, 2) print('Reset cause', machine.reset_cause()) print('Booted in {} phase'.format( 'lowpower' if self.lowpower_phase else 'normal')) if not self.lowpower_phase: self.get_requests() self.load_config() self.load_state(restore=True) esp.sleep_type(esp.SLEEP_LIGHT) network.WLAN(network.AP_IF).active(False) # Disable AP self.setup()
async def Connect(self, aESSID: str, aPassw: str, aAddr: tuple = None): Log.Print(1, 'i', 'Connect() %s, %s, %s' % (aESSID, aPassw, aAddr)) # Improve connection integrity at cost of power consumption if (platform == 'esp8266'): from esp import sleep_type sleep_type(0) R = WLAN(STA_IF) R.active(False) await sleep(1) R.active(True) if (aAddr): R.ifconfig(aAddr) R.connect(aESSID, aPassw) await self._WaitForReady(R.isconnected) Log.Print(1, 'i', 'Net', R.ifconfig()) return R
def __init__(self, client_id=None, server=None, port=0, user='', password='', keepalive=60, ping_interval=0, ssl=False, ssl_params={}, response_time=10, clean_init=True, clean=True, max_repubs=4, will=None, subs_cb=lambda *_: None, wifi_coro=None, connect_coro=None, ssid=None, wifi_pw=None): client_id = client_id or hexlify(unique_id()) wifi_coro = wifi_coro or eliza connect_coro = connect_coro or eliza super().__init__(client_id, server, port, user, password, keepalive, ping_interval, ssl, ssl_params, response_time, clean_init, clean, max_repubs, will, subs_cb, wifi_coro, connect_coro, ssid, wifi_pw) self._isconnected = False # Current connection state keepalive = 1000 * self._keepalive # ms self._ping_interval = keepalive // 4 if keepalive else 20000 p_i = self.ping_interval * 1000 # Can specify shorter e.g. for subscribe-only if p_i and p_i < self._ping_interval: self._ping_interval = p_i self._in_connect = False self._has_connected = False # Define 'Clean Session' value to use. if ESP8266: import esp esp.sleep_type( 0 ) # Improve connection integrity at cost of power consumption.
def main(): while True: gotTime, curr_tm = getDateTime() # get time # check if lighting is needed - if needed, turn on the light if gotTime and time_in_range(START_TIME, END_TIME, curr_tm[4]): print("Light should be ON -> Turning ON ") lightOn() print("Now waiting to load new file for 30 seconds ") utime.sleep(30) print("Now going to light sleep for: ", SLEEP_INTERVAL, " seconds") esp.sleep_type(esp.SLEEP_LIGHT) utime.sleep(SLEEP_INTERVAL) else: print("Light should be OFF -> Turning OFF ") lightOff() # safety sleep to allow multitasking between ESP core and WiFI print("5 seconds sleep before DEEP SLEEP") utime.sleep(5) sleepStart() # put the device to sleep
def connect(self): """ activates the wlan and polls to see if connected returns a tuple: - a boolean to indicate successful connection or not - a msg to display if connection failed """ import esp, network from utime import sleep_ms if "sleep_type" in dir(esp): esp.sleep_type(esp.SLEEP_NONE) # don't shut off wifi when sleeping wlan = network.WLAN(network.STA_IF) wlan.active(True) connected = False for _ in range(20): connected = wlan.isconnected() if connected: return True, None else: sleep_ms(333) if not connected: from setwifi import setwifi as setwifi setwifi() return False, "Warning: unable to connect to WiFi; setWiFi run to get new credentials"
def __init__(self): """Init the weather station.""" # We do not want to sleep, wall socket powered... esp.sleep_type(esp.SLEEP_NONE) # SLEEP_MODEM is also an option, but prevent it from re-loading data... self.display = Display() # Neopixel self.np = neopixel.NeoPixel(Pin(PINNEOPIXEL), 1) self.self_info() self.net = Network() self.dht = dht.DHT22(machine.Pin(PINDHT)) # MQTT self.CLIENT_ID = b"esp8266_"+ubinascii.hexlify(machine.unique_id()) self.mclient = MQTTClient(self.CLIENT_ID, secrets.BROKER) self.mclient.connect() self.door = machine.Pin(PINDOOR, machine.Pin.IN, machine.Pin.PULL_UP) self.net.getForecast() # Initial display self.updateDisplay() # Timer to periodically update display self.tim = machine.Timer(1) self.tim.init(period=60000, mode=machine.Timer.PERIODIC, callback=lambda t: self.updateDisplay()) # Forecast update self.tim = machine.Timer(2) self.tim.init(period=60000*3, mode=machine.Timer.PERIODIC, callback=lambda t: self.net.getForecast())
def sub_cb(topic, msg): msg = json.loads(msg) for c in msg['cmd']: if c[0] == 'fill': oled.fill(c[1]) elif c[0] == 'pixel': oled.pixel(c[1], c[2], c[3]) elif c[0] == 'text': oled.text(c[1], c[2], c[3], c[4]) elif c[0] == 'rect': oled.rect(c[1], c[2], c[3], c[4], c[5]) elif c[0] == 'fill_rect': oled.fill_rect(c[1], c[2], c[3], c[4], c[5]) elif c[0] == 'line': oled.line(c[1], c[2], c[3], c[4], c[5]) elif c[0] == 'vline': oled.vline(c[1], c[2], c[3], c[4]) elif c[0] == 'hline': oled.hline(c[1], c[2], c[3], c[4]) elif c[0] == 'scroll': oled.scroll(c[1], c[2]) elif c[0] == 'blit': oled.blit(c[1], c[2], c[3], c[4]) elif c[0] == 'show': oled.show() elif c[0] == 'poweron': oled.poweron() elif c[0] == 'poweroff': oled.poweroff() elif c[0] == 'collect': gc.collect() elif c[0] == 'reset': machine.reset() elif c[0] == 'sleep': if c[1] == 'none': esp.sleep_type(esp.SLEEP_NONE) elif c[1] == 'light': esp.sleep_type(esp.SLEEP_LIGHT) sleep(c[2]) msg = json.dumps({'ID': CONFIG['CLIENT_ID'], 'mem_free': gc.mem_free()}) client.publish(Topic1, msg)
def __init__(self, my_id, server, port=8123, ssid='', pw='', timeout=2000, conn_cb=None, conn_cb_args=None, verbose=False, led=None, wdog=False): self._my_id = '{}{}'.format(my_id, '\n') # Ensure >= 1 newline self._server = server self._ssid = ssid self._pw = pw self._port = port self._to = timeout # Client and server timeout self._tim_ka = timeout // 4 # Keepalive interval self._concb = conn_cb self._concbargs = () if conn_cb_args is None else conn_cb_args self._verbose = verbose self._led = led if wdog: if platform == 'pyboard': self._wdt = machine.WDT(0, 20000) def wdt(): def inner(feed=0): # Ignore control values if not feed: self._wdt.feed() return inner self._feed = wdt() else: def wdt(secs=0): timer = machine.Timer(-1) timer.init(period=1000, mode=machine.Timer.PERIODIC, callback=lambda t: self._feed()) cnt = secs run = False # Disable until 1st feed def inner(feed=WDT_CB): nonlocal cnt, run, timer if feed == 0: # Fixed timeout cnt = secs run = True elif feed < 0: # WDT control/callback if feed == WDT_CANCEL: timer.deinit() # Permanent cancellation elif feed == WDT_CB and run: # Timer callback and is running. cnt -= 1 if cnt <= 0: machine.reset() return inner self._feed = wdt(20) else: self._feed = lambda x: None self._sta_if = network.WLAN(network.STA_IF) ap = network.WLAN(network.AP_IF) # create access-point interface ap.active(False) # deactivate the interface self._sta_if.active(True) gc.collect() if platform == 'esp8266': import esp # Improve connection integrity at cost of power consumption. esp.sleep_type(esp.SLEEP_NONE) self._evfail = asyncio.Event() # Set by any comms failure self._evok = asyncio.Event() # Set by 1st successful read self._s_lock = asyncio.Lock() # For internal send conflict. self._w_lock = asyncio.Lock() # For .write rate limit self._last_wr = utime.ticks_ms() self._lineq = Queue(20) # 20 entries self.connects = 0 # Connect count for test purposes/app access self._sock = None self._acks_pend = ASetByte() # ACKs which are expected to be received gc.collect() asyncio.create_task(self._run())
# upip packages - see README.md # upip.install('micropython-umqtt.simple') # upip.install('micropython-umqtt.robust') ap_if = network.WLAN( network.AP_IF) # turn off the access point which is on by default ap_if.active(False) cfg = config.Config('config.json') if cfg.isEsp8266: BuiltinLedPin = 2 i2c = I2C(scl=Pin(5), sda=Pin(4)) adc = ADC(0) # create ADC object on ADC pin mqttId = str(esp.flash_id()) esp.sleep_type(esp.SLEEP_LIGHT) else: BuiltinLedPin = 5 i2c = I2C(scl=Pin(22), sda=Pin(21)) adc = None import urandom as random mqttId = str(random.randint(100, 100000)) builtinLed = Pin(BuiltinLedPin, Pin.OUT) mySensor = cfg.sensor.Sensor(i2c) client = MQTTClient(mqttId, cfg.mqttBroker) sta_if.connect(cfg.wifiSsid, cfg.wifiPwd) display = None
import esp esp.sleep_type(esp.SLEEP_LIGHT)
def connect(self): esp.sleep_type(esp.SLEEP_NONE) esp.wifi_mode(esp.STA_MODE) network.connect("MosEisleySpaceport", "supersonic")
def main(): global dht_sensor global dht_tim global v_tim try: i2c = I2C(scl=Pin(PIN_I2C_SCL), sda=Pin(PIN_I2C_SDA)) init_display(i2c) except OSError as e: print("Can not initialize display!", repr(e)) time.sleep(10) machine.reset() return from display import instance as display display.render(sys_status_view) while 1: try: dht_sensor = MultiSensor(pin=PIN_DHT, i2c=i2c) dht_sensor.sample() # test sensor sys_status.set_sensor(True) display.render(sys_status_view) break except OSError as e: print("Sensor failure", repr(e)) time.sleep(3) hass_api = hass.API(HASS_BASE_URL, api_password=HASS_PASSWORD) hass_thermo = HassThermostatAPI(hass_api, HASS_THERMOSTAT_ID) cur_state = hass_thermo.get_state() while cur_state is None: print("[HASS] Connecting to the server...") time.sleep_ms(500) cur_state = hass_thermo.get_state() print("[HASS] Connected") sys_status.set_hass_api(True) display.render(sys_status_view) model.init(cur_state) mqtt.init(mqtt_msg_dispatch) sys_status.set_mqtt(True) display.render(sys_status_view) time.sleep(1) sys_status.boot = False display.render(sys_status_view) t_sensor_mqtt = mqtt.HassMQTTTemperatureSensor(mapper=lambda x: x.t) t_sensor_mqtt.register({}) h_sensor_mqtt = mqtt.HassMQTTHumiditySensor(mapper=lambda x: x.h) h_sensor_mqtt.register({}) v_sensor_mqtt = mqtt.HassMQTTVoltageSensor() v_sensor_mqtt.register({}) dht_tim = Timer(DHT_TIM_ID) sensor_update = dht_updater(t_sensor_mqtt, h_sensor_mqtt, Sensor2Model()) sensor_update(None) dht_tim.init(period=SENSOR_SAMPLE_INTERVAL * 1000, mode=Timer.PERIODIC, callback=sensor_update) v_tim = Timer(V_TIM_ID) v_update = voltage_updater(v_sensor_mqtt) v_update(None) v_tim.init(period=30 * 1000, mode=Timer.PERIODIC, callback=v_update) controller = Controller( hass_thermo_api=hass_thermo, thermostat_model=model.instance, local_changes=LocalChanges( max_temp=float(cur_state['attributes']['max_temp']), min_temp=float(cur_state['attributes']['min_temp']))) if LIGHT_SLEEP_ENABLED: esp.sleep_type(esp.SLEEP_LIGHT) lux_sensor = TSL2561(i2c=i2c) lux_sensor.active(True) time.sleep_ms(500) while 1: adjust_display_brightness(lux_sensor) mqtt.loop() controller.loop()
print('boot.py') # noqa isort:skip import gc import sys import esp import micropython import utime for no in range(2, 0, -1): print('%i boot.py wait...' % no) utime.sleep(1) esp.osdebug(None) # turn off vendor O/S debugging messages esp.sleep_type(esp.SLEEP_NONE) # Don't go into sleep mode micropython.alloc_emergency_exception_buf(128) gc.enable() # https://forum.micropython.org/viewtopic.php?f=2&t=7345&p=42390#p42390 gc.threshold(8192) # default is: # sys.path=['', '/lib', '/'] # But we would like to be possible to overwrite frozen modues with .mpy on flash drive ;) sys.path.insert(0, '.') print('sys.path=%r' % sys.path) print('boot.py END')
else: oled.poweroff() #weather if (page == 1): if wlanstatus == 1: weather() else: oled.fill(0) oled.text("Network Error", 10, 10) oled.show() #timer elif (page == 3): button1() #showtime elif (page == 2): (year, month, mday, hour, minute, second, weekday, yearday) = utime.localtime() timeshow() elif page > 3: oled.fill(0) oled.text("final page", 10, 20) oled.show() page = 3 elif page < 1: oled.fill(0) oled.text("first page", 10, 20) oled.show() page = 1 esp.sleep_type(esp.SLEEP_MODEM) utime.sleep(1)
from machine import freq, Pin, ADC, reset from esp import sleep_type, SLEEP_NONE import webrepl print( "\n\nJust Do It Yourself World Company Incorporated (c) from 2020 to eternity and beyond...\n" ) freq(160000000) sleep_type(SLEEP_NONE) webrepl.start() def rst(): reset() def ir_on(): ir_power = Pin(16, Pin.OUT) ir_power.on() def ir_off(): ir_power = Pin(16, Pin.OUT) ir_power.off() def ir_read(): ir_sensor = ADC(0) print("> IR sensor read: {}".format(ir_sensor.read()))
def wifi_init(): sta = network.WLAN(network.STA_IF) sta.active(True) sta.connect("Wilko Wireless", "WilkoN600") if not sta.isconnected(): time.sleep(0.5) def publish(t, h): c = MQTTClient('my_sensor', 'iot.eclipse.org') #change my_sensor!! c.connect() c.publish('RIFF/phil/temperature', str(t)) # change the topic tree! c.publish('RIFF/phil/humidity', str(h)) # change the topic tree! c.disconnect() def wifi_deinit(): sta = network.WLAN(network.STA_IF) sta.active(False) esp.sleep_type(esp.SLEEP_MODEM) #all sleep is modem sleep while True: t, h = poll_sensor() wifi_init() publish(t, h) wifi_deinit() time.sleep(60)
import uasyncio as asyncio import time import machine from pysmartnode.utils.sys_vars import getDeviceID import network try: s = network.WLAN(network.STA_IF) s.config(dhcp_hostname="{}{}".format("ESP8266_", getDeviceID())) except Exception as e: print(e) # not important enough to do anything about it if config.WIFI_SLEEP_MODE is not None: import esp esp.sleep_type(config.WIFI_SLEEP_MODE) if config.RTC_SYNC_ACTIVE: import ntptime async def _sync(): s = 1 while True: print("Synchronize time from NTP server ...") try: ntptime.settime() gc.collect() tm = time.localtime() hour = tm[3] + config.RTC_TIMEZONE_OFFSET day = tm[2] if hour > 24:
# -*- coding: utf-8 -*- #Micropython on ESP8266 - Smart Home V0.1 (c)2019 Ursa Robotics 1st EPA.L. of Preveza import machine, gc, time print('\n=========== Ursa Robotics - Smart Home (c)2019 ===================') machine.freq(160000000) #Να τρέχει στα 160MHz print('[Initial free RAM:', gc.mem_free(), 'bytes]') import os, network, esp, ustruct, onewire, ds18x20, ubinascii, bme280 from umqtt.simple import MQTTClient #Αρχεία τα οποία ορίζονται μέσα στο έργο import definitions as df import functions as fn esp.osdebug(None) esp.sleep_type(0) #esp.sleep_type(esp.SLEEP_NONE) #Ορισμός timer timer1 = machine.Timer(-1) timer2 = machine.Timer(-1) #Πληροφορίες για το μέγεθος της μνήμης Flash print('[Program file system total :', os.statvfs("/")[0] * os.statvfs("/")[2], 'bytes]') print('[Program file system free :', os.statvfs("/")[0] * os.statvfs("/")[3], 'bytes]') #Δημιουρία αντικειμένων OneWire ds1 = ds18x20.DS18X20(onewire.OneWire(df.OW1_DATA)) #Εξωτερικό θερμόμετρο ds2 = ds18x20.DS18X20(onewire.OneWire(df.OW2_DATA)) #Εσωτερικό θερμόμετρο #Εμφάνισε τα Id των θερμομέτρων roms_ext = ds1.scan()