CCSv4 const in Flash

[Andreas Dot(er) (Gast)]

Hallo,

wieder Einer am verzweifeln: Ich versuche meinen LCD-Text in den Flash 
des MSP430g2553 mittels CCS Version4 zu schreiben:

Definition:
-----------
const char msg_MainMenue1[] = {"Schreibe etwas"};

Hauptprogramm:
--------------
PrintStr((char*)msg_MainMenue1);



Die Funktion PrintStr:
----------------------
void PrintStr(char *Text)
{
    char *c;

    c = Text;

    while ((c != 0) && (*c != 0))
    {
        SendByte(*c, TRUE);
        c++;
    }
}

Leider landen alle Strings im RAM statt im Flash. Was ist denn nur 
falsch? HILFE?!?!?!?! Gibt es eine spezielle IDE-Einstellung vielleicht? 
Oder muss ich die const-Daten ins Header schreiben?

PS: Selbst die FAQ vom CCS sagt es soll gehen...
http://www.ccsinfo.com/faq.php?page=constant_data

[holger (Gast)]

Ist nur geraten, aber machs doch mal so

char const msg_MainMenue1[] = {"Schreibe etwas"};

[Andreas Dot(er) (Gast)]

leider gleich erfolglos...

Hab noch im Map-File nachgeschaut:
.const     0    0000d546    000001a1
                ...
                0000d56a    00000011     Projekt_2.obj 
(.const:msg_MainMenue1)
                0000d57b    00000001     --HOLE-- [fill = 0]
                ...

Also da stehen zumindest alle Messages drunter.
Und im Bereich:
GLOBAL SYMBOLS: SORTED ALPHABETICALLY BY Name
address    name
--------   ----
00000200   .bss
0000c000   .text
...
0000d56a   msg_MainMenue1
...

stehen auch alle Message. Was heißt das nun? Das zwar alles korrekt ins 
Flash gespeichert wird, aber doch im RAM landet, weil irgendwie eine 
Routine nicht passt???

[Andreas Dot(er) (Gast)]

Auch wenn ich grad (fast) mit mir selber rede, aber: Ist die Anzeige im 
CCS von:
MSP430: Program loaded. Code Size - Text: 5446 bytes  Data: 565 bytes

nur die Nutzgröße des übersetzten Programms? Gib nur das *.map-file 
Aufschluß  darüber, ob die const-Daten im Flash stehen?

[Gerhard O. (gerhard_)]

Hier stimmt irgend etwas nicht;-)

Der CCS C-Compiler gibt es doch nur für PIC. Dein Target ist doch ein 
MSP430.
Du meintest bestimmt GCC Compiler für MSP430. So wie Dein Ausschnitt vom 
MAP file aussieht wurde der von einem GCC Compiler produziert.

Ueber Dein Problem kann ich nichts sagen weil ich noch nicht mit MSP430 
gearbeitet habe. Beim PIC geht das was Du machen willst wegen der 
getrennten FLAHS und RAM Speicher Architektur nicht direkt. Also, einen 
Zeiger auf das array machen, geht nicht und ist auch auf Deiner Link auf 
CCS bestaetigt.

Beim CCS compiler und PIC mache ich das immer so mit dem CCS Compiler:

char const msg_MainMenue1[] = {"\r\nSchreibe etwas\r\n"};

void main(void)
{
    // initialisierung weg gelassen
    char buf[32];

    strcpy(buf, msg_MainMenue1);
    printf("%s", buf);  // Nur zur Einfachheit hier ein printf()

    for(;;);
}

Das funktioniert. Der Preis ist halt etwas mehr RAM und Laufzeit. Die 
Strings werden aber tatsächlich im FLASH gespeichert. Nur beim Gebrauch 
solcher Strings wird entsprechend RAM gebraucht.

[Ich (Gast)]

CCS gleich Code Composer Studio. Der MSP und das CCS sind von Ti.

[Gerhard O. (gerhard_)]

Ich schrieb:
> CCS gleich Code Composer Studio. Der MSP und das CCS sind von Ti.

Vielen Dank für den Hinweis. Da ich mich mit MSP430 z. Zt. nicht befasse 
war mir die Abkürzung nicht geläufig.

Gerhard

P.S. Die Link zeigt aber auf CCSINFO:

PS: Selbst die FAQ vom CCS sagt es soll gehen...
http://www.ccsinfo.com/faq.php?page=constant_data

[Ich (Gast)]

Naja, was solls schon sein. Ich vermute, dass der Bootloader dien 
initialisierten String ins Ram lädt.

[Christian R. (supachris)]

Nö, der MSP430 führt Code direkt aus dem Flash aus, da muss nix in den 
RAM gelegt werden. Solange der String in .text auftaucht, ist er im 
Flash. Und ja, das was beim Flashen angezeigt wird ist die wahre Größe 
des Programms (Flash und RAM).

[runtastic (Gast)]

Geb doch direkt die Section an in was für einen Flash er soll...

[real (Gast)]

Im Mapfile sieht man, dass mehr Speicher als nötig für den konstanten 
Text verwendet wird!

Das Konstrukt wird als initialisiert Variable umgesetzt!!!

Probier einmal
const char message[] = "schreibe etwas";

[Andreas Dot(er) (Gast)]

Hi,
danke für die Antworten!
Ich habe mal zwei *map-files verglichen; das Erste ist mit Text global 
als Variable:
MEMORY CONFIGURATION

         name            origin    length      used     unused   attr
----------------------  --------  ---------  --------  --------  ----
  SFR                   00000000   00000010  00000000  00000010  RWIX
  PERIPHERALS_8BIT      00000010   000000f0  00000000  000000f0  RWIX
  PERIPHERALS_16BIT     00000100   00000100  00000000  00000100  RWIX
  RAM                   00000200   00000200  000001ee  00000012  RWIX
  INFOD                 00001000   00000040  00000000  00000040  RWIX
  INFOC                 00001040   00000040  00000000  00000040  RWIX
  INFOB                 00001080   00000040  00000000  00000040  RWIX
  INFOA                 000010c0   00000040  00000000  00000040  RWIX
  FLASH                 0000c000   00003fe0  00001766  0000287a  RWIX

und das Zweite mit volatile const char:

MEMORY CONFIGURATION

         name            origin    length      used     unused   attr
----------------------  --------  ---------  --------  --------  ----
  SFR                   00000000   00000010  00000000  00000010  RWIX
  PERIPHERALS_8BIT      00000010   000000f0  00000000  000000f0  RWIX
  PERIPHERALS_16BIT     00000100   00000100  00000000  00000100  RWIX
  RAM                   00000200   00000200  0000005c  000001a4  RWIX
  INFOD                 00001000   00000040  00000000  00000040  RWIX
  INFOC                 00001040   00000040  00000000  00000040  RWIX
  INFOB                 00001080   00000040  00000000  00000040  RWIX
  INFOA                 000010c0   00000040  00000000  00000040  RWIX
  FLASH                 0000c000   00003fe0  000016f5  000028eb  RWIX

Ich glaube, hier sieht man deutlich, dass es doch mit const funktioniert 
und ich mich nur in die Irre führen lassen habe vom CCS :-).

[Andreas Dot(er) (Gast)]

real schrieb:
> Im Mapfile sieht man, dass mehr Speicher als nötig für den konstanten
> Text verwendet wird!
>
> Das Konstrukt wird als initialisiert Variable umgesetzt!!!
>
> Probier einmal
> const char message[] = "schreibe etwas";

Ah, könnte schon sein - hab ja keine Ahnung. Aber was genau ist denn der 
inhaltliche / funktionelle Unterschied zwischen den Schreibweisen?

const char message[] = "schreibe etwas";
und
const char msg_MainMenue1[] = {"Schreibe etwas"};

[Andreas Dot(er) (Gast)]

Nach ein wenig Recherche:
"Bei der Initialisierung ohne die geschweiften Klammern und bei den 
String-Funktionen wird das Ende-Zeichen automatisch gesetzt. Das 
Ende-Zeichen dient nur zur Markierung, deshalb ist es bei der Ausgabe 
auch nicht zu sehen. Wir sprechen hierbei von sogenannten 
nullterminierten Strings."
Quelle: 
http://www.c-howto.de/tutorial-strings-zeichenketten-nullterminiert.html

D.h., mit {} wird die \0 erzwungen mit angehängt, ohne die Klammern 
werden sie bei der Definition (const) weggelassen und nur zur Laufzeit 
bei der Ausgabe angehängt?

[real (Gast)]

.const     0    0000d546    000001a1
                ...
                0000d56a    00000011     Projekt_2.obj 
(.const:msg_MainMenue1)
                0000d57b    00000001     --HOLE-- [fill = 0]

Wenn ich das richtig deute, ist der string 17 Zeichen groß. Der Text 
umfasst aber nur 14 Zeichen plus Terminierung 1 Zeichen.

Poste einmal den Auszug ohne Klammern. Der string darf nur 15 Zeichen im 
Speicher belegen.

[Andreas Dot(er) (Gast)]

Du hast prinzipiell Recht, doch wenn ich dir jetzt sage - und ich hab 
selber erstmal überlegen müssen :-) - dass der Text oben "schreib etwas" 
nicht der Text war, denn ich beim übersetzten benutzt habe (waren 
16Zeichen lang), dann ist es klar woher die Diskrepanz kommt :-)

Aber Danke für die Antworten!