Adjust docs for uasyncio V2.0.

Author: peterhinch

FASTPOLL.md

@@ -6,7 +6,7 @@ with improved millisecond-level timing accuracy and reduced scheduling latency.
 
 V0.2 Dec 2017. A single module designed to work with the official `uasyncio`
 library. This requires uasyncio.core V1.7 which was released on 16th Dec 2017,
-with firmware of that date or later.
+with firmware of that date or later. It does not yet support `uasyncio` V2.0.
 
 **API CHANGES**
 The API has been changed to simplify the code and to improve consistency.

README.md

@@ -18,20 +18,22 @@ This GitHub repository consists of the following parts:
  mechanism. With suitable application design this improves the rate at which
  devices can be polled and improves the accuracy of time delays. Also provides
  for low priority tasks which are only scheduled when normal tasks are paused.
+ NOTE: this currently supports uasyncio V1.7.1.
  * [Communication between devices](./syncom_as/README.md) Enables MicroPython
  boards to communicate without using a UART. Primarily intended to enable a
  a Pyboard-like device to achieve bidirectional communication with an ESP8266.
 
 # 2. Version and installation of uasyncio
 
 This has become more involved owing to the development of Paul Sokolovsky's
-fork. At the time of writing this fork supports `uasyncio` version 2.0, which
-requires the build of firmware from his repository. The version on PyPI is
-V2.0.
+fork. At the time of writing his fork supports `uasyncio` version 2.0. The
+version on PyPI is also V2.0.
 
-Until the situation becomes clearer I plan to support the official firmware.
-Hence these docs, code samples etc. are based on `uasyncio.core` V1.7.1 which
-is in [micropython-lib](https://github.com/micropython/micropython-lib).
+The version in [micropython-lib](https://github.com/micropython/micropython-lib)
+is version 1.7.1.
+
+With the exception of the priority version all docs and code samples should be
+compatible with both versions. Testing has been done under V1.7.1.
 
 See [tutorial](./TUTORIAL.md#installing-uasyncio-on-bare-metal) for
 installation instructions.

TUTORIAL.md

@@ -22,22 +22,41 @@ features.
 
 # Installing uasyncio on bare metal
 
-As discussed in the [main README](./README.md) these instructions assume the
-official build of MicroPython firmware. Accordingly the `uasyncio` files from
-the [official library](https://github.com/micropython/micropython-lib) are
-required. At the time of writing the PyPI repository contains `uasyncio` V2.0
-which is incompatible with that fimware so `upip` cannot be used.
+MicroPython libraries are located on [PyPi](https://pypi.python.org/pypi).
+Libraries to be installed are:
+
+ * micropython-uasyncio
+ * micropython-uasyncio.queues
+ * micropython-uasyncio.synchro
+
+The `queues` and `synchro` modules are optional, but are required to run all
+the examples below.
+
+The oficial 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 direcory 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.
 
-The aim is to create a `uasyncio` directory on the device's filesystem
-containing the following files:
-
-[`__init__.py`](https://github.com/micropython/micropython-lib/blob/master/uasyncio/uasyncio/__init__.py)  
-[`core.py`](https://github.com/micropython/micropython-lib/blob/master/uasyncio.core/uasyncio/core.py)  
-[`queues.py`](https://github.com/micropython/micropython-lib/blob/master/uasyncio.queues/uasyncio/queues.py)  
-[`synchro.py`](https://github.com/micropython/micropython-lib/blob/master/uasyncio.synchro/uasyncio/synchro.py)
+```
+$ ./micropip.py install -p ~/syn micropython-uasyncio
+$ python3 -m micropip.py install -p ~/syn micropython-uasyncio
+```
 
-These modules may be frozen as bytecode in the usual way, by placing the above
-`uasyncio` directory in the port's `modules` directory and rebuilding.
+The `uasyncio` modules may be frozen as bytecode in the usual way, by placing
+the `uasyncio` directory in the port's `modules` directory and rebuilding.
 
 ###### [Main README](./README.md)
 
@@ -169,7 +188,8 @@ The following modules are provided which may be copied to the target hardware.
  generalisation of switches providing logical rather than physical status along
  with double-clicked and long pressed events.
  3. `asyncio_priority.py` An experimental version of uasyncio with a simple
- priority mechanism. See [this doc](./FASTPOLL.md).
+ priority mechanism. See [this doc](./FASTPOLL.md). Note that this does not yet
+ support `uasyncio` V2.0.
 
 **Demo Programs**
 

auart.py

@@ -3,10 +3,7 @@
 # Copyright Peter Hinch 2017 Released under the MIT license
 # Link X1 and X2 to test.
 
-try:
-    import asyncio_priority as asyncio
-except ImportError:
-    import uasyncio as asyncio
+import uasyncio as asyncio
 from pyb import UART
 uart = UART(4, 9600)
 

htu21d/README.md

@@ -3,12 +3,11 @@
 A breakout board is available from
 [Sparkfun](https://www.sparkfun.com/products/12064).
 
-This driver was derived from the Pyboard specific driver
+This driver was derived from the synchronous Pyboard-specific driver
 [here](https://github.com/manitou48/pyboard/blob/master/htu21d.py). It is
 designed to be multi-platform and uses `uasyncio` to achieve asynchronous (non-
-blocking) operation. In most applications temperature and humidity values vary
-slowly. The driver maintains its `temperature` and `humidity` bound variables
-as a non-blocking background task. Consequently reading the values is
+blocking) operation. The driver maintains `temperature` and `humidity` bound
+variables as a non-blocking background task. Consequently reading the values is
 effectively instantaneous.
 
 ###### [Main README](../README.md)
@@ -44,4 +43,8 @@ async def show_values():
         fstr = 'Temp {:5.1f} Humidity {:5.1f}'
         print(fstr.format(htu.temperature, htu.humidity))
         await asyncio.sleep(5)
-```
+```
+
+Thermal inertia of the chip packaging means that there is a lag between the
+occurrence of a temperature change and the availability of accurate readings.
+There is therefore little practical benefit in reducing the `read_delay`.

htu21d/htu_test.py

@@ -4,20 +4,23 @@
 # Copyright Peter Hinch 2018 Released under the MIT license
 
 import uasyncio as asyncio
+import sys
 from machine import Pin, I2C
 import htu21d_mc
 
-# Specify pullup: on my ESP32 board pullup resistors are not fitted :-(
-scl_pin = Pin(22, pull=Pin.PULL_UP, mode=Pin.OPEN_DRAIN)
-sda_pin = Pin(23, pull=Pin.PULL_UP, mode=Pin.OPEN_DRAIN)
-# Standard port
-i2c = I2C(-1, scl=scl_pin, sda=sda_pin)
+if sys.platform == 'pyboard':
+    i2c = I2C(1)  # scl=X9 sda=X10
+else:
+    # Specify pullup: on my ESP32 board pullup resistors are not fitted :-(
+    scl_pin = Pin(22, pull=Pin.PULL_UP, mode=Pin.OPEN_DRAIN)
+    sda_pin = Pin(23, pull=Pin.PULL_UP, mode=Pin.OPEN_DRAIN)
+    # Standard port
+    i2c = I2C(-1, scl=scl_pin, sda=sda_pin)
+    # Loboris port (soon this special treatment won't be needed).
+    # https://forum.micropython.org/viewtopic.php?f=18&t=3553&start=390
+    #i2c = I2C(scl=scl_pin, sda=sda_pin)
 
-# Loboris port (soon this special treatment won't be needed).
-# https://forum.micropython.org/viewtopic.php?f=18&t=3553&start=390
-#i2c = I2C(scl=scl_pin, sda=sda_pin)
-
-htu = htu21d_mc.HTU21D(i2c, read_delay=2)
+htu = htu21d_mc.HTU21D(i2c, read_delay=2)  # read_delay=2 for test purposes
 
 async def main():
     await htu