C++: struct an class übergeben

[Stefan S. (sschultewolter)]

Hallo,

ich hab ein kleines Verständnisproblem mit "class" in C++.
Ich habe in einem Programm die FastLED Libary (Arduino) eingebunden.
Die Leds werden in einem struct festgehalten und wie folgt initialisiert

const int NUM_LEDS = 8;
CRGB leds[NUM_LEDS]

Ich möchte nun mit einer eigenen Libary auf die Datenwerte mit einer 
class zugreifen und diese je nach aufgerufener Methode verändern. Doch 
hier enden meine Kenntnisse komplett.

#include <FastLED.h>
const int NUM_LEDS = 10;
CRGB leds[NUM_LEDS];

class LedFX{
public:
  int numLeds = NUM_LEDS;
  // Fade aller Leds
  bool fadeAll(int red, int green, int blue, unsigned long interval);

private:
  // Interne Funktions zur Berechnung des Fades
  int fadeVal(int val, unsigned long interval);
};

bool LedFX::fadeAll(int red, int green, int blue, unsigned long interval)
{
  static int lastVal;
  for (int led = 0; led < numLeds; led++)
  {
    leds[led][0] = fadeVal(red, interval);
    leds[led][1] = fadeVal(green, interval);
    leds[led][2] = fadeVal(blue, interval);
  }
  return true;
}

int LedFX::fadeVal(int val, unsigned long interval)
{
  static bool reverse;
  unsigned long currentMillis = 0; // = millis();
  static unsigned long lastMillis;

  if (currentMillis - lastMillis >= interval)
  {
    lastMillis = currentMillis;

    if (val < 255 && !reverse)
    {
      val++;
    }
    else if (val >= 255 && !reverse)
    {
      val--;
      reverse = true;
    }
    else if (val > 0 && reverse)
    {
      val--;
    }
    else if (val <= 0 && reverse)
    {
      val++;
      reverse = false;
    }
  }
  return val;
}


// ---------------------------------------------------- //
// ---------------------------------------------------- //


int main(void)
{
  init();
  FastLED.addLeds<WS2812B, 8, GRB>(leds, NUM_LEDS);

  pinMode(13, OUTPUT);
  Serial.begin(115200);
  while (1)
  {
    if (leds.fadeAll(255, 0, 255, 100)) FastLED.show();
  }
  return 0;
}

Jedoch funktioniert dieses vom Prinzip her überhaupt nicht. Habe mir das 
"C++ Das umfassende Handbuch" aus dem Galileo Computing Verlag bereits 
besorgt, dort wird leider auf dieses Thema nicht direkt eingegangen. 
(Auf Klassen schon, aber nicht, wie ich ein solches struct mit den 
Werten verändern kann).

Wäre für ein jeden Tipp dankbar.

[sebastian (Gast)]

Was "funktioniert nicht"?
Compiliert es nicht? ... Wenn ja, welche Compilermeldungen verstehst du 
nicht?
Compiliert es, aber tut nicht was du denkst? wenn ja, was tut es, und 
was erwartest du dass es tut?

[Dr. Sommer (Gast)]

In C++ ist der einzige Unterschied zwischen class und struct, dass in 
struct per default alles public ist.

Stefan S. schrieb:
> int numLeds = NUM_LEDS;
Das geht nicht, Member-Variablen dürfen nicht im class-Body 
initialisiert werden, es sei denn sie sind constexpr. Sonst nur im 
Konstruktor

Stefan S. schrieb:
> static int lastVal;
Die Variable wird gar nicht benutzt...

Stefan S. schrieb:
> static unsigned long lastMillis
Dir ist klar dass es im programm nur genau eine solche variable gibt, 
die dann für r,g,b gilt - und somit g,b gar nicht bedient werden?

Stefan S. schrieb:
> return true;
Wozu ein Rückgabewert wenn du eh immer nur true zurückgibst?

Stefan S. schrieb:
> Auf Klassen schon, aber nicht, wie ich ein solches struct mit den Werten
> verändern kann
Welches struct wie wo verändern? Du meinst wie in fadeAll? Genauso wie 
du geschrieben hast.

Stefan S. schrieb:
> if (leds.fadeAll(255, 0, 255, 100))
leds ist doch gar keine Instanz von LedFX, das ist doch Unsinn.

Und ganz allgemein - wozu ist deine Klasse LedFX da? Was stellt eine 
Instanz der Klasse dar? Was soll passieren wenn man 5 LedFX Instanzen 
anlegt? Die Klasse greift auf die globale Variable leds zu, mehrere 
Instanzen würden sich vermutlich stören. Du solltest per Konstruktor 
übergeben, worauf die Klasse zugreifen soll. SO ist die Klasse 
jedenfalls sinnlos - sie repräsentiert kein Objekt und enthält keine 
Daten - da kannst du sie auch weglassen umd die Funktionen global 
machen...

[Stefan S. (sschultewolter)]

Hallo Sebastian,

der Compiler haut mir natürlich Fehler raus, welche ich aber soweit 
begründen kann, jedoch weiß ich nicht, wie es richtig an dieser Stelle 
funktioniert.
[quote]Compiling 'test' for 'Arduino Pro or Pro Mini w/ ATmega328 (5V, 
16 MHz)'
test.ino:10: error: ISO C++ forbids initialization of member 'numLeds'
test.ino:10: error: making 'numLeds' static
test.ino:10: error: ISO C++ forbids in-class initialization of non-const 
static member 'numLeds'
test.ino:In function 'int main()'
test.ino:77: error: request for member 'fadeAll' in 'leds', which is of 
non-class type 'CRGB [10]'
Error compiling
[/quote]

Das Programm funktioniert somit auch nicht wie gewollt.
Was in der class fehlt, ist eine Initialisierung/Konstruktor(!?).

Ich brauche aber einen Zeiger auf einen Struct. (CRGB leds[NUM_LEDS])

[Stefan S. (sschultewolter)]

#include <FastLED.h>
const int NUM_LEDS = 10;
CRGB leds[NUM_LEDS];

class LedFX{
public:
  static const int numLeds = 10;
  // Fade aller Leds
  bool fadeAll(int red, int green, int blue, unsigned long interval);

private:
  // Interne Funktions zur Berechnung des Fades
  int fadeVal(int val, unsigned long interval);
};

bool LedFX::fadeAll(int red, int green, int blue, unsigned long interval)
{
  static int val = fadeVal(val, interval);


  for (int led = 0; led < numLeds; led++)
  {
    leds[led][0] = red * val / 255;
    leds[led][1] = green * val / 255;
    leds[led][2] = blue * val / 255;
  }
  return true;
}

int LedFX::fadeVal(int val, unsigned long interval)
{
  static bool reverse;
  unsigned long currentMillis = 0; // = millis();
  static unsigned long lastMillis;

  if (currentMillis - lastMillis >= interval)
  {
    lastMillis = currentMillis;

    if (val < 255 && !reverse)
    {
      val++;
    }
    else if (val >= 255 && !reverse)
    {
      val--;
      reverse = true;
    }
    else if (val > 0 && reverse)
    {
      val--;
    }
    else if (val <= 0 && reverse)
    {
      val++;
      reverse = false;
    }
  }
  return val;
}


// ---------------------------------------------------- //
// ---------------------------------------------------- //


int main(void)
{
  init();
  FastLED.addLeds<WS2812B, 8, GRB>(leds, NUM_LEDS);
  memset(leds, 0, NUM_LEDS * 3);
  FastLED.show();
  LedFX leds;


  pinMode(13, OUTPUT);
  Serial.begin(115200);
  while (1)
  {
    if (leds.fadeAll(0, 0, 255, 100)) FastLED.show();
  }
  return 0;
}

Habe Code etwas angepasst, was aber nicht so erfolgt wie gewünscht. Die 
class soll später ausgelagert werden in eine Libary. Der Fade 
funktioniert gerade garnicht gescheit. Es sieht ein bisschen wie ein 
Lauflicht aus, kann aber auch sein, dass ich irgendwo die Funktion 
zerschossen haben.

Ich bau das noch einmal eben um und stelle entsprechend den Code neu 
rein.

[Dr. Sommer (Gast)]

Lese doch bitte lieber schritt für schritt ein C++ Buch durch als wild 
irgendwelchen Code zusammenzuwürfeln. Insbesondere über 'static'. Und 
dann überlegst du dir warum/ob du eine Klasse brauchst und was die 
Instanzen der Klasse darstellen sollen. Einfach 'static' an die numLeds 
Variable dranzuschreiben macht vermutlich nicht das was du willst und 
erspart dir nicht das Schreiben eines Konstruktors.

[sebastian (Gast)]

Ich kann dem Dr. Sommer eigentlich nur zustimmen - deine Klasse hat 
keine Daten (außer der numLeds Konstanten, die es unter anderem Namen 
aber eh schon gibt). So macht Sie nicht viel Sinn. wenn du nur 
Funktionen irgendwie "zusammenfassen" willst, wär vielleicht ein 
namespace das richtige.

Zu deinem Problem:
> Ich brauche aber einen Zeiger auf einen Struct.
> (CRGB leds[NUM_LEDS])
Wozu? (Was willst du mit dem Zeiger tun? An was übergeben?...)
Und ist CRGB nicht ein Struct Typ? (Ich kenn den Header FastLED nicht)
Falls CRGB ein struct ist, dann ist das seltsam:
> leds[led][0]
das würde eher passen, wenn es ein Array wäre.
Oder willst du wissen, wie du 3 elemente eines Arrays in 3 elemente eies 
structs kopierst?

[Mark B. (markbrandis)]

Stefan S. schrieb:
> Ich brauche aber einen Zeiger auf einen Struct. (CRGB leds[NUM_LEDS])

Wir haben hier durchaus öfter den Fall, dass ein Themenersteller meint 
unbedingt einen bestimmten Lösungsansatz zu brauchen, was sich aber 
nicht selten als totaler Quatsch herausstellt. ;-)

Es gibt hier nur einen richtigen Ansatz: Beschreibe die Aufgabe, also 
das was zu tun ist. Über das "wie" sollte erst danach entschieden 
werden. Ich verwette eine Flasche Bier darauf, dass eine wunderbar 
funktionierende Lösung völlig ohne irgendwelche Zeiger auf irgendeine 
struct auskommt.

[Mark B. (markbrandis)]

In den Code-Beispielen, die man auf dieser Seite herunterladen kann:

https://github.com/FastLED/FastLED

wird CRGB im übrigen wie folgt verwendet (per Volltextsuche 
aufgelistet). Da ist also nix mit "Zeiger auf Struktur". Was zu erwarten 
war. ;-)

Search "CRGB" (25 hits in 5 files)
  D:\FastLED-master\FastLED-master\examples\Blink\Blink.ino (3 hits)

  Line 13: CRGB leds[NUM_LEDS];
  Line 37:   leds[0] = CRGB::Red;
  Line 41:   leds[0] = CRGB::Black;

  D:\FastLED-master\FastLED-master\examples\Cylon\Cylon.ino (5 hits)

  Line 13: CRGB leds[NUM_LEDS];
  Line 23:     leds[i] = CRGB::Red;
  Line 27:     leds[i] = CRGB::Black;
  Line 35:     leds[i] = CRGB::Red;
  Line 39:     leds[i] = CRGB::Black;

  D:\FastLED-master\FastLED-master\examples\Fast2Dev\Fast2Dev.ino (7 hits)

  Line 21: CRGB leds[NUM_LEDS];
  Line 56:       memset(leds, 0,  NUM_LEDS * sizeof(struct CRGB));
  Line 66:          case 2: leds[iLed] = CRGB(0, 0, 128); break;
  Line 77:       LEDS.showColor(CRGB(x, 0, 0));
  Line 83:       LEDS.showColor(CRGB(x, 0, 0));
  Line 89:       LEDS.showColor(CRGB(0, 128, 0), scale);
  Line 95:       LEDS.showColor(CRGB(0, 128, 0), scale);

  D:\FastLED-master\FastLED-master\examples\FirstLight\FirstLight.ino (3 hits)

  Line 21: CRGB leds[NUM_LEDS];
  Line 54:       leds[whiteLed] = CRGB::White;
  Line 63:       leds[whiteLed] = CRGB::Black;

  D:\FastLED-master\FastLED-master\examples\RGBCalibrate\RGBCalibrate.ino (7 hits)

  Line 33: CRGB leds[NUM_LEDS];
  Line 58:    leds[0] = CRGB::Red; 
  Line 59:    leds[1] = CRGB::Green;
  Line 60:    leds[2] = CRGB::Green;
  Line 61:    leds[3] = CRGB::Blue;
  Line 62:    leds[4] = CRGB::Blue;
  Line 63:    leds[5] = CRGB::Blue;

[Stefan S. (sschultewolter)]

Mark Brandis schrieb:
> Stefan S. schrieb:
>> Ich brauche aber einen Zeiger auf einen Struct. (CRGB leds[NUM_LEDS])
>
> Wir haben hier durchaus öfter den Fall, dass ein Themenersteller meint
> unbedingt einen bestimmten Lösungsansatz zu brauchen, was sich aber
> nicht selten als totaler Quatsch herausstellt. ;-)
>
> Es gibt hier nur einen richtigen Ansatz: Beschreibe die Aufgabe, also
> das was zu tun ist. Über das "wie" sollte erst danach entschieden
> werden. Ich verwette eine Flasche Bier darauf, dass eine wunderbar
> funktionierende Lösung völlig ohne irgendwelche Zeiger auf irgendeine
> struct auskommt.

Hallo,

natürlich funktioniert das ganze auch gänzlich ohne die Zeiger auf 
struct und dem Einsatz der Class. Ich habe alles mit Funktionen 
aufgebaut, die alle in der main.c liegen.

Mein Aufbau derzeit:
/* main.c */
Include FastLED Libary
Struct anlegen und Größe definieren

Hier folgen nun meine eigenen Funktionen

int main(void) {
Initialisierung der FastLED Libary (Chipsatz, DATA_PIN)

while(1) { /* Hier werden die Funktionen aufgerufen */ }
return 0;
}

Was ich jedoch gerne möchte:
Die eigenen Funktionen sollen in einer einer eigenen c/cpp-Datei 
unterkommen.
Die neue Datei soll als Libary funktionieren, sprich ich muss sie später 
nur noch in meinem Header einbinden.

Das Problem ist, die Funktionen beinhalten einige Funktionen der FastLED 
Libary. Das FastLED.show() rauszubekommen ist kein Problem. Dafür will 
ich bei den Methoden/Funktionen ein return nutzen. FastLED.show() muss 
nur genutzt werden, wenn eine Änderung erfolgt ist.
Jedoch weiß ich nicht, wie ich leds[x] hier ersetzen kann, ohne alle 
Daten neuzudeklarienen.

Aufbau:
/* main.c */
Include FastLED Libary
Include Eigene Funktionen Libary
Struct anlegen und Größe definieren

int main(void) {
Initialisierung der FastLED Libary (Chipsatz, DATA_PIN)
>>> Eine Initialisierung der Eigenen Funktionen,
 in dem das Struct als Zeiger übergeben wird sowie die NUM_LEDS.

while(1) { /* Hier werden die Funktionen aufgerufen */ }
return 0;
}

[Karl H. (kbuchegg)]

Stefan S. schrieb:


> Jedoch weiß ich nicht, wie ich leds[x] hier ersetzen kann, ohne alle
> Daten neuzudeklarienen.

Das Problem ist, das zu oft mit globalen Variablen gearbeitet wird, bzw. 
die Grundlagen nicht gelernt wurden.
Denn dann wüsstest du, wie man ein Array an eine Funktion übergibt

int werte[5];

void foo( int* daten )
{
  daten[0] = 1;
  daten[1] = 2;
}

int main()
{
  foo( werte );
}

du hast dann eben kein Array von int, sondern ein Array von CRGB's. Aber 
das ändert nichts daran. Array ist Array und es wird an eine Funktion 
übergeben, indem die Funktion einen Pointer auf das erste Array Element 
bekommt. Ob das jetzt ein int-Array ist oder ein CRGB-Array ist hingegen 
völlig wurscht.

Also: übergib deiner FUnktion das Array zusammen mit der Länge des 
Arrays und alles wird gut.

void fadeIt( CRGB* theLeds, int numLeds )
{
  for( i = 0; i < numLeds; i++ )
  {
    theLeds[i][0] = 0;
    theLeds[i][1] = 0;
    theLeds[i][2] = 0;
  }

  ....
}

void loop()
{

  ...
  fadeIt( leds, NUM_LEDS );
  ...
}

Wenn du die Funktion unbedingt in eine Klasse stecken willst - ok, kann 
man machen. Dann kann man der fade Funktion das Array übergeben oder man 
'zeigt' dem Objekt im Konstruktor mit welchem CRGB Array es arbeiten 
soll. Beides ist möglich, wenn ich auch die Konstruktor-Variante 
bevorzugen würde.

class LedFX
{
  public:

  LedFX( CRGB* theLeds, int numLeds )
      : theLeds_( theLeds ), numLeds_( numLeds )
      {}

  // Fade aller Leds
  void fadeAll(int red, int green, int blue, unsigned long interval);

private:
  int fadeVal(int val, unsigned long interval);

  int   numLeds_;
  CRGB* theLeds_;
};

void LedFX::fadeAll(int red, int green, int blue, unsigned long interval)
{
  int val = fadeVal(val, interval);

  for (int led = 0; led < numLeds_; led++)
  {
    theLeds_[led][0] = red * val / 255;
    theLeds_[led][1] = green * val / 255;
    theLeds_[led][2] = blue * val / 255;
  }
}

[Karl H. (kbuchegg)]

sebastian schrieb:

> aber eh schon gibt). So macht Sie nicht viel Sinn.

Zugegeben.
Im Moment macht das noch nicht viel Sinn, die ganze Fade-Funktion in 
eine Klasse zu stecken.

Interessanter wird das ganze dann, wenn man zb eine Effekt-Klasse hat, 
von der dann unter anderem dieser Fader abgeleitet wird (oder auch zb 
ein Lauflicht oder ...), und dann anfängt die fadeAll Funktion etwas zu 
verändern. so wie sie jetzt ist, ist sie noch ein wenig behäbig 
geschrieben. Das müsste unterteilt werden in einen Fade-Setup Teil und 
einen 'Mach jetzt den nächsten Schritt der Arbeit' Teil. Denn letzterer 
ist bei allen Effekten gleich und eine virtuelle Funktion, so dass man 
mehrere Effekt-Objekte in einem Array sammeln kann und dann über die 
virtuelle Funktion jedem Objekt den Auftrag gibt, in der jetzigen 
Zeitsituation seinen Effekt einzustellen.

Aber: das ist alles noch Zukunftsmusik und dazu benötigt es dann schon 
ein bischen bessere C++ Kentnisse des TO.
Aber was predige ich. Mitlerweile predige ich in jedem 3.ten Thread das 
immer gleiche: Leute, lernt eure Programmiersprache!
Schön langsam bin ichs leid, den 350-ten durch die banalsten Untiefen 
seiner Programmiersprache zu leiten, nur weil er nicht begreift, dass er 
sich eine Menge Zeit und Frustr sparen würde, wenn er mal ein C++ Buch 
durcharbeiten würde.