PIN Status merken von mehreren PINS

Hallo miteinander,

in einem Größeren Projekt kann ich per Serielle Schnittstelle Befehle absetzen, einer davon soll sein.

-- Sensoren_TEST --

Hierbei geht es darum das alle Hinterlegten Sensoren (im Array) mit der PIN Nummer in Spalten ausgegeben werden (mit Tab getrennt).

Wenn einer der Sensoren jetzt den Status ändern dann soll eine Neue Zeile mit dem zustand aller Sensoren ausgegeben werden.
Der Sensoren_TEST soll mit dem Befehl END auch wieder beendet werden.

Da das Projekt größer ist habe ich die Funktion in einem Separaten Sketch entwickelt.
Sprich Befehle über die Serielle Schnittstelle werden erst ein mal ignoriert.

Ich habe das auch alle hin bekommen was ich möchte, ich habe nur etwas Bauchschmerzen wie ich die verschiedenen Status der Sensoren Überwache bzw. auf Wechsel prüfe.

Mir kommt das sehr Kompliziert vor was ich da gemacht habe.

Daher meine Frage an euch, mache ich das so richtig oder macht man das auf ein andere weise eleganter?

Gruß Mücke

 int   Endstop_Pins[] = {22, 23, 24, 25, 26, 27, 28};  // PIN Nr. für die Induktive Sensoren (Endstop)
  int   Endstop_Status[]={ 0,  0,  0,  0,  0,  0,  0};  // Staus der PINS der Induktive Sensoren (Endstop)
  
void setup() {
  // Installiren des Seriellen Schnittstelle  
  Serial.begin(9600);

  // Endstop als Eingang definiren
  for (byte i = 0; i < (sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0])); i++) 
  {pinMode(Endstop_Pins[i], INPUT);}

  // Kopfzeile für Induktive Sensoren (Endstop) TEST aufrufen 
  sensoren_test_kopf();
}

void loop() {
    sensoren_test();
}


void sensoren_test() {
  bool Ausgabe = false;  // true = Sensor Status hat gewechselt or false = Sensor Status hat nicht gewechselt
  
  // Sensoren eingang auf Status wechsel Prüfen 
  for (byte i = 0; i < (sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0])); i++){
    // Bei Status wechel merken das ausgabe erfeolgen soll 
    if (Endstop_Status[i] != digitalRead(Endstop_Pins[i])){ Ausgabe = true; }
    // Aktuellen Status merken 
    Endstop_Status[i] = digitalRead(Endstop_Pins[i]); 
  }
  // Ausgabe aller PIN Stause in einer neuen Zeile, nur wenn eine änderung vorlag
  if (Ausgabe) {
    for (byte i = 0; i < (sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0])); i++){
      Serial.print(digitalRead(Endstop_Pins[i]));   // Status ausgabe 
      Serial.print("\t");                           // Tab ausgeben          
    }
    Serial.println(F(""));                          // Zeilenumbruch ausgeben
  }
}

void sensoren_test_kopf() {
  Serial.println(F("OK, Induktive Sensoren (Endstop) TEST wurde gestartet"));    
  Serial.println(F("    Beenden mit Befehl END"));   
  Serial.println(F(""));   
  Serial.println(F("Spalten: Sensoren PIN Nr."));   
  Serial.println(F("Neue Zeile: nur bei Statusänderung"));
  for (byte i = 0; i < (sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0])); i++){
    Serial.print(Endstop_Pins[i]);           // PIN Nummer ausgeben
    Serial.print("\t");                      // Tab ausgeben 
  }
  Serial.println(F(""));                     // Zeilenumbruch ausgeben
}

Hi Mücke, welcome back.

Warst ja lange verschwunden.

Für mich sieht die Routine auf den ersten Blick brauchbar und lesbar aus. Für die for Schleife gibt es eine neue, einfache Syntax, die weniger Fehler zulässt.

Hi

  • warum INT bei Status? Als digitaler Sensor sehe ich Da eher ein BOOLEAN, ein Byte wäre auch noch ok.
  • wider (nur mit i) kommt von Gegen - siehe Widerstand. Bei der Bedeutung Erneut vorne mit ie
  • Status ist ebenfalls die Mehrzahl (keine Angst, musste ich auch Nachlesen :wink: )

Von der Funktion sieht Das doch ganz gut aus - alleine die Wartezeit hätte ich mit dem Testen dieser Funktionen verbracht - die 9600Baud der seriellen Schnittstelle könnten hier stark bremsend wirken, pro Zeichen brauchst Du ungefähr eine Millisekunde (10000 Zeichen a 10 Bit in einer Sekunde -> 1000 Zeichen in 1000ms).
Bei Sketchen mit viel Ausgaben auf dem Terminal benutze ich derzeit 38400 Baud, sonst aber auch ganz gerne 9600 - man braucht einen 'Standard', womit die Steinchen am Anfang ein "Hallo ich bin's" ausgeben, daß man weiß, was man mit dem µC vor hatte - ok, brauchen ist zu viel, ist eher ein nice²have.

Das Erkennen von Start- und Stop-Befehl klappt?

MfG

"Elegant" ist immer auch Geschmacksfrage.
Als Ergänzung zu ElEspanol sehe ich drei statt zwei Funktionen:

  • Kopf ausgeben
  • Änderung erkennen
  • Zustand ausgeben

Deine 7 Zustände kann man in einem einzigen Byte zusammenfassen. Bis zu 16 passen in ein int ( oder uin16_t ) Dann könnte man eine Änderung durch einen einzigen Vergleich
  alt != neu
erledigen.

Aber, wie gesagt, nicht unbedingt erforderlich.

Das dreimalige Lesen ist u.U. unglücklich.

Ich würde es etwa so schreiben (unter Beibehaltung der grundlegenden Struktur)

const byte Endstop_Pins[] = {22, 23, 24, 25, 26, 27, 28};
const byte numberOfSensors = sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0]);
byte Endstop_Status[] = { 0,  0,  0,  0,  0,  0,  0};

void setup() {
  Serial.begin(250000);
  // Endstop als Eingang definieren ist unnötig da der default INPUT ist
  //  for (auto pin : Endstop_Pins) {
  //    pinMode(pin, INPUT);
  //  }
  // Kopfzeile ausgeben
  sensoren_test_kopf();
}

void loop() {
  sensoren_test();
}

void sensoren_test() {
  bool Ausgabe = false;
  for (byte i = 0; i < numberOfSensors; i++) {
    byte neuerZustand = digitalRead(Endstop_Pins[i]);
    if (Endstop_Status[i] != neuerZustand) {
      Ausgabe = true;
    }
    Endstop_Status[i] = neuerZustand;
  }
  if (Ausgabe) {
    for (byte i = 0; i < numberOfSensors; i++) {
      Serial.print(Endstop_Status[i]);
      Serial.write('\t');
    }
    Serial.println();
  }
}

void sensoren_test_kopf() {
  Serial.println(F("OK, Induktive Sensoren (Endstop) TEST wurde gestartet"));
  Serial.println(F("    Beenden mit Befehl END"));
  Serial.println();
  Serial.println(F("Spalten: Sensoren PIN Nr."));
  Serial.println(F("Neue Zeile: nur bei Statusänderung"));
  for (auto pin : Endstop_Pins) {
    Serial.print(pin);
    Serial.write('\t');
  }
  Serial.println();
}

oder macht man das auf ein andere weise eleganter?

Vielleicht...
Interessant, ist deine geschickte Wahl der Pins!

Das kann man ausnutzen!

const byte anzEndstopps = 7;
const byte maskeEndstopps = 0b01111111;
byte merkerEndstopps = maskeEndstopps; // mit erwartungswert vorbesetzen
 

void setup() 
{
 Serial.begin(9600);
 Serial.println("Start");

 // mache Endstopp Pins zu Eingängen
 DDRA &= ~maskeEndstopps; 

 //Pullup aktivieren (nur für mich zum testen)
 PORTA |= maskeEndstopps; 

}

void loop() 
{
  if(merkerEndstopps != (PINA & maskeEndstopps))
  {
    byte muster = PINA;
    for(byte i = 0; i < anzEndstopps; i++, muster >>= 1)
    {
      Serial.print("Endstopp");
      Serial.print(i);
      Serial.print(" Zustand: ");
      Serial.println(muster & 1);
    }
    Serial.println();
    merkerEndstopps = PINA & maskeEndstopps;
  }
}

Servus,

Oh man draußen ist gutes Wetter, das Ihr so fleißig schreibt hätte ich jetzt nicht gedacht.

ElEspanol:
Hi Mücke, welcome back.

Warst ja lange verschwunden. ...

Danke, wie man weiß, bin ich nicht so mit Programmiren etc. verbunden und mache das echt nur gelegentlich.
Was unweigerlich dazu führt das ich oft Dinge wieder vergesse in der langen zeit :frowning:

ElEspanol:
Für mich sieht die Routine auf den ersten Blick brauchbar und lesbar aus. Für die for Schleife gibt es eine neue, einfache Syntax, die weniger Fehler zulässt.

Magst du mir den Syntax noch verraten?

postmaster-ino:

  • warum INT bei Status? Als digitaler Sensor sehe ich Da eher ein BOOLEAN, ein Byte wäre auch noch ok.

du meinst so?

boolean Endstop_Status[]={ 0,  0,  0,  0,  0,  0,  0};  // Staus der PINS der Induktive Sensoren (Endstop)

postmaster-ino:

  • Status ist ebenfalls die Mehrzahl (keine Angst, musste ich auch Nachlesen :wink: )

Ich kann dir nicht ganz folgen :frowning:

Das Wieder :wink: habe ich ausgetauscht, Peinlich

postmaster-ino:
Von der Funktion sieht Das doch ganz gut aus - alleine die Wartezeit hätte ich mit dem Testen dieser Funktionen verbracht ...

In dem Fall sehe ich das nicht ganz so kritisch da diese Ausgabe tatsächlich nur dazu da ist wenn ich die Sensoren eingebaut habe mit einem Stück Metall um und in der Maschine herum zu stiefeln und zu schauen ob ein Signal kommt oder nicht.
Mit der Baudrate habe ich vor längeren mal herum experimentiert und festgestellt das 9600Baud bei mir nie Zeichen verschluckt :-), lasse mich aber gerne eines besseren belehren.

postmaster-ino:
"Hallo ich bin's"

Das ist Lustig machen meine Programme auch :slight_smile: die sagen sogar in der regle noch Ihren Namen :slight_smile:
wenn ich ganz gut drauf bin dann schreibe ich sogar noch etwas was das Programm kann in die Ausgabe :slight_smile:
Da ich hier jedoch wirklich nur eine einzelne Funktion für ein anderes Programm erstelle ist das hier nicht mit drin.

postmaster-ino:
Das Erkennen von Start- und Stop-Befehl klappt?

Jup das klappt.
ich habe einen Funktion die alles auswertet das über die Serielle Schnittstelle kommt und für den Befehl einen Status entsprechend ändert damit diser auch durchlaufen wird, sonst wird die Funktion einfach ignoriert und überspringen :slight_smile:

michael_x:
Als Ergänzung zu ElEspanol sehe ich drei statt zwei Funktionen:

  • Kopf ausgeben
  • Änderung erkennen
  • Zustand ausgeben

Hmm das stimmt, habe jedoch (Änderung und Zustand) mit Absicht zusammen gepackt, dann habe ich bei der Befehls Auswertung (Serielle Schnittstelle) nur ein teil den ich aufrufen muss :wink:
Sonnst gebe ich dir jedoch recht das könnte man auseinander ziehen.

Whandall:

const byte numberOfSensors = sizeof(Endstop_Pins) / sizeof(Endstop_Pins[0]);

Oh das ist ein Gute Idee, das ändert sich nach Start ja nicht mehr, dann muss man das nicht ständig neu berechnen.

Whandall:
Endstop als Eingang definieren ist unnötig da der default INPUT ist

Und schon wider was neues gelernt.

Whandall:

for (auto pin : Endstop_Pins) {

Hier komme ich nicht ganz mit, kannst du mir die ziele bitte erklären ?
die ist gleich zwei mal im Code enthalten :frowning:
Ok, einmal als Kommentar :slight_smile:

Den Rest des Codes verstehe ich, finde ich echt gut.

combie:
Vielleicht...
Interessant, ist deine geschickte Wahl der Pins!

Das kann man ausnutzen!

Das ist echt Zufall das die da sitzen :slight_smile:
Dein Code ist echt der Hammer, jedoch muss ich da erst mal alles mögliche nachschlagen wie wo was.

gruß Mücke

auto specifier (seit C++11)
Range-based for loop (seit C++11).

[quote author=Whandall link=msg=4226292 date=1561815903Range-based for loop (seit C++11).
[/quote]
for (auto pin : Endstop_Pins) {

Diese Syntax meinte ich.

Muecke:
Daher meine Frage an euch, mache ich das so richtig oder macht man das auf ein andere weise eleganter?

Hallo Crasy Mosquito,
heimlich bist Du möglicherweise OOP-Fan, weshalb ich Dir diese Variante nicht vorenthalten möchte. Einem Bienenstich gleich hat mich combie durch die for-Schleife ohne Schleifenzähler infiziert. Und weil ich faul bin, konnte ich Gefallen daran finden. Deine Aufgabenstellung finde ich prädestiniert dafür, wobei ich mich bemüht habe, eng an Deiner Vorlage zu bleiben.

struct Endstop {
  byte pin;		  // PIN Nr. für die Induktive Sensoren (Endstop)
  bool status;	// Status der PINS der Induktive Sensoren (Endstop)
  Endstop(byte pin): pin(pin), status(false) {}

  void init() {
    pinMode(pin, INPUT_PULLUP);		// ich benötige PULLUP
  }
  void kopf() {
    Serial.print(pin);           // PIN Nummer ausgeben
    Serial.print("\t");          // Tab ausgeben
  }
  void test(bool &a) {
    if (status != digitalRead(pin)) {
      a = true;
    }
    status = digitalRead(pin);		// Aktuellen Status merken
  }
  void ausgabe() {
    Serial.print(digitalRead(pin));     // Statusausgabe
    Serial.print("\t");                 // Tab ausgeben
  }
};
Endstop endstop[] = {22, 23, 24, 25, 26, 27, 28}; // PIN Nr. für die Induktiven Sensoren (Endstop)

void setup() {
  Serial.begin(9600);                   // Initialisieren der Seriellen Schnittstelle
  for (Endstop &e : endstop) e.init();  // Endstop als Eingang definieren
  sensoren_test_kopf();                 // Kopfzeile für Induktive Sensoren (Endstop) TEST aufrufen
}

void loop() {
  sensoren_test();
}

void sensoren_test() {
  bool Ausgabe = false;  // true = Sensor Status hat gewechselt or false = Sensor Status hat nicht gewechselt

  for (Endstop &e : endstop) e.test(Ausgabe);		// Bei Statuswechel merken, dass Ausgabe erfolgen soll

  // Ausgabe aller PIN Zustände in einer neuen Zeile, nur wenn eine Änderung vorlag
  if (Ausgabe) {
    for (Endstop &e : endstop) e.ausgabe();
    Serial.println(F(""));                          // Zeilenumbruch ausgeben
  }
}

void sensoren_test_kopf() {
  Serial.println(F("OK, Induktive Sensoren (Endstop) TEST wurde gestartet"));
  Serial.println(F("    Beenden mit Befehl END"));
  Serial.println(F(""));
  Serial.println(F("Spalten: Sensoren PIN Nr."));
  Serial.println(F("Neue Zeile: nur bei Statusänderung"));
  for (Endstop &e : endstop) e.kopf();
  Serial.println(F(""));                     // Zeilenumbruch ausgeben
}

Suche Dir aus, was Dir zusagt :smiley:

Soweit möglich, grüße Hund und Frau von mir.

Oh man da bringst du mich auf was, ... ich glaube wir hatten das schon mal oder ich hatte mir das irgend wo schon mal angeschaut.

Bin gerade dabei eine Art Portal CNC Fräse zu bauen.
Und möchte mir jetzt die Software dazu machen (nein kein G-Code ist auch nicht gewünscht).

wenn ich mir jetzt das struct anschaue könnte ich hier immer alle relevanten Dinge für eine Achse zusammen fassen.

z.B. Achse Z diese hat insgesamt 4 Endspots, 3 Pins für den Motor, dann kommt noch der Encoder dazu, hier könnte ich die Default werte für die RPM, Rampe und den Faktor (wenn Getriebe vorhanden) auch noch hinterlegen. ... Oh man ... was mach ich jetzt nur.

Ich habe es soweit verstanden das ich dienen Code Lesen kann und verstehe was gemacht wir jedoch noch nicht so weit das ich selbst das richtig einsetzen kann :-(.

Lust dazu hätte ich schon. irgend wie, ...

ich glaube ich versuche jetzt erst mal mit dem was ich angefangen habe fertig zu werden, dann sehen wir weiter :slight_smile:

Gruß zurück

Muecke:
Lust dazu hätte ich schon. irgend wie, ...

Was bremst Dich, lernfähig bist Du doch :slight_smile:

Muecke:
z.B. Achse Z diese hat insgesamt 4 Endspots, 3 Pins für den Motor, dann kommt noch der Encoder dazu, hier könnte ich die Default werte für die RPM, Rampe und den Faktor (wenn Getriebe vorhanden) auch noch hinterlegen. ... Oh man ... was mach ich jetzt nur.

Achse achse[] =
{
{ES1,ES2,ES3,ES4,EN,DIR,STEP,EN1,EN2,RPM,Rampe,Faktor}, // X-Achse
{ES1,ES2,ES3,ES4,EN,DIR,STEP,EN1,EN2,RPM,Rampe,Faktor}, // Y-Achse
{ES1,ES2,ES3,ES4,EN,DIR,STEP,EN1,EN2,RPM,Rampe,Faktor} // Z-Achse
}

Tatsächlich stehen da natürlich die entsprechenden Werte für die Pin-Nummern und so drin.

Die Konstanten und Variablen benötigen dann noch einen Namen:

struct Achse {
const byte ES1,ES2,ES3,ES4,EN,DIR,STEP,EN1,EN2;
const uint16_t RPM,Rampe,Faktor;
};

Sieht doch schön übersichtlich aus. In einer Methode schreibst Du digitalWrite(STEP, HIGH); oder in einer Funktion digitalWrite(achse[0].STEP, HIGH); für STEP der X-Achse. Oder mit XACHSE=0 auch digitalWrite(achse[XACHSE].STEP, HIGH);

Übersichtlich, oder?

agmue:
Was bremst Dich, lernfähig bist Du doch :slight_smile:

Das hast du jetzt gesagt, ich würde sagen lernwillig ob auch fähig bei dem was ich da manchmal zusammen schustere bezweifle ich das :wink:

Was mich Bremst, die fehlende zeit :frowning: ich würde gerne so viel machen :-).

ich werde es jetzt wagen und versuche im ersten Step nur meinen Motor anzusprechen.
Danach kommt dann der Rest dazu :slight_smile:

Deine Liste verwirklichter Projekte ist deutlich länger als meine, also nur Mut!

agmue:
Deine Liste verwirklichter Projekte ist deutlich länger als meine, also nur Mut!

:o
dabei sind die echt tollen Dinge noch gar nicht dabei :frowning:
die sollen erst noch alle kommen:-)

Der Anfang ist gemacht :slight_smile:
habe mein Test Programm entsprechend umgeschrieben. um etwas zu üben:-)

Test Code: Alt

  #include <AccelStepper.h>                            // Installiren der AccelStepper LIB 

// Motor Pins 
    int Achse_Z_PUL = 2;                               // PIN für Tackt
    int Achse_Z_DIR = 3;                               // PIN für Drehrichtung     HIGH = Im Uhrzeigersinn LOW = Gegen den Uhrzeigersinn
    int Achse_Z_ENA = 4;                               // PIN für Treiber ON/OFF   HIGH = Motor OFF        LOW = Motor ON 
// Motorpins Typ zuweisen
    AccelStepper Achse_Z(1, Achse_Z_PUL, Achse_Z_DIR); // (1, PUL, DIR)     Motoren Installiren

    long Schritte = 15200;                             // Schrittanzahl definieren

void setup() {
    Serial.begin(9600);                                // Serielle Schnittstelle Implementierung  
    pinMode(Achse_Z_ENA, OUTPUT);                      // setzt den Pin als Output (kommunikation zum Motor)
    Achse_Z.setAcceleration(5000);                     // Beschleunigung 
    Achse_Z.setMaxSpeed(5000);                         // RPM
   
    digitalWrite(Achse_Z_ENA, LOW);                    // Motor Aktiviren 
    Serial.print(F("OK, Motor Start"));                // Ausgabe das Motor Startklar ist
    Achse_Z.moveTo(Schritte);                          // LIB sagen wie viele Schritte gemacht werden sollen 
  }

void loop() {
  Achse_Z.run();                                       // Macht einen schritt wenn diser fällig ist
  
  if (Achse_Z.currentPosition() >= Schritte) {         // Wenn Maximale Schritte erricht sind zur 0       
    Achse_Z.moveTo(0);
    Serial.println(F("Go to: 0"));
  }
  if (Achse_Z.currentPosition() <= 0) {                // wenn 0 dann zu maximalen schritanzahl
    Achse_Z.moveTo(Schritte);
    Serial.print(F("Go to: "));
    Serial.println(Schritte);
  }
}

Test Code: Neu

  #include <AccelStepper.h>                            // Installiren der AccelStepper LIB 
// Declaration
    struct Achse {
      const byte PUL, DIR, EAN;                          // Digitale Pins am Arduino 
      const long Speed, Rampe;                           // Speed & Rampe = Schritte pro Sekunden // Faktor wenn ein getribe verwendet wird
    };
// Werte 
    Achse achse[] =
    {
     {2, 3, 4, 5000, 5000}                           // X-Achse  PUL, DIR, EAN, Speed, Rampe, Faktor
    };
// Motorpins Typ zuweisen
    AccelStepper Achse_Z(1, achse[0].PUL, achse[0].DIR); // (1, PUL, DIR)     Motoren Installiren

    long Schritte = 1000;                                // Schrittanzahl definieren

void setup() {
    Serial.begin(9600);                                  // Serielle Schnittstelle Implementierung  
    pinMode(achse[0].EAN, OUTPUT);                       // setzt den Pin als Output (kommunikation zum Motor)
    Achse_Z.setAcceleration(achse[0].Rampe);             // Beschleunigung 
    Achse_Z.setMaxSpeed(achse[0].Speed);                 // Speed
   
    digitalWrite(achse[0].EAN, LOW);                     // Motor Aktiviren 
    Serial.print(F("OK, Motor Start"));                  // Ausgabe Motor Start
    Achse_Z.moveTo(Schritte);                            // LIB sagen wie viele Schritte gemacht werden sollen 
}

void loop() {
  Achse_Z.run();                                       // Macht einen schritt wenn diser fällig ist
  
  if (Achse_Z.currentPosition() >= Schritte) {         // Wenn Maximale Schritte erricht sind zur 0       
    Achse_Z.moveTo(0);
    Serial.println(F("Go to: 0"));
  }
  if (Achse_Z.currentPosition() <= 0) {                // wenn 0 dann zu maximalen schritanzahl
    Achse_Z.moveTo(Schritte);
    Serial.print(F("Go to: "));
    Serial.println(Schritte);
  }
}

Könnte ich Dich dafür begeistern (kompiliert, sonst ungetestet)?

#include <AccelStepper.h>                            // Installiren der AccelStepper LIB

long Schritte = 1000;                                // Schrittanzahl definieren

struct Achse {
  const byte PUL, DIR, EAN;                          // Digitale Pins am Arduino
  const long Speed, Rampe;                           // Speed & Rampe = Schritte pro Sekunden // Faktor wenn ein getriebe verwendet wird
  AccelStepper achse;
  Achse(const byte PUL, const byte DIR, const byte EAN, const long Speed, const long Rampe)
    : PUL(PUL), DIR(DIR), EAN(EAN), Speed(Speed), Rampe(Rampe), achse(1, PUL, DIR) {}

  void init() {
    pinMode(EAN, OUTPUT);                       // setzt den Pin als Output (kommunikation zum Motor)
    achse.setAcceleration(Rampe);             // Beschleunigung
    achse.setMaxSpeed(Speed);                 // Speed

    digitalWrite(EAN, LOW);                     // Motor Aktiviren
    Serial.print(F("OK, Motor Start"));                  // Ausgabe Motor Start
    achse.moveTo(Schritte);                            // LIB sagen wie viele Schritte gemacht werden sollen
  }

  void bewegen() {
    achse.run();                                       // Macht einen schritt wenn diser fällig ist

    if (achse.currentPosition() >= Schritte) {         // Wenn Maximale Schritte erricht sind zur 0
      achse.moveTo(0);
      Serial.println(F("Go to: 0"));
    }
    if (achse.currentPosition() <= 0) {                // wenn 0 dann zu maximalen schritanzahl
      achse.moveTo(Schritte);
      Serial.print(F("Go to: "));
      Serial.println(Schritte);
    }
  }
};

Achse achsen[] =
{ //PUL, DIR, EAN, Speed, Rampe
  {2, 3, 4, 5000, 5000}                           // Z-Achse  PUL, DIR, EAN, Speed, Rampe, Faktor
};

void setup() {
  Serial.begin(9600);                                  // Serielle Schnittstelle Implementierung
  for (Achse &a : achsen) a.init();
}

void loop() {
  for (Achse &a : achsen) a.bewegen();
}

Ok das dauert jetzt etwas bis ich das alles verstanden habe.
Ich muss das Stück für Stück durcharbeiten um zu schauen was ich verstehe und was nicht.
Ich habe den Eindruck das das ganz anderes Programmiren ist wie ich es gewohnt bin.

Sicht jedoch sehr interessant aus.

OK, Frage 1:

CODE:

 const byte PUL, DIR, EAN;                          // Digitale Pins am Arduino
  const long Speed, Rampe;                           // Speed & Rampe = Schritte pro Sekunden
  AccelStepper achse;
  Achse(const byte PUL, const byte DIR, const byte EAN, const long Speed, const long Rampe)
    : PUL(PUL), DIR(DIR), EAN(EAN), Speed(Speed), Rampe(Rampe), achse(1, PUL, DIR) {}

ist das nicht Doppelt definiert?

kann der teil:

const byte PUL, DIR, EAN; // Digitale Pins am Arduino
const long Speed, Rampe; // Speed & Rampe = Schritte pro Sekunden

nicht weg gelassen werden?

EDIT: Wenn ich es weg lasse bekomme ich einen Fehler, ich verstehe jedoch die gesamten zielen so gar nicht mehr :frowning:

Hi

Alles, was sich um diesen Stepper dreht, ist in dieser Struktur zusammen gefasst.
Unter Anderem auch der Platz, wo Du die Pins speicherst, oder die Beschleunigung.

Da steht vorerst noch nicht viel drin, Das kommt erst, wenn Du eine Instanz der 'Achse' erstellst - und Die braucht dann zwingend neben den Pins auch die Beschleunigung ect.pp., Die für diese Achse gelten sollen.

Als Schmankerl ist die Initialisierung (Funktion/Methode(?)) bzw. das Bewegen in dieser Struktur enthalten - Du kannst so also mehrere Achsen in der FOR-Schleife verarbeiten - alle Achsen machen, was Sie JETZT GERADE machen müssen - dafür ist eine möglichst kurze loop()-Durchlaufzeit nötig - also keine delay() oder stundenlang auf eine Tasteneingabe warten ...

MfG

den Sinn und Zweck der Struktur habe ich verstanden.

versuche mich nur von oben nach unten durch zuarbeiten.
denn ich möchte das auch alleine hin bekommen :slight_smile:

Ich versteh nur schon die ersten zielen nicht.

struct Achse {
  const byte PUL, DIR, EAN;                          // Digitale Pins am Arduino
  const long Speed, Rampe;                           // Speed & Rampe = Schritte pro Sekunden // Faktor wenn ein getriebe verwendet wird
  AccelStepper achse;
  Achse(const byte PUL, const byte DIR, const byte EAN, const long Speed, const long Rampe)
    : PUL(PUL), DIR(DIR), EAN(EAN), Speed(Speed), Rampe(Rampe), achse(1, PUL, DIR) {}

Offensichtlich wird hier die Variablen "PUL, DIR, EAN" als const byte deklariert.
dann werden diese weiter unten bei "Achse(const byte PUL, const byte DIR, const byte EAN," gleich noch mal als const byte beschrieben ?
Danach kommt der : und es folgen merkwürdige Dinge ? die ich so nicht zusammen bekomme und verstehe.

Es reizt mich sehr das zu verstehe, denn das würde meine Programm das ich vorhabe ganz über den Haufen werden und ein Neuen Aufbau bedeuten den ich sehr interessant finde, daher zuerst verstehen dann an das eigentliche Programm machen.