Kämpfe mit Class

Hallo zusammen

ich möchte eines meiner ino’s in eine Klasse verwandeln und scheitere kläglich.

ino:

#include "MyToolz.h"

MyToolz robard();

/* an example of struct */
struct sensors{
  char name[16];
  float value;
};

void setup() {
  Serial.begin(9600);
  while(!Serial);
}

void loop() {

struct sensors structs[] = {
  	{"top", 1.0},
  	{"left", 2.0},
  {"right", 3.0},
  	{"back", 9.9},
  	{"bottom", 0.2 }
};
  // moechte den Name des sensors an position x nach Sortierung des Wertes nach Grösse 
Serial.println(robard.getSortedNameByPosition(sensors, 3));

}

.h:

/*
  MyToolz.h - Library MyToolz sensor.
  Released into the public domain.
*/

#ifndef MyToolz_h
#define MyToolz_h

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

class MyToolz
{

  public:

    MyToolz();

    int  mypos;
    struct mystruct;
    char* getSortedNameByPosition();
    int struct_cmp_by_value();

  private:


};

#endif

cpp:

#include "MyToolz.h"

MyToolz::MyToolz() {}
/* an example of struct */
//struct my{
 // char name[16];
//  float value;
//};

/* qsort struct comparision function (value float field) */
int MyToolz::struct_cmp_by_value(struct _mystruct,const void *a, const void *b)
{
	  /*
      float comparison: returns negative if b > a
	    and positive if a > b. We multiplied result by 100.0
	    to preserve decimal fraction
    */
    struct mystruct *ia = (struct mystruct *)a;
    struct mystruct *ib = (struct mystruct *)b;
    return (int)(100.f*ia->value - 100.f*ib->value);
}

char* MyToolz::getSortedNameByPosition(struct mystruct *_array, int mypos)
{
   size_t structs_len = sizeof(structs) / sizeof(struct mystruct);
   qsort(structs, structs_len, sizeof(struct mystruct), struct_cmp_by_value(mystruct));

    return _array[pos].name;
}

Im Prinzip möchte ich folgendes *.ino in eine Class umwandeln:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 

/* an example of struct */ 
struct sensors{ 
  char name[16];
  float value;
};

/* qsort struct comparision function (value float field) */ 
int struct_cmp_by_value(const void *a, const void *b) 
{ 
    struct sensors *ia = (struct sensors *)a;
    struct sensors *ib = (struct sensors *)b;
    return (int)(100.f*ia->value - 100.f*ib->value);
	/* float comparison: returns negative if b > a 
	and positive if a > b. We multiplied result by 100.0
	to preserve decimal fraction */ 
 
} 

char *pos_struct_array(struct sensors *array, int pos) 
{ 
    return array[pos].name;
} 


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

void loop() {

struct sensors structs[] = {
	{"top", 1.0}, 
	{"left", 2.0}, 
        {"right", 3.0}, 
	{"back", 9.9}, 
	{"bottom", 0.2 }
};
size_t structs_len = sizeof(structs) / sizeof(struct sensors);
qsort(structs, structs_len, sizeof(struct sensors), struct_cmp_by_value);
Serial.println(pos_struct_array(structs, 0)); 
}

Die float Werte im Struct varieren.

ich möchte es am ende so verwenden können:

struct sensors structs = {
{“top”, 1.0},
{“left”, 2.0},
{“right”, 3.0},
{“back”, 9.9},
{“bottom”, 0.2 }
};
robard.getSortedNameByPosition(sensors,5)

→ raus kommt der Name des fünft grössten Wert oder der kleinste :slight_smile: jeh nach dem wie man es sieht

robard.getSortedNameByPosition(sensors,1)

→ raus kommt der Name des zweit grössten Wertes

Wenn mir jemand helfen könnte wäre ich sehr froh … und bitte macht Beispiele - ich bin neu in c++ zu viel Fach Chinesisch verstehe ich nicht :slight_smile: Vielen Dank.

Es geht mir ausdrücklich nicht um min(), max() Werte - es geht mir um den namen des x-ten Wertes, oder key des x grössten values.

warum willst du so viel auf einmal?

Mach doch zunächst nur mal die Klasse in deiner ino lokal im Sketch.
Wenn das läuft, zerteile deinen Sketch in ino und in die .h
Und erst am Schluss überlegst dir, warum du in .h und .cpp trennen willst.

Einverstanden mit dem Weg?

Und was geht nicht?

Das ist übrigens sehr verwirrend benannt wenn man das als Außenstehender liest:

struct sensors structs[] =

Für mich besser:

struct Sensor sensors[] =

Ein Array der Klasse Sensor (welche einen Sensor darstellt, daher Einzahl) mit dem Namen "sensors" (Mehrzahl)

Ja - wrde es versuchen in einer lokalen Klasse - Ziel wäre es dann aber schon den Spagetti-Code weg zu bekommen, da ich doch viel code im ino habe - Das Beispiel oben ist nur eine gekürzte Version.

Vielen Dank

Danke für den Tipp mit der Benennung:

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
/* an example of struct */ 
struct Sensor{ 
  char name[16];
  float value;
};
/* qsort struct comparision function (value float field) */ 
int struct_cmp_by_value(const void *a, const void *b) 
{ 
    struct Sensor *ia = (struct Sensor *)a;
    struct Sensor *ib = (struct Sensor *)b;
    return (int)(100.f*ia->value - 100.f*ib->value);
	/* float comparison: returns negative if b > a 
	and positive if a > b. We multiplied result by 100.0
	to preserve decimal fraction */ 
 
} 
char *pos_struct_array(struct Sensor *array, int pos) 
{ 
    return array[pos].name;
} 
void setup() {
  
  Serial.begin(9600);
 
}
void loop() {
struct Sensor sensors[] = {
	{"top", 1.0}, 
	{"left", 2.0}, 
        {"right", 3.0}, 
	{"back", 9.9}, 
	{"bottom", 0.2 }
};
size_t sensors_len = sizeof(sensors) / sizeof(struct Sensor);
qsort(sensors, sensors_len, sizeof(struct Sensor), struct_cmp_by_value);
Serial.println(pos_struct_array(sensors, 0)); 
 
}

Im Prinzip möchte ich folgendes *.ino in eine Class umwandeln

Ich sehe das eher so, dass du eine class Sensor erstellen möchtest.
Und vermutlich aus der Funktion struct_cmp_by_value eine Methode dieser Klasse.

Ob du die dann auslagerst in eigene Dateien, und wenn ja, in eine Library oder in Zusatzdateien in deinem Sketch-Ordner, ist ein späterer Schritt, wie auch noiasca angemerkt hat.

Ob du für ein Array von Sensor-Elementen nochmal eine Klasse erstellst, um diesem dann die Methode

const char* getSortedNameByPosition(int pos);

verpassen zu können, wäre eine unabhängige weitere Überlegung.

Das scheint mir auch ein wenig verdächtigt:
struct sensors structs = {
{"top", 1.0},
{"left", 2.0},
{"right", 3.0},
{"back", 9.9},
{"bottom", 0.2 }
};

ändert sich der Inhalt der Membervariable name denn überhaupt?

Sind das möglicherweise 5 Sensoren die du hast und du willst eigentlich den Sensor mit dem aktuell niedrigsten/höchsten Wert in Erfahrung bringen?

Nein Es

noiasca:
Das scheint mir auch ein wenig verdächtigt:
struct sensors structs = {
{"top", 1.0},
{"left", 2.0},
{"right", 3.0},
{"back", 9.9},
{"bottom", 0.2 }
};

ändert sich der Inhalt der Membervariable name denn überhaupt?

Sind das möglicherweise 5 Sensoren die du hast und du willst eigentlich den Sensor mit dem aktuell niedrigsten/höchsten Wert in Erfahrung bringen?

noiasca:
Das scheint mir auch ein wenig verdächtigt:
struct sensors structs = {
{"top", 1.0},
{"left", 2.0},
{"right", 3.0},
{"back", 9.9},
{"bottom", 0.2 }
};

ändert sich der Inhalt der Membervariable name denn überhaupt?

Sind das möglicherweise 5 Sensoren die du hast und du willst eigentlich den Sensor mit dem aktuell niedrigsten/höchsten Wert in Erfahrung bringen?

Nein es geht mir nicht um min/max es geht mir um den Namen des Sensors an Position x

Ich Scheitere weiterhin habe nun eine lokale Klasse versucht:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/* an example of struct */

class MyToolz {

public:

struct MySensor{
  char name[16];
  float value;
};

void setMySensors( ?????????????????????? ) {
	struct MySensor sensors = s;
};


/* qsort struct comparision function (value float field) */
int struct_cmp_by_value(const void *a, const void *b)
{
    struct MySensor *ia = (struct MySensor *)a;
    struct MySensor *ib = (struct MySensor *)b;
    return (int)(100.f*ia->value - 100.f*ib->value);
	/* float comparison: returns negative if b > a
	and positive if a > b. We multiplied result by 100.0
	to preserve decimal fraction */

}

char *pos_struct_array(int Pos)
{
	struct MySensor *array;
	size_t sensors_len = sizeof(sensors) / sizeof(struct MySensor);
	qsort(sensors, sensors_len, sizeof(struct MySensor), struct_cmp_by_value);
    	return array[Pos].name;
}

};


MyToolz Huhu;

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

void loop() {

	Huhu.setMySensors({{"red",55.4}});
	Serial.println(Huhu.pos_struct_array(0));

}

Am einfachsten wäre es wenn ich Strings wie {{“red”,55.4}} oder {{“red”,55.4},{“banana”,22,5}} übergeben könnte und diese dann in den struct gewandelt werden - Ich will wissen an welche Position banana nach der Sortierung ist - Es interessiert mich Position und Name - Der Wert interessiert mich nicht oder nur indirekt … Und ja die Variablen ändern ständig - ich habe als Beispiel einfach einen Werte fix rein geschrieben {“banana”, 444,0 <<<< ändert sich nach jedem loop}

Vielen Dank trotzdem :slight_smile:

Leider spreche ich zu wenig C++ Fach-Cinesisch um es richtig zu beschreiben - das tut mir Leid :frowning:

Du kannst C Strings mit strcpy() / strncpy() in ein Array kopieren. Einfache Zuweisungen gehen da nicht da Array Variablen mehr oder weniger Zeiger auf das erste Element ist.

Normal geschieht das automatisch beim Erstellen des Objekts wie du es auch ursprünglich gemacht hast. Der Compiler kann dann solche Methoden auch automatisch generieren.

So wie das jetzt hast ist es etwas sinnlos. Vorher hattest du ein Array aus Strukturen die man vergleichen und sortieren konnte. Jetzt hast du gar nichts. Das hier erzeugt nur ein lokales Objekt, das am Ende der Methode aufhört zu existieren:

void setMySensors( ?????????????????????? ) {
 struct MySensor sensors = s;
};

In der Klasse existiert nicht mal ein ein einziges Objekt der Struktur

Das "struct" Schlüsselwort musst du in C++ übrigens nicht immer wieder hinschreiben. Das hast du vielleicht in C Code gelesen. Da war das glaube ich nötig. C++ weiß auch so was das ist wenn es einmal deklariert wurde

@Serenifly: Vielen dank - darf ich Dich eventuell um ein Beispiel nötigen :slight_smile: - Ich werde dich auch bis ans Ende meiner Tage als C++ Gott/in verehren … (Das ist kein Sarkasmus) … Ich bin momenan entnerft ab mir selber - Ich sehe es einfach nicht und es will nicht klappen >:( … Vieleicht sollte ich auch einfach mal was essen :slight_smile: oder was komplett anderes machen - aaaaaaaaa - es nerft !!!

Serenifly:
Das hast du vielleicht in C Code gelesen. Da war das glaube ich nötig. C++ weiß auch so was das ist wenn es einmal deklariert wurde

Ja, muss man in C. Ich habe vor ein paar Wochen mal wieder ANSI-C geschrieben mit struct. Das nervt gewaltig, wenn man mittlerweile C++ gewohnt ist. :wink:

Gruß Tommy

:wink: PS: Ich nehme auch weitere Götter in meinem Schrein auf ..... Ein kleines Beispiel und ich kann heute gut schlafen ... Vielen Dank Euch allen !

Das hier ist eher des Teufels Werk.
Wenn es denn aber unbedingt eine Klasse, ein Array und qsort() sein muss:

/* class für einen Sensor */
class Sensor
{
  private:
    const char* identifier;
    float value;

  public:
    // Konstruktor
    Sensor(const char* identifier, float value) : identifier(identifier), value(value) {}

    void setValue(const float newValue)
    {
      value = newValue;
    }
    float getValue()
    {
      return value;
    }

    const char* getIdentifier()
    {
      return identifier;
    }
};

// Array für mehrere Sensoren
Sensor sensors[]
{
  {"top", 1.0},
  {"left", 2.0},
  {"right", 3.0},
  {"back", 9.9},
  {"bottom", 0.2 }
};
const size_t sensorsLength = sizeof(sensors) / sizeof(Sensor);


// Vergleichsfunktion
static int compareSensors(const void *a, const void *b)
{
  return ((Sensor*)(a))->getValue() < ((Sensor*)(b))->getValue() ? -1 : ((Sensor*)(a))->getValue() > ((Sensor*)(b))->getValue() ? 1 : 0;
}

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

  qsort((void*)sensors, sensorsLength, sizeof(Sensor), compareSensors);
  Serial.println(sensors[0].getIdentifier());
}

void loop()
{

}

Ein Lösung mit Überschreiben des ‘<’-Operators in der Klasse, die Vewendung eines ‘vector’ und ‘sort’ statt qsort scheint mir nach umfangreicher Verwendung der Suchmaschine meines geringsten Mißtrauens die bessere Lösung zu sein.

Hallo Walter :slight_smile: - Vielen Dank für deine erneute Hilfe … Ich zimmere bereits an einem Schrein für dich. -

Dein Code ist viel schöner als meine kläglichen Versuche.

Eigentlich möchte ich diesen Teil ebenfalls in die Klasse auslagern:

static int compareSensors(const void *a, const void *b)
{
  return ((Sensor*)(a))->getValue() < ((Sensor*)(b))->getValue() ? -1 : ((Sensor*)(a))->getValue() > ((Sensor*)(b))->getValue() ? 1 : 0;
}

    const size_t sensorsLength = sizeof(sensors) / sizeof(Sensor);
  qsort((void*)sensors, sensorsLength, sizeof(Sensor), compareSensors);

Im Prinzip geht sowas und wie immer führen mehrere Wege nach Rom.
Aber es geht nicht mit der Sensor-Klasse wie ich die aufgeschrieben habe. Die behandelt genau einen Sensor.

Was Du also haben willst, ist eine Container-Klasse, die Sensoren als Elemente aufnimmt und sich durch eine Methode sortieren lässt.

Weg 1:
Sowas gibt es schon, das heißt vector und ist recht komfortabel. Vector hat vor allem den Vorteil, dass man zu Beginn nicht unbedingt wissen muss, wie viele Elemente darin gespeichert werden sollen.
Allerdings sortiert auch ein vector sich nicht selbst; das kann man aber durch std::sort erledigen lassen.

Beispiel hier (auf die Schnelle gefunden; gibt bestimmt noch andere/ausführlichere/bessere). Statt ‘int’ hättest Du dann ‘Sensor’ in der Deklaration:

vector<Sensor> v...

Dazu braucht dann die Sensorklasse von oben noch eine Erweiterung, die die Vergleichsvorschrift für ‘kleiner’ implementiert (ungetestet!). Liest sich wie eine Methodenimplementierung:

public:
  bool operator<(const Sensor& foo) const  
  {
    return value < foo.getValue();  
  }

Vergleichsergebnis ist der Vergleich des Objekt-eigenen value mit dem ‘value’ aus dem als ‘foo’ übergebenen Vergleichsobjekt.

Weg 2:
Wenn bei der Erzeugung des ‘Arrays’ schon bekannt ist, wie viele Elemente das werden sollen, kann man kanneine rudimentäre Version eines Containers auch selber stricken, die dann intern einen vector verwendet und die Sortierung sowie den Zugriff auf die Elemente des Vectors als Methoden anbietet. Heute werde ich das nicht mehr versuchen :wink:

Weg 3:
std::set
Das ist vermutlich auf dem Arduino oversized und ich weiß gar nicht mal ob das überhaupt geht.

Hier kommen halt auch viele Probleme zusammen. Und es ist nicht ganz klar wie du das organisieren möchtest. Einmal geht es um Klassen generell. Und dann hast du noch irgendein Problem mit dem sortieren im Speziellen

Hier ist eine Klasse die intern ein Array aus Strukturen verwaltet. Es gibt keinen Konstruktor, aber man kann die Elemente nach Index ändern und die gesamte Klasse drucken. Das mit der Sortierung ist nicht enthalten

class MyClass : public Printable
{
public:
  void setSensor(const char* str, float value, unsigned int index)
  {
    if (index < sizeof(sensors) / sizeof(Sensor))
    {
      strncpy(sensors[index].name, str, sizeof(sensors[0].name) - 1);
      sensors[index].value = value;
    }
  }

  //Damit man eine Klasse direkt drucken kann indem man sie an Print übergibt
  size_t printTo(Print& p) const      
  {
    size_t size = 0;
    for(const Sensor& s : sensors)   //range-based for loop ("for each")
    {
      size += p.print(s.name);
      size += p.print(" - ");
      size += p.println(s.value);
    }
    size += p.println();
    return size;
  }

private:
  struct Sensor
  {
    char name[9];
    float value;
  };

  Sensor sensors[3];
};


void setup()
{
  Serial.begin(115200);
  
  MyClass obj;

  //Elemente mit Werten füllen
  obj.setSensor("Test 1", 1.0, 0);
  obj.setSensor("Test 2", 2.0, 1);
  obj.setSensor("Test 3", 10.0, 2);
  Serial.print(obj);

  obj.setSensor("Blah", 5.0, 0);    //erstes Element ändern
  Serial.print(obj);

  obj.setSensor("Blah Blah", 20.0, 2);   //Test für Überlauf-Erkennung
  Serial.print(obj);
}

void loop() 
{ 
}

Aber das kann man auf viele Arten implementieren. Je nachdem was man genau braucht und wie man es mag

Vektoren und STL sind natürlich praktisch. Die gibt es aber auf den 8-Bit Arduino nicht. In Standard C++ oder auch auf manchen von den 32-Bittern sollte man sowas natürlich bevorzugen

Es gibt für den Arduino immerhin eine Vector-Librarym die lt. Dokumentation mit statischer Speichervereinbarung arbeitet. Man muss die Daten aber selbst anlegen. Habe ich (noch) nie ausprobiert.
Derselbe Autor hat auch eine Array-Klasse veröffentlicht, die die Daten selbst hält.
Und dann wäre noch zu prüfen, ob es sort() gibt.

Eigentlich möchte ich diesen Teil ebenfalls in die Klasse auslagern

static int compareSensors(const void *a, const void *b);

kannst du natürlich in eine Methode

int Sensor::compare(const Sensor& other) const;

ändern.

wno158:
Eine Lösung mit Überschreiben des ‘<’-Operators in der Klasse, die Verwendung eines ‘vector’ und ‘sort’ statt qsort scheint mir … die bessere Lösung zu sein.

Ohne mich tatsächlich da reingeschafft zu haben, scheint es ein guter Hinweis zu sein. Wobei man die generelle Frage, “warum umsortieren?” nicht aus den Augen lassen sollte. Ob eine verkettete Liste nicht auch brauchbar sein könnte?

Ist auch die Frage, ob die Sensor Objekte, und insbesondere ihre Namen, dynamisch erzeugt werden können (müssen)?

Ich habe nochmal etwas gespielt (war für mich eine gute Übung um etwas mehr C++ zu verstehen - bin ja eher ein alter C-Onkel).

Die Lösung funktioniert, hat aber den Makel, dass man die maximale Länge des Sensor-Arrays vorher festlegen muss. Da es immer noch ein Provisorium ist: Noch nicht ausgelagert in ein eigenes File. Der Code gibt so wie er ist reichlich Meldungen über sein Befinden aus.

Die richtige Lösung geht wohl mit Template - das muss ich mir selbst erst erschließen.

/* class für einen Sensor */
class Sensor
{
  private:
    const char* identifier;
    float value;

  public:
    // Konstruktor
    Sensor() {}
    Sensor(const char* identifier, float value) : identifier(identifier), value(value) {}

    void setValue(const float newValue)
    {
      value = newValue;
    }
    float getValue()
    {
      return value;
    }

    const char* getIdentifier()
    {
      return identifier;
    }
};

// Container-Klasse für mehrere Sensoren
// Die maximale Anzahl möglicher Sensoren muss dabei leider außerhalb fix definiert werden.
// Es wird noch nicht geprüft, ob beim Anlegen einer Instanz dieser Klasse der Maximalwert überschritten wird.
const size_t MAX_SENSORS = 10;

class SensorArray
{
  private:
    const size_t numberOfSensorsToBeUsed;
    size_t currentMaxSensorIndex;
    Sensor sensors[MAX_SENSORS];

  public:
    SensorArray(const size_t numberOfSensors) : numberOfSensorsToBeUsed(numberOfSensors), currentMaxSensorIndex(0) {}

    // Hinzufügen eines Sensors mit ID und Wert
    bool addSensor(const char* identifier, float value)
    {
      if (currentMaxSensorIndex >= numberOfSensorsToBeUsed)
        return false;
      sensors[currentMaxSensorIndex] = Sensor(identifier, value);
      Serial.print(F("add '"));
      Serial.print(identifier);
      Serial.print(F("' with value "));
      Serial.print(value);
      Serial.print(F(" at index "));
      Serial.println(currentMaxSensorIndex);
      currentMaxSensorIndex++;
      return true;
    }

    // Ändern eines Sensor-Wertes über Index
    bool setSensorValueByIndex(size_t index, float value)
    {
      if (index >= numberOfSensorsToBeUsed)
        return false;
      sensors[index].setValue(value);
      Serial.print(F("change value of '"));
      Serial.print(sensors[index].getIdentifier());
      Serial.print(F("' to "));
      Serial.print(value);
      Serial.print(F(" at index "));
      Serial.println(index);
      return true;
    }

    // Ändern eines Sensor-Wertes über Identifier
    bool setSensorValueByIdentifier(const char* identifier, float value)
    {
      for (size_t i = 0; i < currentMaxSensorIndex; i++)
      {
        if (strcmp(identifier, sensors[i].getIdentifier()) == 0)
          return setSensorValueByIndex(i, value);
      }
      return false;
    }

    // Vergleichsfunktion für qsort()
    static int compareSensors(const void *a, const void *b)
    {
      /*
        Serial.print(F("compare "));
        Serial.print(((Sensor*)(a))->getIdentifier());
        Serial.print(F(" vs. "));
        Serial.println(((Sensor*)(b))->getIdentifier());
      */
      return ((Sensor*)(a))->getValue() < ((Sensor*)(b))->getValue() ? -1 : ((Sensor*)(a))->getValue() > ((Sensor*)(b))->getValue() ? 1 : 0;
    }

    // Durchführen des Sortierens
    void doSort()
    {
      Serial.println(F("sort array"));
      // wo (noch fast) nix ist, braucht man auch nix sortieren
      if (currentMaxSensorIndex <= 1)
        return;
      qsort((void*)sensors, currentMaxSensorIndex, sizeof(Sensor), compareSensors);

      Serial.println(F("new order is"));
      for (size_t i = 0; i < currentMaxSensorIndex; i++)
      {
        Serial.print(F("  "));
        Serial.print(sensors[i].getIdentifier());
        Serial.print(F("  "));
        Serial.println(sensors[i].getValue());
      }
    }

    // Abholen des Identifiers über Index
    const char* getIdentifier(size_t index)
    {
      if (index >= currentMaxSensorIndex)
        return NULL;
      return sensors[index].getIdentifier();
    }
};

// Deklariere einen Sensor-Array mit 5 Einträgen
SensorArray mySensors(5);

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

  // Setze die Sensoreinträge
  mySensors.addSensor("top", 1.0);
  mySensors.addSensor("left", 2.0);
  mySensors.addSensor("right", 3.0);
  mySensors.addSensor("back", 9.9);
  mySensors.addSensor("bottom", 0.2);

  // sortiere und gib den Identifier des niedrigsten Werts aus
  mySensors.doSort();
  Serial.print(F("identifier of sensor with lowest value is '"));
  Serial.print(mySensors.getIdentifier(0));
  Serial.println(F("'"));

  // ändere niedrigsten Wert
  mySensors.setSensorValueByIndex(0, 5.5);
  // sortiere nochmals und gib den Identifier des niedrigsten Werts aus
  mySensors.doSort();
  Serial.print(F("identifier of sensor with lowest value is '"));
  Serial.print(mySensors.getIdentifier(0));
  Serial.println(F("'"));

  // ändere Wert für 'right'
  mySensors.setSensorValueByIdentifier("right", 0.5);
  // sortiere nochmals und gib den Identifier des niedrigsten Werts aus
  mySensors.doSort();
  Serial.print(F("identifier of sensor with lowest value is '"));
  Serial.print(mySensors.getIdentifier(0));
  Serial.println(F("'"));
}

void loop()
{
}

Den Konstruktor Sensor() {} braucht man eigentlich nicht, solange man nachträglich den Namen nicht ändern kann.
Zumindest sollte dann identifier auf NULL (bzw. nullptr) oder besser auf

static const char* leer  { "" };

gesetzt werden. Wenn das überhaupt Sinn macht.

Aber da der Thread ja darum geht, dass ardudummy c++ lernt und übt
-> viel Spaß, und teile gern deine Ergebnisse mit :slight_smile: