Featured Articles
Announcing Pi
Technical Specifications
Raspberry Pi FAQs
Win a Pi
GPIO Pinout
Raspberry Pi Wishlist
Comparison Chart
Quiz
Group Actions
Engagement
  • Author Author: Jan Cumps
  • Date Created: Date Created
  • Views 732 views
  • Likes 8 likes
  • Comments 7 comments
Related
Recommended

OO Library to handle Pico PIO relative interrupts: intro

Jan Cumps

Object Oriented library to design C++ classes that support PIO interrupts.
Goal: make a PIO state machine call the very C++ object that's managing (or watching) it.

When I designed a Pico library to manage stepper motors with the PIO co-controllers, I created a utility to handle PIO relative interrupts.
My design was object oriented, and I used objects to handle the PIO state machine for each stepper motor. One of the things I got working then, was to call the right stepper object when a PIO interrupt occurred for its particular PIO state machine. The PIO APIs aren't very OO friendly, and require bridging mechanisms to translate raw interrupts into something that's delegating duties to objects. Here is the documentation of that exercise: Handle Raspberry Pico PIO "relative interrupts" in C++ 

This is functionality that is useful in many OO PIO designs. I developed it specifically for stepper motors. In this series, I try to make it generic. Usable for any OO designer that wants to react on PIO notifications.

A PIO relative interrupt is an interrupt that contains info of the PIO controller and the state machine that generated the interrupt.

This will be an evolving series. I'm going to make it as flexible as reasonable, for an embedded system. Initially, I'll try to support objects that can be executed. (in C++ language, that means that they overload the () operator).

Watch this thread while I'm trying to transform a project specific construct into a reusable library ...

sneak preview:

/*
PIO interrupts can only call functions without parameters. They can't call object members.
This static embedded class delegates interrupts to the relevant object.
The objects have to implement the () operation.
*/

// guard that E has to support () operator.
template <std::invocable E, uint32_t interrupt_number> class pio_irq {

How to use the library, with example:  OO Library to handle Pico PIO relative interrupts: usage and example 

  • in reply to Jan Cumps

    ... and - to be embedded savvy - no heap allocation. If you are concerned about dynamic memory use: the library doesn't allocate any dynamic memory at runtime. Its API will use stack - as any C function call does. But no new(), ...

    It uses 1 array of fixed size*. The size is either 8 (Pico) or 12 (Pico2) memory pointers. Really not a lot.

    *If you use more than one handler class (not object), or if your PIO state machine throws more than 1 distinct relative interrupt and you want to handle all of them, you have to count that array size per combination. Still very little data. You'd have a hard time to make it require half a kilobyte of static data.

    • There is some code that needs to be executed at the start of the program, to enable the interrupt and register the handler. This is something you would have to do when using C too.
    • No runtime cost. It doesn't run anything in the background.
    • When an interrupt fires, it has to decide what object to execute. This logic isn't more expensive than what you 'd have to do in a C program, to understand what state machine fired what interrupt, and what to do with it ...

  • All 12 available PIO state machines on a Pico2 having all their PIO relative interrupts managed by their own object:

    image

    This is captured on a RISCV core. It works the same on the ARMs

  • Early results:

    image

    The mechanism works. A single class with 2 public methods supports the mechanism.

    image

    One to tell that we're interested in managing an interrupt. The other to register the object that will handle the interrupt.

    The screen capture shows a minimal handler, that just prints a message and counts how many times it's been invoked. 
    The only requirement for a handler class is that it has line 15. All other implementation parts are for demo use.