ein Int-Array einer Funktion

[Sisor]

oder so:

...
int MW[3];//globales Variablenfeld
...
void updateMW(){
MW[0]  = analogRead(IR_RFL_V) ;
MW[1]  = analogRead(IR_RFL_L) ;
MW[2]  = analogRead(IR_RFL_R) ;
}
...
void loop() {
....
updateMW();
....
}

[Peter(TOO)]

Hallo,
Ist zwar die einfachste, aber leider auch unschönste Variante:

- Seiteneffekte sind nun mal unschön:
In einem grösseren Projekt, wird schnell übersehen, dass update() die globale Variable verändert.
Jeder darf sich ausmalen, was man da an Zeit zur Fehlersuche aufwenden kann, besonders wenn ein Fremder etwas am Code ändern muss.

- unflexibel
Am flexibelsten ist die Variante bei welcher das Array über einen Zeiger übergeben wird.
Man kann beliebig viele Messwerte abspeichern. Zudem ist es auch egal, ob man die Messwerte Global. lokal oder auf dem Heap ablegen will, update muss dazu nicht verändert werden.

MfG Peter(TOO)

[oderlachs]

Ich habe es auch so erst ein mal gelöst..:

void mess()
{
 
IR_FL_I[0]  = analogRead(IR_RFL_V);
IR_FL_I[1]  = analogRead(IR_RFL_L);
IR_FL_I[2]  = analogRead(IR_RFL_R);

}

int IR_FL_I[3] ist in meiner Lib zum Projekt global deklariert...

praktische Erfahrungen habe ich noch nicht damit..muss noch was löten, montieren...usw..

Danke für Eure Hilfe..
ich werde berichten wie ich weiter komme...

Gerhard

Hier mein bisheriger CODE zum Projekt

[Wsk8]

void mess(int *arr) {
arr[0]  = analogRead(IR_RFL_V) ;
arr[1]  = analogRead(IR_RFL_L) ;
arr[2]  = analogRead(IR_RFL_R) ;
}

void loop()
{....
mess(MW);
....
}

Sollte in deinem Fall die beste Lösung sein. Globale Variablen sollte man wenn möglich vermeiden.
Funktion ist natürlich nicht sicher, da keine Überprüfung des Arrays stattfindet.

mfg

[shedepe]

Die Ideale Variante währe (so wird das auch von den C Standard Funktionen gemacht):

int * mess(int *arr, int length)
{
    //Array befüllen und dabei length beachten
    return arr;
}

[Sisor]

Wir programmieren hier für einem Arduino. Da sind globale Variablen einfach praktisch.
Wer schon mal größere objektoorientierte Programme geschrieben hat, weiß das das Gefahren birgt.
Je größer ein Arduino Sketch, desto unübersichtlicher. Die Probleme fangen an, wenn man nicht mehr weiß, wie groß z.B. ein Variablenfeld ist und über die Feldgrenzen hinweg schreibt oder ließt. Oder wenn sich ein zweiter Programmierer über den Code hermacht.

Aber für einfachere Sketches finde ich es durchaus empfehlenswert mit globalen Variablen zu arbeiten.
Wenn man seinen Code anständig kommentiert, und sprechende Namen vergibt, ist es für mich ok.
Es ist halt auch die schnellste Variante, da die Variablen global erhalten bleiben und keine Parameter übergeben werden.

Da hat halt jeder hat seinen eigenen Stil.

[shedepe]

Globale Variablen würde ich nicht als eigenen Stil sondern als sehr schlechte Angewohnheit bezeichen, besonders wenn die Alternative kaum Mehraufwand bedeutet.
Also Regel würde ich mal sagen: so lokal wie möglich, so global wie nötig. Also wenn ich eine Variable nur in einer Funktion brauche, dann deklare ich die auch nur dort, usw.