Gibt es sowas wie eine Buildnumber in AVR-GCC ?

[N. N. (drnicolas)]

Ich würde gerne in mein Firmware-Projekt so etwas wie eine Build-Nummer 
oder Versionsabfrage einbauen.

Gib es ein feature, das automatisch bei jeder neu-Kompilierung die 
Build-nummer um eins erhöht und bei jeder Komplett-Neuerstellung 
ausserdem die Versionsnummer ?

[Klaus W. (mfgkw)]

M.W. nicht.
So etwas regle ich normalerweise mit einer paar Skriptzeilen
im Makefile.

Außerdem gibt es natürlich noch _DATE_

[Bernhard (Gast)]

Meines Wissens gibt es sowas wie eine Versionsnummer nur mit einem
Versionverwaltunsgsystem wie rcs, cvs, oder subversion. Da wird im
source code ein id-string hinterlegt, der beim ein- und auschecken
verändert wird. Sowas könnte man auch per script nachbauen.

[Peter (Gast)]

Die Build-Nummer passe ich manual an. Daran kann man sich rasch gewöhnen 
es auch konsequent zu machen.

Zudem verwende ich aber noch TIME_ und _DAT als Timestamp für den 
entsprechenden Build:

prog_char VERSION[] = "01.02.33";
prog_char AUTOR[]   = "Peter";
prog_char BUILT[]   = __DATE__ ", " __TIME__;


static void BOOT_check(int status)
{
  //----------------------------------------------------------------------
  printf_I("\n\n");                               // two new lines
  //----------------------------------------------------------------------
  if (status & (1<<BORF))                         // Brown-Out Reset
  {
    printf_I("Brown-Out Reset\n");
  }
  else if (status & (1<<PORF))                    // Power-On Reset
  {
    printf_I("Power-On Reset\n");
  }
  else if (status & (1<<JTRF))                    // JTAG Reset
  {
    printf_I("JTAG Reset\n");
  }
  else if (status & (1<<EXTRF))                   // External Reset
  {
    printf_I("External Reset\n");
  }
  else if (status & (1<<WDRF))                    // Watchdog Reset
  {
    printf_I("Watchdog Reset\n");
  }
  else
  {
    printf_I("SW Restart\n");                    // jump, call or run into reset
  }
  printf_I("----------------------------------------\n");
  printf_I("| Beispiel - Testprogram               |\n");
  printf_I("----------------------------------------\n");
  printf_I("Version: V-");printf_P(VERSION);printf_I("\n");
  printf_I("Built:    ");printf_P(BUILT);printf_I("\n");
  printf_I("Autor:    ");printf_P(AUTOR);printf_I("\n");

[Klaus (Gast)]

Was für eine Speicherverschwendung! oO

[N. N. (drnicolas)]

Gerade die manuelle Änderung wollte ich umgehen.
Time & Date könnte immerhin eine ganz gute Unterscheidung bieten ...

[Markus J. (markusj)]

Code::Blocks hat eine solche Funktion die automatisch beim 
speichern/kompilieren eine Build-Nummer inkrementieren kann - da ich 
aber inzwischen zu (AVR) Eclipse gewechselt habe, werden solche Aufgaben 
bei Bedarf von Hand erledigt.

mfG
Markus

[Rolf Magnus (Gast)]

Bernhard schrieb:
> Meines Wissens gibt es sowas wie eine Versionsnummer nur mit einem
> Versionverwaltunsgsystem wie rcs, cvs, oder subversion. Da wird im
> source code ein id-string hinterlegt, der beim ein- und auschecken
> verändert wird.

Der ändert seinen Wert aber nur bei einem Commit dieser Datei, d.h. um 
hier so eine Build-Nummer zu bekommen, müßtest du bei jedem 
Compiliervorgang die Datei verändern und dann commiten.

[tuppes (Gast)]

Nicolas Nickisch schrieb:
> Gib es ein feature, das automatisch bei jeder neu-Kompilierung die
> Build-nummer um eins erhöht und bei jeder Komplett-Neuerstellung
> ausserdem die Versionsnummer ?

Willst du das wirklich, bei jeder einzelnen Kompilierung eine Nummer 
erhöhen? Nummerieren musst du nur, was du irgendwo verwahrst oder was du 
nach außen gibst.

99 % der Kompilate erzeugst du nur für deinen eigenen Schreibtisch, die 
werden auch nirgendwo archiviert, stimmts? Also wozu die alle zählen?

[tuppes (Gast)]

Rolf Magnus schrieb:
> Bernhard schrieb:
>> Meines Wissens gibt es sowas wie eine Versionsnummer nur mit einem
>> Versionverwaltunsgsystem wie rcs, cvs, oder subversion. Da wird im
>> source code ein id-string hinterlegt, der beim ein- und auschecken
>> verändert wird.
>
> Der ändert seinen Wert aber nur bei einem Commit dieser Datei, d.h. um
> hier so eine Build-Nummer zu bekommen, müßtest du bei jedem
> Compiliervorgang die Datei verändern und dann commiten.

Das ist ein sinnvoller Ansatz. Was wertvoll genug ist, um im SCCS zu 
landen, ist auch wertvoll genug für eine Buildnummer. So könnte man es 
machen.

Nicht jeder Zwischenstand, bei dem man nur die Debugausgaben geändert 
hat, muss eine eigene Buildnummer haben.

[Andreas F. (aferber)]

tuppes schrieb:
> 99 % der Kompilate erzeugst du nur für deinen eigenen Schreibtisch, die
> werden auch nirgendwo archiviert, stimmts? Also wozu die alle zählen?

Ack. Eine Build-Nummer ist nur dann sinnvoll, wenn später der exakte für 
den Build verwendete Sourcecode reproduzierbar ist, ergo alles was in 
ein VCS eingecheckt wurde.

Eine bei jedem make hochgezählte Nummer ist wertlos, da das erstens 
nicht reproduzierbar ist, und zweitens wird das inkonsistent, sobald es 
mehr als eine Arbeitskopie gibt. Letzteres lässt sich i.d.R. spätestens 
dann nicht mehr vermeiden, wenn man mit mehreren Leuten an dem Projekt 
arbeitet, aber selbst alleine schränkt man sich mit nur einer Working 
Copy IMO sehr ein.

Allerdings sollte man irgendwie über den Build-Prozess dafür sorgen, 
dass wirklich nur ein aus einem komplett eingecheckten Source gebautes 
Image eine "Buildnummer" bekommt. Bei lokal geänderten Sourcen, z.B. 
zwecks Debugging, sollte das Feld dann z.B. mit "DEV" oder ähnlichem 
gefüllt werden, damit eindeutig erkennbar ist, dass es sich um einen 
"Bastel-Build" handelt.

Andreas