Prior to improving error handling.

Author: peterhinch

TUTORIAL.md

@@ -1078,6 +1078,11 @@ The mechanism works because the device driver (written in C) implements the
 following methods: `ioctl`, `read`, `write`, `readline` and `close`. See
 section 5.3 for further discussion.
 
+Applications using the UART should be designed such that all coros minimise
+blocking periods. This is because blocking while the UART is receiving data can
+lead to buffer overflows with consequent loss of data. This can be ameliorated
+by using a larger UART read buffer length or a lower baudrate.
+
 ### 5.1.1 A UART driver example
 
 The program `auart_hd.py` illustrates a method of communicating with a half

gps/README.md

@@ -398,6 +398,12 @@ and subsequent characters are stripped from the last. Thus if the string
 was received `reparse` would see  
 `['GPGGA','123519','4807.038','N','01131.000','E','1','08','0.9','545.4','M','46.9','M','','']`
 
+## 2.6 Public class variable
+
+ * `FULL_CHECK` Default `True`. If set `False` disables CRC checking and other
+ basic checks on received sentences. This is intended for use at high baudrates
+ where the time consumed by these checks can be excessive.
+
 # 3. The GPS class read-write driver
 
 This is a subclass of `AS_GPS` and supports all its public methods, coroutines
@@ -538,9 +544,10 @@ Under investigation.                                                          **
 
 Further, there are problems (at least with my GPS firmware build
 ['AXN_2.31_3339_13101700', '5632', 'PA6H', '1.0']) whereby setting baudrates
-only works for certain rates. 19200, 38400 and 115200 work. 4800 sets 115200.
-Importantly 9600 does nothing. This means that the only way to restore the
-default is to perform a `FULL_COLD_START`. The test programs do this.
+only works for certain rates. 19200, 38400, 57600 and 115200 work. 4800
+sets 115200. Importantly 9600 does nothing. This means that the only way to
+restore the default is to perform a `FULL_COLD_START`. The test programs do
+this.
 
 If you change the GPS baudrate the UART should be re-initialised immediately
 after the `baudrate` coroutine terminates:

gps/as_GPS.py

@@ -171,20 +171,21 @@ def __init__(self, sreader, local_offset=0, fix_cb=lambda *_ : None, cb_mask=RMC
         self._valid = 0  # Bitfield of received sentences
         if sreader is not None:  # Running with UART data
             loop = asyncio.get_event_loop()
-            loop.create_task(self._run())
+            loop.create_task(self._run(loop))
 
     ##########################################
     # Data Stream Handler Functions
     ##########################################
 
-    async def _run(self):
+    async def _run(self, loop):
         while True:
             res = await self._sreader.readline()
             try:
                 res = res.decode('utf8')
             except UnicodeError:  # Garbage: can happen e.g. on baudrate change
                 continue
-            self._update(res)
+            loop.create_task(self._update(res))
+            await asyncio.sleep_ms(0)  # Ensure task runs and res is copied
 
     # Update takes a line of text
     def _update(self, line):
@@ -195,21 +196,26 @@ def _update(self, line):
                 return None  # Bad character received
             except StopIteration:
                 pass  # All good
-
+            await asyncio.sleep_ms(0)
             if len(line) > self._SENTENCE_LIMIT or not '*' in line:
                 return None  # Too long or malformed
 
         a = line.split(',')
         segs = a[:-1] + a[-1].split('*')
+        await asyncio.sleep_ms(0)
+
         if self.FULL_CHECK:  # 6ms on Pyboard
             if not self._crc_check(line, segs[-1]):
                 self.crc_fails += 1  # Update statistics
                 return None
+            await asyncio.sleep_ms(0)
+
         self.clean_sentences += 1  # Sentence is good but unparsed.
         segs[0] = segs[0][1:]  # discard $
         segs = segs[:-1]  # and checksum
         if segs[0] in self.supported_sentences:
-            s_type = self.supported_sentences[segs[0]](segs)
+            s_type = self.supported_sentences[segs[0]](segs)  # Parse
+            await asyncio.sleep_ms(0)
             if isinstance(s_type, int) and (s_type & self.cb_mask):
                 # Successfully parsed, data was valid and mask matches sentence type
                 self._fix_cb(self, s_type, *self._fix_cb_args)  # Run the callback

gps/as_GPS_time.py

@@ -105,10 +105,17 @@ def time(minutes=1):
     loop.run_until_complete(do_time(minutes))
 
 # ******** Measure accracy of μs clock ********
+# At 9600 baud see occasional lag of up to 3ms followed by similar lead.
+# This implies that the ISR is being disabled for that period (~3 chars).
+# SD 584μs typical.
+# Test produces better numbers at 57600 baud (SD 112μs)
+# and better still at 10Hz update rate (SD 34μs). Why??
+# Unsure why. Setting of .FULL_CHECK has no effect (as expected).
+
 # Callback occurs in interrupt context
 us_acquired = None
 def us_cb(my_gps, tick, led):
-    global us_acquired
+    global us_acquired  # Time of previous PPS edge in ticks_us()
     if us_acquired is not None:
         # Trigger event. Pass time between PPS measured by utime.ticks_us()
         tick.set(utime.ticks_diff(my_gps.acquired, us_acquired))

gps/as_rwGPS_time.py

@@ -29,9 +29,9 @@
 
 # Avoid multiple baudrates. Tests use 9600 or 115200 only.
 # *** Baudrate over 19200 causes messages not to be received ***
-BAUDRATE = 19200
-UPDATE_INTERVAL = 200 # 100
-READ_BUF_LEN = 1000 # test
+BAUDRATE = 57600
+UPDATE_INTERVAL = 100
+READ_BUF_LEN = 200 # test
 print('Available tests:')
 print('calibrate(minutes=5) Set and calibrate the RTC.')
 print('drift(minutes=5) Repeatedly print the difference between RTC and GPS time.')
@@ -58,7 +58,7 @@ async def shutdown():
     #gps.close()  # Stop ISR
     #print('Restoring default 1s update rate.')
     #await asyncio.sleep(0.5)
-    #await gps.update_interval(1000)  # 1s update rate **** DO WE NEED TO SET END EVENT? *****
+    #await gps.update_interval(1000)  # 1s update rate 
     #print('Restoring satellite data.')
     #await gps.command(as_rwGPS.DEFAULT_SENTENCES)  # Restore satellite data
 
@@ -73,6 +73,7 @@ async def setup():
     gps = as_tGPS.GPS_RWTimer(sreader, swriter, pps_pin, local_offset=1,
                              fix_cb=lambda *_: red.toggle(),
                              pps_cb=lambda *_: blue.toggle())
+    gps.FULL_CHECK = False
     await asyncio.sleep(2)
     await gps.baudrate(BAUDRATE)
     uart.init(BAUDRATE)
@@ -164,8 +165,12 @@ def time(minutes=1):
         loop.run_until_complete(shutdown())
 
 # ******** Measure accracy of μs clock ********
+# Test produces better numbers at 57600 baud (SD 112μs)
+# and better still at 10Hz update rate (SD 34μs).
+# Unsure why.
+
 # Callback occurs in interrupt context
-us_acquired = None
+us_acquired = None  # Time of previous PPS edge in ticks_us()
 def us_cb(my_gps, tick, led):
     global us_acquired
     if us_acquired is not None:
@@ -185,12 +190,15 @@ async def us_setup(tick):
     gps = as_tGPS.GPS_RWTimer(sreader, swriter, pps_pin, local_offset=1,
                              fix_cb=lambda *_: red.toggle(),
                              pps_cb=us_cb, pps_cb_args=(tick, blue))
+    gps.FULL_CHECK = False
     await asyncio.sleep(2)
     await gps.baudrate(BAUDRATE)
     uart.init(BAUDRATE)
     await asyncio.sleep(1)
     await gps.enable(gsa=0, gsv=0)  # Disable satellite data
     await gps.update_interval(UPDATE_INTERVAL)
+    pstr = 'Baudrate {} update interval {}ms satellite messages disabled.'
+    print(pstr.format(BAUDRATE, UPDATE_INTERVAL))
 
 async def do_usec(minutes):
     global gps