Link C Based .mpy file to Pico SDK

[AshbyGeek]

I'm trying to do some PWM audio with the Pi Pico, all the examples I've found do this through the C SDK and some of the functions required aren't available through micropython (In particular, they use the PWM IRQ with a callback to process the next sample). I really want to be able to use python though because I have still need to write the MQTT interface for managing the sound clip being played and don't want to have to do that through C.

So it looks like I have two options:

1. Compile the firmware from source and include my own module that will play my sounds.
2. Write my C code as a .mpy native module that MicroPython can import for me

I like option number 2 because that way I can continue to use off-the-shelf firmware. Less future upgrade headache for me. So I tried to implement that, even though there's basically no examples that interface this with the pi pico C sdk. I hit a snag though, when I tried to link my compiled code to objects from the Pico SDK (after I compiled it) I got a LinkError:

LinkError: .../pico-sdk/src/rp2_common/hardware_sync/sync.c.obj: .data.striped_spin_lock_num non-empty"`

I found the file in question and sure enough theres a line at the top that is not allowed by the .mpy linker:

static uint8_t striped_spin_lock_num = PICO_SPINLOCK_ID_STRIPED_FIRST;

My question is this: am I doing this wrong or does this limitation honestly prevent me from referencing large parts of the Pico C SDK from a native .mpy module?

More details about my .mpy module compilation process in case it becomes pertinent to the question:

The example native modules all use a very simple Makefile, but I couldn't figure out how to get all the proper include and linker options set up with the makefile as written, so I got my code compiling (and tested) using the straight C sdk.

For the record, my C code used https://github.com/rgrosset/pico-pwm-audio as a starting point. I need to be able to output the same audio sample to multiple devices, with the option to turn any single off, and I wanted to make it more of a library so my code has diverged significantly from his. You can follow his instructions for setup, and then I added main.c:

#include <stdio.h>
#include "pico-pwm-audio.h"

#include "thats_cool.h"

int main(void) {
    SetWavData(WAV_DATA, WAV_DATA_LENGTH);
    Init_pwm();

    EnableWav1(true);

    sleep_ms(500);
    EnableWav2(true);

    sleep_ms(500);
    EnableWav2(false);

    while (true)
    {
        sleep_ms(500); // Wait for Interrupt
    }
}

and pico-pwm-audio.h:

#ifndef PICO_PWM_AUDIO
#define PICO_PWM_AUDIO

#include "pico/stdlib.h"   // stdlib 

uint SetPin(uint gpio, bool enable, uint position);

void Init_pwm();

void EnableWav1(bool enable);

void EnableWav2(bool enable);

void SetWavData(uint8_t* data, uint data_length);

#endif

and modified pico-pwm-audio.c:

#include "pico-pwm-audio.h"

#include "hardware/irq.h"  // interrupts
#include "hardware/pwm.h"  // pwm 
#include "hardware/sync.h" // wait for interrupt 

 
// Audio PIN is to match some of the design guide shields. 
#define AUDIO_PIN 15  // you can change this to whatever you like

#define AUDIO_PIN_2 13

/* 
 * This include brings in static arrays which contain audio samples. 
 * if you want to know how to make these please see the python code
 * for converting audio samples into static arrays. 
 */
uint wav_position;
uint wav2_position;

bool wav_enable;
bool wav2_enable;

struct WavData{
    uint32_t Length;
    uint8_t* Data;
} WavData;

uint SetPin(uint gpio, bool enable, uint position) {
    if (position > (WavData.Length<<3)) { 
        // reset to start
        position = 0;
    }

    pwm_set_gpio_level(gpio, WavData.Data[position>>3]);  
    position++;

    return position;
}

/*
 * PWM Interrupt Handler which outputs PWM level and advances the 
 * current sample. 
 * 
 * We repeat the same value for 8 cycles this means sample rate etc
 * adjust by factor of 8   (this is what bitshifting <<3 is doing)
 * 
 */
void pwm_interrupt_handler() {
    pwm_clear_irq(pwm_gpio_to_slice_num(AUDIO_PIN));    

    if (wav_enable){
        wav_position = SetPin(AUDIO_PIN, wav_enable, wav_position);
    }

    if (wav2_enable){
        wav2_position = SetPin(AUDIO_PIN_2, wav2_enable, wav2_position);
    }
}

void Init_pwm() {
    /* Overclocking for fun but then also so the system clock is a 
     * multiple of typical audio sampling rates.
     */
    stdio_init_all();
    set_sys_clock_khz(176000, true); 
    gpio_set_function(AUDIO_PIN, GPIO_FUNC_PWM);
    gpio_set_function(AUDIO_PIN_2, GPIO_FUNC_PWM);

    int audio_pin_slice = pwm_gpio_to_slice_num(AUDIO_PIN);
    int audio_pin_slice_2 = pwm_gpio_to_slice_num(AUDIO_PIN_2);

    // Setup PWM interrupt to fire when PWM cycle is complete
    pwm_clear_irq(audio_pin_slice);
    pwm_set_irq_enabled(audio_pin_slice, true);

    // set the handle function above
    irq_set_exclusive_handler(PWM_IRQ_WRAP, pwm_interrupt_handler); 
    irq_set_enabled(PWM_IRQ_WRAP, true);

    // Setup PWM for audio output
    pwm_config config = pwm_get_default_config();

    /* Base clock 176,000,000 Hz divide by wrap 250 then the clock divider further divides
     * to set the interrupt rate. 
     * 
     * 11 KHz is fine for speech. Phone lines generally sample at 8 KHz
     * 
     * 
     * So clkdiv should be as follows for given sample rate
     *  8.0f for 11 KHz
     *  4.0f for 22 KHz
     *  2.0f for 44 KHz etc
     */
    pwm_config_set_clkdiv(&config, 8.0f); 
    pwm_config_set_wrap(&config, 250); 
    pwm_init(audio_pin_slice, &config, true);
    pwm_init(audio_pin_slice_2, &config, true);

    pwm_set_gpio_level(AUDIO_PIN, 0);
    pwm_set_gpio_level(AUDIO_PIN_2, 0);

    wav_position = 0;
    wav2_position = WavData.Length / 2;

    wav_enable = false;
    wav2_enable = false;
}

void EnableWav1(bool enable){
    wav_enable = enable;
}

void EnableWav2(bool enable){
    wav2_enable = enable;
}

void SetWavData(uint8_t* data, uint data_length){
    WavData.Data = data;
    WavData.Length = data_length;
}

Once that was compiling I borrowed .config.h file from native module example and tried to manually run the mpy_ld.py script on it:

python3 $PICO_SDK/tools/mpy_ld.py --arch armv6m --qstrs build/pico-pwm-audio.config.h -o build/pico-pwm-audio.native.mpy build/main.o pico-pwm-audio.c.obj

which failed with

LinkError: pico-pwm-audio.c.obj: undefined symbol: stdio_init_all

because it needs to link against the various referenced Pi Pico SDK objects.

So I dug into the CMake cache and found the link.txt file for pico-pwm-audio.c and grabbed the list of files it links against so I could feed them to mpy_ld.py which failed with

LinkError: .../lots-of-pathing/.../pico-sdk/src/rp2_common/hardware_sync/sync.c.obj: .data.striped_spin_lock_num non-empty

[andrewleech]

Unfortunately dynamic native modules can't link against / reuse any C libraries like Pico SDK directly because every time a firmware is built they'll likely be in sightly different places in flash.

The dynamic modules can only use functions exposed in dynruntime because micropython builds and exposes a lookup table the module can use to access the functions.

I've made a dynamic C module for stm that uses stm SDK (HAL) functions by compiling and linking the Hal C files directly during the native module build. This works fine for me, basically meaning my module has its own copy of the functions, not reusing the copy in micropython.

[AshbyGeek]

Aha, that makes sense. I've spent the better part of the past couple days figuring out how to implement option 1 and in so doing I have learned a lot about how python integrates with C and how the pico sdk actually talks to the hardware.

Thanks for the response! I'm probably going to keep working on option 1 for now because that clearly has fewer limitations and since this is my first rodeo with C/Python interop I expect I'll run into more hurdles.