Ein Video habe ich auch beriet gestellt: << Hier >>
Nach meiner Logik sollte der Arbeitsbereich immer gleich groß sein.
Das ist er jedoch nicht.
Was habe ich für einen Fehler eingebaut bzw. was für einen Zustand frage ich nicht ab?
So langsam glaube ich wirklich das ich das ganze teil sehr Tief in der erde vergraben sollte.
Gruß Mücke
//Arrays werden für das endprogramm definirt
#include <AccelStepper.h> // Installiren der AccelStepper LIB
AccelStepper Achse_A(1, 4, 3); // Motor Installiren
const byte Sensoren[] = {44}; // Sensor Pin`s
const int Speed[] = {600}; // Default (Schritte pro Sekunde)
const int Rampe[] = {600}; // Default (Schritte pro Sekunde)
bool Nullpunkt_A = false; // Nullpunkt Status Achse A
int Arbeitsbereich_A = 0; // Arbeitsbereich Achse A
void setup() {
Serial.begin(250000); // Serielle Schnittstelle Implementierung
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
Serial.println(F("Arduino bereit!")); // Ausgabe das Motor Startklar ist
}
void loop() {
if (!Nullpunkt_A and Arbeitsbereich_A <= 0) {
Nullpunkt();
}
// Debugger
delay(1000); // Pause
Nullpunkt_A = false; // Nullpunkt Löschen
Arbeitsbereich_A = 0; // Arbeitsbereich Löschen
// Debugger
}
void Nullpunkt() {
// Nullpunkt Achse A
// 1. zum Null Sensor Fahne
Serial.print(F("| 1 "));
Achse_A.move(-30000); // Achsen ist etwas kleiner wie 30.000 Schritte
// 2. Motor Stoppen und Rampe auslaufen lassen wenn Sensor 0 Auslöst
Serial.print(F("| 2 "));
while (!digitalRead(Sensoren[0])){ // Solange Sensor nicht ausgelöst hat
Achse_A.run(); // soll die Achse weiter laufen
} // im vollem Speed
Achse_A.stop(); // Sensor ausgelöst Stopen mit Rampe
while (Achse_A.distanceToGo() != 0) { // Prüft auf Offene Schritte (Rampe)
Achse_A.run(); //
} //
// 3. Anfang des Sensors suchen, im Schneckentempo
Serial.print(F("| 3 "));
Achse_A.setMaxSpeed(100); // Speey auf Schnekentempo drosseln
Achse_A.setAcceleration(100); // Rmpe an Schnekentempo anpassen
Achse_A.move(30000); // Schritte vorgeben
while (!digitalRead(Sensoren[0])){ // Prüfen ob wie noch am Sensor sind
Achse_A.run(); // wenn nicht zum Ende es Sensors fahren
} //
while (digitalRead(Sensoren[0])){ // Prüfen wann wir am anfang
Achse_A.run(); // des Sensors uns befinden
} //
// 4. Aktuelle Position als 0 Setzen
Serial.print(F("| 4 "));
Achse_A.setCurrentPosition(0); // Sofortiges Stopen und Aktuelle Position auf 0 setzen
Nullpunkt_A = true; // Nullpunkt Marker setzen
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
// Debugger
Serial.print(F("| Debugger "));
delay(1000); // 1 Sekunde warten, damit man die Position erkennt
// 5. zum END-Sensor Fahne
Serial.print(F("| 5 "));
Achse_A.move(30000); // Achsen ist etwas kleiner wie 30.000 Schritte
// 6. Motor Stoppen und Rampe auslaufen lassen wenn END-Sensor auslöst
Serial.print(F("| 6 "));
while (!digitalRead(Sensoren[0])){ // Solange Sensor nicht ausgelöst hat
Achse_A.run(); // soll die Achse weiter laufen
} // im vollem Speed
Achse_A.stop(); // Sensor ausgelöst Stopen mit Rampe
while (Achse_A.distanceToGo() != 0) { // Prüft auf Offene Schritte (Rampe)
Achse_A.run(); //
} //
// 7. Anfang des Sensors suchen, im Schneckentempo
Serial.print(F("| 7 "));
Achse_A.setMaxSpeed(100); // Speey auf Schnekentempo drosseln
Achse_A.setAcceleration(100); // Rmpe an Schnekentempo anpassen
Achse_A.move(-30000); // Schritte vorgeben
while (digitalRead(Sensoren[0])){ // Prüfen ob wie noch am Sensor sind
Achse_A.run(); // wenn nicht zum Ende es Sensors fahren
} //
while (!digitalRead(Sensoren[0])){ // Prüfen wann wir am anfang
Achse_A.run(); // des Sensors uns befinden
} //
// 8. Aktuelle Position als Arbeitsbereich Setzen
Serial.print(F("| 8 "));
Achse_A.setCurrentPosition(Achse_A.currentPosition()); // Sofortiges Stopen und Aktuelle Position setzen
Arbeitsbereich_A = Achse_A.currentPosition(); // Arbeitsbereich Marker setzen
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
// Debugger 2
Serial.print(F("| Debugger 2 "));
delay(1000); // 1 Sekunde warten, damit man die Position erkennt
Serial.print(F("| Arbeitsbereich: "));
Serial.println(Arbeitsbereich_A);
}
Zumindest bei der -400 fährt der Stepper 'falsch herum' - denke, durch Vibrationen o.Ä. wurde der Beru de- und erneut aktiviert, was normal erst während der Schnecken-Runde passieren sollte.
an Vibration habe ich auch schon gedacht. Jedoch ist mir das in der Maschine auch schon passiert da hat er dann einfach mal einen Sensor ganz ignoriert und ist auf meinen Notaus Schalter gefahren ( hier wird der Motor Mechanisch vom Strom genommen).
Daher habe ich das wider auf den Tisch verlagert um zu testen.
ich bekomme auch zum teil die Länge -1 oder 0
ab und an bleibt er auch am Sensor hegen, und macht einen schritt vor uns zurück und das dann 4 bis 6 mal dann ist meine Achse nur 0 Schritte lang und das 4 bis 6 mal hintereinander.
Ich habe den Eindruck das manchmal der Controller zu langsam ist oder zu schnell. und sich dann verhaspelt, kann das sein?
Wie würde ich so etwas auf die schliche kommen?
oder mache ich einen Denkfehler in meiner Abfolge? und vergesse etwas abzufragen?
ps. das ist das Aktuelle Protokoll das ich gerade mal erstellt habe, habe den Zeitstempel mit rein genommen dann sieht man wie schnell er alles abarbeitet ;-).
irgendwie scheint mir die Benennung Verwirrung stiften zu wollen. Deine Werte 398, 0, 414, -400 stellen laut meiner Meinung keinen Arbeitsbereich dar. Die stellen laut meiner Meinung den neuen "Nullpunkt" dar der am Sensor gefunden wird. Ich vermute der Motor verliert Schritte. Testweise Rampe flacher machen und max. reduzieren.
Schrittverlust sollte ignoriert werden, da wir ohne Positionsangabe arbeiten, es wird auf Sensoren reagiert.
Habe das ganze aufsplittetet
Ablauf von Nullpunkt()
Zum Null-Sensor Fahne
Motor Stoppen bei NULL-Sensor
Rampe abarbeiten
Schnekentempo
Zum Null-Sensor Fahne
Null-Sensor Anfang finden
Nullpunkt setzen
Standardwerte wider herstellen
Debugger 1
Zum END-Sensor Fahne
Motor Stoppen bei END-Sensor
Rampe abarbeiten
Schnekentempo
Zum END-Sensor Fahne
Null-Sensor Anfang finden
Nullpunkt setzen
Standardwerte wider herstellen
Debugger 2
void Nullpunkt() {
/* 1. Zum Null-Sensor Fahne */ Serial.print(F("| 1 "));
Achse_A.move(-30000); // Achsen ist etwas kleiner wie 30.000 Schritte
/* 2. Motor Stoppen bei NULL-Sensor */ Serial.print(F("| 2 "));
while (!digitalRead(Sensoren[0])){ // Solange Sensor nicht ausgelöst hat
Achse_A.run(); // soll die Achse weiter laufen
} // im vollem Speed
Achse_A.stop(); // Sensor ausgelöst Stopen mit Rampe
/* 3. Rampe abarbeiten */ Serial.print(F("| 3 "));
while (Achse_A.distanceToGo() != 0) { // Prüft auf offene schritte
Achse_A.run(); // schritt muss gemacht werden
}
/* 4. Schnekentempo */ Serial.print(F("| 4 "));
Achse_A.setMaxSpeed(100); // Speed drosseln
Achse_A.setAcceleration(100); // Rmpe drosseln
/* 5. Zum Null-Sensor Fahne */ Serial.print(F("| 5 "));
Achse_A.move(30000); // Schritte vorgeben
/* 6. Null-Sensor Anfang finden */ Serial.print(F("| 6 "));
while (!digitalRead(Sensoren[0])){ // Prüfen ob wier noch am Sensor sind
Achse_A.run(); // wenn nicht zum Ende es Sensors fahren
}
while (digitalRead(Sensoren[0])){ // Prüfen ob wir wir am anfang
Achse_A.run(); // des Sensors uns befinden
}
/* 7. Nullpunkt setzen */ Serial.print(F("| 7 "));
Achse_A.setCurrentPosition(0); // Sofortiges Stopen und Aktuelle Position auf 0 setzen
Nullpunkt_A = true; // Nullpunkt Marker setzen
/* 8. Standardwerte wider herstellen */ Serial.print(F("| 8 "));
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
/* Debugger */ Serial.print(F("| D-1 "));
// Ab jetzt wird der Arbeitsbereich ermittelt
/* 9. Zum END-Sensor Fahne */ Serial.print(F("| 9 "));
Achse_A.move(30000); // Achsen ist etwas kleiner wie 30.000 Schritte
/* 10. Motor Stoppen bei END-Sensor */ Serial.print(F("| 10 "));
while (!digitalRead(Sensoren[0])){ // Solange Sensor nicht ausgelöst hat
Achse_A.run(); // soll die Achse weiter laufen
} // im vollem Speed
Achse_A.stop(); // Sensor ausgelöst Stopen mit Rampe
/* 11. Rampe abarbeiten */ Serial.print(F("| 11 "));
while (Achse_A.distanceToGo() != 0) { // Prüft auf offene schritte
Achse_A.run(); // schritt muss gemacht werden
}
/* 12. Schnekentempo */ Serial.print(F("| 12 "));
Achse_A.setMaxSpeed(100); // Speed drosseln
Achse_A.setAcceleration(100); // Rmpe drosseln
/* 13. Zum END-Sensor Fahne */ Serial.print(F("| 13 "));
Achse_A.move(-30000); // Schritte vorgeben
/* 14. Null-Sensor Anfang finden */ Serial.print(F("| 14 "));
while (digitalRead(Sensoren[0])){ // Prüfen ob wier noch am Sensor sind
Achse_A.run(); // wenn nicht zum Ende es Sensors fahren
}
while (!digitalRead(Sensoren[0])){ // Prüfen ob wir wir am anfang
Achse_A.run(); // des Sensors uns befinden
}
/* 15. Nullpunkt setzen */ Serial.print(F("| 15 "));
Arbeitsbereich_A = Achse_A.currentPosition(); // Aktuelle Position ist Arbeitsbereich
/* 16. Standardwerte wider herstellen */ Serial.print(F("| 16 "));
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
/* Debugger 2 */ Serial.print(F("| D-2 "));
Serial.print(F("| Arbeitsbereich: "));
Serial.println(Arbeitsbereich_A);
}
Das ist das Ergebnis, wie zu erwarten keine Besserung
ich habe gedacht das es vielleicht am Sensor liegen kann das der durch die Vibration auslöst ohne das was vorliegt, ist ja billig wahre
Dem ist leider nicht so
jetzt habe ich das ganze mal ohne Rampen programmiert, sprich das teil bleibt brachial von jetzt auf nachher stehen, ja das ist nicht gut
Es ist nur noch einen kleine Rampe mit drin am ende, die habe ich so gut es geht Element da ich einen Beschleunigung von 5.000 schritten mache, somit ist nahezu keine Rampe mehr vorhanden.
Der Code hat sich demnach etwas verändert.
#include <AccelStepper.h> // Installiren der AccelStepper LIB
AccelStepper Achse_A(1, 4, 3); // Motor Installiren
const byte Sensoren[] = {44}; // Sensor Pin`s
const int Speed[] = {600}; // Default (Schritte pro Sekunde)
const int Rampe[] = {5000}; // Default (Schritte pro Sekunde)
bool Nullpunkt_A = false; // Nullpunkt Status Achse A
int Arbeitsbereich_A = 0; // Arbeitsbereich Achse A
int Diff;
void setup() {
Serial.begin(250000); // Serielle Schnittstelle Implementierung
Achse_A.setMaxSpeed(Speed[0]); // Geschwindigkeit setzen
Achse_A.setAcceleration(Rampe[0]); // Rampe setzen
Serial.println(F("Arduino bereit!")); // Ausgabe das Motor Startklar ist
Serial.print(F("Speed: "));
Serial.print(Speed[0]);
Serial.print(F(" Rampe: "));
Serial.println(Rampe[0]);
}
void loop() {
if (!Nullpunkt_A or Arbeitsbereich_A <= 0) {
Nullpunkt();
}
// Debugger
Nullpunkt_A = false; // Nullpunkt Löschen
// Arbeitsbereich_A = 0; // Arbeitsbereich Löschen
// Debugger
}
void Nullpunkt() {
/* 1. Zum Null-Sensor Fahne */ Serial.print(F("| 1 "));
Achse_A.move(-30000); // Auftrag zur Position zu Fahren
while(digitalRead(Sensoren[0]) == 0) // Prüft ob Null-Sensor ausgelöst hat
{ Achse_A.run(); } // Richtung Null-Sensor fahren
/* 2. Nullpunkt setzen */ Serial.print(F("| 2 "));
Achse_A.setCurrentPosition(-10); // Aktuelle Position auf -10 stellen
Nullpunkt_A = true; // Nullpunkt Marker setzen
/* 3. Position Null anfahren */ Serial.print(F("| 3 "));
Achse_A.moveTo(0); // Auftrag zur Position zu Fahren
while(Achse_A.currentPosition() != 0) // Positions überprüfung
{Achse_A.run(); } // Weiter zur position fahren
/* 4. Zum Ende-Sensor Fahne */ Serial.print(F("| 4 "));
Achse_A.move(30000); // Auftrag zur Position zu Fahren
while(digitalRead(Sensoren[0]) == 0) // Prüft ob Ende-Sensor ausgelöst hat
{Achse_A.run(); } // Richtung Ende-Sensor fahren
/* 5. Arbeoitsbereich setzen */ Serial.print(F("| 5 "));
Diff = Achse_A.currentPosition() - Arbeitsbereich_A; // Debugg information
Arbeitsbereich_A = Achse_A.currentPosition(); // Aktuelle position ist Arbeitsbereich
/* 6. Position Null anfahren */ Serial.print(F("| 6 "));
Achse_A.moveTo(0); // Auftrag zur Position zu Fahren
while(Achse_A.currentPosition() != 0) // Positions überprüfung
{Achse_A.run(); } // Weiter zur position fahren
/* 7. Arbeitsbereich ausgeben */ Serial.print(F("| 7 "));
Serial.print(F("| Arbeitsbereich: "));
Serial.print(Arbeitsbereich_A);
Serial.print(F(" | Diff.: "));
Serial.println(Diff);
}
Das erstaunliche ist jetzt das ich bei 1 bis 5 durchlaufen eine Abweichung erhalte und dann der Arbeitsbereich immer exakt gleich groß ist.
Hat jemand eine Idee warum zu beginn noch eine Abweichung vorhanden ist?
Hallo Mücke,
ohne dein letztes Problem exakt angeschaut zu haben.
Ein grundsätzliches Problem bei deinem Code scheint mir zu sein, dass Du nicht kontrollierst, ob der Stepper nach dem Anhalten noch innerhalb des Sensorbereiches steht, oder schon darüber hinausgelaufen ist. Beim Zurückdrehen, um die Kante genau zu bestimmen ist das aber wichtig, da Du jeweils anders weitermachen musst.
Habe mir auch nochmal Gedanken gemacht. Der Einwand von Microbahner ist sehr gut. Das könnte/wird das falsch drehen im Video erklären.
Ansonsten behaupte ich immer noch das die Werte welche du Arbeitsbereich nennst eine Position ist, denn du ermittelst die mit
currentPosition(). Desweiteren suchst du den Sensor mit Speed und Rampe 100. Das wird noch zu hoch sein und die schwankenden Debugwerte ist die Toleranz der Schalthysterese vom Sensor. Das der Wert Steps/360° entspricht ist Zufall.
Bsp. wie man es machen könnte.
Wenn du im Uhrzeigersinn am Sensor vorbeisaust dann gibt es 2 Flanken. Mit der 2. Flanke weißt du, du bist am Sensor vorbei und musst wieder zurück. Das wäre deine 3. Flanke die man Nullpunkt nennen könnte.
Fährt man im Uhrzeigersinn vorbei, registrierst eine Flanke aber die 2. kommt innerhalb eines festgelegten Weges nicht, dann weiß man man ist außerhalb des Sensors und muss rückwärts suchen oder man ein anderes Problem.
Kommt man Gegenuhrzeigersinn am Sensor vorbei hat man wieder eine erste Flanke und dann muss die 2. Flanke kommen. Dann weiß man man hat genau den Sensorbereich soeben erfasst und wieder verlassen. Jetzt muss man im Uhrzeigersinn fahren, 1. Flanke, 2. Flanke, vorbei, zurück, 3. Flanke wie oben, Nullpunkt erfasst.
und das 4 bis 6 mal hintereinander.