Drehgeber-Abfrage mit Drehgeschwindigkeits-Erkennung

Hallo hochgeschätzte Community,

ich versuche meinen Drehgeber-Sketch dahingehend zu verfeinern, dass es nicht nur die Drehrichtung erkennt, sondern auch noch die Drehgeschwindigkeit ausliest.

Konkret arbeitet angehängter Sketch so, dass abhängig von der Drehrichtung einmal die gelbe (Pin 8 ) und einmal die rote LED (Pin 9) aufblitzt.

Nun möchte ich gerne realisieren, dass bei normaler Drehgeschwindigkeit eben die eben genannten LEDs weiterhin aufblitzen, bei schneller Drehgeschwindigkeit jedoch zwei andere LEDs je nach Drehrichtung aufblinken (Pin 10 und 11).

Ich habe den ganzen Tag mit dem Intervall im Verhältnis zu millis rumprobiert, aber ich komme absolut nicht auf eine Lösung. Vielleicht habt Ihr einen Vorschlag oder auch ein paar ergänzende Codezeilen?

Vielen Dank im Voraus für Eure Hilfe.

VG Chris

struct rotary_t {byte pinA; byte pinB; byte state; int count;};

rotary_t encoder[]={
  {4,5},      // Encoder1
  {2,3},      // Encoder2
};

#define NUMENCODERS (sizeof(encoder)/sizeof(encoder[0]))

void beginEncoders()
{
  for (int i=0; i<NUMENCODERS; i++)
  {
    pinMode(encoder[i].pinA, INPUT_PULLUP);
    pinMode(encoder[i].pinB, INPUT_PULLUP);
    readEncoder(i);
  }
}

short readEncoder(byte i)
{
  short result=0;
  byte state=encoder[i].state;
  state= state<<2 | (byte)digitalRead(encoder[i].pinA)<<1 | (byte)digitalRead(encoder[i].pinB); 
  state= state & 0xF;
  if (state==0b0001 || state==0b0111 || state==0b1110 || state==0b1000) result= -1;
  else if (state==0b0010 || state==0b1011 || state==0b1101 || state==0b0100) result= 1;
  encoder[i].state= state;
  return result;
}

void input()
{
  for (int i=0; i<NUMENCODERS; i++)
  {
    encoder[i].count+= readEncoder(i); 
  }
}

void output()
{
  #define INTERVAL_slow 10
  static unsigned long lastOutput;
  static int lastCount[NUMENCODERS];
  
  if (millis()-lastOutput>=INTERVAL_slow)
  {
    lastOutput=millis();
    boolean changed=false;
    for (int i=0;i<NUMENCODERS;i++)
    {
      if (encoder[i].count!=lastCount[i])
      {
        changed=true;    
      }
    }
    if (changed)
    {
      for (int i=0;i<NUMENCODERS;i++)
      {
        if (lastCount[i]>encoder[i].count)
        {
        digitalWrite(i+7, HIGH);
        delay(30);
        digitalWrite(i+7, LOW);
        lastCount[i]=encoder[i].count;
        }
        else if (lastCount[i]<encoder[i].count)
        {
        digitalWrite(i+8, HIGH);
        delay(30);
        digitalWrite(i+8, LOW);
        lastCount[i]=encoder[i].count;
        }
      }
    }
  }
}


void setup() {

  beginEncoders();
   pinMode(8, OUTPUT);
   pinMode(9, OUTPUT);
   pinMode(10, OUTPUT);
   pinMode(11, OUTPUT);
}


void loop() {
  input();
  output();
}

Hallo,

du müsstest noch vom Encoder einen Zählwert haben mit dem du die Differenzwerte und die benötigte Zeit dafür verrechnest. Ergebnis wäre deine Drehgeschwindigkeit.

Hallo Doc Arduino,

herzlichen Dank für deinen Vorschlag. Der Sketch ist nicht alleine auf meinem Mist gewachsen, da ich nicht besonders fit in Programmierung bin. Daher versuche ich gerade, deine Anregung einzuordnen und sie erstmal zu verstehen. Das Programmieren der Codezeilen an der korrekten Position ist dann ein anderes Thema, denn da tue ich mich dann doch bissel schwer. Hier erstmal mein Gedankengang:

Dieser Zählwert müsste ja bei jedem Drehimpuls hoch- bzw. runterzählen, der dann ins Verhältnis zur vergangenen Zeit während dieser Drehung gesetzt wird, richtig?

Fall 1: Wenn Drehrichtung LINKS und Differenz aus Encoder-Zählwert und vergangener Zeit <= als definierte Referenzzeitspanne tref in millis, dann LED 2.

Fall 2: Wenn Drehrichtung RECHTS und Differenz aus Encoder-Zählwert und vergangener Zeit <= als tref, dann LED 3.

Fall 3: Wenn Drehrichtung LINKS und Differenz aus Encoder-Zählwert und vergangener Zeit > als tref, dann LED 4.

Fall 4: Wenn Drehrichtung RECHTS und Differenz aus Encoder-Zählwert und vergangener Zeit > als tref, dann LED 5.

Habe ich das erstmal so richtig verstanden?

Viele Grüße

Chris

Hallo,

ist das ein mechanischer Drehgeber den du mit der Hand drehst?
Wenn ja, dann würde ich das so oder so ähnlich angehen. Habs auch noch nicht gemacht. Ich würde innerhalb einer festen Zeitspanne ( eine Sekunde ?) die Zählerdifferenz auswerten und daraus die Drehgeschwindigkeit berechnen. Für die neue Messung den alten Zählerstand merken und wenn die Messzeit vorbei ist den aktuellen Zählerstand merken. Erneute Differenz bilden und verrechnen. Das wird ständig wiederholt. Mit links/rechts Erkennung würde ich dafür nichts machen. Die Richtungserkennung ist nur ein “Nebenprodukt” der Encoderauswertung.

Da ich vor einer Weile eine Lib für mich geschrieben hatte mit den Infos von Peter Dannegger, kann ich dir was geben. Ein Bsp. für dich ist drin, da ich davon ausgehe das du einen mechanischer Drehgeber hast. Du musst nur sorgfältig den Portnamen und die Port Bits anpassen. Dafür habe ich Links zu den Pinouts eingefügt. Also das vor setup und innerhalb setup.

GrayEncoder_v2 … ist für reine Encoder gedacht
Alps_Encoder … ist für mechanische Encoder gedacht, die zählen 2 Digits pro Drehklick, ist in der Lib korrigiert, zumindestens macht das mein Alps EC11 so. Das mit der 2 Klick Korrektur ist der einzigste Unterschied zwischen beiden Instanzen.

Ich hoffe ich mute dir jetzt nicht zu viel auf einmal zu. Guck dir das in Ruhe an. Dann änderst du die L/R LED Anzeige ab. Dann überlegste dir wie du die Zählerwerte speicherst bis zum verrechnen.

GrayEncoder_v2.zip (4.77 KB)

Hallo Doc Arduino,

danke für deine ausführliche Antwort - ich werde mir das gleich in Ruhe mal ansehen. Lach, ja ich hoffe auch, dass ich das verstehe. Zwischenzeitlich habe ich ein bissel mit einer Zeitabfrage rumprobiert, aber da fehlt mir noch ein Impulszähler am Encoder, sonst ist keine Berechnung des Verhältnisses zu einer festen Zeitspanne möglich. Ist im Moment mehr Trial & Error-Learning :smiley:

Es handelt sich bei meinen verwendeten um hochwertige optische 5V-Encoder von Cui, die mit der Hand gedreht werden:
http://www.de.cui.com/product/motion/rotary-encoders/incremental/panel/optical/c14-series

Mit meinem gestern geposteten Sketch läuft die alleinige Abfrage der Drehrichtung perfekt, sowohl mit optischen als auch mit mechanischen Encodern. Wichtig war mir dabei, dass jeder einzelne Detent ausgelesen wird. Aber ich gucke mir jetzt erstmal deine Datei an :slight_smile:

Viele Grüße

Chris

Hallo,

nobel, dann sind deine besser wie meine einfachen mechanischen. :slight_smile: Musste mal schauen ob sie ein oder zwei weiter zählen pro "Klick". Je nachdem nimmste entweder die eine oder andere Instanz. Einfach ausprobieren. Viel Spass.

Jo, die CUIs sind halt butterweich :slight_smile:

Ich habe deinen Gray-Sketch für den ProMicro modifiziert und noch die Blitzfunktion abhängig von der Drehrichtung integriert, aber noch keine Abhängigkeit von der Anzahl der Impulse in Relation zu einem festgelegten Zeitraum. Das muss ich erst durchdenken.

Das Ganze läuft wirklich sehr flüssig mit den optischen Encodern, insofern erstmal vielen Dank! Allerdings blitzt bei schneller Drehung auch ab und zu mal die LED der jeweils anderen Drehrichtung auf. Vielleicht “verschluckt” er bei zu schneller Drehung den Vergleich zwischen aktuellem und vorherigem Zählwert?

Viele Grüße

Chris

/*
  Doc Arduino - german Arduino Forum
  IDE 1.8.5
  Arduino Mega2560
  05.11.2017
  
  mit Klassen-Vererbung  http://forum.arduino.cc/index.php?topic=444899
  
  Board Pinouts   >>>  http://www.pighixxx.com/test/pinoutspg/boards/
*/

#include <GrayEncoder_v2.h>

GrayEncoder_v2 Encoder1 (&PIND, 0, 1);  // Pin 2,3 > Port.D "Bit 0","Bit 1"

int Encoder1_Direction;
int Encoder1_CurrentCounter;
int Encoder1_PreviousCounter;

const byte LED_Pin1 = 7;
const byte LED_Pin2 = 8;


void setup() {
  Serial.begin(9600);
  
  pinMode(2, INPUT_PULLUP);
  pinMode(3, INPUT_PULLUP);
  pinMode(LED_Pin1, OUTPUT);
  pinMode(LED_Pin2, OUTPUT); 
}


void loop() {

  update_Encoder();
  
  if ( Encoder1.getDirection() > 0 && Encoder1_CurrentCounter > Encoder1_PreviousCounter) {
    Encoder1_PreviousCounter = Encoder1_CurrentCounter;
    digitalWrite(LED_Pin1, HIGH);
    delay(20);
    digitalWrite(LED_Pin1, LOW);
  }
  
  else {
    if ( Encoder1.getDirection() < 0 && Encoder1_CurrentCounter < Encoder1_PreviousCounter ) {
    Encoder1_PreviousCounter = Encoder1_CurrentCounter;
    digitalWrite(LED_Pin2, HIGH);
    delay(20);
    digitalWrite(LED_Pin2, LOW);
    }
  }
  
  serieller_Monitor();
}


void update_Encoder()
{  
  Encoder1.encode(); 
  Encoder1_Direction = Encoder1.getDirection(); 
  Encoder1_CurrentCounter = Encoder1.getCounter();
}


void serieller_Monitor()
{
  static unsigned int intervall = 250;
  static unsigned long prevMillis = 0;

  if (millis()-prevMillis<intervall) return; // Zeit noch nicht erreicht, Funktion abbrechen
  
  prevMillis+=intervall; 
  Serial.print(Encoder1_Direction); Serial.print('\t');
  Serial.print(Encoder1_CurrentCounter); Serial.print('\t');
  Serial.print(Encoder1_PreviousCounter);
  Serial.println();
}

Hallo,

hat deiner eine Rastfunktion oder merkt man da nichts? Meine Alps rasten ja ein und klicken/ratzen leicht beim drehen. Bedingt durch die mechanischen Schalter. Deine müsste widerstandslos drehbar sein? :slight_smile:

Zum Problem. Wenn du schnell drehst macht dir dein delay vom LED Blitz einen Strich durch die Rechnung. Während des delays bleibt die loop stehen und kann zum Bsp. die Encodereingänge nicht einlesen. Die LED Blitze musste mit millis() machen. Jedes delay ist untersagt. Alles was irgendwie warten soll oder verzögert werden muss mit millis behandelt. Eine kleines Bsp. siehste schon im Aufruf der seriellen Monitor Funktion.

Nimm das delay erstmal von 20 auf 1 runter. Dann siehste schon was abgeht. :slight_smile:

Grundlagen:

Theseus erklärt millis()

GuntherB - BlinkwithoutDelay - Die Nachtwächtererklärung

Du hast natürlich vollkommen recht mit den delays, das werde ich ändern. Ich werde mich auch nochmal intensiv mit den millis auseinandersetzen. Das Hauptproblem ist für mich jedoch die Position der millis-Vergleichs im Code, wo er die Encodercounts zählen soll sowie dessen Relation zur Zeit. Aber ich bleibe am Ball!

Meine optischen Encoder haben auch kleine Rasten pro Detent, da kann man sehr fein einstellen. Sind 32 Detents/Rasten pro Umdrehung.

Erstmal eine gute Nacht :slight_smile:

Viele Grüße

Chris

Hallo,

okay, ein Bsp. LED aufleuchten ohne delay zeige ich dir noch. Wenn du das grundlegende Prinzip an Hand der gut erklärenden Links einmal verstanden hast, ist alles weitere einfach. Es gibt leider immer den Zusammenhang, je schneller ein Programm auf irgendwas reagieren soll mit anderen Zeitabläufen zusammen, umso unfangreicher wird das Programm selbst.

Wenn das Vorhaben größere Dimensionen annimmt mache ich mir einen Ablaufplan. Wenn der detailliert genug ist, ist es leichter das in Code umzusetzen. Man gewinnt mehr Überblick.

so, musst nur wieder deine Pins anpassen!

/*
  Doc Arduino - german Arduino Forum
  IDE 1.8.5
  Arduino Mega2560
  06.11.2017
  
  mit Klassen-Vererbung  http://forum.arduino.cc/index.php?topic=444899
  
  Info >>> https://www.mikrocontroller.net/articles/Drehgeber
       >>> https://www.mikrocontroller.net/topic/drehgeber-auslesen
  
  Board Pinouts   >>>  http://www.pighixxx.com/test/pinoutspg/boards/
  Pinout Uno      >>>  http://www.pighixxx.com/test/portfolio-items/uno/?portfolioID=314
  Pinout Mega2560 >>>  http://www.pighixxx.com/test/portfolio-items/mega/?portfolioID=314
*/


#include <GrayEncoder_v2.h>

// GrayEncoder_v2 Encoder1 (&PINH, 5, 6);  // Pin 8,9 > Port.H, Bit 5 und 6
ALPS_Encoder   Encoder1 (&PINH, 5, 6);  // Pin 8,9 > Port.H, Bit 5 und 6
int Encoder1_Direction;
int Encoder1_Counter;

const byte Taster_Pin = 4;    // Taster am Drehencoder
const byte LED_13 = 13;       // einfache Richtungsanzeige L/R >> ein/aus

const byte LED_L = 32;
const byte LED_R = 33;

void setup() {
  Serial.begin(9600);
  
  pinMode(8, INPUT_PULLUP);     // Encoder Phase A
  pinMode(9, INPUT_PULLUP);     // Encoder Phase B
  pinMode(Taster_Pin, INPUT_PULLUP);
  pinMode(LED_13, OUTPUT);
  pinMode(LED_L, OUTPUT);
  pinMode(LED_R, OUTPUT); 
  
}

void loop() {

  update_Encoder();

  update_Taster();
  
  if ( Encoder1.getDirection() > 0 ) {
    digitalWrite(LED_13, HIGH);
  }  
  else {
    digitalWrite(LED_13, LOW);
  }

  Richtungsauswertung();
  
  serieller_Monitor();

}


// ****** Funktionen ******
void Richtungsauswertung ()
{
  static char last_direction = 0;
  static bool rechts = false;
  static bool links = false;
  static unsigned long R_Einschaltzeitpunkt = 0;
  static unsigned long L_Einschaltzeitpunkt = 0;
  const unsigned int dauer = 400;
  
  if (Encoder1_Direction != last_direction) {   // neue Richtung verschieden zur alten?
    if (Encoder1_Direction > 0) {               // auswerten und entsprechend setzen
      rechts = true;
      links = false;
      digitalWrite(LED_R, HIGH);
      digitalWrite(LED_L, LOW);
      R_Einschaltzeitpunkt = millis();          // und LED Einschaltzeitpunkt merken
    }
    else {
      links = true;
      rechts = false;
      digitalWrite(LED_L, HIGH);
      digitalWrite(LED_R, LOW);
      L_Einschaltzeitpunkt = millis();
    }  
    last_direction = Encoder1_Direction;        // neue Richtung merken
  }

  if (rechts == true && (millis() > R_Einschaltzeitpunkt+dauer) ) {  // LED verzögert ausschalten
    digitalWrite(LED_R, LOW);
    rechts = false;
  }
  if (links == true && (millis() > L_Einschaltzeitpunkt+dauer) ) {
    digitalWrite(LED_L, LOW);
    links = false;
  }  
}


void update_Encoder ()
{  
  Encoder1.encode(); 
  Encoder1_Direction = Encoder1.getDirection(); 
  Encoder1_Counter   = Encoder1.getCounter();
}


void update_Taster ()
{
  if ( digitalRead(Taster_Pin) == LOW ) {
    Encoder1.setCounter(333);
  }  
}

void serieller_Monitor ()
{
  static unsigned int intervall = 500;
  static unsigned long last_ms = 0;

  if (millis()-last_ms < intervall) return; // Zeit noch nicht erreicht, Funktion abbrechen
  
  last_ms += intervall; 
  Ueberschriftszeile();
  Serial.print(Encoder1_Direction); Serial.print('\t');
  Serial.print(Encoder1_Counter); Serial.print('\t');
  Serial.println();
}


void Ueberschriftszeile ()
{
  static int counter = 33;

  counter++;
  
  if (counter<20) return; // Zeit noch nicht erreicht, Funktion abbrechen
  
  counter = 0; 
  Serial.print(F("DIR")); Serial.print('\t');
  Serial.print(F("COUNT")); Serial.print('\t');
  Serial.println();
}

Hallo,

in der Funktion Richtungsauswertung ist mir ein Fehler in der Auswertung unterlaufen. Muss noch korrigiert werden sonst schlägt der millis Vergleich irgendwann fehl.

if (rechts == true && ( millis() - R_Einschaltzeitpunkt > dauer) ) { // LED verzögert ausschalten
digitalWrite(LED_R, LOW);
rechts = false;
}
if (links == true && ( millis() - L_Einschaltzeitpunkt > dauer) ) {
digitalWrite(LED_L, LOW);
links = false;
}

Hallo Doc Arduino,

ja habs gemerkt, vielen Dank :slight_smile:

Dein letzter Sketch von gestern erkennt zwar elegant die Richtungsänderung und steuert dementsprechend auch die jeweilige LED an, aber ich möchte ja für jeden Detent ein kurzes LED-Aufblitzen haben, quasi als optische Visualisierung des Detents.

Deinen Sketch hab ich dahingehend modifiziert, was auch prima funktioniert. Die millis-Abfrage habe ich verstanden und somit gibt es auch keine ungewünschten “Fremdblitze” wie bei delay() mehr!

Gleichzeitig habe ich versucht, den Counterwert der Encoderabfrage nur in einem festen Zeitraum zu bekommen und mittels der Differenz aus Zeitraum und ermitteltem Counterwerts die EncoderSpeed zu ermitteln, um damit eben schnell und langsam für die Weiterverarbeitung zu identifizieren. Das klappt leider gar nicht, weil ich wie gesagt nicht genau weiß, wo diese Abfrage stattfinden muss. Er soll ja solange in dem Zeitraum von sagen wir mal 250ms den Counter zählen, bis der Zeitraum abgelaufen ist. Dann soll er das Verhältnis zur Zeit berechnen, weitergeben, und dann geht das Ganze von vorne los. Kann ja eigentlich nur unter update_Encoder stattfinden, oder?

Viele Grüße

Chris

/*
Doc Arduino - german Arduino Forum
IDE 1.8.5
Arduino Mega2560
05.11.2017

mit Klassen-Vererbung http://forum.arduino.cc/index.php?topic=444899

Board Pinouts >>> http://www.pighixxx.com/test/pinoutspg/boards/
*/

#include <GrayEncoder_v2.h>

GrayEncoder_v2 Encoder1 (&PIND, 0, 1); // Pin 2,3 > Port.D “Bit 0”,“Bit 1”

int Encoder1_Direction;
int Encoder1_CurrentCounter;
int Encoder1_PreviousCounter;
int Encoder1_Speed;

static unsigned long Einschaltzeitpunkt = 0;
const unsigned int Dauer = 10;
const unsigned int Messzeit = 250;
const byte LED_Pin1 = 6;
const byte LED_Pin2 = 7;

void setup() {

Serial.begin(9600);

pinMode(2, INPUT_PULLUP);
pinMode(3, INPUT_PULLUP);
pinMode(LED_Pin1, OUTPUT);
pinMode(LED_Pin2, OUTPUT);
}

void loop() {

update_Encoder();

if (Encoder1_CurrentCounter > Encoder1_PreviousCounter) {
Encoder1_PreviousCounter = Encoder1_CurrentCounter;
digitalWrite(LED_Pin1, HIGH);
digitalWrite(LED_Pin2, LOW);
Einschaltzeitpunkt = millis();
}

else if (Encoder1_CurrentCounter < Encoder1_PreviousCounter) {
Encoder1_PreviousCounter = Encoder1_CurrentCounter;
digitalWrite(LED_Pin2, HIGH);
digitalWrite(LED_Pin1, LOW);
Einschaltzeitpunkt = millis();
}

if (millis() > Einschaltzeitpunkt + Dauer) {
digitalWrite(LED_Pin1, LOW);
digitalWrite(LED_Pin2, LOW);
}

serieller_Monitor();

}

void update_Encoder() {

Encoder1.encode();
Encoder1_Direction = Encoder1.getDirection();
Encoder1_CurrentCounter = Encoder1.getCounter();
}

void serieller_Monitor() {

static unsigned int intervall = 250;
static unsigned long prevMillis = 0;

Serial.print(Encoder1_Direction); Serial.print(’\t’);
Serial.print(Encoder1_CurrentCounter); Serial.print(’\t’);
Serial.print(Encoder1_PreviousCounter);
Serial.println();
}

Hallo,

fang bitte nicht an alles in globale Variablen zuverfrachten. Das kann zu unklaren Zuständen führen wenn man den Überblick verliert. Zudem sind "gekappselte" Funktionen einfacher portierbar.

Geschwindigkeitsmessung. Ganz einfach und nicht alles in die update Funktion werfen. Schreib eine neue Funktion die in loop regelmäßig aufgerufen wird. Der Zählerstand ist global verfügbar. Guck dir serieller Monitor an. Der wird aller 500ms aufgerufen. Das heißt alles da drin wird nur aller 500ms abgearbeitet. Das kannste dir meinetwegen kopieren und erhöhst es auf 1s. Dann musste dir noch den alten Zählerstand merken und mit dem neuen vergleichen und Differenz bilden und damit die Geschwindigkeit ausrechnen und wieder den neue Zähler als alten merken. Das passiert dann regelmäßig aller 1s. Du musst ja nicht jede Zähleränderung mitbekommen. Du musst nur wissen was war der Zählerstand vor und nach der 1s.

Hallo Doc Arduino,

ich hab's hinbekommen, vielen Dank! Die Erkennung langsam/schnell läuft prima.
Nun bastele ich gerade daran, den Sketch mit deiner Encoder-Bibliothek so zu verändern, dass er möglichst schlank bis zu sechs optische Encoder gleichzeitig abfragen kann. Wie mache ich das am elegantesten? Mit dem alten Sketch ging das bereits, jedoch waren dort ja delays verwendet.

Viele Grüße
Chris

Hallo,

jetzt kommt der Vorteil einer Lib ins Spiel. Man muss nur mehrere Instanzen vom Objekt erstellen.

GrayEncoder_v2 Encoder1 (&PIND, 0, 1); // Pin 2,3 > Port.D "Bit 0","Bit 1"
GrayEncoder_v2 Encoder2 ( ... );
GrayEncoder_v2 Encoder3 ( ... );

Das verstehe ich schon und hab es auch schon so vorbereitet, aber in der Abfrage müsste ich ja jetzt für jeden Encoder 1-6 eigene Variablen und eine eigene Abfrageroutine implementieren. Oder geht das auch mit einer Variable, die für die EncoderNummer steht?

In irgendeinem Thread der letzten Tage (?) tauchte mal ein Array aus Encodern auf. Suche mal danach.

Gruß Tommy

Hallo Tommy,

danke, habs gefunden: Encoder im zusammenführen (Array) - Deutsch - Arduino Forum

Nur bei dem hier vorliegenden Fall habe ich ja sowohl die Pindefinition aus Buchstaben und erst dann die beiden Pin-Bits:
GrayEncoder_v2 Encoder1 (&PIND, 0, 1);
GrayEncoder_v2 Encoder2 (&PIND, 4, 7);
...

Wie schreibe ich denn dafür ein Array und wie frage ich in der Loop die Encoder 1-6 dann ab?
Ich hab leider nicht viel Ahnung von solchen Dingen, daher freu ich mich über jede Hilfe :slight_smile:

Viele Grüße
Christiane

Welche Parameter Du an den Konsruktor übergibst, ist ja für das Objektarray egal.
Um zu erfahren, wie man auf Werte in einem Array zugreift, solltest Du wirklich mal anfangen, Dich mit den Grundlagen zu beschäftigen.
Nach einer Weile wirkt das Argument “keine Ahnung” nur noch als Ausrede für “keine Lust”.

Gruß Tommy

Das tue ich bereits seit längerem, aber für mich ist das nicht mehr ganz so leicht :wink:
Also von keine Lust kann definitiv keine Rede sein, ich beschäftige mich aber erst seit zwei Jahren mit solchen Sachen, und für die kleinen Projektlein hat es bisher gereicht. Dauert nun mal ein Weilchen länger bei mir, aber ich versuche es natürlich trotzdem weiter. Danke für die Antworten.

VG Chris