def __init__(self, device, conf): LenferController.__init__(self, device) self._conf = conf self.pin = Pin(conf['pin'], Pin.INOUT) self.pin.value(0) self.timers = [] self._schedule_params = None self._timers_param = None self._pulse_interval = conf.get('pulse_interval') self._pulse_length = conf.get('pulse_length') if conf.get('schedule_params'): self._schedule_params = conf['schedule_params'] self._schedule_params_idx = [ self.device.schedule.param_idx(param) for param in self._schedule_params ] else: self._timers_param = conf.get('timers_param') or 'timers' if self.device.settings.get(self._timers_param): self.init_timers() if self._pulse_length: self._on = False uasyncio.get_event_loop().create_task(self.pulse_task()) self._log_prop_name = conf.get('log_prop_name') or self._timers_param self.api = {'on': self.api_on} if conf.get('api_buttons'): self._api_buttons = [] for params in conf['api_buttons']: self._api_buttons.append((Pin(params['pin'], Pin.IN, Pin.PULL_UP, handler=self.on_api_button, trigger=Pin.IRQ_FALLING, debounce=500000), params))
def api_on(self, value=True, time=1000, manual=True): logging.info('api_on value: %s time: %s manual: %s' % (value, time, manual)) self.on(value) if value and time: uasyncio.get_event_loop().create_task( self.delayed_off(time, manual=manual)) return value
def factory_reset_irq(self, pin): LOG.info("factory reset irq %s" % pin.value()) if pin.value(): if self.status['factory_reset'] == 'pending': self.status['factory_reset'] = 'cancel' else: if not self.status['factory_reset']: self.status['factory_reset'] = 'pending' uasyncio.get_event_loop().create_task(self.factory_reset())
async def get_wlan_settings(req, rsp): if req.method == 'POST': await req.read_json() NETWORK_CONTROLLER._wlan.conf.update(req.json) NETWORK_CONTROLLER._wlan.save_conf() if DEVICE: DEVICE.status["ssid_delay"] = True uasyncio.get_event_loop().create_task(delayed_reset(5)) await send_json(rsp, {"reset": True}) else: await send_json(rsp, NETWORK_CONTROLLER._wlan.conf)
def start_async(self): loop = uasyncio.get_event_loop() loop.create_task(self.bg_leds()) loop.create_task(self.check_wlan_switch()) if self._network._wlan and (self._network._wlan.mode == AP_IF and self._network._wlan.conf['ssid']): loop.create_task(self.delayed_ssid_switch()) for module_type in self.modules: if module_type == 'climate' or module_type == 'power_monitor': loop.create_task(self.modules[module_type].read()) if self.online(): loop.create_task(self.post_sensor_data()) elif module_type == 'relay_switch': loop.create_task(self.modules['relay_switch'].adjust_switch()) elif module_type == 'gate': loop.create_task(self.modules['gate'].adjust_switch()) elif module_type == 'rtc': loop.create_task(self.modules['rtc'].adjust_time()) elif module_type == 'feeder': loop.create_task(self.modules['feeder'].check_timers()) if self.online(): if self.id.get('updates'): loop.create_task(self.post_log()) loop.create_task(self.check_updates()) if not self.id.get('disable_software_updates'): loop.create_task(self.task_check_software_updates()) self.append_log_entries('device start')
async def monitorLED(self, debug=False): """coroutine for monitor event to change the LED color""" print('''%s - %s: monitorLED Started''' % (self.name(), time())) mainLoop = asyncio.get_event_loop() mainLoop.create_task(self.setColor(self.LED_BLUE)) while True: for pair, func, color, clear in self.ledServerList: v = True for event, test in pair: v = event() == test and v if v: if debug: print( '''%s - %s: v is: %s, last color is: %s, current color is: %s''' % (self._name, time(), v, self.lastColor, color)) if self.lastColor != color: self.lastColor = color mainLoop.create_task(func(color)) print('''%s - %s: added task to loop, color: %s''' % (self._name, time(), color)) if clear != None: clear.clear() break await asyncio.sleep_ms(80)
def on(self, value=True, source='manual', manual=False): if manual: source = 'manual' if value: self._active[source] = True else: if source in self._active: del self._active[source] if self.state != bool(self._active): if self.state: self.reverse = False self.device.busy = self._active RelaySwitchController.on(self, self._active, source == 'manual') if 'manual' in self._active and len( self._active) == 1 and self._power_monitor: uasyncio.get_event_loop().create_task(self.check_current()) LOG.debug('Feeder state: %s' % self.state) manage_memory()
async def monitorPump(self, debug=False): """coroutine for handling pump requests""" print('''%s - %s: Monitor of pump started''' % (self._name, time())) loopcount = 0 while True: loopcount += 1 await asyncio.sleep_ms(50) if debug: print('''%s - %s: loop count: %s''' % (self._name, time(), loopcount)) for event, func in self.pumpMonitorEvents: if event.is_set(): mainLoop = asyncio.get_event_loop() mainLoop.create_task(func(event.value())) print('''%s - %s: added %s to loop %s''' % (self._name, time(), event._name, func)) event.clear()
def start(self): WDT(True) self.ntp_sync() if self.deepsleep(): loop = uasyncio.get_event_loop() for module_type in self.modules: if module_type == 'rtc': loop.run_until_complete( self.modules['rtc'].adjust_time(once=True)) machine.resetWDT() elif module_type == 'climate': loop.run_until_complete( self.modules['climate'].read(once=True)) machine.resetWDT() if self.online(): loop.run_until_complete( self.post_sensor_data(once=True)) machine.resetWDT() if self.modules['climate'].light: loop.run_until_complete( self.modules['climate'].adjust_light(once=True)) machine.resetWDT() if self.online(): if self.id.get('updates'): loop.run_until_complete(self.check_updates(once=True)) machine.resetWDT() if not self.id.get('disable_software_updates'): loop.run_until_complete( self.task_check_software_updates(once=True)) machine.resetWDT() if self.deepsleep(): if self._network: self._network.off() machine.deepsleep(self.deepsleep() * 60000) self.start_async()
from WaterPumps.buttons import button from WaterPumps.leds import triLed pins = [4,5,12,13,14,15] lakeButton = button(5, name='Lake Button') parkButton = button(4, name='Park Button') statusLed = triLed(redpin=13,bluepin=15,greenpin=12, name='statusLED') #set button states states = [state('pumpOff', event=Event())] states.append(state('pumpOn', event=Event()) lakeButton.states.setStates(states) states = [state('pumpOff', event=Event())] states.append(state('pumpOn', event=Event()) parkButton.states.setStates(states) #Get handle for event loop main_loop = asyncio.get_event_loop() #register led monitors statusLed.registerLedClient(([(mainPump.pumpNotReadyEvent.is_set, True)],statusLed.setColor,statusLed.LED_YELLOW,None),0) #Load tasks main_loop.create_task(powerButton.monitorButton(startState='pumpOff',debug=False)) main_loop.create_task(statusLed.monitorLED()) #start main Loop main_loop.run_forever() main_loop.close()
import lib.uasyncio as uasyncio import machine import re import ujson import logging from network_controller import NetworkController from lenfer_device import LenferDevice from utils import manage_memory, load_json LOOP = uasyncio.get_event_loop() LOG = logging.getLogger("Main") async def wdt_feed(): await uasyncio.sleep(10) machine.resetWDT() LOOP.create_task(wdt_feed()) machine.WDT(True) NETWORK_CONTROLLER = NetworkController() if NETWORK_CONTROLLER.online(): software_version = load_json('version.json') if software_version and software_version['update']: from software_update import perform_software_update perform_software_update() machine.reset()
def addTasktoLoop(self, func, args): """add a func to main loop""" import uasyncio as asyncio buttonTask = func(self.event) mainLoop = asyncio.get_event_loop() mainLoop.create_task(buttonTask)
def on_off(self): self.on() uasyncio.get_event_loop().call_later(self.duration, self.off)
def onReceive(lora, payload): try: payload = payload.decode() rssi = lora.packetRssi() q.put_nowait([payload, rssi]) except Exception as e: print('recieved failed') raiseFailure() print(e) station = setupWifi() mqtt_client = setupMqtt() lora = setupLora() lora.onReceive(onReceive) lora.receive() q = Queue() loop = uasyncio.get_event_loop() message_worker = loop.create_task(messageWorker(mqtt_client, station)) try: loop.run_forever() except KeyboardInterrupt: pass finally: print("Closing Loop") loop.close()
def _on_off(self): uasyncio.get_event_loop().create_task(self.relay.run_for( self.duration))