Verständnisfrage zu "__low_level_init"

[Mario G. (suicided)]

Hallo Forum,

folgender Kommentar ist aus einem Beispielprogramm für den SiLabs 
C8051F320:

/**************************************************
 *
 * This module contains the function `__low_level_init', a function
 * that is called before the `main' function of the program.  Normally
 * low-level initializations - such as setting the prefered interrupt
 * level or setting the watchdog - can be performed here.
 *
 * Note that this function is called before the data segments are
 * initialized, this means that this function can't rely on the
 * values of global or static variables.
 *
 * When this function returns zero, the startup code will inhibit the
 * initialization of the data segments.  The result is faster startup,
 * the drawback is that neither global nor static data will be
 * initialized.
 *
 * Copyright 2003 IAR Systems. All rights reserved.
 *
 * $Revision: 4559 $
 *
 * $Log $
 *
 **************************************************/

Ich verstehe den Sinn der __low_level_init Funktion. Vollkommen unklar 
ist mir jedoch, was es für einen Sinn macht, wenn diese Funktion 0 
zukück gibt und somit keine globalen Variablen (...) initialisiert 
werden. Ist der Startvorgang dann wirklich so viel schneller? ...und 
kann man komplett ohne globale Variablen arbeiten?
Ich wäre sehr erfreut, wenn das einer der vielen Profis hier mal einen 
Anfänger wie mir erklären könnte.

Vielen Dank schon mal und viele Grüße
mario

[Läubi .. (laeubi)]

Naja ich glaub das soll nur ein Hinweis sein das wenn du 0 zurückgibst 
es halt keine initialisierung gibt.
Kann auch Sinnvoll sein, wenn du z.B. die Initialisierung garnicht 
brauchst weil sie eh vor dem ersten Zugriff auf die Variable 
überschrieben wird. (z.B. der gemessene ADC Wert wird in einem Feld 
abgelegt, ist das Feld voll wird ein Flag gesezt und die Main liest die 
Daten aus, dann müßtest du das Flag in der Main zwar inizialisieren, das 
Feld wird aber ja eh überschrieben bevor es genuzt wird)
Ob das was bringt ist natürlich ne andere Frage, vieleicht spart es Code 
ein und wenn man das lezte bischen an Startup Zeit braucht.

__low_level_init selbst kann Sinn machen wenn du so schnell wie möglich 
nach dem Start eine Aktion ausführen mußt, z.B. bei einem AVR das 
ResetReason register auslesen (die Werte dadrinn sind nur eine bestimmte 
Zeit gültig) oder den Watchdoch vorübergehen deaktivieren bis dein 
Programm die Kontrolle hat und den wieder zurücksetzen kann damit er 
nicht in einem fort einen Reset auslöst weil der Startup so lange 
dauert.

[Karl H. (kbuchegg)]

Mario G. schrieb:

> Ich verstehe den Sinn der __low_level_init Funktion. Vollkommen unklar
> ist mir jedoch, was es für einen Sinn macht, wenn diese Funktion 0
> zukück gibt und somit keine globalen Variablen (...) initialisiert
> werden. Ist der Startvorgang dann wirklich so viel schneller?

Kommt wohl auf die Menge der globalen Variablen an.
In der µC Porgrammierung benötigt man globale Variablen auf jeden Fall 
um mit einer ISR zu kommunizeren.
In der generellen, allgmeinen Programmierung hingegen lautet die 
Empfehlung: so wenig globale Variablen wie möglich. Funktionen werden 
universeller benutzbar, wenn sie nicht über globale Variablen gefüttert 
werden, sondern ihre Argumente als Funktionsargumente bekommen.

> ...und
> kann man komplett ohne globale Variablen arbeiten?

Nur weil sie nicht automatisch initialisiert werden, heißt das ja noch 
lange nicht, dass man deswegen auf globale Variablen verzichten muss.

Wenn du in deinem Programm 200 globale Variablen hast, von denen es aber 
nur bei 2 kritisch ist, dass sie am Anfang mit 0 initialisiert werden, 
kannst du ja immer noch schreiben

int main()
{
  global1 = 0;
  global2 = 0;

  ... und los gehts

die anderen globalen Variablen kriegen ihre Werte dagegen erst zur 
Laufzeit und es ist völlig unerheblich welchen Wert sie beim Start von 
main() haben.

[Stefan (Gast)]

Ich benutze IAR für MSP430, sollte aber ähnlich sein...

>was es für einen Sinn macht, wenn diese Funktion 0
>zukück gibt und somit keine globalen Variablen (...) initialisiert werden.
Wenn Du Variablen anlegst, dann geht der Compiler (sicherheitshalber) 
davon aus, dass diese auch initialisiert werden sollten. Dann gibt 
__low_level_init '1' zurück und die Init findet statt.
Wenn Du selbst die Kontrolle haben willst, welche Variablen und wie 
diese initialisiert werden sollen, dann kannst Du die Variablen als 
__no_init definieren. Machst Du das bei allen, dann wird 
__low_level_init '0' zurückgeben.

>Ist der Startvorgang dann wirklich so viel schneller?
Hängt von der Anzahl und Größe deiner Variablen und von der Taktfrequenz 
ab!

>und kann man komplett ohne globale Variablen arbeiten?
Freilich! Viele C/C++ Gurus halten globale Variablen ja eh' für 
Teufelszeug ;-)
Ich verwende in meinen Embedded-System jedoch sehr häufig Globals.
Zum Einen finde ich's persönlich oft Übersichtlicher, als zig 
Übergabeparameter in Funktionen zu haben. Zudem habe ich die Kontrolle, 
weil die Variablen im RAM und nicht auf dem Stack/Heap landen. Ausserdem 
benötige ich ab und zu Zugriff auf diese Variablen von aussen und muss 
die Adresse der Variable kennen.