RPI Pico (RS2040) PIO supprt?

[linfan68]

I'm planning on a small side project that needs to use the PIO (Programmable IO) function of the RPI Pico. What's the status of PIO support? I found the .pio file used for the RGB LED, but not sure if it's been used, and there is no example as far as I can tell.

[phoddie]

There's no JavaScript API around the PIO support. As you noted, PIO can be in the native implementations (such as Neopixel). Given the nature of PIO. I'm not entirely clear on how it would be meaningful exposed in a JavaScript API. It is an interesting direction. Do you have some idea of what that might look like?

[linfan68]

I made some progress on this project. Basically I got a Pico board running Moddable, and added a module (pins/pio) which calling the PIO functions from C SDK. Right now I'm not manipulating PIO functions from JS code, instead I implemented my logic inside the module.

However, after getting familiar with PIO, I think a pure JS API is very feasible, let's look at the C code I have now:

  // Prepare Program
  uint _pc = 0;
  uint _wrapStart;
  uint _wrapEnd;
  uint16_t _program_instructions[32];
  _wrapStart = _pc;

  _program_instructions[_pc++] = pio_encode_mov_not(pio_isr, pio_null);
  _program_instructions[_pc++] = pio_encode_in(pio_pins, modPio->setup.in_count);
  _program_instructions[_pc++] = pio_encode_mov_not(pio_x, pio_isr) | pio_encode_delay(10);
  _program_instructions[_pc++] = pio_encode_jmp_not_x(_pc + 3);
  _program_instructions[_pc++] = pio_encode_set(pio_pins, 0x0);
  _program_instructions[_pc++] = pio_encode_jmp(_wrapStart);
  _program_instructions[_pc++] = pio_encode_set(pio_pins, 0x1);
  _wrapEnd = _pc - 1;

  struct pio_program _program;
  _program.instructions = _program_instructions;
  _program.length = _pc;
  _program.origin = -1;
  PRINT_PROGRAM()
  

  // Setup program
  uint offset = pio_add_program(pio, &_program);
  modPio->programOffset = offset;
  sm_config_set_wrap(c, offset + _wrapStart, offset + _wrapEnd);

  pio_sm_init(pio, sm, offset, c);
  pio_sm_set_enabled(pio, sm, true);

I think all the pio_sm_ functions could be a direct mapping to the C SDK, the tricky part is how to prepare the PIO program (the _program_instructions).

But in my code above I've demonstrated how to construct a program without any external tools. The above code only using pio_encode* functions provided by the C SDK. Those functions are actually very simple, as we can see, they're just encoding instructions (mov, in, jmp, set...) and parameters into a 16-bit number, which can be easily implemented on the JS side.

Or we can just forward all the pio_encode* functions too (notice the parameters like pio_isr, pio_pins are all constants).

After the construction, just passing a uint_16 array, plus two numbers (_wrapStart and _wrapEnd, indicating the start and end of the program loop) to the C side should be sufficient to set the PIO program.

I was trying to implement the module as described above; however, I'm hesitating due to:

1. I'm in a hurry to prototyping my project ...
2. PIO is tricky to use and extremely hard to debug... Adding another layer of forwarding make things worse... people won't be able to copy and paste the C examples.
3. Maybe a better approach is what I'm doing now, which is keeping the logic in C side. We can provide few examples to demonstrate how to port a PIO example from pico sdk to Moddable.
4. There is a better way even we decided composing the PIO instructions from JS side. They are some very tricky rules on writing those instructions, like the pio_encode_delay() alone is not a valid instruction, it needs to be ORed with another instruction.
   If we decided to do the composition on JS side, we can write an "instruction builder" and adding some TypeScript typing rules on it, so that the TS compiler will help enforce only valid instructions can be composed.

[phoddie]

Really interesting stuff.

Generating the PIO program from JavaScript definitely looks possible. I like the idea of an "instruction builder" that can help prevent errors and perhaps perform validation. It could also be organized so that it isn't necessary to statically declare the length of the instructions, for example using the new resizable array buffer (which lets you make resizable TypedArrays).

PIO is tricky to use and extremely hard to debug

That's for certain.

Maybe a better approach is what I'm doing now, which is keeping the logic in C side. We can provide few examples to demonstrate how to port a PIO example from pico sdk to Moddable.

It is more direct. I mean... PIO is an assembly language. There are many JavaScript developers who aren't comfortable working in C, so they are also unlikely to be comfortable working in assembly language. But, for developers who can work in both JavaScript and PIO, it would be very powerful.

FWIW – @mkellner did some great work to support PIO in Moddable SDK 4.2 (released today!). It allows a project manifest to reference PIO programs to build. The Moddable SDK uses that in three places now. Perhaps that can be a starting point for an examples.

[linfan68]

I think the PIO support added on version 4.2 should be the official answer (although I haven't tried it yet).

[phoddie]

Cool. Please give it a try when you can. It is always helpful to have independent confirmation.