Implementing Callbacks with Function Pointers

What is a Callback?

At its core, a callback is a mechanism where a function accepts a pointer to another function and invokes it at a specific time or in response to an event.

Think of it like subscribing to a notification service. You provide your phone number (the callback function pointer) to the service (a lower-level library or driver). You don't know exactly when they'll call, but you've instructed them to notify you when a specific event happens. The service doesn't need to know who you are or what you'll do when you get the call; it just needs the number to dial.

This decouples the high-level policy (what to do) from the low-level mechanism (when to do it). This is a cornerstone of modular design in systems like AUTOSAR, where a generic COM module can notify any number of application-level components about incoming messages without needing to know anything about them.

The diagram below, from the Beningo Embedded Group, illustrates this flow. The application registers a Callback function with the Driver Library. Later, when an event occurs, the Signal Handler in the driver invokes the registered callback, transferring control back to the application layer.

The Core Mechanism: Passing a Function as an Argument

Let's start by seeing how this works at a fundamental level. The following video provides a concise introduction to the concept.

As you saw, the syntax is straightforward: a function parameter is simply declared as a function pointer. The calling function can then pass the name of any compatible function as the argument.

Here is a practical code example that solidifies this idea.

This ArithMaticOperation function demonstrates the key benefit: code reuse and flexibility. Instead of writing separate logic for each operation inside a large switch statement, the core logic is generic, and the specific operation is injected by the caller.

A Classic and Powerful Use Case: Generic Sorting

One of the most classic examples of callbacks is creating a generic sorting algorithm. The sorting logic (like Bubble Sort or Quick Sort) remains the same, but the criteria for ordering elements can be customized by the caller.

For instance, you might want to sort an array of integers in:

• Increasing order
• Decreasing order
• By their absolute value

Instead of writing three separate sort functions, you can write one generic sort function that accepts a callback to a comparison function.

The following video walks through this exact scenario, first building a custom sort function and then showing how the C standard library's qsort function uses the same principle.

The qsort example is particularly relevant as it introduces the use of void* pointers to make the function truly generic—it can sort arrays of any type. The callback function is responsible for correctly casting the void* pointers back to the appropriate type before performing the comparison. This is a common pattern in generic C APIs.

Callbacks in an Embedded and Automotive Context

While sorting is a great example, callbacks are most often used in embedded systems for handling asynchronous events. Your work with ADAS communication stacks and AUTOSAR middleware relies heavily on this pattern. When a CAN frame arrives or an Ethernet packet is received, the low-level driver or middleware needs to notify the correct application component.

Let's explore a design pattern specifically for implementing robust callbacks in embedded C.

The techniques discussed in this video, such as wrapping function pointers in structs and using macros like container_of (prevalent in the Linux kernel), represent a mature, robust approach to callback design that you can apply directly to your work in gateway development and AUTOSAR middleware. The point about unregistering callbacks is especially critical in systems where objects have dynamic lifetimes and functional safety is a requirement.

#include <stdio.h>
#include <stdint.h>

// --- Definitions ---

// 1. PDU struct
typedef struct {
    uint32_t PduId;
    uint8_t payload[8];
} PDU_t;

// PDU IDs for our example
#define RADAR_PDU_ID 0x100
#define CAMERA_PDU_ID 0x200

// 2. Typedef for the handler function pointer
typedef void (*PduHandler_t)(const PDU_t* pdu);

// 3. Struct for a routing rule
typedef struct {
    uint32_t pdu_id_to_match;
    PduHandler_t handler;
} RouterRule_t;

// --- Callback Implementations ---

void process_radar_pdu(const PDU_t* pdu) {
    printf("Processing RADAR PDU (ID: 0x%X). Payload[0]=0x%02X\n", pdu->PduId, pdu->payload[0]);
}

void process_camera_pdu(const PDU_t* pdu) {
    printf("Processing CAMERA PDU (ID: 0x%X). Payload[0]=0x%02X\n", pdu->PduId, pdu->payload[0]);
}

// 4. The dispatcher/router function
void route_pdu(const PDU_t* pdu, const RouterRule_t rules[], size_t num_rules) {
    for (size_t i = 0; i < num_rules; ++i) {
        if (rules[i].pdu_id_to_match == pdu->PduId) {
            // Found a match, invoke the callback!
            if (rules[i].handler != NULL) {
                rules[i].handler(pdu);
            }
            return; // PDU handled
        }
    }
    printf("No handler found for PDU ID 0x%X\n", pdu->PduId);
}

// --- Main Application ---
int main() {
    // 5. Create the routing table
    RouterRule_t routing_table[] = {
        {RADAR_PDU_ID, process_radar_pdu},
        {CAMERA_PDU_ID, process_camera_pdu}
    };
    size_t num_rules = sizeof(routing_table) / sizeof(routing_table[0]);

    // Create a sample PDU from the radar
    PDU_t radar_data = {
        .PduId = RADAR_PDU_ID,
        .payload = {0xDE, 0xAD, 0xBE, 0xEF, 0, 0, 0, 0}
    };
    
    // Create a sample PDU from the camera
    PDU_t camera_data = {
        .PduId = CAMERA_PDU_ID,
        .payload = {0xAA, 0xBB, 0, 0, 0, 0, 0, 0}
    };

    // Route the PDUs
    printf("Routing PDU with ID 0x%X...\n", radar_data.PduId);
    route_pdu(&radar_data, routing_table, num_rules);

    printf("\nRouting PDU with ID 0x%X...\n", camera_data.PduId);
    route_pdu(&camera_data, routing_table, num_rules);

    return 0;
}

Conclusion

Today, we explored the powerful and fundamental concept of callbacks. By passing function pointers as arguments, you can create flexible, reusable, and modular code where low-level modules can signal events to high-level modules without being tightly coupled.

Key Takeaways:

• A callback is a function passed as an argument to another function, intended to be "called back" later.
• This pattern enables inversion of control, decoupling the "what" from the "when."
• It is the foundation for event-driven programming, crucial for handling asynchronous hardware and communication events in embedded systems.
• Advanced implementations often wrap callback pointers in structs and use techniques like container_of to provide context to the callback in a type-safe manner.

Preview of the Next Lesson:
We will now do a deep dive into one of the most common applications of this pattern. In the next lesson, we will implement a generic sorting function that accepts a custom comparison function via a function pointer. While we touched on qsort today, you will now implement a similar mechanism from scratch, giving you a complete understanding of how to build your own generic, callback-driven utility functions.