aus Funktion ins Array schreiben

[MasterBrained (Gast)]

Guten Tag,

Ich bin noch ein Anfänger was programmieren am µC angeht und habe 
deshalb folgende Frage:

Ich habe eine Funktion die mir Messwerte liefert über den Parameter 
value.
Ich möchte in einem Array nun die letzen 10 Messungen speichern. Es soll 
immer der älteste Messwert aktualisiert werden. Anschließend soll der 
Mittelwert berechnet werden.

Leider verzweifle ich an der genauen herangehensweise dieses Problemes. 
In  der Theorie ist es mir zwar klar wie es zu machen wäre, leider weiss 
ich nicht wie ich es auch programmieren kann.

Ich hoffe auf Unterstützung :)

MfG,
MB

[Einer K. (Gast)]

Vermutlich suchst du einen Ringbuffer.

[sid (Gast)]

bei zehn Messwerten klingt mir das schwer nach rauschunterdrückung..
da würd ich immer tatsächlich zehn Ablesungen nehmen
(also das komplette array vollschreiben)

Aber nundenn, wenn Du immer nur einen Messwert aktualisieren möchtest 
geht das natürlich auch;
da Du für den Mittelwert  keinen UNterschied bei der Reihenfolge machen 
musst am einfachsten in etwa so:

int buffer[10]={0}; // das array, zunächst null gefüllt
int arpt = 0; // array_pointer für später
float mean =0; // der Mittelwert

void readSensor()
{
   // int value = analogRead(SensorPin);
   // oder wie auch immer Du den WErt liest
   buffer[arpt] = value;
   arpt = (arpt+1)%10 ;  // zähle hoch von 0-9 und wiederhole; dies nur ein einzelschritt natürlich
}

void setup ()
{
  // buffer schonmal mit werten füllen um ein Anfangsmittelwert zu haben
  for(int i=0, i<10; i++) 
    readSensor();
  // und was auch immer Du sonst so brauchst
}

void loop()
{
  // readSensor();
  // und wann immer Du den Mittelwert brauchst
  int sum;
  for(int i=0; i<10; i++)
    sum += buffer[i];
  mean = sum/10.0; // .0 zwingt den compiler die dezimalstelle zu beachten
  // was immer Du mit dem mittelwert tun möchtest

  // willst Du unbedingt "ersten" und "letzten" Wert gesondert behandeln
  // wird es nur minimal komplizierter:
  for (int i =0; i<10; i++)
  {
    if((arpt > 0 && i == arpt-1)|| (arpt==0 && i==9))
    {
       // der erste 'älteste' Wert
       sum += 5; // was auch immer
    }
    else if (arpt==i)
    {
       // der letzte 'neueste' Wert
       sum += 2* buffer[i]; // was auch immer
    }
    else
    {
      // alle Anderen Werte
      sum += bugger[i]; // was auch immer
    }
    // wie Du hier addierst ist Dir überlassen
  }
  // mean ist summe durch 10kommanull du weisst schon ;)
}

So in etwa jdf.. hab's jetzt nur hingespuckt,
könnten also Tippfehler und sogar logikfehler drin sein
geht ja nur um's Prinzip, gell?

Achso, ich weiss jetzt nicht wie gross deine values sind, oder von 
welchem Typ (ich gehe von 10bit integer aus.. dann ist alles gut)
solltest du floats brauchen, oder besonders grosse Werte addieren, musst 
Du natürlich die Typen anpassen.

'sid

[sid (Gast)]

ups, blödsinn.. der älteste WErt ist arpt plus eins, nciht minus eins..
da ist schon der erste Logikfehler :(

achja 5-uhr morgens, das Hirn ist Brei.. verzeih

'sid

[foobar (Gast)]

// give it a new value, returns the average of the last 10 given values
int average(int val)
{
    static int last[10], i, sum;

    sum -= last[i];
    last[i] = val;
    sum += last[i];

    if (++i == 10)
        i = 0;

    return (sum + 5) / 10;
}

[M. K. (sylaina)]

sid schrieb:
> arpt = (arpt+1)%10 ;  // zähle hoch von 0-9 und wiederhole; dies nur ein
> einzelschritt natürlich

Das würde ich noch mal überdenken:

arpt beim Start sei 0

1. Durchlauf: (0+1)%10 = 9
2. Durchlauf: (9+1)%10 = 0
3. Durchlauf: (0+1)%10 = ... ;)

[foobar (Gast)]

> 1. Durchlauf: (0+1)%10 = 9

Das solltest du noch mal überdenken ;-)

[M. K. (sylaina)]

Hm, stimmt. Ich hatte da ne andere Funktion im Kopf, % ist ja der 
Modulo-Operator in C

[Alex (Gast)]

Mh, schöne Funktion. Könntest du erklären wieso beim return Value 
nocheinmal 5 addiert werden müssen, bevor durch 10 dividiert wird?

[Cyblord -. (cyblord)]

Alex schrieb:
> Mh, schöne Funktion. Könntest du erklären wieso beim return Value
> nocheinmal 5 addiert werden müssen, bevor durch 10 dividiert wird?

Rundung

[W.S. (Gast)]

MasterBrained schrieb:
> Ich habe eine Funktion die mir Messwerte liefert über den Parameter
> value.
> Ich möchte in einem Array nun die letzen 10 Messungen speichern. Es soll
> immer der älteste Messwert aktualisiert werden. Anschließend soll der
> Mittelwert berechnet werden.
>
> Leider verzweifle ich an der genauen herangehensweise dieses Problemes.

So, du verzweifelst daran, daß du dein Problem nicht präzise formulieren 
kannst? Dann mußt du daran arbeiten - und das hat rein garnichts mit 
Programmieren zu tun, sondern mit Strategie.

Beispiel:
Du hast ein Feld mit 10 Einträgen, dazu eine Variable mit der Summe aus 
allen Einträgen und obendrein eine Laufvariable, die von 1 bis 10 (oder 
0 bis 9) läuft.
Wie also machst du es, daß du dein Feld aktualisierst und den Mittelwert 
aus ihm berechnest?
Denk nach.
Der älteste muß raus aus der Summe und dafür der neueste rein.

Mal ne Formulierung aus dem Handgelenk:
variable Summe;
feld     Wertefeld[1..10];
integer  i;

wenn neuerWertDa dann
begin
  Summe:= Summe - Wertefeld[i]; // alter Wert raus
  Wertefeld[i]:= NeuerWert;
  Summe:= Summe + Wertefeld[i]; // neuer Wert rein
  increment(i);
  if i > 10 then i:= 1;
  Mittelwert:= Summe / 10;
end

Und zu den Startbedingungen: Du füllst vorher i, Summe und Wertefeld mit 
null. Dein Algorithmus hat FIR Charakteristik, also nach 10 Meßwerten 
ist es eingeschwungen.

Das Prinzip dahinter solltest du jetzt verstanden haben - und die 
Umsetzung in irgend eine Programmiersprache sollte jetzt kein Problem 
mehr sein. Merke: das Wichtigste beim Programmieren ist, sich über die 
Strategie, also die Herangehensweise und prinzipielle Durchführung klar 
zu werden. Das Codieren ist dann erst der zweite Schritt.

W.S.

[W.S. (Gast)]

Nachtrag: i auf irgend einen Index im Feld. Nicht unbedingt auf 0.
W.S.

[HildeK (Gast)]

@MasterBrained (Gast)
Ein Tipp:
Wenn du nicht unbedingt auf die 10 Elemente angewiesen bist und ggf. 
auch 8 oder 16 verwenden kannst, machst du es deinem µC etwas einfacher, 
die Division durchzuführen.
Die Addition zur Rundung musst du dann anpassen: 4 oder 8 addieren vor 
der Division durch 8 bzw. 16.