Funktion soll Array ausgeben

Hallo,

ich würde gerne einen Array an eine Funktion übergeben.
In dieser Funktion soll der letzte Wert gelöscht werden und die restlichen Werte um eins nach hinten verschoben werden.
An die Stelle “null” soll jetzt ein neuer Wert eingefügt werden.
Danach soll der neue Array an eine weitere Funktion übergeben werde, die den Array ausgibt.

Leider kommt immer der folgende Fehler:

cannot convert 'float*' to 'float' in return

Hier mein Code:

float array1[10] = {0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0};
float randomVal;

void setup() {
  Serial.begin(115200);
}
float shiftArray(float myArray[], float newVal) {
  for (int z = 9; z >= 0; z--)
  {
    myArray[z] = myArray[z - 1];
  }
  myArray[0] = newVal;
  return myArray;
}

float printArray(float myArray[]) {
  Serial.print("[");
  for (int i = 0; i < 10; i++)
  {
    Serial.print(array1[i]);
    Serial.print(" ");
  }
  Serial.print("]\n");
}
void loop() {
  randomVa1 = random(0.0, 10.0);
  array1 = shiftArray(array1, randomVal);
  printArray(array1);
   delay (5000);
}

Könnt Ihr mir sagen, was ich falsch mache und wie ich es richtig machen kann?

Generell musst du verstehen dass Arrays als Zeiger übergeben werden. Auch wenn man bei den Parametern die eckigen Klammern verwendet. Ein Array Name zerfällt zu einem Zeiger auf das erste Element

Rückgabewerte solltest du dir mal genauer ansehen. Bei shiftArray() hast du einfach float aus Rückgabewert. Wenn du die Funktion direkt in andere Funktionen einsetzen willst, muss der Rückgabewert float* sein. Genau das was die Fehlermeldung auch anmeckert. Float ist schließlich nur ein einzelner Wert. Aber kein Array

Und printArray() hat eine Rückgabewert, aber gibt nichts zurück

In dieser Funktion soll der letzte Wert gelöscht werden und die restlichen Werte um eins nach hinten verschoben werden.

Tut das denn Not…?

Reicht es nicht, einfach nur einen Zeiger zu verschieben?

combie:
Reicht es nicht, einfach nur einen Zeiger zu verschieben?

Da er vorne wieder einen neuen Wert reinschreibt wohl eher nicht. Oder er müsste das Ganze als Umlaufpuffer organisieren.

@TO: Da Du - wie Serenifly schon schrieb - einen Zeiger auf dein Array übergibst, wird auch dein Original-Array verändert. D.h. Du muss da für deine Funktionalität erstmal gar nichts zurückgeben.

Versuch es mal so:

float array1[10] = {0.1, 1.2, 2.3, 3.4, 4.5, 5.6, 6.7, 7.8, 8.9, 9.0};
float randomVal;

void setup() {
  Serial.begin(115200);
}
 void shiftArray(float myArray[], float newVal) {
  for (int z = 9; z >= 0; z--)
  {
    myArray[z] = myArray[z - 1];
  }
  myArray[0] = newVal;
}

void printArray(float myArray[]) {
  Serial.print("[");
  for (int i = 0; i < 10; i++)
  {
    Serial.print(myArray[i]);
    Serial.print(" ");
  }
  Serial.print("]\n");
}
void loop() {
  randomVal = random(0.0, 10.0);
  shiftArray(array1, randomVal);
  printArray(array1);
   delay (5000);
}

P.S. Es waren auch noch Tipfehler in deinem Sketch.
P.P.S. Der feste Wert in der for-Schleife ( z=9 ) ist eine potentielle Fehlerquelle, wenn Du mal die Größe deines Arrays änderst.

Versuch es mal so:

Vielen Dank!

Danke auch für den Tipp mit der Fehlerquelle!

MicroBahner:
Du muss da für deine Funktionalität erstmal gar nichts zurückgeben.

Müssen tut man das natürlich nicht. Aber es wird oft gemacht um die Funktion in andere Funktionen einzusetzen

z.B.:

printArray(shiftArray(...));

Oder er müsste das Ganze als Umlaufpuffer organisieren.

Meine ich doch!
Einzig ein Schreibzeiger, ist dazu nötig.
Also Umbauarbeit nahe Null, und Geschwindigkeitssteigerung ca vierzig fach!

Da er vorne wieder einen neuen Wert reinschreibt wohl eher nicht.

Naja...
Wenn es unbedingt sein muss .......
Dann aber doch nicht "händisch" per Schleife, sondern memcpy() o.ä.!
Oder?

Und wenn was anderes, als 8bittige AVR, dann hat der Compiler solche Container im Lieferumfang.
Muss man dann nicht selber bauen.

In dieser Funktion soll der letzte Wert gelöscht werden und die restlichen Werte um eins nach hinten verschoben werden.
An die Stelle "null" soll jetzt ein neuer Wert eingefügt werden.
Danach soll der neue Array an eine weitere Funktion übergeben werde, die den Array ausgibt.

Auf einem ESP...?

Gruß Fips

Derfips:
Auf einem ESP...?

Ja, das Programm sollte aber auch auf anderen Entwicklerboards laufen.
Gibt es da einen Unterschied im Programm zwischen ESP und Arduino?

Auf einem Esp.. würde ich das Problem mit einem der Container erschlagen.

Da ist hinten raus oder vorne rein ganz einfach zu machen.

Arduino.

Gruß Fips

Ein solcher Container ist leicht zu bauen.
Der tuts dann auch mit allen Arduino kompatiblen Boards.

Zu haltender Datentype und Größe ist einstellbar.

Die Operatoren sorgen dafür, dass man es wie ein Array behandeln kann
Der Zuweisungsoperator ruckelt weiter und fügt die Daten an Position Null an.

Anstatt die Daten durch den Speicher zu schieben, wird nur ein “Zeiger” über die Daten bewegt.
So liegt das zuletzt angefügte Element immer auf container[0]

template<typename DataType, size_t count>
class CombiesContainer : public Printable 
{
  private:
  DataType data[count];
  unsigned dataIndex;

  public:
  CombiesContainer():dataIndex(0){}

  constexpr size_t size()
  {
    return count;
  }

  void fill(const DataType value) 
  {
    for(DataType &d:data) d = value;
  }

  DataType operator [](const size_t index) const
  {
    size_t i = dataIndex + index;
    while(i>=count)i -= count; // wrap around
    return data[i];
  }
  
  DataType &operator[] (const size_t index)
  {
    size_t i = dataIndex + index;
    while(i>=count) i -= count; // wrap around
    return data[i];
  }
  
  DataType operator = (const DataType value)
  {
    dataIndex--;
    while(dataIndex>=count) dataIndex += count; // wrap around
    data[dataIndex] = value;
    return value;
  }
  
  virtual size_t printTo(Print &p) const override
  {
    size_t len = 0;
    for(unsigned i = 0; i < size(); i++)
    {
      len += p.print("Index "); 
      len += p.print(i); 
      len += p.print(": "); 
      len += p.println((*this)[i]);
    }
    len += p.println("------------ ");
    return len;
  }

};

CombiesContainer<float,10> container;




void setup() 
{
  Serial.begin(9600);

  // container fluten
  container.fill(1.1);

  Serial.println(container);


  // ein paar Dinge hinein tun und dabei den internen "Zeiger" weiter setzen
  container = 33.3;
  container = 34.3;
  container = 35.3;

  Serial.println(container);

  // an eine gegebene Position schreiben, ohne den "Zeiger" zu bewegen
  container[6] = 4711.0;

  Serial.println(container);

  // noch ein Ding hineintun, und weiter ruckeln
  container = 55.55;
  
  Serial.println(container);
  
}

void loop() 
{

}

EDIT: Repariert und Streaming entfernt.

combie:
Ein solcher Container ist leicht zu bauen.

Für dich sicherlich, ich bin noch unterwegs.

Gruß Fips

ich bin noch unterwegs.

Sind wir das nicht alle?

Wir lernen, indem wir es tun.

Und in dieser Sache kann ich wahrlich auf alte Erfahrungen zurückgreifen.

Man schiebt einfach keine Daten durch die Gegend,
wenn man nicht unbedingt dazu gezwungen wird.
Denn Daten werden durch kopieren meist weder besser,
noch sonst irgendwie schmackhafter.

Ich halte es da gerne mit Pipi Langstrumpf:

Ich mach mir die Welt, widde widde wie sie mir gefällt.
Und dafür nutze ich hier den Pool der C++ Möglichkeiten.

So habe ich beides....
Die Sicht auf ein Array, welches die die Daten weiter ruckelt und immer am Anfang einfügt.
Und intern, nur den weiter laufenden "Zeiger"

Im Grunde sind das zwei völlig unterschiedliche Sichtweisen/Projektionen.
Das "Innen" wird vom "Außen" durch die Schnittstelle abgegrenzt.

Für dich sicherlich,

Viel Übung mit Sichtweisen und Projektionen.
Das ist mir ein wichtiges "Ding".

ich bin noch unterwegs.
Da bin ich noch unterwegs!

Aus dem Nähkästchen:
Leider neige ich dazu, einmal erfolgreich umgesetzte "Dinge" immer wieder auf die gleiche Art zu erledigen!
Streng nach dem "Prinzip der geringsten Verwunderung":

Was du einmal auf die eine Art getan hast,
erledige immer wieder auf die gleiche Art.

Notwendige Erweiterung:

Halte dich an das "Prinzip der geringsten Verwunderung", bis dir
neue Erkenntnisse ins Hirn tropfen, oder du eines Besseren belehrt wirst.

Dazu querläufig, sagte Nico Semsrott mal:

Jede Entscheidung, ist der Tod von Milliarden Möglichkeiten.
Hier kann man das Wort "Möglichkeiten" auch durch "Sichtweisen/Projektionen" ersetzen.

combie:
Und intern, nur den weiter laufenden “Zeiger”

Die Standart Containerklassen werden bestimmt auch keine Daten schieben.

combie:
Dazu querläufig, sagte Nico Semsrott mal:

Jede Entscheidung, ist der Tod von Milliarden Möglichkeiten.

Ich erinner mich, das war ein Klasse Tip von dir.

Gruß Fips

Die Standart Containerklassen werden bestimmt auch keine Daten schieben.

Ja!
Würde mich stark wundern, wenn sie es täten.

Ich erinner mich, das war ein Klasse Tip von dir.

Ich denke mal, dass dieses gemeint ist.

Genau dieses!

Hat mir gefallen, mal eine andere Sichtweise auf die Dinge die uns durch's Leben begleiten.

So ein Demotivationstrainer ist mir bedeutend lieber als die aktuellen Verschwörungstheoretiker!

Gruß Fips