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 1334 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 

  • C++ has a mechanism to enforce that a class has to provide particular operations. This allows to only accept classes and objects that can do a particular thing, without the need for a base class. And without inheritance.

    In the lib that I'm writing, it's expected that the objects you pass to it for interrupt handling, can actually be executed. They need to provide the () operator.

    C++ has concepts. Guards that you can use to investigate capabilities at compile time. There are standard ones, and you can define your own checks.

    In this case, I'm lucky, because there is a standard concept to check if a template type can be executed: std::invocable. If I set that as a requirement for a template parameter, the code will not compile if you use the template class with a type that doesn't have the () operator:

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

    This is a help to the user of the library. They get a clear message that they are using the library with objects that aren't fit to handle the interrupts.

    image

    The nice thing is that E can actually be a simple function pointer. Doesn't need to be a class with () operator.

    Another nice thing is that the runtime cost is zero.

  • Looking forward to this! And it's becoming more relevant since number of PIO are increasing in each RPxxxx chip generation it seems. It will remove a bit of the 'wild west' when it comes to developing with them, when there are decent libraries to help with these common tasks.