Want to create a capacitance proximity/touch sensor with a RP2040 Pico board using PIO

We all have to start somewhere and the usual place to start is with a "hello world" type example. This sets the platform to build upon and for me it is right at the very bottom... hence here is my take (from an Arduino c++ perspective) on the hello_pio example found on GitHub: https://github.com/raspberrypi/pico-examples/tree/master/pio/hello_pio

Now I am looking at this very basic example and wondering, which comes first (the chicken or the egg?)... namely the PIO routine or the sketch. It's not immediately obvious. Maybe others can give guidance here.

Anyhow, I thought to start with the PIO file.

Here I see we need to give our instruction set a name

Then it looks like we need to "pull" in some data for the PIO to use, that is, load a 32-bit word from the TX FIFO into the Output Shift Register (OSR).

Then it looks like we need to do something and in this case as it is using this "out" command this means (according to the documentation) we will be shifting bits out of the Output Shift Register (OSR), and writing those bits to a Destination (and in this case I think the destination is "pins") and the value 1 is related to PINDIRS which determines whether that pin is input or output. Then it seems that we return back to the start as defined by the name "loop" and wait for the next "pull".

And this is where I get stumped. The PIO code seems to include an initialisation function. It is hard to determine if this is standard, as in the same function can be used for any example, or it is example specific.

% c-sdk {
static inline void hello_program_init(PIO pio, uint sm, uint offset, uint pin) {
    pio_sm_config c = hello_program_get_default_config(offset);

    // Map the state machine's OUT pin group to one pin, namely the `pin`
    // parameter to this function.
    sm_config_set_out_pins(&c, pin, 1);
    // Set this pin's GPIO function (connect PIO to the pad)
    pio_gpio_init(pio, pin);
    // Set the pin direction to output at the PIO
    pio_sm_set_consecutive_pindirs(pio, sm, pin, 1, true);

    // Load our configuration, and jump to the start of the program
    pio_sm_init(pio, sm, offset, &c);
    // Set the state machine running
    pio_sm_set_enabled(pio, sm, true);
}
%}

Then we get to the application code itself. Even though I don't fully understand the PIO side fully, it was pretty easy to convert the c code for Arduino. I even added a few mods myself:

#include "hardware/pio.h"
#include "hardware/clocks.h"

#include "blink.pio.h"

#define PICO_DEFAULT_LED_PIN    12

// Choose which PIO instance to use (there are two instances)
PIO pio = pio0;

// Find a free state machine on our chosen PIO (erroring if there are
// none). Configure it to run our program, and start it, using the
// helper function we included in our .pio file.
unsigned int sm = 0;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  while(!Serial) {;;}

  Serial.println("\r\nPIO Hello World Blink Example");
    
  // Our assembled program needs to be loaded into this PIO's instruction
  // memory. This SDK function will find a location (offset) in the
  // instruction memory where there is enough space for our program. We need
  // to remember this location!
  unsigned int offset = pio_add_program(pio, &hello_program);
  Serial.println("Assembled program loaded into memory with offset set at "+String(offset));
  
  sm = pio_claim_unused_sm(pio, true);    // An error will be generated if none available
  
  Serial.println("State machine "+String(sm)+ " was claimed for our chosen PIO");
  
  hello_program_init(pio, sm, offset, PICO_DEFAULT_LED_PIN);
  Serial.println("Hello World Blink PIO instance now initialised");
  
}

void loop() {
  // The state machine is now running. Any value we push to its TX FIFO will
  // appear on the LED pin.
  // Blink
  pio_sm_put_blocking(pio, sm, 1);
  sleep_ms(500);
  // Blonk
  pio_sm_put_blocking(pio, sm, 0);
  sleep_ms(500);
  // Blink
  pio_sm_put_blocking(pio, sm, 1);
  sleep_ms(1500);
  // Blonk
  pio_sm_put_blocking(pio, sm, 0);
  sleep_ms(500);
}

Of course, I learnt through other element14 posts that you have to convert your PIO code and a simple way to do this is use this online tool: https://wokwi.com/tools/pioasm

Once done you can compile and upload your code.

Of course one example does not give all the answers or offer up a solution suited for my design to create a capacitive sensor.

As such I moved onto the pio_blink example. This PIO code is considerably more complicated using jmp, mov and set commands as well as a .wrap directive. Thankfully "pull block" is intuitive enough in that the block parameter means it will block until some data has been received as compared to the noblock parameter or not using a parameter at all.

I get a sense this is going to take awhile...

I just came across this author who has shared a number of PIO examples with fairly detailed comments and explanations

https://github.com/GitJer/Some_RPI-Pico_stuff/blob/main/HCSR04/HCSR04.pio   

Not exactly the same problem, but similar ideas I think

I just came across this author who has shared a number of PIO examples with fairly detailed comments and explanations

https://github.com/GitJer/Some_RPI-Pico_stuff/blob/main/HCSR04/HCSR04.pio   

Not exactly the same problem, but similar ideas I think

Oh wow thanks. Good find. What's really really helpful here is that each line is explained through comment.

PS. I wondered why the PIO code looked familiar. It's the same PIO code that comes from the Arduino NanoConnectHcSr04 library, which I had used in my own project: /challenges-projects/project14/7segmentdisplay/b/blog/posts/raspberry-pi-pico-multicore-demo-using-ultrasonic-ranger-and-4-digit-7-segment-display

As mentioned in my original comment, I can readily use these examples but it's trickier to understand the mechanics.