Articles tagged embedded at Royyan Dzakiy

Zephyr App Event Manager (app_event_manager)

2026-04-06T00:00:00Z

Another design of event-driven architecture is the AEM (app_event_manager) in Zephyr. This subsystem/framework enforces its users to structure their code in modules. Each module connected to the event-driven backend will need to explicitly subscribe/listen to another module to get notified of any events happening.

To me, this architecture style really helps when I need to isolate a particular module to debug or test easily. I could simply remove it from the CMakeLists.txt, and logically, the tight coupling design will not affect other modules.

https://docs.nordicsemi.com/bundle/ncs-3.0.2/page/nrf/libraries/others/app_event_manager.html

Here’s a small snippet of how it looks in practice:

/* --- Event Definition --- */
APP_EVENT_TYPE_DEFINE(sensor_data_event,
		  NULL,
		  NULL,
		  APP_EVENT_FLAGS_CREATE(
			APP_EVENT_TYPE_FLAG_INIT_LOG_ENABLE
		  ));

/* --- Module A: Publisher --- */
static void publish_sensor_data(int32_t value) {
	struct sensor_data_event *evt = new_sensor_data_event();
	evt->value = value;
	APP_EVENT_SUBMIT(evt);
}

/* --- Module B: Subscriber --- */
static bool app_event_handler(const app_event_header *aeh) {
	if (is_sensor_data_event(aeh)) {
		struct sensor_data_event *evt = cast_sensor_data_event(aeh);
		LOG_INF("Received sensor data: %d", evt->value);
		return true;
	}
	return false;
}

APP_EVENT_LISTENER_DEFINE(sensor_event_listener, app_event_handler);
APP_EVENT_SUBSCRIBE(sensor_event_listener, sensor_data_event);

With this approach, if I want to test Module B in isolation, I can simply remove Module A from the build, and the app still runs, it simply stops sending events. Really nice for unit testing and incremental development.

RTOS Sharing Session

2025-11-11T00:00:00Z

Had a blast sharing with the Synapsis team! The topic was about Embedded RTOSes, we mainly talked about FreeRTOS and did hands-on using ESP32.

One thing that I don’t find talked about enough are RTOS & design patterns. How state machines are the bread and butter in many RTOS systems, also problems that may arise in different biz contexts, for instance in a multiple sensor and multi stage data processing device, we can leverage the pipeline pattern.

Had fun preparing the talk, and hopefully it sparked some ideas!

Somethings that I think I would do better on next RTOS sessions:

I’d rather have a handson session, rather than a talkish one, especially when majority are beginners. This way they can bring back the experience of running the code on their pcs, and me checking on them
For complex topics and abstract software ones like architecture, it’s best to have it during qna or in a consulting manner when someone in the mid senior level actually bringing it up
I should reduce the amount of examples being run through. And I should groom them better, to not have too many example cases being presented. Or even better, just rewrite the code live (rather than running a premade code) to help give a gist to the students, including how to read the texh docs to get the API correct

ESP-IDF Build System

2025-10-16T00:00:00Z

Lately I’ve been going back and forth with zephyr and esp-idf. Something that often times trips me when exploring new frameworks is in understanding their build systems. What goes where, what gets called by what, how to structure things as intended, how can I elevate more with what they have given and make a beautiful (lol) automated and robust build process. I love to fanboy on them gud foldering structures, module seperations, and different build-system task goodness.

This talk by Ivan Grokhotkov really helps to be a primer on most things on what to expect on the esp-idf build system.

Man, really love these espressif talks, super practical and recent. Really grateful for their effort in these

DevCon24 - Keynote 2nd Day - Mastering ESP-IDF Build System

Here’s for further reading on espressifs concept of “components”:

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-guides/build-system.html

ESP-IDF Test Frameworks

2025-10-05T00:00:00Z

I’ve lately been keen in learning test systems in the embedded, especially for esp-idf. I’ve been wanting to really understand how far I can take the automated testing and CI processes using built in tools of the espressif ecosystem, or common practices. This talk by Zim Kalinowski really fascinates me, knowing that within espressif, they have been implementing these full blown processes for the longest time. Really excited to ramp up my gear and try implementing these tools myself.

Some of the things he will talk about is as follows:

Test framework Introduction
Using PyTest with Unity
Setting Up CI in GitHub
Using CMock and several already mocked IDF components
Using QEMU
Using Self-hosted test runner for on target tests (hardware based)

EDC22 Day 2 Talk 9: Leveraging ESP IDF Test Framework in Third-Party Projects