iotest4.py added.

Author: peterhinch

DRIVERS.md

@@ -168,11 +168,14 @@ Constructor arguments (defaults in brackets):
  1. `func` The **function** to call on timeout (default `None`).
  2. `args` A tuple of arguments for the **function** (default `()`).
  3. `can_alloc` Boolean, default `True`. See below.
+ 4. `duration` Integer, default 1000ms. The default timer period where no value
+ is passed to the `trigger` method.
 
 Methods:
 
- 1. `trigger` mandatory argument `duration`. A timeout will occur after
- `duration` ms unless retriggered.
+ 1. `trigger` optional argument `duration=0`. A timeout will occur after
+ `duration` ms unless retriggered. If no arg is passed the period will be that
+ of the `duration` passed to the constructor.
  2. `stop` No argument. Cancels the timeout, setting the `running` status
  `False`. The timer can be restarted by issuing `trigger` again.
  3. `running` No argument. Returns the running status of the object.

aswitch.py

@@ -38,10 +38,11 @@
 
 
 class Delay_ms(object):
-    def __init__(self, func=None, args=(), can_alloc=True):
+    def __init__(self, func=None, args=(), can_alloc=True, duration=1000):
         self.func = func
         self.args = args
         self.can_alloc = can_alloc
+        self.duration = duration  # Default duration
         self.tstop = None  # Not running
         self.loop = asyncio.get_event_loop()
         if not can_alloc:
@@ -57,8 +58,10 @@ async def _run(self):
     def stop(self):
         self.tstop = None
 
-    def trigger(self, duration):  # Update end time
-        if self.can_alloc and self.tstop is None:
+    def trigger(self, duration=0):  # Update end time
+        if duration <= 0:
+            duration = self.duration
+        if self.can_alloc and self.tstop is None:  # No killer task is running
             self.tstop = time.ticks_add(time.ticks_ms(), duration)
             # Start a task which stops the delay after its period has elapsed
             self.loop.create_task(self.killer())

gps/as_GPS.py

@@ -94,6 +94,7 @@ def __init__(self, sreader, local_offset=0, fix_cb=lambda *_ : None, cb_mask=RMC
         self._fix_cb = fix_cb
         self.cb_mask = cb_mask
         self._fix_cb_args = fix_cb_args
+        self.battery = False  # Assume no backup battery
 
         # CPython compatibility. Import utime or time for fix time handling.
         try:
@@ -307,11 +308,15 @@ def _set_date_time(self, utc_string, date_string):
     def _gprmc(self, gps_segments):  # Parse RMC sentence
         self._valid &= ~RMC
         # Check Receiver Data Valid Flag ('A' active)
-        if gps_segments[2] != 'A':
-            raise ValueError
+        if not self.battery:
+            if gps_segments[2] != 'A':
+                raise ValueError
 
         # UTC Timestamp and date. Can raise ValueError.
         self._set_date_time(gps_segments[1], gps_segments[9])
+        # Check Receiver Data Valid Flag ('A' active)
+        if gps_segments[2] != 'A':
+            raise ValueError
 
         # Data from Receiver is Valid/Has Fix. Longitude / Latitude
         # Can raise ValueError.

gps/as_tGPS.py

@@ -79,6 +79,8 @@ def _isr(self, _):
         msecs += self._update_ms
         if msecs >= 86400000:  # Next PPS will deal with rollover
             return
+        if self.t_ms == msecs:  # No RMC message has arrived: nothing to do
+            return
         self.t_ms = msecs  # Current time in ms past midnight
         self.acquired = acquired
         # Set RTC if required and if last RMC indicated a 1 second boundary

iotest4.py

@@ -0,0 +1,112 @@
+# iotest4.py Test PR #3836. Demonstrate the anomaly with a read/write device.
+# User class write() performs unbuffered writing.
+# For simplicity this uses buffered read: unbuffered is tested by iotest2.py.
+
+# Run iotest4.test() to see expected output
+# iotest4.test(False) to demonstrate the issue.
+
+# Pass/Fail is determined by whether the StreamReader and StreamWriter operate
+# on the same (fail) or different (pass) objects.
+# I suspect that the issue is with select/ipoll (uasyncio __init__.py)
+# The fault is either in select/poll or uasyncio __init__.py.
+# As soon as PollEventLoop.add_writer() is called, reading stops.
+# PollEventLoop.add_writer() is called when StreamWriter.awrite() issues
+# yield IOWrite(self.s), which for unbuffered devices is after the 1st char
+# of a multi-char buf is written.
+
+import io, pyb
+import uasyncio as asyncio
+import micropython
+micropython.alloc_emergency_exception_buf(100)
+
+MP_STREAM_POLL_RD = const(1)
+MP_STREAM_POLL_WR = const(4)
+MP_STREAM_POLL = const(3)
+MP_STREAM_ERROR = const(-1)
+
+def printbuf(this_io):
+    print(this_io.wbuf[:this_io.wprint_len])
+
+class MyIO(io.IOBase):
+    def __init__(self, read=False, write=False):
+        if read:
+            self.ready_rd = False
+            self.rbuf = b'ready\n'  # Read buffer
+            pyb.Timer(4, freq = 1, callback = self.do_input)
+        if write:
+            self.wbuf = bytearray(100)  # Write buffer
+            self.wprint_len = 0
+            self.widx = 0
+            self.wch = b''
+            pyb.Timer(5, freq = 10, callback = self.do_output)
+
+    # Read callback: emulate asynchronous input from hardware.
+    # Typically would put bytes into a ring buffer and set .ready_rd.
+    def do_input(self, t):
+        self.ready_rd = True  # Data is ready to read
+
+    # Write timer callback. Emulate hardware: if there's data in the buffer
+    # write some or all of it
+    def do_output(self, t):
+        if self.wch:
+            self.wbuf[self.widx] = self.wch
+            self.widx += 1
+            if self.wch == ord('\n'):
+                self.wprint_len = self.widx  # Save for schedule
+                micropython.schedule(printbuf, self)
+                self.widx = 0
+        self.wch = b''
+
+
+    def ioctl(self, req, arg):  # see ports/stm32/uart.c
+        ret = MP_STREAM_ERROR
+        if req == MP_STREAM_POLL:
+            ret = 0
+            if arg & MP_STREAM_POLL_RD:
+                if self.ready_rd:
+                    ret |= MP_STREAM_POLL_RD
+            if arg & MP_STREAM_POLL_WR:
+                if not self.wch:
+                    ret |= MP_STREAM_POLL_WR  # Ready if no char pending
+        return ret
+
+    # Emulate a device with buffered read. Return the buffer, falsify read ready
+    # Read timer sets ready.
+    def readline(self):
+        self.ready_rd = False
+        return self.rbuf
+
+    # Emulate unbuffered hardware which writes one character: uasyncio waits
+    # until hardware is ready for the next. Hardware ready is emulated by write
+    # timer callback.
+    def write(self, buf, off, sz):
+        self.wch = buf[off]  # Hardware starts to write a char
+        return 1  # 1 byte written. uasyncio waits on ioctl write ready
+
+async def receiver(myior):
+    sreader = asyncio.StreamReader(myior)
+    while True:
+        res = await sreader.readline()
+        print('Received', res)
+
+async def sender(myiow):
+    swriter = asyncio.StreamWriter(myiow, {})
+    await asyncio.sleep(5)
+    count = 0
+    while True:
+        count += 1
+        tosend = 'Wrote Hello MyIO {}\n'.format(count)
+        await swriter.awrite(tosend.encode('UTF8'))
+        await asyncio.sleep(2)
+
+def test(good=True):
+    if good:
+        myior = MyIO(read=True)
+        myiow = MyIO(write=True)
+    else:
+        myior = MyIO(read=True, write=True)
+        myiow = myior
+    loop = asyncio.get_event_loop()
+    loop.create_task(receiver(myior))
+    loop.create_task(sender(myiow))
+    loop.run_forever()