Best Way To Find Message by ID in PROGMEM? - c++

Question

I am trying to determine what the best way would be to retrieve and display an error message from PROGMEM based on an integer return from an external device.
const prog_char error_1000[] PROGMEM = "No data provided.";
const prog_char error_1001[] PROGMEM = "device not activated";
const prog_char error_2000[] PROGMEM = "Machine ID invalid";
const prog_char error_3000[] PROGMEM = "Insufficient Balance";
void loop()
{
int result = device.GetStatus();
Serial.println(/*error by code here*/);
}
The errors are grouped together by the leading number (i.e. 1xxx are device errors, 2xxx are issues with another component, 3xxx are transaction errors). There are probably only 5-10 errors in each category though.
I am using a few memory heavy libraries and my memory is already almost exhausted on the Uno so I am trying to keep things small here.
Basically someway to lookup strings by an ID is what is required but I am not making much progress on the best way to do this.

Answer 1

instead of doing the following:
const prog_char error_1000[] PROGMEM = "No data provided.";
const prog_char error_1001[] PROGMEM = "device not activated";
const prog_char error_2000[] PROGMEM = "Machine ID invalid";
const prog_char error_3000[] PROGMEM = "Insufficient Balance";
I'd advise you to index the error category (1000s, 2000s etc..) as first index of a matrix, and the actual error as second index of the array:
Here's the idea:
const prog_char error_code[1][0] PROGMEM = "No data provided.";
const prog_char error_code[1][1] PROGMEM = "device not activated";
const prog_char error_code[2][0] PROGMEM = "Machine ID invalid";
const prog_char error_code[3][0] PROGMEM = "Insufficient Balance";
(edit) Here's a valid syntax:
const prog_char* error_code[][3] PROGMEM = {{"ERROR 1000", "ERROR 1001", "ERROR 1002"},
{"ERROR 2000", "ERROR 2001", "ERROR 2002"},
{"ERROR 3000", "ERROR 3001", "ERROR 3002"}};
the only drawback will be that you shall specify the length of the inner array, and thus need to have the same number of string in each inner array.
And then you could code a function that does status code conversion:
const prog_char* fmt_error(int code) {
return error_code[code/1000][code%1000];
}
void loop()
{
int result = device.GetStatus();
Serial.println(fmt_error(result));
}
That solution does not use more memory than using one array (just one more pointer). The only downside of that is if you need status code that are not contiguous, like 1000, 1010, 1042 and 1300. Then there is no cool solution I can think of, except using a good old switch/case:
const prog_char* fmt_error(int code) {
switch (code) {
case (1000): return F("Error XXX");
case (1042): return F("Error which code is not contiguous");
case (2042): return F("Another error");
}
}
(edit) I had a third idea on how to deal with your problem:
typedef struct
{
int code;
prog_char* message;
} error_code;
const error_type error_codes[] =
{
{0000, F("Unknown error code")},
{1000, F("Error foo")},
{1001, F("Error bar")},
{2000, F("Error foobar")}
...
};
const prog_char* fmt_error(int code) {
for (int i=0; i<sizeof(error_codes);++i)
if (error_codes[i].code == code)
return error_codes[i].message;
return error_codes[0];
}
But I think the solution that uses the less memory of all three solution is the second one using use cases. Because everything is done in program memory, and all the strings are in the flash thanks to the F() macro. To save a few extra bytes, you could even make the fmt_error() function inline, so it does not add to the function call stack.
HTH