Add as_drivers/client_server alpha code.

Author: peterhinch

v3/as_drivers/client_server/heartbeat.py

@@ -0,0 +1,26 @@
+# flash.py Heartbeat code for simple uasyncio-based echo server
+
+# Released under the MIT licence
+# Copyright (c) Peter Hinch 2019
+
+import uasyncio as asyncio
+from sys import platform
+
+
+async def heartbeat(tms):
+    if platform == 'pyboard':  # V1.x or D series
+        from pyb import LED
+        led = LED(1)
+    elif platform == 'esp8266':
+        from machine import Pin
+        led = Pin(2, Pin.OUT, value=1)
+    elif platform == 'linux':
+        return  # No LED
+    else:
+        raise OSError('Unsupported platform.')
+    while True:
+        if platform == 'pyboard':
+            led.toggle()
+        elif platform == 'esp8266':
+            led(not led())
+        await asyncio.sleep_ms(tms)

v3/as_drivers/client_server/uclient.py

@@ -0,0 +1,53 @@
+# uclient.py Demo of simple uasyncio-based client for echo server
+
+# Released under the MIT licence
+# Copyright (c) Peter Hinch 2019-2020
+
+import usocket as socket
+import uasyncio as asyncio
+import ujson
+from heartbeat import heartbeat  # Optional LED flash
+
+server = '192.168.0.41'
+port = 8123
+
+async def run():
+    # Optional fast heartbeat to confirm nonblocking operation
+    asyncio.create_task(heartbeat(100))
+    sock = socket.socket()
+    def close():
+        sock.close()
+        print('Server disconnect.')
+    try:
+        serv = socket.getaddrinfo(server, port)[0][-1]
+        sock.connect(serv)
+    except OSError as e:
+        print('Cannot connect to {} on port {}'.format(server, port))
+        sock.close()
+        return
+    while True:
+        sreader = asyncio.StreamReader(sock)
+        swriter = asyncio.StreamWriter(sock, {})
+        data = ['value', 1]
+        while True:
+            try:
+                swriter.write('{}\n'.format(ujson.dumps(data)))
+                await swriter.drain()
+                res = await sreader.readline()
+            except OSError:
+                close()
+                return
+            try:
+                print('Received', ujson.loads(res))
+            except ValueError:
+                close()
+                return
+            await asyncio.sleep(2)
+            data[1] += 1
+
+try:
+    asyncio.run(run())
+except KeyboardInterrupt:
+    print('Interrupted')  # This mechanism doesn't work on Unix build.
+finally:
+    _ = asyncio.new_event_loop()

v3/as_drivers/client_server/userver.py

@@ -0,0 +1,52 @@
+# userver.py Demo of simple uasyncio-based echo server
+
+# Released under the MIT licence
+# Copyright (c) Peter Hinch 2019
+
+import usocket as socket
+import uasyncio as asyncio
+import uselect as select
+import ujson
+from heartbeat import heartbeat  # Optional LED flash
+
+class Server:
+
+    async def run(self, port=8123):
+        print('Awaiting client connection.')
+        self.cid = 0
+        asyncio.create_task(heartbeat(100))
+        self.server = await asyncio.start_server(self.run_client, '0.0.0.0', port)
+        while True:
+            await asyncio.sleep(100)
+
+    async def run_client(self, sreader, swriter):
+        self.cid += 1
+        print('Got connection from client', self.cid)
+        try:
+            while True:
+                res = await sreader.readline()
+                if res == b'':
+                    raise OSError
+                print('Received {} from client {}'.format(ujson.loads(res.rstrip()), self.cid))
+                swriter.write(res)
+                await swriter.drain()  # Echo back
+        except OSError:
+            pass
+        print('Client {} disconnect.'.format(self.cid))
+        await sreader.wait_closed()
+        print('Client {} socket closed.'.format(self.cid))
+
+    def close(self):
+        print('Closing server')
+        self.server.close()
+        await self.server.wait_closed()
+        print('Server closed')
+
+server = Server()
+try:
+    asyncio.run(server.run())
+except KeyboardInterrupt:
+    print('Interrupted')  # This mechanism doesn't work on Unix build.
+finally:
+    server.close()
+    _ = asyncio.new_event_loop()