Variablen für Hauptprogramm und Funktionen

[Balou B. (baloubaer)]

Hallo alle zusammen,

ich habe wahrscheinlich wieder eine einfahce Frage.

Wenn ich eine z.B. eine uint8_t variable vor meinem Hauptprogramm ( void 
main (void)) deklariere, ist diese doch Global in meinem Programm 
verfügbar, oder?

Also ich habe Variable x als uint8_t und möchte diese Variable sowohl im 
Hauptprogramm wie auchin meinen Funktionen benutzen. Soll heißen ich 
möchte sie nicht separat übergeben sonder direkt auslesen und schreiben 
in den Funktionen.

....
void dumm(void);
....
uint8_t x=0;
....
void main (void)
{....
x=5;
....
dumm();
....
x=??????????? //x=2 oder X=5??????
}

void dumm (void)
{
.....
x=2;
.....
return (void)
}

Funktioniert das so, oder habe ich da zu einfach gedacht?

Ich bedanke mich für eure Hilfe und verbleibe

Mit freundlichen Grüßen
Balou Baer

[Falk B. (falk)]

@ Balou Baer (baloubaer)

>Wenn ich eine z.B. eine uint8_t variable vor meinem Hauptprogramm ( void
>main (void)) deklariere, ist diese doch Global in meinem Programm
>verfügbar, oder?

Ja.

>Also ich habe Variable x als uint8_t und möchte diese Variable sowohl im
>Hauptprogramm wie auchin meinen Funktionen benutzen. Soll heißen ich
>möchte sie nicht separat übergeben sonder direkt auslesen und schreiben
>in den Funktionen.

Dann tu das.

>Funktioniert das so,

Ja.

[Tom (Gast)]

Balou Baer schrieb:
> Funktioniert das so,

Theoretisch ja, in der Praxis ist das der sicherste Weg zu verbuggten 
und unlesbaren Programmen. Gar nicht erst damit anfangen. Wenn das 
Gefummel in globalen Variablen sinnvoll scheint, ist die Struktur des 
Programms sehr wahrscheinlich verbesserungswürdig.

Wenn dumm den Wert von x wissen muss, bekommt es x als Parameter 
übergeben¹, wenn dumm einen Wert liefert, tut es das als return-Wert² 
(oder bekommt einen Zeiger auf x als Parameter³, den es lesen und ändern 
kann).

¹ void set7SegDisplay(uint8_t x);
² uint8_t readTemperature(void);
¹+² uint8_t readADC(uint8_t adc_channel);
³ void halbiere(uint8_t* x);

Alles andere sollte man nur aus sehr guten Gründen tun, eingebildeter 
Speichermangel und unnötige Optimierungen an falscher Stelle gehören 
nicht zu diesen.

[Sven B. (scummos)]

Jup, globale Variablen sind nur ganz selten der richtige Weg ein Problem 
zu lösen. I.d.R. sollten Parameter und Rückgabewerte verwendet werden. 
Ich persönlich mag auch diesen "output parameter"-Pattern nicht, da 
mache ich mir lieber eine struct als Rückgabewert.

[Balou B. (baloubaer)]

Hallo,

danke euch für euere Antworten.

Das es gefährlich ist globale Variablen zu nutzen ist mir klar, jedoch 
die Variablen die ich nutze sind einmalig und werden nur einmal nach 
Spannungsanlegung zur einmessung benötigt. Verbessungsvorschläge sind 
aber gern genommen.

uint8_t vorher_endschalter_links_x-achse = 0, 
vorher_endschalter_rechts_x-achse = 0 ;
  uint8_t vorher_endschalter_oben_y-achse = 0, 
vorher_endschalter_unten_y-achse = 0;
uint8_t endschalter_links_x-achse = 0, endschalter_rechts_x-achse = 0, 
endschalter_oben_y-achse = 0;
  uint8_t  endschalter_unten_y-achse = 0;

int main (void)
{
//  DDRA = ;
  
//  DDRB = ;
  
//  DDRC = ;
  
  DDRD = _BV ( PD4 ) | _BV ( PD5 ) | _BV ( PD6 ) | _BV ( PD7 ); 
  //PD4 links X-Achse; PD5 rechts X-Achse; PD6 oben Y-Achse; PD7 unten Y-ACHSE


//Interrupts einstellen
/*
  //Timer:

    TCCR1B = _BV ( WGM12 ) | _BV ( CS12 ) | _BV ( CS10 ); //Timer1 konfiguriert
    OCR1A = 15624 //Vergleichsregister setzen, bei Prescaler 1024 und 16 MHz steht die 15624 für eine Sekunde
    TIMSK = _BV ( OCIE1A ) //Timer 1 Interrupt aktiviert
*/

  //Externe Interrupts

    MCUCR |= _BV ( ISC11 ) | _BV ( ISC00 );  
    /*INT1 reagiert auf fallende Flanke
      INT0 reagiert bei jeder änderung
    */
//    MCUCSR |= _BV ( ISC2 );
    /* ISC2 = 0 im MCUCSR Register, reagiert INT2 auf fallende Flanke.
       ISC2 = 1 im MCUCSR Register, reagiert INT2 auf steigende Flanke */
    GICR |= _BV ( INT1 ) | _BV ( INT0 ) | _BV ( INT2);  //INT0, INT1 und INT2 aktiviert
    

  //POWER Managment:

    MCUCR |= _BV ( SE ) | _BV ( SM2 ) | _BV ( SM1 ) | _BV ( SM0 );  
    /* SE = 1 Sleep Aktiviert, 
       SM0, SM1 und SM2 = 1   Extended Standby 
    */

    sei();

  
  //ADC Initialisieren
    
    ADC_Init ();

  //Definition der ersten Zustände für Flankenerkennung (positive Flanke)
  
    vorher_entschalter_links_x-achse = ( PINX & _BV ( PXX ) );
    vorher_entschalter_rechts_x-achse = ( PINX & _BV ( PXX ) );
    vorher_entschalter_oben_y-achse = (PINX & _BV ( PXX ) );
    vorher_entschalter_unten_y-achse = ( PINX & _BV ( PXX ) );
    vorher_zaehltaster_x-achse = ( PINX & _BV ( PXX ) );
    vorher_zaehltaster_y-achse = ( PINX & _BV ( PXX ) );
      
  //Einmessen der X-Achse:

    einmessen_x-achse();
    einmessen_y-achse();
......
while (1)
{
......
}
}

uint8_t einmessen_x-achse (void)
  {
    PORTD |= _BV ( PD4 );  //Motor X-Achse links fahren bis Sicherheitsendabschaltung

    endschalter_links_x-achse = ( PINX & _BV ( PXX ) );  //Abfrage ob Endschalter betätigt wurde

    if (endschalter_links_x-achse != vorher_endschalter_links_x-achse )
    {
      vorher_endschalter_links_x-achse = entschalter_links_x-achse;

      PORTD &= ~_BV ( PD4 );  //Ausgang PD4 abschalten
      
      zaehler_x-achse = 0;
    }
    return;
  }

[Sven B. (scummos)]

Ich schätze mal für so einen Zweck ist das tragbar.
(Funktionsnamen dürfen übrigens keine "-"-Zeichen enthalten)

[Balou B. (baloubaer)]

UPS.... Danke!!!!