Round displays using GC9A01 controller

[peterhinch]

These are now supported by nano-gui, also micro-gui. The CST816S touch controller is commonly used with these displays. Such hardware is also supported by micropython-touch.

For anyone thinking of using these, logically they are 240x240 displays but only those pixels in the circular region are visible. The display driver is written in Python and uses 4 bit pixels with a color lookup table to conserve RAM. It may readily be adapted for an 8 or 16 bit frame buffer.

[mcauser]

Nice work!
It's a shame most of these display are write-only.
Could have used those offscreen pixels for extra data storage, like a weird secret eeprom.

[samneggs]

I’ve really enjoyed working with this display. At one time the non visible portions bothered me so I created some assembly to ignore these areas using left and right circular edge buffers in lookup tables. It only added a few instructions per pixel but it was still faster to just write every pixel.

[peterhinch]

A couple of observations. I plan to release an 8-bit version of the driver to allow a bigger range of colors to be visible on a single screen - the penalty being a 57,600 byte frame buffer.

Secondly it's worth noting that the GC9A01 is a pig with numerous undocumented registers. My driver is based on a C driver from Russ Hughes. I contacted him for guidance on the undocumented registers - his source was driver code from a display manufacturer. So we're none the wiser about the purpose of these registers.

I'm familiar with poorly documented argument values assigned by display manufacturers, but undocumented registers are new to me and repulsive.

I'm hoping someone here knows better and can point me to a decent datasheet!

[samneggs]

@peterhinch your post inspired me to go back to my ILI9488 display. Working with a partial frame buffer for the 480x320 display was lacking.
I hacked together a 1-bit frame buffer with no intermediate buffer and no impact to frame rate. Here is the core code from the display class that writes directly to the SPI FIFO register:

    @staticmethod
    @micropython.asm_thumb
    def _spi_write_asm(r0,r1): # r0 buffer address
        mov(r5,r1)        # r5 = color
        align(4)          # align pc to read 4 byte word
        mov(r7,pc)
        b(LOAD_REGS)
        data(2,0x0,0x4004, 0x4b00,0x0)
        align(2)          # align for 2 byte instructions
        label(LOAD_REGS)
        ldr(r4,[r7,4])    # r4 = length (480W * 320H) // 8 bits (0x4b00)
        ldr(r1,[r7,0])    # r1 = SPI1_BASE  = 0x40040000
        label(MAIN_LOOP)
        mov(r2,0)         # r2 = byte position
        ldrb(r7,[r0,0])   # r7 = byte pixel data
        lsl(r7,r7,24)     # move to top of word
        label(BYTE_LOOP)
        mov(r6,0x0)       # set color to BLACK
        lsl(r7,r7,1)      # shift data to overflow
        bcc(NO_PIXEL)     # no bit in overflow
        mov(r6,r5)
        label(NO_PIXEL)
        mov(r3,0xff)
        and_(r3,r6)
        str(r3,[r1,0x8])  # write high color word to FIFO
        mov(r3,0b10)       
        str(r3,[r1,0x4])  # enable
        bl(SPI_WAIT)      # check FIFO status
        lsr(r3,r6,8)
        str(r3,[r1,0x8])  # write low color word to FIFO
        mov(r3,0b10)       
        str(r3,[r1,0x4])  # enable
        bl(SPI_WAIT)      # check FIFO status          
        add(r2,1)
        cmp(r2,8)
        blt(BYTE_LOOP)    #    
        add(r0,1)
        sub(r4,1)
        bne(MAIN_LOOP)
        b(EXIT)
        label(SPI_WAIT)   # wait sub
        push({r3,r5,lr})
        label(WAIT_LOOP)
        ldr(r3,[r1,0xc])  # get FIFO status
        mov(r5,0b10)      # is it full?
        and_(r3,r5)
        cmp(r3,r5)
        bne(WAIT_LOOP)    # loop till empty
        pop({r3,r5,pc})
        label(EXIT)

Seems crazy having 195k free memory with a big display. I may also do one for 4-bit frame buffer.

[samneggs]

Here is the 4-bit version. Looks like I lost two frames per second. May get them back if I unroll those subs.

    @micropython.asm_thumb
    def _spi_write_4bit(r0,r1): # r0 buffer address
        mov(r5,r1)        # r5 = color array address
        align(4)          # align pc to read 4 byte word
        mov(r7,pc)
        b(LOAD_REGS)
        data(2,0x0,0x4004, 0x2c00,0x0001)
        align(2)          # align for 2 byte instructions
        label(LOAD_REGS)
        ldr(r4,[r7,4])    # r4 = length (480W * 320H) // 2  (0x0001_2c00)
        ldr(r1,[r7,0])    # r1 = SPI1_BASE  = 0x40040000
        label(MAIN_LOOP)       
        ldrb(r2,[r0,0])   # r2 = 2 pixels colors
        lsr(r6,r2,4)      # move to low byte
        add(r6,r6,r6)     # double for ldrh
        add(r6,r6,r5)     # index of color array
        ldrh(r6,[r6,0])   # r6 = color word
        bl(WRITE_COLOR)   # first pixel color  
        mov(r3,0x0f)      # low nibble mask 
        and_(r3,r2)       # mask it
        add(r3,r3,r3)     # double for ldrh
        add(r6,r3,r5)     # index of color array
        ldrh(r6,[r6,0])   # r6 = color word
        bl(WRITE_COLOR)   # second pixel color 
        add(r0,1)
        sub(r4,1)
        bne(MAIN_LOOP)
        b(EXIT)        
        label(WRITE_COLOR) # r6 = color word ------------------------
        push({lr})
        mov(r3,0xff)
        and_(r3,r6)
        str(r3,[r1,0x8])  # write low color word to FIFO
        mov(r3,0b10)       
        str(r3,[r1,0x4])  # enable
        bl(SPI_WAIT)      # check FIFO status
        lsr(r3,r6,8)
        str(r3,[r1,0x8])  # write high color word to FIFO
        mov(r3,0b10)       
        str(r3,[r1,0x4])  # enable
        bl(SPI_WAIT)      # check FIFO status
        pop({pc})       
        label(SPI_WAIT)   # wait sub--------------------------------
        push({r3,r5,lr})
        label(WAIT_LOOP)
        ldr(r3,[r1,0xc])  # get FIFO status
        mov(r5,0b10)      # is it full?
        and_(r3,r5)
        cmp(r3,r5)
        bne(WAIT_LOOP)    # loop till empty
        pop({r3,r5,pc})
        label(EXIT)