Docs: implications of uasyncio V2.2. aswitch: remove asyn dependency.

Author: peterhinch

FASTPOLL.md

@@ -60,19 +60,24 @@ formerly provided by `asyncio_priority.py` is now implemented.
 
 # 1. Installation
 
-Install and test uasyncio on the target hardware. Replace `core.py` and
-`__init__.py` with the files in the `fast_io` directory.
-
-In MicroPython 1.9 `uasyncio` was implemented as a frozen module on the
-ESP8266. To install this version it is necessary to build the firmware with the
-above two files implemented as frozen bytecode. See
-[ESP Platforms](./FASTPOLL.md#6-esp-platforms) for general comments on the
+The basic approach is to install and test `uasyncio` on the target hardware.
+Replace `core.py` and `__init__.py` with the files in the `fast_io` directory.
+
+The current MicroPython release build (1.9.4) has `uasyncio` implemented as a
+frozen module. The following options for installing `fast_io` exist:
+
+ 1. Use a daily build, install `uasyncio` as per the tutorial then replace the
+ above files.
+ 2. Build the firmware with the `fast_io` version implemented as frozen
+ bytecode.
+ 3. Use a release build. Install as in 1. above. Then change the module search
+ order by modifying `sys.path`. The initial entry `''` specifies frozen
+ bytecode. If this is deleted and appended to the end, frozen files will only
+ be found if there is no match in the filesystem.
+
+See [ESP Platforms](./FASTPOLL.md#6-esp-platforms) for general comments on the
 suitability of ESP platforms for systems requiring fast response.
 
-It is possible to load modules in the filesystem in preference to frozen ones
-by modifying `sys.path`. However the ESP8266 probably has too little RAM for
-this to be useful.
-
 ## 1.1 Benchmarks
 
 The benchmarks directory contains files demonstrating the performance gains

README.md

@@ -35,10 +35,20 @@ This repository comprises the following parts.
 
 # 2. Version and installation of uasyncio
 
+As of 24th Dec 2018 Paul Sokolovsky has released uasyncio V2.2. This version
+is on PyPi and requires his [Pycopy](https://github.com/pfalcon/micropython)
+fork of MicroPython.
+
+I support only the official build of MicroPython. The library code guaranteed
+to work with this build is in [micropython-lib](https://github.com/micropython/micropython-lib).
+Most of the resources in here should work with Paul's forks (the great majority
+work with CPython). I am unlikely to fix issues which are only evident in an
+unofficial fork.
+
 The documentation and code in this repository assume `uasyncio` version
-2.0.x, which is the version on PyPi and in the official micropython-lib. This
-requires firmware dated 22nd Feb 2018 or later. Use of the stream I/O mechanism
-requires firmware after 17th June 2018.
+2.0.x, the version in [micropython-lib](https://github.com/micropython/micropython-lib).
+This requires firmware dated 22nd Feb 2018 or later. Use of the stream I/O
+mechanism requires firmware after 17th June 2018.
 
 See [tutorial](./TUTORIAL.md#installing-uasyncio-on-bare-metal) for
 installation instructions.

TUTORIAL.md

@@ -91,42 +91,38 @@ CPython V3.5 and above.
 
 ## 0.1 Installing uasyncio on bare metal
 
-MicroPython libraries are located on [PyPi](https://pypi.python.org/pypi).
-Libraries to be installed are:
-
- * micropython-uasyncio
- * micropython-uasyncio.queues
- * micropython-uasyncio.synchro
+If a release build of firmware is used no installation is necessary as uasyncio
+is compiled into the build. The current release build (V1.9.4) does not support
+asynchronous stream I/O.
+
+The following instructions cover the case where a release build is not used or
+where a later official `uasyncio` version is required for stream I/O. The
+instructions have changed as the version on PyPi is no longer compatible with
+official MicroPython firmware.
+
+The following instructions describe copying the bare minimum of files to a
+target device, also the case where `uasyncio` is to be frozen into a compiled
+build as bytecode. For the latest release compatible with official firmware
+files must be copied from the official
+[micropython-lib](https://github.com/micropython/micropython-lib).
+
+Clone the library to a PC with
+```
+git clone https://github.com/micropython/micropython-lib.git
+```
+On the target hardware create a `uasyncio` directory and copy the following
+files to it:
+ * `uasyncio/uasyncio/__init__.py`
+ * `uasyncio.core/uasyncio/core.py`
+ * `uasyncio.synchro/uasyncio/synchro.py`
+ * `uasyncio.queues/uasyncio/queues.py`
 
 The `queues` and `synchro` modules are optional, but are required to run all
 the examples below.
 
-The official approach is to use the `upip` utility as described
-[here](https://github.com/micropython/micropython-lib). Network enabled
-hardware has this included in the firmware so it can be run locally. This is
-the preferred approach.
-
-On non-networked hardware there are two options. One is to use `upip` under a
-Linux real or virtual machine. This involves installing and building the Unix
-version of MicroPython, using `upip` to install to a directory on the PC, and
-then copying the library to the target.
-
-The need for Linux and the Unix build may be avoided by using
-[micropip.py](https://github.com/peterhinch/micropython-samples/tree/master/micropip).
-This runs under Python 3.2 or above. Create a temporary directory on your PC
-and install to that. Then copy the contents of the temporary directory to the
-device. The following assume Linux and a temporary directory named `~/syn` -
-adapt to suit your OS. The first option requires that `micropip.py` has
-executable permission.
-
-```
-$ ./micropip.py install -p ~/syn micropython-uasyncio
-$ python3 -m micropip.py install -p ~/syn micropython-uasyncio
-```
-
 The `uasyncio` modules may be frozen as bytecode in the usual way, by placing
-the `uasyncio` and `collections` directories in the port's `modules` directory
-and rebuilding.
+the `uasyncio` directory and its contents in the port's `modules` directory and
+rebuilding.
 
 ###### [Main README](./README.md)
 

aswitch.py

@@ -30,8 +30,20 @@
 
 import uasyncio as asyncio
 import utime as time
-from asyn import launch
+# Remove dependency on asyn to save RAM:
 # launch: run a callback or initiate a coroutine depending on which is passed.
+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):
+        loop = asyncio.get_event_loop()
+        loop.create_task(res)
 
 
 class Delay_ms(object):