Arduino RAM sparen mit PROGMEM und strcpy_P()

[Ardur (Gast)]

Im Internet habe ich viel zum Thema "Arduino RAM sparen mit PROGMEM und 
strcpy_P()" gefunden. Daher hier nur ganz konkrete Detailfragen, die 
eben nicht klar beantwortet werden. Zunächst zwei Code-Beispiele in C:

void doSomething( char fall ) {
  char command[45] = "Dies ist ein zu modifizierendes Textgerippe\n";

  // verändere jetzt etwas am String command, bevor er weiterverarbeitet wird
  ...
}

Nun die RAM-sparende Variante:

void doSomething( char fall ) {
  const static char Cmd[] PROGMEM = "Dies ist ein zu modifizierendes Textgerippe\n";
  char command[45];
  strcpy_P( command, Cmd );

  // verändere jetzt etwas am String command, bevor er weiterverarbeitet wird
  ...
}

Fragen dazu:

1) Stimmt es, dass beim 1. Programm der String vor main() zur Laufzeit 
ins Ram kopiert wird und dann beim Aufruf der Funktion doSomething() 
Platz auf dem Stack für command[] resierviert wird und zu Beginn der 
Funktion der String aus dem Ram an diesen Platz kopiert wird?

2) Stimmt es, dass beim 2. Programm beim Funktionsaufruf von 
doSomething() Platz auf dem Stack für command[] resierviert wird und 
dann nur mittels strcpy_P() direkt aus dem Flash in diesen Stack-Platz 
kopiert wird?

3) Wieviel länger braucht auf dem ATmega328 strcpy_P() als das Kopieren 
in 1)? 1 Taktzyklus pro Zeichen?

[Falk B. (falk)]

Ardur schrieb:

> 1) Stimmt es, dass beim 1. Programm der String vor main() zur Laufzeit
> ins Ram kopiert wird und

Ja, denn das ist eine statische, lokale Variable.

> dann beim Aufruf der Funktion doSomething()
> Platz auf dem Stack für command[] resierviert wird und zu Beginn der
> Funktion der String aus dem Ram an diesen Platz kopiert wird?

Nein, denn die Variable ist statisch, sie ist schon dauerhaft angelegt, 
siehe oben.

> 2) Stimmt es, dass beim 2. Programm beim Funktionsaufruf von
> doSomething() Platz auf dem Stack für command[] resierviert wird und
> dann nur mittels strcpy_P() direkt aus dem Flash in diesen Stack-Platz
> kopiert wird?

Ja.

> 3) Wieviel länger braucht auf dem ATmega328 strcpy_P() als das Kopieren
> in 1)? 1 Taktzyklus pro Zeichen?

So in etwa. Aber 99,9% aller Programme stört das nicht, denn die CPU ist 
in den meisten Fällen mit anderen Sachen beschäftigt als zu 100% Strings 
zu kopieren.

[Stefan F. (Gast)]

Falk B. schrieb:
> Nein, denn die Variable ist statisch, sie ist schon dauerhaft angelegt,
> siehe oben.

Er meint die Ziel Variable, in die er den String hinein kopiert. Die ist 
nicht statisch. Aber auch nicht auf dem Heap, sondern auf dem Stack.

[Falk B. (falk)]

Stefan ⛄ F. schrieb:
> Er meint die Ziel Variable, in die er den String hinein kopiert. Die ist
> nicht statisch. Aber auch nicht auf dem Heap, sondern auf dem Stack.

Die gibt es im 1. Beispiel aber nicht!

[Frank M. (ukw) (Moderator)]

Falk B. schrieb:
> Die gibt es im 1. Beispiel aber nicht!

Doch:

char command[45] = "Dies ist ein zu modifizierendes Textgerippe\n";

command ist nicht statisch im ersten Programm, deshalb wird dieses Array 
bei jedem Aufruf von doSomething() neu gefüllt.

[Irgend W. (Firma: egal) (irgendwer)]

Frank M. schrieb:
> Doch:char command[45] = "Dies ist ein zu modifizierendes Textgerippe\n";
>
> command ist nicht statisch im ersten Programm, deshalb wird dieses Array
> bei jedem Aufruf von doSomething() neu gefüllt.

Er sagt hier ja explizit das er "command" auch verändern können möchte 
und somit muss das im RAM stehen. Damit erstmal den ganzen Code zu 
durchsuchen das der Programmierer das hier eventuell falsch deklariert 
hat und er es eigentlich garnicht verändern will, soviel Esoterik ist 
nicht der Stiel von C/C++. Das geht öfters davon aus das der 
Programmierer weis was er will (und das auch richtig angeben kann:-).

folgender wäre zulässig:

char command[45] = "Dies ist ein zu modifizierendes Textgerippe\n";
strcpy(command, "Neuer Text");

Hier würde das ganze meckern:

const char command[] = "Dies ist ein zu modifizierendes Textgerippe\n";
strcpy(command, "Neuer Text");

Durch das const sagt der Programiere das die Variable in ihrem 
Gültigkeitsbereich nicht verändert werden darf und somit darf der 
Compiler/Linker das auch annehmen und entsprechende Optimierungen 
durchführen.

[Peter D. (peda)]

Ardur schrieb:
> Nun die RAM-sparende Variante:

Spart das wirklich was?
Was sagt denn avr-size dazu.

[Apollo M. (Firma: @home) (majortom)]

... mich interessiert mal der Sinn von static hier, wenn die Variable 
doch sowieso "statisch" fix im Flash liegt.

Das erscheint mir reduntant/unnötig?! Sehe ich aber immer wiedermal ...

Ardur schrieb:
> const static char Cmd[] PROGMEM = "Dies ist ein zu modifizierendes
> Textgerippe\n";

[Falk B. (falk)]

Peter D. schrieb:
> Ardur schrieb:
>> Nun die RAM-sparende Variante:
>
> Spart das wirklich was?

Es spart die (unsichtbare) RAM-Kopie! Denn der String wird beim 
Funktionsaufruf NICHT direkt aus dem Flash initialisiert sondern aus der 
Kopie im RAM. Eben darum sind konstante Strings auf dem AVR Mist 
(RAM-Verschwendung), welche man besser mit den _P Funktionen sowie 
PSTR("") Makro umgeht. Das sollte DIR aber als altem AVR-Hasen aber 
bekannt sein.

[batman (Gast)]

Ack, so verdoppelt man sich schnell mal den freien RAM.

[Falk B. (falk)]

Hier der Test für jeden nachvollziehbar. Test2 und 3 sind praktisch 
identisch, wenn gleich test3 kompakter ist.

#include <avr/io.h>
#include <avr/pgmspace.h>

#define TEST 1

#if TEST==1
void test1(void) {
    int i=0;
    char command[45] = "Hallo RAM-Verbrauchstest!";

    while(command[i]) {
        PORTD = command[i];
    }
}
#endif

#if TEST==2
void test2(void) {
    int i=0;
    char command[45];
    const static char cmd_init[45] PROGMEM= "Hallo RAM-Verbrauchstest!";
    
    strcpy_P(command, cmd_init);
    while(command[i]) {
        PORTD = command[i];
    }
}
#endif

#if TEST==3
void test3(void) {
    int i=0;
    char command[45];
    
    strcpy_P(command, PSTR("Hallo RAM-Verbrauchstest!"));
    while(command[i]) {
        PORTD = command[i];
    }
}
#endif


int main(void) {
#if TEST==1
   test1();
#endif

#if TEST==2
   test2();
#endif

#if TEST==3
    test3();
#endif

}

Test Flash RAM
1      270  46
2      242   0
3      222   0

[Ardur (Gast)]

Dann ist also für meinen Fall, einen längeren String in einer Funktion 
verändern zu müssen, die von Falk B. (falk) vorgeschlagene 3. Variante 
die RAM- und Flash-sparendste:

void doSomething( char fall ) {
   char command[45];
   strcpy_P( command, PSTR("Dies ist ein zu modifizierendes Textgerippe\n") );

   // verändere jetzt etwas am String command, bevor er weiterverarbeitet wird
   ...
}

Ich bedanke mich ehrlich.

[Stefan F. (Gast)]

Wenn du den modifizerten Text irgendwo seriell ausgibts (z.B. auf einem 
Display) könntest du ihn auch in mehreren Stücke zerlegen. Beispiel:

Statt: "Die Temperatur ist # Grad Celsius", wo dann # durch die Zahl 
ersetzt wird, könntest zu auch das tun:

ausgeben_P(PSTR("Die Temperatur ist "));
ausgeben(zahl);
ausgeben_P(PSTR(" Grad Celsius"));

Das würde noch viel weniger RAM belegen.

[MaWin (Gast)]

Apollo M. schrieb:
> mich interessiert mal der Sinn von static hier, wenn die Variable doch
> sowieso "statisch" fix im Flash liegt

Wäre sie nicht static, könnte sie nicht im flash liegen, daher ist 
static nötig.

Falk B. schrieb:
> Das sollte DIR aber als altem AVR-Hasen aber bekannt sein.

Das schlimme ist, dass es dem GCC Compiler nicht bekannt ist. Der könnte 
optimieren, er weiss ob in Speicher hineingeschrieben wird, welche Kopie 
unnötig ist, der könnte selber eine vernünftige Speicheraufteilung 
erzeugen, aber er ist offenkundig noch immer zu doof dazu.

DAS ist das eigentlich Erschreckende im Jahr 2020.

Die ganzen Jubelperser "der beste Compiler, optimiert super, besser ist 
man per Hand in Assembler nie" müsstest du ansprechen.

(ich musste gerade den Takt eines AVR von 1 auf 8 MHz hochsetzen, damit 
er eine simple Interruptroutine noch schafft, die nicht häufiger als 
alle 50us aufgerufen wird:)

uint16_t buffer[256];
uint8_t pos;
ISR(TIMER1_CAPT_vect)
{
  buffer[pos++]=ICR1;
  TCCR1B^=(1<<ICES1);
}

Der Compiler ist damit überfordert.

[Stefan F. (Gast)]

MaWin schrieb:
> Das schlimme ist, dass es dem GCC Compiler nicht bekannt ist. Der könnte
> optimieren, er weiss ob in Speicher hineingeschrieben wird, welche Kopie
> unnötig ist, der könnte selber eine vernünftige Speicheraufteilung
> erzeugen, aber er ist offenkundig noch immer zu doof dazu.

Der arm-gcc kann diesbezüglich einiges besser, als der avr-gcc. 
Vermutlich hat es damit zu tun, dass AVR spezielle Befehle für den 
Zugriff auf den Flash Speicher brauchen, die gängigen ARM Controller 
aber nicht.

[Einer K. (Gast)]

Stefan ⛄ F. schrieb:
> Statt: "Die Temperatur ist # Grad Celsius", wo dann # durch die Zahl
> ersetzt wird, könntest zu auch das tun:
>
> ausgeben_P(PSTR("Die Temperatur ist "));
> ausgeben(zahl);
> ausgeben_P(PSTR(" Grad Celsius"));

#include <Streaming.h>

void setup() 
{
  Serial.begin(9600);
  Serial << F("Start: ") << __FILE__ << endl;
}

void loop() 
{
  float grad {47.11};
  Serial << F("Die Temperatur ist ") << grad << F(" Grad Celsius") << endl;
}

F() Makro:
https://www.arduino.cc/reference/de/language/variables/utilities/progmem/

[M. K. (sylaina)]

MaWin schrieb:
> Das schlimme ist, dass es dem GCC Compiler nicht bekannt ist. Der könnte
> optimieren, er weiss ob in Speicher hineingeschrieben wird, welche Kopie
> unnötig ist, der könnte selber eine vernünftige Speicheraufteilung
> erzeugen, aber er ist offenkundig noch immer zu doof dazu.

Da das ja deiner Meinung nach so einfach zu implementieren ist: Na dann 
mal ran, MaWin. Muss ja ein Klacks für jemanden wie dich sein. ;)

[Oliver S. (oliverso)]

MaWin schrieb:
> Der Compiler ist damit überfordert.

Kein Compiler dieser Welt ist foolproof. Wenn sich da der Anwender sich 
absichtlich dummer darstellt, als er ist, kann der Compiler nichts 
dafür.

Oliver

[Stefan F. (Gast)]

Arduino Fanboy D. schrieb:
> Arduino Beispiel

Ja, so macht man das "richtig" im Arduino Style. Hat den Vorteil, dass 
es genau so auch auf ARM Controllern funktioniert.