Convert __DATE__ into const char variable

[Moschdi (Gast)]

Hallo zusammen,

Ich würde gerne den Inhalt des Makros _DATE_ (Datum)das vom Compiler 
kommt zur Compilerlaufzeit in eine Konstante z.B const char var 
überführen. Ich verwende einen WinRiver Compiler Diab 5.2.1. hat 
irgendjemand von Euch eine Ahnung wie sowas zur Compilerlaufzeit 
funktioniert?
Wäre um Hilfe sehr Dankbar!!

Liebe Grüße
Moschdi

[Stefan B. (stefan)]

const char *var = _DATE_;

[Moschdi (Gast)]

Hallo Stefan,

vielen Dank für Deine Antwort! jetzt hab ich zwar einen Pointer auf 
_DATE_, wie bekomme ich aber zur Compilerlaufzeit den Wert  aus 
_DATE_
in eine Konstant?

Liebe Grüße
Moschdi

[Stefan B. (stefan)]

In welche Konstante?

Der Inhalt von _DATE_, welcher an sich ein String ist, ist doch 
konstant (fix) vorhanden z.B. in deinem Flash. Und der als 
unveränderlich gekennzeichnete Zeiger var zeigt auf diesen Inhalt.

Was brauchst du mehr? Wenn du lieber ein Array möchtest, um z.B. über 
dessen Laufindex an die einzelnen Buchstaben/Zahlen ranzukommen, geht 
auch:

const char var[] = _DATE_;

Siehe auch
http://www.dclc-faq.de/kap2.htm#2.2

[Moschdi (Gast)]

Hallo Stefan,

so weit war ich auch schon mit:
const char [] = _DATE_;

leider funktioniert es aber so nicht, da bekomme ich einen 
Compilerfehler.

Mir wäre auch schon geholfen, wenn ich wüsste, wo genau der Compiler das 
Makro _Date_ genau ablegt. In meinem *.map File ist davon nichts zu 
finden. Aber irgendwo muss er es ja im Flash ablegen.

Hintergrund der Fragerei ist:

Meinem Board kommuniziert mit einem anderen System das Daten zu meinem 
Controller runterladen kann. Um sicher zu stellen, dass das System mit 
der richtigen Version kommuniziert wird zuvor ein CodeCheck auf beiden 
Seiten durchgeführt. Dazu soll ein Code Check pattern auf einen 
bekannten Speicherbereich gelegt werden, der von meinem Controller, 
sowie von dem System gelesen werden kann. Genau in diesen 
Speicherbereich möchte ich gerne das Datum und die Uhrzeit des 
Compilvorgangs ablegen. In einem ersten Schritt benötige ich dazu den 
Inhalt aus _DATE_ in einer einfachen Konstante. Dies Konstante muss 
aber während der Copilerlaufzeit beschrieben werden!

Liebe Grüße
Moschdi

[Rolf Magnus (Gast)]

> so weit war ich auch schon mit:
> const char [] = _DATE_;

Das kann ja auch nicht gehen. Deine Variable hat nämlich keinen Namen.

> leider funktioniert es aber so nicht, da bekomme ich einen
> Compilerfehler.

Sollen wir raten, welchen, oder verrätst du es uns freiwillig?

[Karl H. (kbuchegg)]

Stell dir einfach den String

  "12/03/07"

vor. (Ob der jetzt so aufgebaut ist oder anders, weiss ich
nicht auswändig. Wahrscheinlich aber anders)

Überall dort, wo du den verwenden kannst, kannst du auch _DATE_
einsetzen. _DATE_ ist nichts anderes als so ein String, nur
dass er
  * vom Compiler bereitgestellt wird, also immer das aktuelle
    Datum hat
  * einen Namen bekommen hat

Das ganze ist so, als ob du selbst ein

#define DATE "06/28/07"

machen würdest, nur das das halt der Compiler für dich macht.
Aber ansonsten ist das ein ganz normaler String, so wie jeder
andere String auch.

[Karl H. (kbuchegg)]

> In einem ersten Schritt benötige ich dazu den
> Inhalt aus _DATE_ in einer einfachen Konstante. Dies Konstante muss
> aber während der Copilerlaufzeit beschrieben werden!

Du hast schon eine Konstante dafür.
_DATE_ ist die Konstante

void foo( const char* arg )
{
  char c = arg[0];
}

int main()
{
  printf( "%s", __DATE__ );
  printf( __DATE__ );
  foo( __DATE__ );

  // das unterscheidet sich in nichts von
  printf( "%s", "06/28/07" );
  printf( "06/28/07" );
  foo( "06/28/07" );

  // oder wenn man so will, von
#define ABC "06/28/07"
  printf( "%s", ABC );
  printf( ABC );
  foo( ABC );
}

[Moschdi (Gast)]

Hallo zusammen,

alles schön und gut, das _DATE_ bereits meine Konstante ist, ist mir 
klar, ich sollte nur wissen an welcher Adresse im Flash der Inhalt von 
_DATE_ liegt. Wie schon gesagt, greift nicht nur mein Controller auf 
den _DATE_ Inhalt zu, sondern auch mein System. Um einen code check 
durchzuführen muss dass System genau den Speicherplatz (Adresse) von 
_Date_ kennen, um selbst einen code check durchführen zu können.

1. Möglichkeit: ich bekomme irgendwie heraus wo der Compiler _DATE_ im 
Flash ablegt. Somit wäre der Speicherort bekannt und ich könnte diesen 
Speicherort dem System mitteilen oder:

2. Möglichkeit: ich lade den Inhalt von _DATE_ zur Compilierzeit in 
eine Konstante um, dessen Speicherbereich mir bekannt ist und könnte 
dann somit den Speicherbereich der von mir erzeugten Konstante dem 
System mitteilen.

Danke für Eure Antworten!!

Ich hoffe ich kann mein Problemchen mit diesem Eintrag noch näher 
beschreiben. Letztenendes liegt der Schlüssel zu meinen Überlegungen 
darin, dass ich die Adresse wissen sollte wo _DATE_ im Flash abgelegt 
wird. Da ich das bis jetzt noch nicht rausgefunden habe, kam mir die 
Idee, den Inhalt von _DATE_ einfach zur Compilierzeit in eine mir 
bekannte Konstane zu überführen. Leider ist das auch nicht so einfach 
möglch!

Eine weitere Möglichkeit wäre noch während meines Make Prozesses ein 
Perl Skript aufzurufen, dass sich die Systemzeit des Rechners holt und 
mir dann ein Header file generiert, welches wiederum eine mir bekannte 
Konstante beinhaltet und dem ich dann den Datum- und Zeitstempel 
verpassen kann.

Liebe Grüße
Moschdi

[Stefan B. (stefan)]

Die erste Möglichkeit kannst du beim GCC durch Ansehen des MAP Files 
bzw. bzw. der Ausgabe des nm Tools realisieren. Dort steht drin, welche 
Daten, Funktionen welche Adressen usw. haben. Dein System kann an diesen 
dir als Programmierer bekannten Adressen nachsehen.

Nachteil: Die Adresse wird sich beim Hinzufügen weiterer Variablen und 
weiterem Code ändern. Dann musst du deine Systemsoftware neu 
kompilieren, wenn sich die µC Software ändert.

Die zweite Möglichkeit ist ja oben angegeben. Einmal als Zeigerlösung 
und einmal als Arraylösung. Den Fehler bei deinem Übersetzungsversuch 
kannst du beheben, wenn du einen Variablennamen benutzt z.B. var wie in 
meinen Beispielen. Dein System könnte die Adresse oder den Inhalt vom µC 
abfragen und darauf reagieren.

Möglicherweise gibt es bei deinem Compiler eine Erweiterung, um zu 
verhindern, dass Konstanten ins RAM kopiert werden. Beim AVR-GCC wäre 
das das PROGMEM Keyword 
(http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Programmspeicher_.28Flash.29). 
In diesem Fall würde der Zeiger oben direkt ins ROM zeigen, bingo...

Vorteil: Die Abfrage kann komplett flexibel gestaltet werden. 
Systemsoftware und µC Software sind unabhängig (bis auf gemeinsamen 
Datenaustausch). Nachteil: Tja halt die erforderliche Kommunikation. 
Einfaches Nachsehen von einer Seite aus ist problematisch.

Eine dritte Möglichkeit wäre, eine Sektion im Flash mit bekannter 
Adresse zu definieren und eine Konstante, die mit _DATE_ initialisiert 
ist, gezielt in diese Sektion abzuspeichern. Das würde man bei GCC 
basierten Compilern im Quellcode mit dem _attribute_ section zusammen 
mit dem passenden Linkercontrolscript machen. Dein System kann an den 
dir als Programmierer bekannten Adressen nachsehen.

Vorteil: Die Adressen bleiben solange konstant, wie das 
Linkercontrolscript nicht geändert wird und keine Variablen (Konstanten) 
vor die DATE-Konstante in die gleiche Sektion eingefügt werden. Eine 
etwas bessere Variante der ersten Lösung...

[Moschdi (Gast)]

Hallo Stefan,

ich werde Deine angegebenen Möglichkeiten mal überprüfen und schauen, ob 
ich da weiter komme!

Vielen Vielen Dank für Deine Hilfe!!!!

Hab mir gerade noch die Möglichkeit mit dem perl script gestrickt und 
damit funktioniert es einwandfrei! Die Komfortablere Lösung wäre jedoch 
deine Möglichkeiten!

Liebe Grüße
Moschdi