Passing a pointer to PROGMEM in function

Projects Programming
1

Hello all.

What I try to do is to pass a pointer to a PROGMEM char-array to a class. I want that the calls gets a "name" which is stored in PROGMEM. I want the class only to hold the pointer to the char-array in PROGMEM. I failed.

So I tried to narrow it down and it seems like whenever I try to copy the pointer to another variable I just read the wrong portion in the memory. I put together some sample code which exactly shows the unintenden behavior.

So hier is the code:

const char verboseName_000[] PROGMEM = "String 0";
const char verboseName_001[] PROGMEM = "String 1";
const char verboseName_002[] PROGMEM = "String 2";
const char verboseName_003[] PROGMEM = "String 3";
const char verboseName_004[] PROGMEM = "String 4";

const char* const verboseTexts[] PROGMEM = {
    verboseName_000, verboseName_001, verboseName_002, verboseName_003, verboseName_004
};

String version = "v0.1";

void setup() {
    char buffer[50];
    const char* testpointer = verboseTexts[1];

    Serial.begin(115200);
    Serial.print(F("AquaMaster NT "));
    Serial.print(version);
    Serial.println(F(" is starting up ..."));
    Serial.print("verboseTexts[1] pointer: ");
    Serial.println((long)verboseTexts[1], HEX);

    strlcpy_P(buffer, (char*)pgm_read_word(&verboseTexts[1]), 50);
    Serial.print("Read Try: ");
    Serial.println(buffer);
    Serial.println(" ************************************ ");
    Serial.print("testpointer: ");
    Serial.println((long)testpointer, HEX);
    strlcpy_P(buffer, (char*)pgm_read_word(&testpointer), 50);
    Serial.print("Read Try: ");
    Serial.println(buffer);    
}

void loop() {}

And here is what I read on Serial-monitor:

AquaMaster NT v0.1 is starting up ...
verboseTexts[1] pointer: 135
Read Try: String 1
 ************************************ 
testpointer: 135
Read Try: v⸮⸮⸮6⸮⸮⸮⸮/⸮⸮⸮#⸮⸮⸮⸮=⸮c⸮v⸮⸮⸮%⸮⸮⸮⸮⸮

As you can see the simple instruction const char* testpointer = verboseTexts[1]; seems to be wrong. I guess I cannot just copy since the pointers are stored in PROGMEM too. I tried already some things with pgm_read_ptr and similar but I never could get the same output.
Strange: If I try it on an NodeMCU Board with an ESP8266 this is working without issue. Seems like they do use some different memory-management there or whatever.

I tried two different Ardunio Mega 2560 since this is the hardware it should run - same behavior.

Really hope someone can tell me what is going oin there.

Cheers,
Schetter

2

There are examples of what you're trying to do here: PROGMEM - Arduino Reference

3

Thanks.
I read this. This ist why the first part successfully displayed the string from PROGMEM. However, as soon as I copy the const char pointer I read garbage. Even as if it looks like the content is the same. Or do I miss something on that example page?

Regards, Schetter

1 Like
4 
const char verboseName_000[] PROGMEM = "String 0";
const char verboseName_001[] PROGMEM = "String 1";
const char verboseName_002[] PROGMEM = "String 2";
const char verboseName_003[] PROGMEM = "String 3";
const char verboseName_004[] PROGMEM = "String 4";

const char* const verboseTexts[] PROGMEM = {
  verboseName_000, verboseName_001, verboseName_002, verboseName_003, verboseName_004
};

void setup() {
  char buffer[50];
  const char* testpointer = (char*)pgm_read_word(&verboseTexts[1]);

  Serial.begin(115200);
  Serial.println(F(" is starting up ..."));

  Serial.print("verboseTexts[1] pointer: ");
  strlcpy_P(buffer, (char*)pgm_read_word(&verboseTexts[1]), 50);
  Serial.print("Read Try: ");
  Serial.println(buffer);

  Serial.println(" ************************************ ");

  Serial.print("testpointer: ");
  Serial.println((uint16_t)testpointer, HEX);
  strlcpy_P(buffer, testpointer, 50);
  Serial.print("Read Try: ");
  Serial.println(buffer);
}

void loop() {}
5 
    Serial.println((long)verboseTexts[1], HEX);

This fails to tell println that verboseTexts[1] is a pointer into PROGMEM space.
Try

    Serial.println(reinterpret_cast<const __FlashStringHelper *>verboseTexts[1], HEX);

That''s SUPPOSED to invoke the same println code that F("literalstring") would (except the F macro also contains code to put the literal string in flash, which won't work if there's already a pointer.)

6 
    strlcpy_P(buffer, (char*)pgm_read_word(&testpointer), 50);

testpointer is already a pointer to a progmem location, and strlcpy_P() expects the 2nd argument to be a pointer to progmem, so the (char*) and pgm_read_word are unnecessary.

 strlcpy_P(buffer, testpointer, 50); //this works in your code - see explanation below

Note that this only works because the compiler sets the value of testpointer during compilation, testpointer is a constant value pointing to one specific location in progmem that the compiler knows the value of while compiling.

    const char* testpointer = verboseTexts[1];  //<<<< this line will work properly 

    //these lines of code WILL NOT work properly, vecause verboseTexts[] is stored in progmem
    //  and testpointer has to be set during program execution, not during compilation.
    char* testpointer;  
    testpointer = verboseTexts[random(5)];

    //this will produce the expected results
    char* testpointer;
    testpointer = pgm_read_word(&verboseTexts[random(5)]);

The compiler optimizations can trick you with stuff like that when testing simple examples, the test code appears to work fine, but later on when you actually start setting values dynamically within the code you no longer get the expected results.

7

david_2018:
The compiler optimizations can trick you with stuff like that when testing simple examples, the test code appears to work fine, but later on when you actually start setting values dynamically within the code you no longer get the expected results.

The code posted in Reply #3 works and handles dynamic selection of the array element correctly.

8

Dear all.

What shall I tell you: It works. Many thanks. I already got suspicious about the simple assingment of testpointer. Like told I already tried to use the prgm_read...stuff and did not succed. What I was missing is simply the change in strcpy_P-function I always still used

strlcpy_P(buffer, (char*)pgm_read_word(&testpointer), 50);

insted of

strlcpy_P(buffer, testpointer, 50);

That is why I never reched the desiered behavior.

And I of course when calling the constructor of an object I need to pass the pointer like in the example below.

const char verboseName_000[] PROGMEM = "String 0";
const char verboseName_001[] PROGMEM = "String 1";
const char verboseName_002[] PROGMEM = "String 2";
const char verboseName_003[] PROGMEM = "String 3";
const char verboseName_004[] PROGMEM = "String 4";

const char* const verboseTexts[] PROGMEM = {
  verboseName_000, verboseName_001, verboseName_002, verboseName_003, verboseName_004
};

class Verbose
{
  public:
    Verbose();
    Verbose(const char* name);
    ~Verbose();

    unsigned int GetName(char *name);

  private:;
    const char* name;
};

Verbose::Verbose()
{
  this->name = NULL;
}

Verbose::Verbose(const char* name)
{
  this->name = name;
}

unsigned int Verbose::GetName(char *name)
{
  if (this->name != NULL) {
    strcpy_P(name, this->name);
    return strlen(name);
  }
  else name[0] = '\0';
  return 0;
}

Verbose *verbCommon;

void setup() {
  char buffer[50];

  Serial.begin(115200);
  Serial.println(F(" is starting up ..."));
  verbCommon = new Verbose((char*)pgm_read_word(&verboseTexts[0]));
  verbCommon->GetName(buffer);
  Serial.println(buffer);
}

void loop() {

}

Works great. Now my objects got their names. Thank you very much.

kind regards,
Schetter