Forum - Recent Threads

GitHub: automate Raspberry Pico project build verification with GitHub Actions

Jan Cumps — Mon, 15 Jul 2024 09:44:56 GMT

Moved to GitHub: automate Raspberry Pico project build verification with GitHub Actions

You can Make GitHub build your project. I'm using an Action to check out branches and build them, when a pull request is submitted.
I adapted an existing flow from the Raspberry organisation. Here's what it does

check out the branch that's the source for the pull request
check out Pico-SDK, the current development branch
install CMake
install the arm bare metal GNU toolchain
build the SDK
build the project
react on pull request creation on the main and develop branch.
make successful compilation a mandatory check for the pull request.

If the build fails, the pull request fails. That's what I try to achieve in this exercise:

developers can check in non-working in feature branches.
once ready to ask merging with one of the two protected branches (develop or main), code should meet quality requirements and should build.
That's the moment that you deem your work done, and should be ready for a code review.
If your code breaks the build at this point, you impact others - and maybe the production release. It's a fail.
Code reviewers don't have to spend time validating non-funcioning code.

The script I'm using is based on the Raspberrry MacOS build for Pico. I adapted it for Linux.

Script source of build.yml:

name: Build on ubuntu against pico-sdk develop
on:
  workflow_dispatch:
  #push:
  #  branches:
  #    - 'develop'
  #    - 'main'
  pull_request:
    types: [opened, reopened]
    branches:
      - 'develop'
      - 'main'

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
    
      - name: Clean workspace
        run: |
          echo "Cleaning up previous run"
          rm -rf "${{ github.workspace }}"
          mkdir -p "${{ github.workspace }}"
      - name: Checkout pico_gps_teseo_i2c
        uses: actions/checkout@v4
        with:
          path: pico_gps_teseo_i2c

      - name: Checkout pico-sdk/develop
        uses: actions/checkout@v4
        with:
          repository: raspberrypi/pico-sdk
          ref: develop
          path: pico-sdk

      - name: Checkout pico-sdk submodules
      
        working-directory: ${{github.workspace}}/pico-sdk
        run: git submodule update --init
      - name: Install dependencies
        run: |
          sudo apt-get install cmake
          #curl -Lo gcc-arm-none-eabi.tar.bz2 "https://developer.arm.com/-/media/Files/downloads/gnu-rm/10.3-2021.10/gcc-arm-none-eabi-10.3-2021.10-x86_64-linux.tar.bz2?rev=78196d3461ba4c9089a67b5f33edf82a&hash=5631ACEF1F8F237389F14B41566964EC"
          #sudo mkdir /opt/gcc-arm-none-eabi
          #sudo tar xf gcc-arm-none-eabi.tar.bz2 --strip-components=1 -C /opt/gcc-arm-none-eabi
          #echo 'export PATH=$PATH:/opt/gcc-arm-none-eabi/bin' | sudo tee -a /etc/profile.d/gcc-arm-none-eabi.sh
          #export PATH=$PATH:/opt/gcc-arm-none-eabi/bin
          #export PICO_TOOLCHAIN_PATH=/opt/gcc-arm-none-eabi/bin
          #source /etc/profile
          #arm-none-eabi-gcc --version
          sudo apt install gcc-arm-none-eabi
          
      - name: Build Project

Excuses for the formatting. The code editor does not want to accept this code. Click on this link for a better view.

When you create this script in the .github/workflows folder, it 'll kick off each time a pull rrequest is opened for main or develop. But it will not impact the pull request.
If you want to make pull requests dependent on successful build, you 'll also hav to create a ruleset for the branch.

On your repository's web page on GitHub, select settings -> Rules -> Rulesets.
If the branch(es) you want to protect don't have a ruleset yet, create one. Else you can update the existing one.

The first checkbox will take care that the branches you want to protect, can only accept commits via a pull request. When you work together as a team, it's good that branch owners can check code before it's merged in the code base.
The second check also adds the condition, that the build job must complete in good order.

A developer that submits a pull request, gets this page:

They don't have to wait for this to complete. They 'd get an email if it failed. Once the job is completed, the reviewer sees the screen capture I posted at the start of this blog. If the job was successful, code review and merge can happen.

How does it fit in my workflow:

I created another action earlier: GitHub: automate project documentation with DoxyGen, and publish online after pushing commits . Together, the 2 automate a decent part of code management:

the build validation described here, when a pull request is made to development or main
when a pull request to main is accepted and merged by the branch manager (me :) ), the doucmentation is regenerated and published to github.io.

Future improvements:

I'm considering to let the job create a project release, when a new Version TAG is created in the repository. I'd have to make these changes:

add trigger on TAG creation event. Filter on tags that start with 'v'.
change the build type from Debug to Release
use a GitHub Action to create a release in the repository, and upload the .uf2 file as asset to that release.

Link to all posts.

C++ and templates: callbacks that return a value, or a void

Jan Cumps — Fri, 21 Jun 2024 16:38:59 GMT

In C(++), a function can return a value. Or a void.
A function with a return value ends with return X;.
A function that returns void, has a last line return;. Without value. (and you don't have to write that return;, but that doesn't matter in this discussion)
When using templates, this needs consideration, if you allow the return type to be "templated" and you want to support void as one of the options for a return value of a member.

A void function (named a procedure in a lot of programming languages) is different than a function that returns something. Internally and conceptually.
internally: the return value is a position on the stack. void functions don't have that position.
conceptually: ignoring the internally difference, and returning something in a void() function anyways, breaks the C(++) language. Also not returning a value (of the correct type) in a function that does require a return value, fails to compile.

I wrote a templated class that can call a callback. And I wanted it to support returning numbers / bools.
The thing is: when no callback function is set, the class had to work too. It has to return a value in that case .So I wrote this code:

	inline R call(Args... args) {
		if (_callback == nullptr) {
			return 0; // R can only be a arithmetic type. 0 should work as default.
		}
		return (*_callback)(args...);
	}

This works great for boolean, integer, float return values. But it you want to support callbacks that don't have a return value, it will fail.
If R is type void, the compilation will not allow return 0;. And if R is a number, compilation will not allow return;.

solution: constant expressions

In C++ , we can write constant expressions. A condition that's checked at compile time. If it's true, the containing block will be compiled. If it's false, not.
A bit related to the C style #ifdef , but context aware. A constant expression knows the code it's acting upon (including parameter types). These constant expressions understand C++ source code.
What they have in common with defines: they both are static: they resolve everything during compilation. They have no runtime cost.

I use this construct to have different behaviour if the return type of my callback function is void, and when it's an arithmetic (number) type:

	/*
	 * R can either be an arithmetic type, or void
	 */
	inline R call(Args... args) {
		if constexpr (std::is_void<R>::value) {
			if (_callback == nullptr) {
				return;
			}
			(*_callback)(args...);
		}

		if constexpr (! std::is_void<R>::value) {
			if (_callback == nullptr) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			}
			return (*_callback)(args...);
		}
	}

You can see that when my templated code is configured for a callback function that returns a bool or a number, it 'll use the lower part, and always return a value.
When the template is configured for a void() type of callback (a procedure), it just returns, without a return value.

This compiles, runs, is type safe and has no runtime impact. if constexpr gets resolved when you build the code. If your code doesn't have void() callbacks, the top part doesn't get compiled. If it doesn't have callbacks that expect a return value, the bottom part doesn't get compiled.

Check my set of test cases below, to see how this works:

#include <cstdio>
#include "callbackmanager.h"
#include <string>

class MyClass {
public:
	inline int handler(const int& num1, const int& num2) const {
          return num1 + num2;
      }
      static inline int staticHandler(const int& num1, const int& num2) {
          return num1 + num2;
      }
};

int functionHandler(const int& num1, const int& num2) {
    return num1 + num2;
}

int main() {

    int a = 4;
    int b = 5;

	{ // scenario: call object method
    MyClass myClass;

    Callback<int, const int&, const int&> cb;
    // Use a lambda to capture myClass and call the object method
    cb.set([&myClass](const int& num1, const int& num2) -> int {
        return myClass.handler(num1, num2);
    });

    int o = cb.call(a, b);
    printf("Value: %i\n", o);
	fflush(stdout);
	}

	{ // scenario: call static method
    Callback<int, const int&, const int&> cb;
    // Use a lambda to call the static method
    cb.set([](const int& num1, const int& num2) -> int {
        return MyClass::staticHandler(num1, num2);
    });

    int o = cb.call(a, b);
    printf("Value: %i\n", o);
	fflush(stdout);
	}

	{ // scenario: call C function
    Callback<int, const int&, const int&> cb;
    // Use a lambda to call the classic C function
    cb.set([](const int& num1, const int& num2) -> int {
        return functionHandler(num1, num2);
    });

    int o = cb.call(a, b);
    printf("Value: %i\n", o);
	fflush(stdout);
	}

	{ // scenario: call pure lambda
    Callback<int, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> int {
        return num1 + num2;
    });

    int o  = cb.call(a, b);
    printf("Value: %i\n", o);
	fflush(stdout);
	}

	{ // scenario: return a bool
    Callback<bool, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> bool {
        return num1 == num2;
    });

    printf("Value: %s\n", cb.call(a, b) ? "true" : "false");
	fflush(stdout);
	}

	{ // scenario: use a callback that returns void
    Callback<void, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) {
        printf("void gets num1: %i, num2: %i\n", num1, num2);
    	fflush(stdout);
        return;
    });
    cb.call(a, b);
	}

	{ // scenario: use a callback that returns void, and has no attributes
    Callback<void> cb;
    // Use a lambda to execute anonymous C code
    cb.set([]() {
        printf("void with no parameters\n");
    	fflush(stdout);
        return;
    });
    cb.call();
	}

	/*
	{ // scenario: use an unsupported (non-fundamental) type for return value R
	  // this will generate a compile error
    Callback<std::string, const int&, const int&> cb;
	}
*/

}

a constexpr knows "everything" about your code. When you use it in a template class, it will know for what types your project will use that template class. Then it 'll take care that it 'll only send that part of the code to the compiler, that is needed for your project.

For classes like the one that I'm writing, this is great. My class has no clue how it 'll be used. But I provide logic for a set of scenarios that I want to support.
C++ constructs like constexpr will take care that this flexibility has no cost when executing the code. All code gets checked at compilation, and needs to pass the strict C++ type checks. But at no cost for the final firmware.

C++ and templates: restrict what types can be used in a template

Jan Cumps — Mon, 17 Jun 2024 15:33:54 GMT

When you use templates in C++, the user can normally plug any C type in a program. For a template class I developed (read C++ callbacks and templates ), I want to restrict one of the template arguments: R. This is the type of the return value of a callback function. The restriction that I want to impose, is that the function should not return an object, array, string, ... . Numeric and bool types should do. Or return nothing (void).

I want to be able to return a 0 if no function is set in _callback. So as long as the return value is a C++ arithmetic types, I'll be good. My mechanism will fail if a developer wants to use functions that return strings, arrays, objects, ...
I think that being able to return any arithmetic type is flexible enough for a generic callback handler.

template <typename R, typename... Args>
// restrict to arithmetic data types for return value, or void
  requires std::is_void<R>::value || std::is_arithmetic_v<R>
class Callback {

// ...

	/*
	 * R can either be an arithmetic type, or void
	 */
	inline R call(Args... args) {
		if constexpr (std::is_void<R>::value) {
			if (_callback == nullptr) {
				return;
			}
			(*_callback)(args...);
		}

		if constexpr (! std::is_void<R>::value) {
			if (_callback == nullptr) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			}
			return (*_callback)(args...);
		}
	}

// ...

I could do nothing. In that case the developer would get a compilation error on this line in my code: return 0;. And they 'll have to go and investigate why my code throws an error.

C++ now has a mechanism that's called concept. With that, I can restrict the C++ type that a particular template attribute can have. I will use that to only allow arithmetic types for the return value type R.
When doing that, the compiler will give a clear message, pointing to the user's code line where they defined an invalid return type:

78 | Callback<std::string, const int&, const int&> cb; error: template constraint failure for 'template<class R, class ... Args> requires std::is_arithmetic<_Tp>::value class Callback'
note: constraints not satisfied

Thank you for reading. Check C++ and templates: callbacks that return a value, or a void for yet another dive into hip C++...

C++ callbacks and templates: make the Callback class call an object member, a static member, a C function and a pure lambda function

Jan Cumps — Sun, 16 Jun 2024 10:25:57 GMT

I developed a templated C++ callback manager: C++ callbacks and templates . I claimed that it can call back

a classic C function,
a lambda,
a static class method or
an object method,

and it supports these return types:

void
bool
number
objects (if the class has a default constructor and "is returnable".

But in that first post, I only showed an example where the method of an object was used as callback handler. In this post, I show all 4 scenarios. This time, I'm not showing the power of templates, but the power of lambda functions.

As a refresher, here is the Callback manager. Unchanged since previous post.

callmanager.cpp

module;

#include <concepts>
#include <functional>

export module callbackmanager;

namespace callbackmanager {

// concept guards what types of return values we can handle
template<typename R>
concept Callbackable = 
	std::is_void<R>::value ||
	std::is_arithmetic_v<R> ||
	std::is_class_v<R>;

export template <Callbackable R, typename... Args>
class Callback {
	using callbackfunction_t = std::function<R(Args...)>;	
public:
	Callback() : callback_(nullptr), is_callback_set(false){}

	inline void set(callbackfunction_t callback) {
	    callback_ = callback;
		is_callback_set = true;
	}

	inline void unset() {
		callback_ = nullptr;
		is_callback_set = false;
	}

	[[deprecated("Use operator () instead.")]]
	inline R call(Args... args) {
		return *this(args...);
	}

	inline bool is_set() {
		return is_callback_set;		
	}

	/*
	 * R can be an arithmetic type, an object, or void
	 */
	inline R operator()(Args... args) {
		if constexpr (std::is_void<R>::value) {  // void
			if (!is_callback_set) {
				return;
			} else {
				(callback_)(args...);
			}
		} else if constexpr (std::is_class<R>::value) { // object
			if (!is_callback_set) {
				return R();
			} else {
				return (callback_)(args...);
			}
		} else { // not void nor object
			if (!is_callback_set) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			} else {
				return (callback_)(args...);
			}
		}
	}

private:
	callbackfunction_t callback_;
	bool is_callback_set;
};

} // namespace callbackmanager

And here is the code that exercises the 4 scenarios. Each scenario is surrounded by {}. That means that they run in their own little isolated scope, And they don't spoil each other.

First, some code that will be used in the test. They are 3 different types of functions / methods:

MyClass, now with a static and normal member function. So that we can test a scenario where we call an object member, and a scenario where we call a static class member.
classic C function functionHandler().

All 3 do the same thing. They return the sum of two integers.

#include <cstdio>
#include <string>
#include <typeinfo>

import callbackmanager;

class MyClass {
public:
      inline int handler(const int& num1, const int& num2) const {
          return num1 + num2;
      }
      static inline int staticHandler(const int& num1, const int& num2) {
          return num1 + num2;
      }
};

int functionHandler(const int& num1, const int& num2) {
    return num1 + num2;
}

Then the 4 tests:

int main() {

    int a = 4;
    int b = 5;

    Callback<int, const int&, const int&> cb;
    // Use a lambda to capture myClass and call the object method
    cb.set([&myClass](const int& num1, const int& num2) -> int {
        return myClass.handler(num1, num2);
    });

    int o = cb(a, b);
    printf("Value: %i\n", o); // We might be on an embedded system, use printf() and not std::cout
	fflush(stdout);
	}

	{ // scenario: call static method
    Callback<int, const int&, const int&> cb;
    // Use a lambda to call the static method
    cb.set([](const int& num1, const int& num2) -> int {
        return MyClass::staticHandler(num1, num2);
    });

    int o = cb(a, b);
    printf("Value: %i\n", o); // We might be on an embedded system, use printf() and not std::cout
	fflush(stdout);
	}

	{ // scenario: call C function
    Callback<int, const int&, const int&> cb;
    // Use a lambda to call the classic C function
    cb.set([](const int& num1, const int& num2) -> int {
        return functionHandler(num1, num2);
    });

    int o = cb(a, b);
    printf("Value: %i\n", o); // We might be on an embedded system, use printf() and not std::cout
	fflush(stdout);
	}

	{ // scenario: call pure lambda
    Callback<int, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> int {
        return num1 + num2;
    });

    int o  = cb(a, b);
    printf("Value: %i\n", o);
	fflush(stdout);
	}

	{ // scenario: return a bool
    Callback<bool, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) -> bool {
        return num1 == num2;
    });

    printf("Value: %s\n", cb(a, b) ? "true" : "false");
	fflush(stdout);
	}

	{ // scenario: use void
    Callback<void, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) {
        return;
    });
    cb(a, b);
	}
	
    { // scenario: return an object
    class return_class {
    public:
        return_class() : value_(0) {};
        int value_;
    };

	callbackmanager::Callback<return_class> cb;
    // Use a lambda to execute anonymous C code
    cb.set([]() -> return_class {
        return_class rc;
        rc.value_ = 1;
        return rc;
    });
    return_class ret = cb();
    printf("Value: %d\n", ret.value_ );
	fflush(stdout);
	}

	/*
	{ // scenario: use an unsupported (non-fundamental) type for return value R
	  // this will generate a compile error
    Callback<std::string, const int&, const int&> cb;
	}
}

edit: The template also allows void return values. Some more tests:

	{ // scenario: use void
    Callback<void, const int&, const int&> cb;
    // Use a lambda to execute anonymous C code
    cb.set([](const int& num1, const int& num2) {
        printf("void gets num1: %i, num2: %i\n", num1, num2);
    	fflush(stdout);
        return;
    });
    cb.call(a, b);
	}

	{ // scenario: use void, and no attributes
    Callback<void> cb;
    // Use a lambda to execute anonymous C code
    cb.set([]() {
        printf("void with no parameters\n");
    	fflush(stdout);
        return;
    });
    cb.call();
	}

Scenarios, in order of execution: (edit: this was written before I revised the code to support configurable return value. The test code above is adapted, but I didn't change the images below)

call object method
In this one, I create object myClass of type MyClass. Then pass its handle() method as callback.
This was the scenario of the first post.
call static class method
In this test, I don't declare an object of type MyClass. I pass the static MyClass::staticHandle()
classic C function
Here, the callback gets a very common C function, named functionHandler(), as handler.
a pure lambda.
In this test, I pass an anonymous block of code as handler:
return num1 + num2;
return an object. This is added on 09-mar-2025.Works as long as the object supports a default constructor and does not forbid copy / assign.

In each test, the Callback object cb will call the code that's given to it in the set() call. All using the exact same little Callback template class. If you would set breakpoints, here is where the code would stop for each of the 4 cases:

edit: this was written before I replaced call() by operator ()..In your code, don't use cb.call(args), but cb(args). The test code in the blog is adapted, but I didn't change the images.

The test code is available as a Gist.

C++ callbacks and templates

Jan Cumps — Sat, 15 Jun 2024 10:50:00 GMT

I'm experimenting: can I use a method of a particular object as a callback? This can be used in typical callback situations, e.g.: in a UART driver. But also in interrupt handlers.

lightweight: small runtime cost, low firmware hit. Can be used for tiny embedded systems.
reusable: don't assume parameters and types for the handler, when writing this little framework -> C++ templates
hip -> object oriented, modern C++ constructs
type safe -> again C++ templates
allow a classic C function, a lambda, a static class method or an object method as handler

example: Raspberry Pico blinky using this design

#include <new>
#include <stdio.h>
#include "pico/stdlib.h"

import callbackmanager;

const uint32_t delay_ms = 250;

callbackmanager::Callback<void> cb;

int main() {
gpio_init(PICO_DEFAULT_LED_PIN);
gpio_set_dir(PICO_DEFAULT_LED_PIN, GPIO_OUT);
cb.set([]() {
static bool state = false;
gpio_put(PICO_DEFAULT_LED_PIN, state = !state);
});

while (true) {
cb();
sleep_ms(delay_ms);
}
}

project: community.element14.com/.../2133.pico_5F00_callback_5F00_blink.zip

Callback template class

The template callback class. This is in essence the whole mechanism. A generic class that allows you to register and call event handler functions, lambda's and methods.

#include <functional>

// concept guards what types of return values we can handle
template<typename R>
concept Callbackable = 
	std::is_void<R>::value ||
	std::is_arithmetic_v<R> ||
	std::is_class_v<R>;
	
template <Callbackable R, typename... Args>
class Callback {
	using callbackfunction_t = std::function<R(Args...)>;	
public:
	Callback() : callback_(nullptr), isSet(false){}

	inline void set(callbackfunction_t callback) {
	    callback_ = callback;
		isSet = true;
	}

	inline void unset() {
		callback_ = nullptr;
		isSet = false;
	}

	inline bool is_set() {
		return isSet;		
	}

	/*
	 * R can be an arithmetic type, an object, or void
	 */
	inline R operator()(Args... args) {
		if constexpr (std::is_void<R>::value) {  // void
			if (!is_callback_set) {
				return;
			} else {
				(callback_)(args...);
			}
		} else if constexpr (std::is_class<R>::value) { // object
			if (!is_callback_set) {
				return R();
			} else {
				return (callback_)(args...);
			}
		} else { // not void nor object
			if (!is_callback_set) {
				return 0; // R can only be a arithmetic type. 0 should work as default.
			} else {
				return (callback_)(args...);
			}
		}

	}
	
private:
	callbackfunction_t callback_;
	bool isSet;
};

This generic class allows for handlers that pass any amount of parameters. No assumption of the types.

When we use the class in our code, we 'll tell it what the parameters are, and their type. For this blog, I am going to pass it 2 integers. The return value is also an integer.

Callback<int, int, int> cb;

In the declaration above, the first int is the return value type, the 2 others are parameter 1 and 2. Once you write this code, the object cb will only accept handler methods that take two integers as parameter, and return an integer.

Example of class that will handle the callback

This could be a gio class (blinky a led when an interrupt occurred?), a GUIwidget, or a business object. Typical guidelines apply: a handler should be swift. In particular if it's an interrupt handler.

class MyClass {
public:
      int handler(int num1, int num2) {
          return num1 + num2;
      }
};

The example does not do a lot today. It just sums up the two integers passed. But as a POC this will do.

Actual code using the two

#include <cstdio>

int main()
{
    MyClass myClass;

    Callback<int, int, int> cb;
    // Use a lambda to capture myClass and call the member method
    cb.set([&myClass](int num1, int num2) -> int {
        return myClass.handler(num1, num2);
    });

    int a = 4;
    int b = 5;

    int o = cb(a, b);
    printf("Value: %i\n", o); // We might be on an embedded system, use printf() and not std::cout
}

Why use a lambda to pair the handler and Callback ?

In the code, I did not learn the MyClass how to register itself. And the Callback doesn't know anything about who or what it 'll call. These classes (and their objects) are unaware of each other. Loose coupling.

Callback<int, int, int> cb;

cb.set([&myClass](int num1, int num2) -> int { return myClass.handler(num1, num2); });

In the application logic, I tie the two together. The lambda function code (the anonymous function, starting with the [, and ending with the } above), is used as the vehicle to hold the code that the Callback object will execute when needed.

The lambda function could as well be a straigtforward piece of code, not related to any object:

Callback<int, int, int> cb;

cb.set([](int num1, int num2) -> int {
return num1 + num2;
});

Or we could pass completely different executable code. As long as the lambda matches the signature given when instantiating the Callback class.

In an embedded system,

myClass would be one of your application objects.
cb could be part of a driver, or the HAL layer
cb.set() would be called by you, to register the handler
cb.call() would be done by the driver, or HAL ISR, when it wants to notify you (call your callback handler)

In the case of this example, it will execute myClass.handler(). If you 'd have many MyClass objects, it would call the exact one that's registered in with set().

Example use of the callback class in an embedded application

Anything special?

This approach allows to write a reusable callback system. It is type safe. But it does not assume what the type is of the object it 'll call the handler off. (Or if it's actually an object).
It's a small amount of code, that performs a function that you regularly need in an embedded or event driven design.

What does type-safe mean in this context?

If your interrupt handler assumes a function that passes 2 integers, and you pass it a callback function that has different parameters,
you get a compile time error. Your code will not build, because the handler is not compatible.

And you get all of that, without having to specify the number of variables, and their types, in the Callback class code. We get a reusable class. Type safe. Without the need to foresee all possible combinations.

this library now also works for Arduino (tested with IDE2, and an Arduino MKT GSM 1400)

For Arduino, you can download callbackmanager.h to your computer, then use Sketch -> Add File ... to get the callbackmanager included to your project.
Add this line to your sketch:

#include "callbackmanager.h"

I added a sketch to test the callback manager to this gist: test_arduino.ino

Arduinos that use the gcc-avg toolchain are not supported (UNO, Mega, the original basic Nano)

shortcuts:

I assume fixed return value type. A richer implementation can use template for that too, and should allow void. edit: this works
I pass arguments by value. A better design would also allow pass by reference. And to pass const references. edit: this works
should I use a shared pointer, so that I can never call the handler of an object that no longer exists? (solved by alternative: provide an unset() method). edit: the class no longer uses pointers
it only allows to call one handler. Good for ISR use. But in an event driven design, you may want to register more handlers. I prefer just one handler. simple scope, simple responsibility.

Inspiration:

I started from this example by Geoffrey Hunter.
mbed's Callback class, although I didn't use any of the code
cplusplus' tutorial for std::function, to validate if it works for static class member, object member, classic C function and lambda function.

Code is available on github. Additional assets available on Gist.

CMakeLists.txt to build an example program:

cmake_minimum_required(VERSION 3.28)

project(callbackmanager C CXX ASM)

# GoogleTest requires at least C++14
set(CMAKE_CXX_STANDARD 26)
set(CMAKE_CXX_STANDARD_REQUIRED ON)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fmodules-ts -fcommon")

add_executable(${CMAKE_PROJECT_NAME})
target_sources(${CMAKE_PROJECT_NAME}
        PUBLIC
        ${CMAKE_CURRENT_SOURCE_DIR}/example/callback_examples.cpp
)
target_sources(${CMAKE_PROJECT_NAME}
        PUBLIC
        FILE_SET cxx_modules TYPE CXX_MODULES FILES
        ${CMAKE_CURRENT_SOURCE_DIR}/callbackmanager.cpp
)

target_link_libraries( ${CMAKE_PROJECT_NAME}
)

I test this code in C++ callbacks and templates: make the Callback class call an object member, a static member, a C function and a pure lambda function
edit 20250208: I converted it to a c++ module: modern C++ modules: convert existing example from .h to module

Github Template repository: get updates from origin

Jan Cumps — Fri, 14 Jun 2024 08:49:50 GMT

When you create a Github repository from a Template, there is no origin <> destination relationship. They live separate lives. This is different from Forking a repository. In that case the fork knows its origin, and you can sync your Fork from the origin.

I would like to update my repository from the original template though. Because that repository gets bug fixes, and I want to inherit them.

The Original template repo: https://github.com/jancumps/pst_rtos
My repository that's based on that template: https://github.com/jancumps/pst_rtos_xiao

I have been looking for solutions. I found a few custom Github actions that can do this. But they fail if there's a merge conflict. And because it's a job, you can't interactively resolve that. Then I found a solution on Stack Overflow that uses the git command. It worked for me:

I'm looking for feedback. Do you think that this will corrupt the pst_freertos_xiao repo?
The Stack Overflow page lists the side effects, and I've read them. It also has different suggestions, e.g.: patching ...

I started a command line, and navigated to the root of pst_rtos_xiao repository clone on my hard disk.

Then I executed these commands:

$ git pull

$ git remote add template https://github.com/jancumps/pst_rtos.git

$ git fetch --all

$ git merge template/main --allow-unrelated-histories

If merge conflicts occcur, this would be where you fix them.

$ git status

$ git add CMakeLists.txt

$ git add source/scpi/scpi-def.h

$ git commit -a -m "refreshing from template"

$ git push

This merged all changes in my oinline Github repo https://github.com/jancumps/pst_rtos_xiao. That was the goal.

Member insight with Ubuntu Pro & esm-apps

colporteur — Sun, 03 Sep 2023 20:47:11 GMT

I did a command line software update and came across esm-apps. Well there was a lot more printing on the screen than what I would expect so I gained some knowledge.

The following security updates require Ubuntu Pro with 'esm-apps' enabled:

After some research I discovered Ubuntu Pro has been a service available since Jan 2023. For personal use (that's me) the service is free for up to five machines. I'm thinking of dipping my toe in the water.

My primary O/S is Ubuntu and has been for years. CentOS was what I used up until I retired. RedHat was the companies Linux, so CentOS allowed me to play in Linux for work without a licence. When I retired I switched to Ubuntu and haven't look at any others.

I'm new to the Ubuntu Pro party and was wondering if any other members who's dedicated operating system (O/S) is Ubuntu have any insight.

x2 or x4 clock problem ATxMEGA128C3

ElectroMiam — Thu, 09 Feb 2023 13:09:53 GMT

I am trying to get the clock out of pin 23 (PORTC7) of the ATxMEGA128C3 but some parameters are not working. The clock is well generated by the code below but when going to x2 or x4, it stops.

The current initialization is like this:

PORTC_PIN7CTRL |= 0x07;

PORTCFG_VPCTRLA = 0x10;

PORTCFG_VPCTRLB = 0x32;

PORTCFG_CLKEVOUT = 0b00000001;

But the clock multiplier on CLKOUTSEL (01 or 10) is not taken into account and disables the output.

Someone would have an idea or an example to share with me to solve this problem ?

anyone investigating, learning or using the recent c++ or STL functionality?

Jan Cumps — Fri, 02 Dec 2022 17:56:26 GMT

What the title says 🙂.

Since autumn 2021, I'm learning the c++ 20 language evolutions. Almost finished. Is anyone else into this?

Tenma 72-8710A DSO software

huroniatech — Sat, 02 May 2020 16:44:29 GMT

Are there any drivers for the software included with the 72-8710A for Windows 10 v1909?

Could not create SCTP socket

jaypeng — Tue, 03 Mar 2020 21:30:20 GMT

Dear all,

I do have an issue regarding SCTP socket. I am using srsLTE to setup test environment. srsEPC is acting as LTE core network and srsENB is acting as LTE access network. Both of two applications need to run on the same Ultrazed board. After I do local compile on a linux box which is Intel CPU supported, it works fine. But when I do cross compile for Ultrazed board which is for ARM platform and run srsEPC, I got error in console - "Could not create SCTP socket".

Below is the source code of srsEPC

m_s1ap_log->info("S1-MME Initializing\n");

sock_fd = socket(AF_INET, SOCK_SEQPACKET, IPPROTO_SCTP);

if (sock_fd == -1) {

m_s1ap_log->console("Could not create SCTP socket\n");

return -1;

}

I will very appreciate it if any expert can share your experience on how to fix it. Looking forward to your reply.

Bests,

Jay

3D scanning software

claytond — Mon, 06 Aug 2018 06:38:27 GMT

Hello! Are there any experienced people in 3d scanning? I'm looking for a compatible software for my Kinect V2 and all I've found so far is Skanect (is not a good option for me cause of limited polygon export), KScan3D (but it seems like this project "died" for some reason) and Artec Studio (professinal software with 30day trial version)? Any help will be greatly appreciated.

Clayton

Ver 8.6.3 New CAM processor operation tutorial

rdmurg — Tue, 13 Mar 2018 02:10:08 GMT

Upgraded to 8.6.3 and the CAM processor has changed.

is there some documentation on the changed operation

...Rod

Virtual Inc.

bradnorwood — Thu, 15 Feb 2018 15:56:21 GMT

Hello,

I am assembling a virtual team across USA for software and web design. If anyone is interested in networking with our current 10 members, please reply. We are forming now, looking to work on projects from government, already registered and active with all federal agencies for NASA, DOD, DOE, DOA, and planning for state and local governments for a better day...

PCBWeb Designer schematic issue

nweller922 — Sun, 11 Feb 2018 04:39:44 GMT

Hello,

I've been using PCBWeb Designer recently and happened across a problem I can't find a solution to anywhere. I am trying to put the TE Connectivity 1-5499786-1 into my design, pulled from the Arrow parts catalog within PCBWeb. Its listing within the catalog shows two schematic symbols, A and B, which each make up half of the 60 pins in the connector. I have successfully placed the first symbol – J1A – but cannot for the life of me figure out how to place J1B.

If anyone who knows anything about this software could shed some light on this situation, it would be much appreciated.

Thank you!

3D Printing Software

realjg21 — Thu, 26 Oct 2017 12:36:12 GMT

Does anyone have any experience with 3D printing software SelfCAD. My class has been using Tinkercad and need something with sculpting and dimensions. Its all free for Class's and browser based which will allow me to get it on all of our computers without calling IT

WEBINAR: Why using an SDK for automotive development?

yoSoyTono — Wed, 06 Sep 2017 15:39:53 GMT

SDK is the acronym for “Software Development Kit” and usually refers to a set of software development tools that allow engineers to create systems and produce applications for hardware kits, software frameworks, or development platforms. SDKs are implementation tools for developing source-codes for almost any software modern users are interacting with.

SDKs usually contain APIs (Application Programming Interfaces) as they are required when an SDK is being used to create an application that needs to connect with other application. An API typically communicates and cannot be used to create applications by itself. APIs allow application functioning within the SDKs defined parameters.

SDK commonly provides a package of tools (libraries, APIs, code samples, documentation, and guides) to create software applications on a dedicated platform. Engineers get SDKs from a system developer for both easing their development process and fostering an ecosystem for them. SDKs are a driving force to expedite time-to-market for application development, that is especially useful in stringent industries, like transportation.

NXP has a free-early release for a full automotive-grade SDK that supports the Power Architecture® MPC5748G MCU focused on gateway solutions. Their SDK includes software stacks & middleware (TCP/IP, Ethernet AVB, USB, and SDHC) and also offers Safety and Security software to comply with Functional Safety requirements.

They are hosting a webinar (Wednesday, September 13th 10:00 am EDT) to show the MPC57 family SDK and explain how development projects can be started right away with graphical-based configurations in their S32 Design Studio IDE.

Register today to learn how to simplify and accelerate application development with an SDK for Power Architecture MCUs!

Suggestions on the Best Free EDA tool for Beginners

hadleywhite — Fri, 06 Nov 2015 04:24:23 GMT

　　Hello everyone, just a quick opinion survey, what EDA do you think is best and why? Something that is hopefully often updated and is stable. I have looked into EasyEDA and Design spark, but are there any other EDAs there?

　　Opinions are highly appreciated, Thanks

Java

nick123 — Wed, 30 Sep 2015 18:38:50 GMT

I have a Java Circuit simulator that I used on Windows, When I had it and It worked just fine. When I migrated to linux, I installed Java Runtime 6 which Let's me run java apps. Well, Now my Java Circuit simulator looks like This:

This makes me mad, as I used this on a daily basis just to have fun, and design projects I'm planning and to experiment and learn.

Does anyone else use this simulator?

It's broken, I doesn't work, The menus have gone. Could it have something to do with Java Runtime? or The OS.

This worked on Windows Flawlessly.

Software Guys, How Does This Happen?

michaelwylie — Wed, 03 Jun 2015 06:05:57 GMT

O.K. software guys, you're up. This happens too often for me. Seriously, though, how does this happen? Three tabs open: Element14, GMail, and Twitter.