Beschleunigungsrampe nach Stop geht irgendwie nicht

Ein Hallo ins Forum und danke für Euer Wirken!
Konnte schon einige Probleme mithilfe des Forums lösen, aber jetzt komme ich nicht mehr weiter…

Ich habe folgendes Problem:

Scrittmotor soll drehen, mit Beschleunigungsrampe. “Drehzahl” kann mit Poti variiert werden.
Schalter (runPin) auf GND gibt drehen frei, quasi ein/aus
Mikroschalter (leakagePin) auf GND unterbricht Drehbewegung sofort (öffner) und deaktiviert den ENABLE Eingang des Treibers, damit der Motor frei dreht. Wenn der Mikroschalter wieder aktiv ist ist, soll der Motor wieder mit der Rampe hochdrehen.

Rampe bei Programmstart und nach RESET Taster funktioniert, der Motor dreht wunschgemäss hoch, alles OK.
Jedoch wenn einer der Schalter den Stop ausgelöst hat, funktioniert die Rampe nur zufällig, manchmal geht es, manchmal nicht. Der Motor wird gleich angesteuert und verliert je nach Drehzahl Schritte bzw. “singt” nur und dreht nicht. Die Drehzahleinstellung ist davon nicht betroffen, diese funktioniert immer.

Ich habe mit der Debounce Library versucht zu entprellen, das scheint aber nicht der Grund zu sein, egal welchen Wert ich bei debouncer.interval verwende…

Oder mache ich da einen grundsätzlichen Denkfehler?

Und ja, der Code ist bestimmt nicht perfekt und kann und wird noch aufgeräumt, die Schnipsel habe ich einfach mal zusammengefügt. Ich hoffe, man verzeiht mir…

Danke Euch!

BitSchieber

#include <Bounce2.h>

#define leakPin 8
#define runPin  9

const int stepPin = 5;
const int dirPin = 6;
const int enPin  = 7;
//const int leakPin = 8;
//const int runPin = 9;

int customDelay, customDelayMapped; // Defines variables
int newcustomDelay;
int switchState;                // On/Off switch state
int leakageState;               // Leakage detection state

int numAccelSteps = 700; 
int stepsToGo;


unsigned long prevStepMicros = 0;
unsigned long slowMicrosBetweenSteps = 1500; // microseconds
unsigned long fastMicrosBetweenSteps = 150;
unsigned long stepIntervalMicros;
unsigned long stepAdjustmentMicros;
unsigned long numSteps = 9000000;

byte direction = 1;

Bounce debouncer1 = Bounce();
Bounce debouncer2 = Bounce();


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

void setup() {

  Serial.begin(115200);
  Serial.println("Starting Stepper Demo with acceleration");

  pinMode(dirPin, OUTPUT);
  pinMode(stepPin, OUTPUT);
  pinMode(enPin, OUTPUT);
  pinMode(leakPin, INPUT_PULLUP);
  pinMode(runPin, INPUT_PULLUP);

  debouncer1.attach(leakPin);
  debouncer1.interval(50); // interval in ms
  debouncer2.attach(runPin);
  debouncer2.interval(50); // interval in ms



  stepAdjustmentMicros = (slowMicrosBetweenSteps - fastMicrosBetweenSteps) / numAccelSteps;
  stepIntervalMicros = slowMicrosBetweenSteps;
  digitalWrite(dirPin, direction);

}

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

void loop() {

  debouncer1.update();
  debouncer2.update();
  leakageState = debouncer1.read();
  switchState = debouncer2.read();
  onOff();
  Leakage();


}

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

void moveMotor() {

  if (stepsToGo > 0) {
    if (micros() - prevStepMicros >= stepIntervalMicros) {
      prevStepMicros += stepIntervalMicros;
      singleStep();
      stepsToGo --;
      if (stepsToGo <= numAccelSteps) {
        if (stepIntervalMicros < slowMicrosBetweenSteps) {
          stepIntervalMicros += stepAdjustmentMicros;
        }
      }
      else {
        if (stepIntervalMicros > fastMicrosBetweenSteps) {
          stepIntervalMicros -= stepAdjustmentMicros;
        }
      }
    }
  }
}


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

void singleStep() {
  customDelayMapped = speedUp(); // Gets custom delay values from the custom speedUp function
  // Makes pules with custom delay, depending on the Potentiometer, from which the speed of the motor depends
  digitalWrite(stepPin, HIGH);
  delayMicroseconds(customDelayMapped);
  digitalWrite(stepPin, LOW);
  delayMicroseconds(customDelayMapped);
}
// Function for reading the Potentiometer
int speedUp()
{
  int customDelay = analogRead(A0); // Reads the potentiometer
  int newCustom = map(customDelay, 0, 1023, 1500, 1); // Convrests the read values of the potentiometer from 0 to 1023 into desireded delay values (300 to 4000)
  return newCustom;
}

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

void onOff()
{
  if (switchState == LOW && leakageState == LOW) {
    digitalWrite(enPin, LOW);
    moveMotor();
    stepsToGo = numSteps;
  } else {
    stopMotor();
  }
}

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

void Leakage()
{


  if (leakageState == LOW && switchState == LOW ) {
    digitalWrite(enPin, LOW);
    moveMotor();
  } else {
    stopMotor();
  }
}

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

void stopMotor()
{
  digitalWrite(stepPin, LOW);
  digitalWrite(enPin, HIGH);

  slowMicrosBetweenSteps = 1500;
  fastMicrosBetweenSteps = 150;
  numAccelSteps = 700;
  stepAdjustmentMicros = (slowMicrosBetweenSteps - fastMicrosBetweenSteps) / numAccelSteps;
  stepIntervalMicros = slowMicrosBetweenSteps;
  //stepsToGo = numAccelSteps;

}

Hallo,

warum benutzt Du keine Lib die das kann.

Heinz

Hallo,

irgendwas wird mit den Funktionen moveMotor und stopMotor nicht stimmen in Bezug auf Variablen Berechnung und Rücksetzung. Jetzt heißt es debuggen. Lasse dir in den Funktionen alle Variablenwerte ausgeben.

Desweiteren solltest du konstant bleibende Variablen auch konstant machen und nicht irretierenderweise den gleichen Wert neu zuweisen.
Trifft zum Bsp. zu auf
slowMicrosBetweenSteps
fastMicrosBetweenSteps
numAccelSteps
numSteps

Und für alles was nur 0 oder 1, Low oder High, false oder true sein kann, solltest du den Datentyp bool verwenden. Dann ist beim lesen schon klar welchen Wertebereich das haben kann.

Was bedeutet Leakage?