How to call void function in response to receiving serial data (Arduino)

Question

I'm new to Arduino, and I'm trying to decipher this code. There are various void functions that I am trying to call in response to receiving serial data (the Monitor outputs "Please enter valid function to call"), but I suppose I don't really know how.

typedef void (* Caller)();
Caller FuncCall[] = {a, b, c};
String func_list[] = {"a","b","c"}; //correspond to functions in FuncCall, order matters.

"a", "b", and "c" are 3 separate functions that are written out later in the code.

Am I missing something here? I can elaborate if needed.

Answer 1

The Serial Monitor is nothing more than a window that displays the serial data sent to the PC. Are you saying that you are passing characters to the ATMega328 and calling certain functions based on what you send?

But as for your question:

typedef void (* Caller)()

Is a typedef for a void* function pointer (with void type) with the name of Called.

Caller FuncCall[] = {a, b, c);

Will evaluate at compile-time to:

void (* Caller)() FuncCall[] = {a, b, c);

Which is essentially an array of void* function pointers.

I am not sure of what you mean by void a(), but to use function pointers you must initialize them to point to functions. Consider the following example:

void printFunc(){
    printf("Print Test\n");
}

int main(){
    void (*functionPtr)();
    functionPtr = &printFunc; //functionPtr points to the address of printFunc()
    functionPtr();
    return 0;
}

---

Consider the following code:

#include <SoftwareSerial.h>

/* These are function prototypes - required by the compiler */
void a();
void b();
void c();

typedef void (* Caller)();
Caller FuncCall[] = {&a, &b, &c}; //initialize addresses for pointers 
//String func_list[] = {"a","b","c"}; //this is a terrible way to do this
char func_list[] = {'a', 'b', 'c'};   //use this instead - if you wish


void setup(){
    Serial.begin(9600);
}

void a(){
    Serial.println("Called Function: a\n");
}

void b(){
    Serial.println("Called Function: b\n");
}

void c(){
    Serial.println("Called Function: c\n");
}

void loop(){
    if(Serial.available())
        switch(Serial.read()){
            case 'a':           //this could also be func_list[0], if you want
                FuncCall[0]();
                break;

            case 'b':
                FuncCall[1]();
                break;

            case 'c':
                FuncCall[2]();
                break;

            default:
                Serial.println("There was an error\n");
                break;
    }
}

Where you simply send the Arduino a character (a, b, or c) through the Serial Monitor. You can make the implementation as complicated you want. You could, for example, have string parsing and indexing into the array as suggested - but the above implementation could not get any more simple to the best of my knowledge.

Answer 2

You need to indicate that you want to access what the pointer points to.

Add an asterisk in front of the pointer and parenthesises around it.

 (*FuncCall[0])();

Answer 3

It looks like the intent is to look up an incoming string in func_list[], turning into an index value if found, and then use that index to get the corresponding entry in FuncCall[], and call that function.

Once you have i, the index to the name of the function, the call would look like:

(FuncCall[i])();

Also, note that you have a typo in your initializer for FuncCall — the closing paren should be a brace.

Answer 4

From a comment:

I am trying to call the functions outside of the code (i.e., in the text entry space in the serial monitor)

Whoa there... you can't collect functions written in C into a buffer and then "execute" them. You'd have to build a compiler, asembler, linker etc into the Arduino program to perform their functions at runtime. C is a compiled (not an interpeted) language.

The constructs in your question merely allow you to call functions, which were available at compile time, with compliant signatures "dynamically" at runtime, by accessing them through an array. This is one way that "callback" functions are sometimes implemented.