microbus is a small C99 event bus for embedded and host applications that want caller-owned storage, copied payload bytes, and bounded queued dispatch without heap allocation.

• Immediate publish is synchronous and deterministic.
• Deferred queue dispatch is bounded to the events present at mbus_dispatch() entry.
• MBUS_TOPIC_ANY is subscribe-only.
• Payload bytes are copied into the event object.
• Counter fields wrap modulo 2^32.
• Default mode is single-context only.
• Optional ISR/main-loop SPSC mode is configuration-driven and requires caller-supplied critical-section hooks.
• General thread safety is not provided. Use external locking around bus operations outside the supported single-context or configured ISR mode.

#include "mbus.h"

#include <stdint.h>
#include <string.h>

static void on_sensor(const mbus_event_t *event, void *ctx)
{
    uint16_t millivolts = 0;
    (void)ctx;

    if (event->payload_len != sizeof(millivolts)) {
        return;
    }

    memcpy(&millivolts, event->payload, sizeof(millivolts));
}

int main(void)
{
    mbus_t bus;
    uint16_t value = 3300;
    int rc;

    rc = mbus_init(&bus, NULL);
    if (rc != MBUS_OK) {
        return 1;
    }

    rc = mbus_subscribe(&bus, MBUS_TOPIC_SENSOR, on_sensor, NULL);
    if (rc < 0) {
        return 2;
    }

    rc = mbus_publish(&bus, MBUS_TOPIC_SENSOR, &value, sizeof(value));
    if (rc < 0) {
        return 3;
    }

    return 0;
}

cmake -S . -B out/build -DMBUS_BUILD_TESTS=ON
cmake --build out/build
ctest --test-dir out/build --output-on-failure

make test

The top-level Makefile is a thin wrapper around the CMake build and honors CC, CPPFLAGS, CFLAGS, LDFLAGS, and LDLIBS.

The public configuration contract lives in mbus_config.h.

Installed consumers must use the generated mbus_config.h shipped with the package rather than redefining ABI-shaping macros independently.

• API reference
• Design notes
• Porting guide
• Cookbook
• Troubleshooting
• Verification log
• Contributing
• Security

MIT. See LICENSE.