Add ILI9486 driver.

drivers/ili94xx/ili9486.py

@@ -0,0 +1,194 @@
+# ILI9486 nano-gui driver for ili9486 displays
+# As with all nano-gui displays, touch is not supported.
+
+# Copyright (c) Peter Hinch 2022
+# Released under the MIT license see LICENSE
+
+# Inspired by @brave-ulysses https://github.com/micropython/micropython/discussions/10404
+
+# Design note. I could not find a way to do landscape display at the chip level
+# without a nasty hack. Consequently this driver uses portrait mode at chip level,
+# with rotation performed in the driver.
+
+from time import sleep_ms
+import gc
+import framebuf
+import uasyncio as asyncio
+from drivers.boolpalette import BoolPalette
+
+# Portrait mode
+@micropython.viper
+def _lcopy(dest:ptr16, source:ptr8, lut:ptr16, length:int):
+    # rgb565 - 16bit/pixel
+    n = 0
+    for x in range(length):
+        c = source[x]
+        dest[n] = lut[c >> 4]  # current pixel
+        n += 1
+        dest[n] = lut[c & 0x0f]  # next pixel
+        n += 1
+
+# FB is in landscape mode, hence issue a column at a time to portrait mode hardware.
+@micropython.viper
+def _lscopy(dest:ptr16, source:ptr8, lut:ptr16, ch:int):
+    col = ch & 0x1ff  # Unpack (viper 4 parameter limit)
+    height = (ch >> 9) & 0x1ff
+    wbytes = ch >> 19  # Width in bytes is width // 2
+    # rgb565 - 16bit/pixel
+    n = 0
+    clsb = col & 1
+    idx = col >> 1  # 2 pixels per byte
+    for _ in range(height):
+        if clsb:
+            c = source[idx] & 0x0f
+        else:
+            c = source[idx] >> 4
+        dest[n] = lut[c]  # 16 bit transfer of rightmost 4-bit pixel
+        n += 1  # 16 bit
+        idx += wbytes
+
+
+class ILI9486(framebuf.FrameBuffer):
+
+    lut = bytearray(32)
+
+    # Convert r, g, b in range 0-255 to a 16 bit colour value
+    # LS byte goes into LUT offset 0, MS byte into offset 1
+    # Same mapping in linebuf so LS byte is shifted out 1st
+    # ILI9486 expects RGB order. 8 bit register writes require padding
+    @staticmethod
+    def rgb(r, g, b):
+        return (r & 0xf8) | (g & 0xe0) >> 5 | (g & 0x1c) << 11 | (b & 0xf8) << 5
+
+    # Transpose width & height for landscape mode
+    def __init__(self, spi, cs, dc, rst, height=320, width=480, usd=False, init_spi=False):
+        self._spi = spi
+        self._cs = cs
+        self._dc = dc
+        self._rst = rst
+        self.height = height  # Logical dimensions for GUIs
+        self.width = width
+        self._long = max(height, width)  # Physical dimensions of screen and aspect ratio
+        self._short = min(height, width)
+        self._spi_init = init_spi
+        pmode = framebuf.GS4_HMSB
+        self.palette = BoolPalette(pmode)
+        gc.collect()
+        buf = bytearray(height * width // 2)
+        self._mvb = memoryview(buf)
+        super().__init__(buf, width, height, pmode)  # Logical aspect ratio
+        self._linebuf = bytearray(self._short * 2)
+
+        # Hardware reset
+        self._rst(0)
+        sleep_ms(50)
+        self._rst(1)
+        sleep_ms(50)
+        if self._spi_init:  # A callback was passed
+            self._spi_init(spi)  # Bus may be shared
+        self._lock = asyncio.Lock()
+        # Send initialization commands
+
+        self._wcmd(b'\x01')  # SWRESET Software reset
+        sleep_ms(100)
+        self._wcmd(b'\x11') # sleep out
+        sleep_ms(20)
+        self._wcd(b'\x3a', b'\x55') # interface pixel format 
+        self._wcd(b'\x36', b'\x48' if usd else b'\x88')  # MADCTL: RGB portrait mode
+        self._wcmd(b'\x11') # sleep out
+        self._wcmd(b'\x29') # display on
+
+    # Write data.
+    def _wdata(self, data):
+        self._dc(1)
+        self._cs(0)
+        self._spi.write( data )
+        self._cs(1)
+
+    # Write a command.
+    def _wcmd(self, command):
+        self._dc(0)
+        self._cs(0)
+        self._spi.write( command )
+        self._cs(1)
+
+    # Write a command followed by a data arg.
+    def _wcd(self, command, data):
+        self._dc(0)
+        self._cs(0)
+        self._spi.write( command )
+        self._cs(1)
+        self._dc(1)
+        self._cs(0)
+        self._spi.write( data )
+        self._cs(1)
+
+    @micropython.native
+    def show(self):  # Physical display is in portrait mode
+        clut = ILI9486.lut
+        lb = self._linebuf
+        buf = self._mvb
+
+        if self._spi_init:  # A callback was passed
+            self._spi_init(self._spi)  # Bus may be shared
+        # Commands needed to start data write
+        self._wcd(b'\x2a', int.to_bytes(self._short -1, 4, 'big'))  # SET_COLUMN works 0 .. width
+        self._wcd(b'\x2b', int.to_bytes(self._long -1, 4, 'big'))  # SET_PAGE ht
+        self._wcmd(b'\x2c')  # WRITE_RAM
+        self._dc(1)
+        self._cs(0)
+        if self.width < self.height:  # Portrait 214ms on RP2 120MHz, 30MHz SPI clock
+            wd = self.width // 2
+            ht = self.height
+            for start in range(0, wd*ht, wd):  # For each line
+                _lcopy(lb, buf[start :], clut, wd)  # Copy and map colors
+                self._spi.write(lb)
+        else:  # Landscpe 264ms on RP2 120MHz, 30MHz SPI clock
+            cargs = (self.height << 9) + (self.width << 18)  # Viper 4-arg limit
+            for col in range(self.width -1, -1, -1):  # For each column of landscape display
+                _lscopy(lb, buf, clut, col + cargs)  # Copy and map colors
+                self._spi.write(lb)
+        self._cs(1)
+
+    async def do_refresh(self, split=4):
+        async with self._lock:
+            lines, mod = divmod(self._long, split)  # Lines per segment
+            if mod:
+                raise ValueError('Invalid do_refresh arg.')
+            clut = ILI9486.lut
+            lb = self._linebuf
+            buf = self._mvb
+            self._wcd(b'\x2a', int.to_bytes(self._short -1, 4, 'big'))  # SET_COLUMN works 0 .. width
+            self._wcd(b'\x2b', int.to_bytes(self._long -1, 4, 'big'))  # SET_PAGE ht
+            self._wcmd(b'\x2c')  # WRITE_RAM
+            self._dc(1)
+            if self.width < self.height:  # Portrait: write sets of rows
+                wd = self.width // 2
+                ht = self.height
+                line = 0
+                for _ in range(split):  # For each segment
+                    if self._spi_init:  # A callback was passed
+                        self._spi_init(self._spi)  # Bus may be shared
+                    self._cs(0)
+                    for start in range(wd * line, wd * (line + lines), wd):  # For each line
+                        _lcopy(lb, buf[start :], clut, wd)  # Copy and map colors
+                        self._spi.write(lb)
+                    line += lines
+                    self._cs(1)  # Allow other tasks to use bus
+                    await asyncio.sleep_ms(0)
+            else:  # Landscape: write sets of cols. lines is no. of cols per segment.
+                cargs = (self.height << 9) + (self.width << 18)  # Viper 4-arg limit
+                sc = self.width -1  # Start and end columns
+                ec = sc - lines  # End column
+                for _ in range(split):  # For each segment
+                    if self._spi_init:  # A callback was passed
+                        self._spi_init(self._spi)  # Bus may be shared
+                    self._cs(0)
+                    for col in range(sc, ec, -1):  # For each column of landscape display
+                        _lscopy(lb, buf, clut, col + cargs)  # Copy and map colors
+                        self._spi.write(lb)
+                    sc -= lines
+                    ec -= lines
+                    self._cs(1)  # Allow other tasks to use bus
+                    await asyncio.sleep_ms(0)
+

setup_examples/ili9486_pico.py

@@ -0,0 +1,29 @@
+# ili9486_pico.py Customise for your hardware config
+
+# Released under the MIT License (MIT). See LICENSE.
+
+# ILI9486 on Pi Pico
+# See DRIVERS.md for wiring details.
+
+from machine import Pin, SPI, freq
+import gc
+
+from drivers.ili94xx.ili9486 import ILI9486 as SSD
+freq(250_000_000)  # RP2 overclock
+
+pdc = Pin(17, Pin.OUT, value=0)
+pcs = Pin(14, Pin.OUT, value=1)
+prst = Pin(7, Pin.OUT, value=1)
+spi = SPI(0, sck=Pin(6), mosi=Pin(3), miso=Pin(4), baudrate=30_000_000)
+gc.collect()  # Precaution before instantiating framebuf
+ssd = SSD(spi, pcs, pdc, prst)
+gc.collect()
+from gui.core.ugui import Display
+# Create and export a Display instance
+# Define control buttons
+nxt = Pin(19, Pin.IN, Pin.PULL_UP)  # Move to next control
+sel = Pin(16, Pin.IN, Pin.PULL_UP)  # Operate current control
+prev = Pin(18, Pin.IN, Pin.PULL_UP)  # Move to previous control
+increase = Pin(20, Pin.IN, Pin.PULL_UP)  # Increase control's value
+decrease = Pin(21, Pin.IN, Pin.PULL_UP)  # Decrease control's value
+display = Display(ssd, nxt, sel, prev, increase, decrease)  # Pushbutton control