Separate network hardware interface from mqtt client

README.md

@@ -15,10 +15,11 @@ An effective PC client and server is [mosquitto](https://mosquitto.org/).
 
 # This repository
 
-This contains two separate projects:  
+This contains three separate projects:  
  1. A "resilient" asynchronous non-blocking MQTT driver.
  2. A means of using a cheap ESP8266 module to bring MQTT to MicroPython
  platforms which lack a WiFi interface.
+ 3. A basic network hardware controller (WLAN) which the mqtt client uses
 
 ## 1. The "resilient" driver
 

mqtt_as/__init__.py

@@ -0,0 +1 @@
+from .mqtt_as import MQTTClient, config  # allow backwards compatible import statements

mqtt_as/interfaces/__init__.py

@@ -0,0 +1,92 @@
+from uerrno import EINPROGRESS, ETIMEDOUT
+import usocket
+import uasyncio as asyncio
+
+
+async def _g():
+    pass
+
+
+_type_coro = type(_g())
+
+
+# If a callback is passed, run it and return.
+# If a coro is passed initiate it and return.
+# coros are passed by name i.e. not using function call syntax.
+def launch(func, tup_args):
+    res = func(*tup_args)
+    if isinstance(res, _type_coro):
+        res = asyncio.create_task(res)
+    return res
+
+
+class BaseInterface:
+    def __init__(self, socket=None):
+        # Legitimate errors while waiting on a socket. See uasyncio __init__.py open_connection().
+        self.BUSY_ERRORS = [EINPROGRESS, ETIMEDOUT]
+        self.socket = socket or usocket  # support for custom socket implementations
+        self._subs = []
+        self._state = None
+
+    async def connect(self):
+        """Serve connect request. Triggers callbacks if state changes"""
+        if await self._connect():
+            self._change_state(True)
+            return True
+        return False
+
+    async def _connect(self):
+        """Hardware specific connect method"""
+        # return True  # if connection is successful, otherwise False
+        raise NotImplementedError()
+
+    async def disconnect(self):
+        """Serve disconnect request. Triggers callbacks if state changes"""
+        if await self._disconnect():
+            self._change_state(False)
+            return True
+        return False
+
+    async def _disconnect(self):
+        """Hardware specific disconnect method"""
+        # return True  # if disconnect is successful, otherwise False
+        raise NotImplementedError()
+
+    async def reconnect(self):
+        """Serve reconnect request"""
+        return await self._reconnect()
+
+    async def _reconnect(self):
+        """Hardware specific reconnect method"""
+        if await self._disconnect():
+            return await self._connect()
+        return False
+
+    def isconnected(self):
+        """"Checks if the interface is connected. Triggers callbacks if state changes"""
+        st = self._isconnected()
+        self._change_state(st)
+        return st
+
+    def _isconnected(self):
+        """Hardware specific isconnected method"""
+        raise NotImplementedError()
+
+    def _change_state(self, state):
+        """
+        Private method executing all callbacks or creating asyncio tasks
+        on connection state changes
+        """
+        st = self._state
+        if st != state:
+            self._state = state
+            if st is None and state is False:
+                # not triggering disconnect cbs when interface state was unknown
+                # (probably disconnected on startup)
+                return
+            for cb in self._subs:
+                launch(cb, (state,))
+
+    def subscribe(self, cb):
+        """Subscribe to interface connection state changes"""
+        self._subs.append(cb)

mqtt_as/interfaces/linux.py

@@ -0,0 +1,12 @@
+from . import BaseInterface
+
+
+class Linux(BaseInterface):
+    async def _disconnect(self):
+        return True  # just to prevent errors we'll pretend to be disconnected.
+
+    def _isconnected(self):
+        return True  # always connected.
+
+    async def _connect(self):
+        return True  # always connected or can't do anything about it

mqtt_as/interfaces/wlan/__init__.py

@@ -0,0 +1,11 @@
+from sys import platform
+
+if platform == "esp8266":
+    from .esp8266 import WLAN
+elif platform == "esp32":
+    from .esp32 import WLAN
+elif platform == "pyboard":
+    from .pyboard import WLAN
+else:
+    # just try esp32 implementation. Seems most mature.
+    from .esp32 import WLAN

mqtt_as/interfaces/wlan/esp32.py

@@ -0,0 +1,20 @@
+from .wlan_base import BaseWLAN
+import network
+import uasyncio as asyncio
+
+
+class WLAN(BaseWLAN):
+    def __init__(self, ssid, wifi_pw):
+        super().__init__(ssid, wifi_pw)
+        # https://forum.micropython.org/viewtopic.php?f=16&t=3608&p=20942#p20942
+        self.BUSY_ERRORS += [118, 119]  # Add in weird ESP32 errors
+
+    async def _connect(self):
+        s = self._sta_if
+        s.active(True)
+        if not s.isconnected():
+            s.connect(self._ssid, self._wifi_pw)
+            while s.status() == network.STAT_CONNECTING:  # Break out on fail or success. Check once per sec.
+                await asyncio.sleep(1)
+
+        return await self._check_reliability()

mqtt_as/interfaces/wlan/esp8266.py

@@ -0,0 +1,30 @@
+from .wlan_base import BaseWLAN
+import network
+import uasyncio as asyncio
+
+
+class WLAN(BaseWLAN):
+    def __init__(self, ssid=None, wifi_pw=None):
+        super().__init__(ssid, wifi_pw)
+        import esp
+        esp.sleep_type(0)  # Improve connection integrity at cost of power consumption.
+
+    async def _connect(self):
+        s = self._sta_if
+        if s.isconnected():  # 1st attempt, already connected.
+            return True
+        s.active(True)
+        s.connect()  # ESP8266 remembers connection.
+        for _ in range(60):
+            if s.status() != network.STAT_CONNECTING:  # Break out on fail or success. Check once per sec.
+                break
+            await asyncio.sleep(1)
+        if s.status() == network.STAT_CONNECTING:  # might hang forever awaiting dhcp lease renewal or something else
+            s.disconnect()
+            await asyncio.sleep(1)
+        if not s.isconnected() and self._ssid is not None and self._wifi_pw is not None:
+            s.connect(self._ssid, self._wifi_pw)
+            while s.status() == network.STAT_CONNECTING:  # Break out on fail or success. Check once per sec.
+                await asyncio.sleep(1)
+
+        return await self._check_reliability()

mqtt_as/interfaces/wlan/pyboard.py

@@ -0,0 +1,17 @@
+from .wlan_base import BaseWLAN
+import uasyncio as asyncio
+
+
+class WLAN(BaseWLAN):
+    def __init__(self, ssid, wifi_pw):
+        super().__init__(ssid, wifi_pw)
+
+    async def _connect(self):
+        s = self._sta_if
+        s.active(True)
+        s.connect(self._ssid, self._wifi_pw)
+        # Pyboard doesn't yet have STAT_CONNECTING constant
+        while s.status() in (1, 2):
+            await asyncio.sleep(1)
+
+        return await self._check_reliability()

mqtt_as/interfaces/wlan/wlan_base.py

@@ -0,0 +1,37 @@
+from .. import BaseInterface
+import network
+import uasyncio as asyncio
+
+
+class BaseWLAN(BaseInterface):
+    def __init__(self, ssid=None, wifi_pw=None):
+        super().__init__()
+        self.DEBUG = False
+        self._ssid = ssid
+        self._wifi_pw = wifi_pw
+        # wifi credentials required for ESP32 / Pyboard D. Optional ESP8266
+        self._sta_if = network.WLAN(network.STA_IF)
+        self._sta_if.active(True)
+
+    async def _check_reliability(self):
+        s = self._sta_if
+        if not s.isconnected():
+            return False
+        # Ensure connection stays up for a few secs.
+        if self.DEBUG:
+            print('Checking WiFi integrity.')
+        for _ in range(5):
+            if not s.isconnected():
+                return False  # in 1st 5 secs
+            await asyncio.sleep(1)
+        if self.DEBUG:
+            print('Got reliable connection')
+        return True
+
+    async def _disconnect(self):
+        self._sta_if.disconnect()
+        await asyncio.sleep(1)
+        return True  # not checking if really disconnected.
+
+    def _isconnected(self):
+        return self._sta_if.isconnected()