Added support for fast loading.

Added IR library https://github.com/peterhinch/micropython_ir
Updated axp202_adc_brightness.py
Updated mpconfigboard.h

Author: OPHoperHPO

Diff for: examples/ttgo/axp202_adc_brightness.py

@@ -69,7 +69,7 @@ def set_batt_per(per):
     update_task(None)
     lv.scr_load(scr)
     watch.tft.backlight_fade(100)
-    # lv.task_create(update_task, 1000, 5, None)
+    lv.task_create(update_task, 1000, 5, None)
 
 
 

Diff for: ports/esp32/boards/LILYGO_T_WATCH_2020_V1/modules/ir_rx/__init__.py

@@ -0,0 +1,70 @@
+# ir_rx __init__.py Decoder for IR remote control using synchronous code
+# IR_RX abstract base class for IR receivers.
+
+# Author: Peter Hinch
+# Copyright Peter Hinch 2020 Released under the MIT license
+
+from machine import Timer, Pin
+from array import array
+from utime import ticks_us
+
+# Save RAM
+# from micropython import alloc_emergency_exception_buf
+# alloc_emergency_exception_buf(100)
+
+
+# On 1st edge start a block timer. While the timer is running, record the time
+# of each edge. When the timer times out decode the data. Duration must exceed
+# the worst case block transmission time, but be less than the interval between
+# a block start and a repeat code start (~108ms depending on protocol)
+
+class IR_RX():
+    # Result/error codes
+    # Repeat button code
+    REPEAT = -1
+    # Error codes
+    BADSTART = -2
+    BADBLOCK = -3
+    BADREP = -4
+    OVERRUN = -5
+    BADDATA = -6
+    BADADDR = -7
+
+    def __init__(self, pin, nedges, tblock, callback, *args):  # Optional args for callback
+        self._pin = pin
+        self._nedges = nedges
+        self._tblock = tblock
+        self.callback = callback
+        self.args = args
+        self._errf = lambda _ : None
+        self.verbose = False
+
+        self._times = array('i',  (0 for _ in range(nedges + 1)))  # +1 for overrun
+        pin.irq(handler = self._cb_pin, trigger = (Pin.IRQ_FALLING | Pin.IRQ_RISING))
+        self.edge = 0
+        self.tim = Timer(-1)  # Sofware timer
+        self.cb = self.decode
+
+    # Pin interrupt. Save time of each edge for later decode.
+    def _cb_pin(self, line):
+        t = ticks_us()
+        # On overrun ignore pulses until software timer times out
+        if self.edge <= self._nedges:  # Allow 1 extra pulse to record overrun
+            if not self.edge:  # First edge received
+                self.tim.init(period=self._tblock , mode=Timer.ONE_SHOT, callback=self.cb)
+            self._times[self.edge] = t
+            self.edge += 1
+
+    def do_callback(self, cmd, addr, ext, thresh=0):
+        self.edge = 0
+        if cmd >= thresh:
+            self.callback(cmd, addr, ext, *self.args)
+        else:
+            self._errf(cmd)
+
+    def error_function(self, func):
+        self._errf = func
+
+    def close(self):
+        self._pin.irq(handler = None)
+        self.tim.deinit()

Diff for: ports/esp32/boards/LILYGO_T_WATCH_2020_V1/modules/ir_rx/acquire.py

@@ -0,0 +1,106 @@
+# acquire.py Acquire a pulse train from an IR remote
+# Supports NEC protocol.
+# For a remote using NEC see https://www.adafruit.com/products/389
+
+# Author: Peter Hinch
+# Copyright Peter Hinch 2020 Released under the MIT license
+
+from machine import Pin, freq
+from sys import platform
+
+from utime import sleep_ms, ticks_us, ticks_diff
+from ir_rx import IR_RX
+
+
+class IR_GET(IR_RX):
+    def __init__(self, pin, nedges=100, twait=100, display=True):
+        self.display = display
+        super().__init__(pin, nedges, twait, lambda *_ : None)
+        self.data = None
+
+    def decode(self, _):
+        def near(v, target):
+            return target * 0.8 < v < target * 1.2
+        lb = self.edge - 1  # Possible length of burst
+        if lb < 3:
+            return  # Noise
+        burst = []
+        for x in range(lb):
+            dt = ticks_diff(self._times[x + 1], self._times[x])
+            if x > 0 and dt > 10000:  # Reached gap between repeats
+                break
+            burst.append(dt)
+        lb = len(burst)  # Actual length
+        # Duration of pulse train 24892 for RC-5 22205 for RC-6
+        duration = ticks_diff(self._times[lb - 1], self._times[0])
+
+        if self.display:
+            for x, e in enumerate(burst):
+                print('{:03d} {:5d}'.format(x, e))
+            print()
+            # Attempt to determine protocol
+            ok = False  # Protocol not yet found
+            if near(burst[0], 9000) and lb == 67:
+                print('NEC')
+                ok = True
+
+            if not ok and near(burst[0], 2400) and near(burst[1], 600):  # Maybe Sony
+                try:
+                    nbits = {25:12, 31:15, 41:20}[lb]
+                except KeyError:
+                    pass
+                else:
+                    ok = True
+                    print('Sony {}bit'.format(nbits))
+
+            if not ok and near(burst[0], 889):  # Maybe RC-5
+                if near(duration, 24892) and near(max(burst), 1778):
+                    print('Philps RC-5')
+                    ok = True
+
+            if not ok and near(burst[0], 2666) and near(burst[1], 889):  # RC-6?
+                if near(duration, 22205) and near(burst[1], 889) and near(burst[2], 444):
+                    print('Philips RC-6 mode 0')
+                    ok = True
+
+            if not ok and near(burst[0], 2000) and near(burst[1], 1000):
+                if near(duration, 19000):
+                    print('Microsoft MCE edition protocol.')
+                    # Constant duration, variable burst length, presumably bi-phase
+                    print('Protocol start {} {} Burst length {} duration {}'.format(burst[0], burst[1], lb, duration))
+                    ok = True
+
+            if not ok and near(burst[0], 4500) and near(burst[1], 4500):  # Samsung?
+                print('Unsupported protocol. Samsung?')
+                ok = True
+
+            if not ok and near(burst[0], 3500) and near(burst[1], 1680):  # Panasonic?
+                print('Unsupported protocol. Panasonic?')
+                ok = True
+
+            if not ok:
+                print('Unknown protocol start {} {} Burst length {} duration {}'.format(burst[0], burst[1], lb, duration))
+
+            print()
+        self.data = burst
+        # Set up for new data burst. Run null callback
+        self.do_callback(0, 0, 0)
+
+    def acquire(self):
+        while self.data is None:
+            sleep_ms(5)
+        self.close()
+        return self.data
+
+def test():
+    # Define pin according to platform
+    if platform == 'pyboard':
+        pin = Pin('X3', Pin.IN)
+    elif platform == 'esp8266':
+        freq(160000000)
+        pin = Pin(13, Pin.IN)
+    elif platform == 'esp32' or platform == 'esp32_LoBo':
+        pin = Pin(23, Pin.IN)
+    irg = IR_GET(pin)
+    print('Waiting for IR data...')
+    return irg.acquire()

Diff for: ports/esp32/boards/LILYGO_T_WATCH_2020_V1/modules/ir_rx/mce.py

@@ -0,0 +1,68 @@
+# mce.py Decoder for IR remote control using synchronous code
+# Supports Microsoft MCE edition remote protocol.
+
+# Author: Peter Hinch
+# Copyright Peter Hinch 2020 Released under the MIT license
+
+# WARNING: This is experimental and subject to change.
+
+from utime import ticks_us, ticks_diff
+from ir_rx import IR_RX
+
+class MCE(IR_RX):
+    init_cs = 4  # http://www.hifi-remote.com/johnsfine/DecodeIR.html#OrtekMCE says 3
+    def __init__(self, pin, callback, *args):
+        # Block lasts ~19ms and has <= 34 edges
+        super().__init__(pin, 34, 25, callback, *args)
+
+    def decode(self, _):
+        def check(v):
+            if self.init_cs == -1:
+                return True
+            csum = v >> 12
+            cs = self.init_cs
+            for _ in range(12):
+                if v & 1:
+                    cs += 1
+                v >>= 1
+            return cs == csum
+
+        try:
+            t0 = ticks_diff(self._times[1], self._times[0])  # 2000μs mark
+            t1 = ticks_diff(self._times[2], self._times[1])  # 1000μs space
+            if not ((1800 < t0 < 2200) and (800 < t1 < 1200)):
+                raise RuntimeError(self.BADSTART)
+            nedges = self.edge  # No. of edges detected
+            if not 14 <= nedges <= 34:
+                raise RuntimeError(self.OVERRUN if nedges > 28 else self.BADSTART)
+            # Manchester decode
+            mask = 1
+            bit = 1
+            v = 0
+            x = 2
+            for _ in range(16):
+                # -1 convert count to index, -1 because we look ahead
+                if x > nedges - 2:
+                    raise RuntimeError(self.BADBLOCK)
+                # width is 500/1000 nominal
+                width = ticks_diff(self._times[x + 1], self._times[x])
+                if not 250 < width < 1350:
+                    self.verbose and print('Bad block 3 Width', width, 'x', x)
+                    raise RuntimeError(self.BADBLOCK)
+                short = int(width < 750)
+                bit ^= short ^ 1
+                v |= mask if bit else 0
+                mask <<= 1
+                x += 1 + short
+
+            self.verbose and print(bin(v))
+            if not check(v):
+                raise RuntimeError(self.BADDATA)
+            val = (v >> 6) & 0x3f
+            addr = v & 0xf  # Constant for all buttons on my remote
+            ctrl = (v >> 4) & 3
+
+        except RuntimeError as e:
+            val, addr, ctrl = e.args[0], 0, 0
+        # Set up for new data burst and run user callback/error function
+        self.do_callback(val, addr, ctrl)

Diff for: ports/esp32/boards/LILYGO_T_WATCH_2020_V1/modules/ir_rx/nec.py

@@ -0,0 +1,62 @@
+# nec.py Decoder for IR remote control using synchronous code
+# Supports NEC protocol.
+# For a remote using NEC see https://www.adafruit.com/products/389
+
+# Author: Peter Hinch
+# Copyright Peter Hinch 2020 Released under the MIT license
+
+from utime import ticks_us, ticks_diff
+from ir_rx import IR_RX
+
+class NEC_ABC(IR_RX):
+    def __init__(self, pin, extended, callback, *args):
+        # Block lasts <= 80ms (extended mode) and has 68 edges
+        super().__init__(pin, 68, 80, callback, *args)
+        self._extended = extended
+        self._addr = 0
+
+    def decode(self, _):
+        try:
+            if self.edge > 68:
+                raise RuntimeError(self.OVERRUN)
+            width = ticks_diff(self._times[1], self._times[0])
+            if width < 4000:  # 9ms leading mark for all valid data
+                raise RuntimeError(self.BADSTART)
+            width = ticks_diff(self._times[2], self._times[1])
+            if width > 3000:  # 4.5ms space for normal data
+                if self.edge < 68:  # Haven't received the correct number of edges
+                    raise RuntimeError(self.BADBLOCK)
+                # Time spaces only (marks are always 562.5µs)
+                # Space is 1.6875ms (1) or 562.5µs (0)
+                # Skip last bit which is always 1
+                val = 0
+                for edge in range(3, 68 - 2, 2):
+                    val >>= 1
+                    if ticks_diff(self._times[edge + 1], self._times[edge]) > 1120:
+                        val |= 0x80000000
+            elif width > 1700: # 2.5ms space for a repeat code. Should have exactly 4 edges.
+                raise RuntimeError(self.REPEAT if self.edge == 4 else self.BADREP)  # Treat REPEAT as error.
+            else:
+                raise RuntimeError(self.BADSTART)
+            addr = val & 0xff  # 8 bit addr
+            cmd = (val >> 16) & 0xff
+            if cmd != (val >> 24) ^ 0xff:
+                raise RuntimeError(self.BADDATA)
+            if addr != ((val >> 8) ^ 0xff) & 0xff:  # 8 bit addr doesn't match check
+                if not self._extended:
+                    raise RuntimeError(self.BADADDR)
+                addr |= val & 0xff00  # pass assumed 16 bit address to callback
+            self._addr = addr
+        except RuntimeError as e:
+            cmd = e.args[0]
+            addr = self._addr if cmd == self.REPEAT else 0  # REPEAT uses last address
+        # Set up for new data burst and run user callback
+        self.do_callback(cmd, addr, 0, self.REPEAT)
+
+class NEC_8(NEC_ABC):
+    def __init__(self, pin, callback, *args):
+        super().__init__(pin, False, callback, *args)
+
+class NEC_16(NEC_ABC):
+    def __init__(self, pin, callback, *args):
+        super().__init__(pin, True, callback, *args)