Controlling the RGB LED on pico display

The pico display pack is a small LCD with four buttons and an RGB LED. The LED can be controlled using PWM for which the Raspberry Pi Pico has hardward support.

For this attempt I’m trying to combine a few things:

Not use include files
Use look-up tables
Call functions

Rome wasn’t built in a day…

Some constants from the datasheet:

        .syntax unified
        .cpu cortex-m0plus

        .equ    IO_BANK0_GPIO6_CTRL_OFFSET, 0x34
        .equ    IO_BANK0_GPIO7_CTRL_OFFSET, 0x3c
        .equ    IO_BANK0_GPIO8_CTRL_OFFSET, 0x44

        .equ    IO_BANK0_GPIO6_CTRL_FUNCSEL_VALUE_PWM_A_3, 0x4
        .equ    IO_BANK0_GPIO7_CTRL_FUNCSEL_VALUE_PWM_B_3, 0x4
        .equ    IO_BANK0_GPIO8_CTRL_FUNCSEL_VALUE_PWM_A_4, 0x4

        .equ    CH3_CSR, 0x3c
        .equ    CH3_DIV, 0x40
        .equ    CH3_CTR, 0x44
        .equ    CH3_CC, 0x48
        .equ    CH3_TOP, 0x4c
        .equ    CH4_CSR, 0x50
        .equ    CH4_DIV, 0x54
        .equ    CH4_CTR, 0x58
        .equ    CH4_CC, 0x5c
        .equ    CH4_TOP, 0x60

Some standard preamble. I’m using the easiest option here, so the C runtime calls main instead of finding a way to get rid of everything and just have “pure” assembly.

Starting off with setting the function. The GPIO numbers are taken from the Pimoroni product page, but I did cheat a bit because it wasn’t working at first - I checked the SDK and realised that GPIO number is not the same as pin number…

        .section text.startup,"ax"
        .align 2

        .global main

        .code   16
        .thumb_func
        .type   main, %function
main:
        @ The function we want here is PWM, which is F4
        ldr     r4, io_bank0_base
        movs    r1, #IO_BANK0_GPIO6_CTRL_FUNCSEL_VALUE_PWM_A_3
        str     r1, [r4, #IO_BANK0_GPIO6_CTRL_OFFSET]
        movs    r1, #IO_BANK0_GPIO7_CTRL_FUNCSEL_VALUE_PWM_B_3
        str     r1, [r4, #IO_BANK0_GPIO7_CTRL_OFFSET]
        movs    r1, #IO_BANK0_GPIO8_CTRL_FUNCSEL_VALUE_PWM_A_4
        str     r1, [r4, #IO_BANK0_GPIO8_CTRL_OFFSET]

For the LED, I’m passing R, G, B components in three different registers. It’s not very efficient, but there will plenty of time to work on efficiency. For now I’m just trying to get things to work.

I’ve written a few functions to avoid repeating myself, so set_rgb sets the colours. PWM uses a threshold and the colours are the thresholds.

enable_led simply enables the PWM machinery. More details below.

        @ Start with 0 for all channels (3 A/B, 4 A)
        movs    r0, #0
        movs    r1, #0
        movs    r2, #0
        bl      set_rgb         @ set the colours before we
        bl      enable_led      @ enable the LED

Trying to use index-based look-up. So r4 is the index into the colour array. But r4 is just a byte offset, not an index.

        movs    r4, #0

The program is just one big loop. In each iteration we first get the colour from the table, and set the LED. I’m doing something a bit more involved, starting with 0 and adding a “colour value” until it gets to the maximum value. For example, if I want to get to 0xff0000 (red), I start with 0 and add 0x020000 127 times (yes, it gets to 0xfe but that’s good enough).

main_loop:
        adr     r5, colours
        ldr     r5, [r5, r4]            @ r5 is the value to add/subtract
        movs    r6, #0                  @ r6 is the accumulator

The reason I’m loading r5 is that I’m out of registers for some reason. Still need to understand what’s going on with “high” and “low” registers, but for now it’s good enough.

Two loops, one to go up (to the full colour) and one to go down (back to zero). In each loop I simply count to 127. I could do all kinds of tricks to avoid the explicit counter, but I just don’t want to.

The code is pretty straight-forward.

        movs    r7, #0x7f
up_loop:
        movs    r0, r6
        bl      expand
        bl      set_rgb
        bl      delay

        add     r6, r6, r5              @ increase
        subs    r7, r7, #1
        bne     up_loop

        movs    r7, #0x7f
down_loop:
        movs    r0, r6
        bl      expand
        bl      set_rgb
        bl      delay

        subs    r6, r6, r5              @ decrease
        subs    r7, r7, #1
        bne     down_loop

Last but not least - update the byte offset (add 4, not 1 because that casues the program to crash).

        adds    r4, r4, #4      @ increment colour index
        cmp     r4, #48         @ was that the last one?
        bne     main_loop       @ no, continue

        movs    r4, #0          @ from the start
        b main_loop

Enabling the PWM channels. We also need to invert the outputs, I don’t know why but that’s what the SDK does.

        .code   16
        .thumb_func
enable_led:
        ldr     r0, pwm_base
        movs    r1, #13                 @ enable the PWM channel, invert outputs A and B
        str     r1, [r0, #CH3_CSR]
        movs    r1, #5                  @ enable the PWM channel, invert output A
        str     r1, [r0, #CH4_CSR]

        bx      lr

Set the LED values. I’m also squaring the values (so 0 to 255 becomes 0 to 65052 but that’s fine). The SDK calls it “gamma” so we’ll go with that.

@ r0 = red
@ r1 = green
@ r2 = blue
        .code   16
        .thumb_func
set_rgb:
        ldr     r3, pwm_base

        @ red and green
        muls    r0, r0, r0              @ square r0 for gamma
        muls    r1, r1, r1              @ square r1 for gamma
        lsls    r1, #16
        adds    r0, r0, r1
        str     r0, [r3, #CH3_CC]
        @ blue
        muls    r2, r2, r2              @ square r2 for gamma
        str     r2, [r3, #CH4_CC]

        bx      lr

This extracts the R, G and B componet from a single word that holds all three. To be honest, set_rgb could have done that, but that’s OK.

@ r0 is the input, expected to contain three bytes (rgb)
@ output:
@ r0 contains the red component
@ r1 contains the green component
@ r2 contains the blue component
        .code   16
        .thumb_func
expand:
        movs    r3, #255        @ mask
        movs    r2, r0          @ r2 = r0 & 0xff
        ands    r2, r3
        movs    r1, r0          @ r1 = (r0 >> 8) & 0xff
        lsrs    r1, #8
        ands    r1, r3
        lsrs    r0, #16         @ r0 = r0 >> 16
        bx      lr

And for the delay, I’m just counting to 131072 (or rather from 131072 downwards). Later on I’ll try to use the actual hardware timers.

        .code   16
        .thumb_func
delay:
        movs    r0, #1
        lsls    r0, #17
delay_loop:
        subs    r0, r0, #1
        bne     delay_loop

        bx      lr

Some more constants. I don’t think I can just use equ because I can’t load a 32 bit value into a register. Instead I’m using ldr with an address.

        .align 2
io_bank0_base:
        .word   0x40014000
pwm_base:
        .word   0x40050000

And the colours (12 colours):

colours:
        .word   0x00020000
        .word   0x00020100
        .word   0x00020200
        .word   0x00010200
        .word   0x00000200
        .word   0x00000201
        .word   0x00000202
        .word   0x00000102
        .word   0x00000002
        .word   0x00010002
        .word   0x00020002
        .word   0x00020001

I’m happy with the result, it’s not very sophisticated, but it works and I’ve learnt a few things along the way.