Function Pointers (Dynamic Execution)

Variables usually hold Data (integers, floats).

A Function Pointer is a variable that holds Code (the address of a function in Flash memory).

It allows you to decide which function to run at runtime, rather than compile time.

Think of it as a "Blank Button" on a remote control. You can program this button to do "Volume Up" today, and reprogram it to do "Change Channel" tomorrow. The hardware (the button) stays the same; the behavior changes.

Syntax & Usage (The "C" Style)

The syntax is notoriously ugly ("Right-Left Rule"), but essential to know.

Declaration:

Return_Type (*Pointer_Name)(Argument_Types);

// 1. Define standard functions
void led_on()  { printf("LED ON\n"); }
void led_off() { printf("LED OFF\n"); }

int main() {
    // 2. Declare a function pointer named 'action'
    // It can point to ANY function that takes void and returns void.
    void (*action)(); 

    // 3. Assign address (Function name is the address)
    action = &led_on; 
    action(); // Calls led_on() -> Prints "LED ON"

    // 4. Re-assign dynamically
    action = &led_off;
    action(); // Calls led_off() -> Prints "LED OFF"
}

Modern C++ Alternative (using):

To make it readable, use using (or typedef).

using EventHandler = void (*)(int); // 'EventHandler' is now a type

EventHandler myPtr = &someFunction;

Key Patterns in Firmware

A. Callbacks (Event Notification)

Instead of hardcoding what happens when a button is pressed, the driver lets the user "register" a function.

// --- Driver File ---
// Variable to store the user's function
void (*button_callback)(void) = nullptr; 

void register_callback( void (*cb)(void) ) {
    button_callback = cb;
}

// ISR (Interrupt)
void Button_ISR() {
    // If a user registered a function, call it!
    if (button_callback != nullptr) {
        button_callback(); 
    }
}

// --- Application File ---
void my_app_logic() { printf("Button Pressed!"); }

int main() {
    register_callback(&my_app_logic); // Hook it up
}

B. Jump Tables (State Machines)

Instead of a giant switch-case with 50 if/else blocks, use an array of function pointers. This is O(1) (Constant Time) and extremely fast.

// Define the state handler type
using StateHandler = void (*)();

void handle_idle()  { /* ... */ }
void handle_run()   { /* ... */ }
void handle_error() { /* ... */ }

// The Jump Table (Array of functions)
StateHandler state_machine[] = {
    &handle_idle,  // Index 0
    &handle_run,   // Index 1
    &handle_error  // Index 2
};

// Run state 'current_state' (No if/else needed!)
state_machine[current_state](); 

Advanced: Member Function Pointers (The Trap)

This is the most common error for C++ beginners.

A regular function pointer cannot point to a non-static class member function.

• Reason: Member functions have a hidden this argument. Regular pointers don't know how to handle this.

• Syntax: You must include the class name scope.

class Motor {
public:
    void stop() { /* ... */ }
};

int main() {
    // void (*ptr)() = &Motor::stop; // ❌ ERROR: Type Mismatch

    // Correct Syntax (Member Function Pointer)
    void (Motor::*ptr)() = &Motor::stop; 

    Motor m;
    (m.*ptr)(); // Syntax to call it on object 'm' (Very rare in practice)
}

• Fix: In Embedded C++, if you need a callback to a class method, either use a Static member function (which matches regular pointers) or pass a void* context (the this pointer) alongside the function pointer.

Relevance in Embedded/Firmware

1. Bootloaders (Jump to App)

A bootloader runs, checks for a new firmware, and then jumps to the main application.

It does this by casting a specific memory address (e.g., 0x08004000) to a function pointer and calling it.

// "Function" at specific address
void (*app_reset_handler)(void) = (void (*)(void)) (*(uint32_t*)0x08004004);

// Jump!
app_reset_handler(); 

2. Interrupt Vector Table (IVT)

The IVT is literally just an array of function pointers stored at the beginning of Flash. When an interrupt fires, the hardware looks up the address in this array and jumps to it.

Common Pitfalls (Practical Tips)

Summary Checklist

• Use using or typedef to make syntax readable.

• Always check for NULL before calling.

• Use Jump Tables to replace massive switch-statements.

• Remember: You cannot point a raw pointer to a non-static class member.