AccelStepper mit variablem Sensor

Hallo zusammen.

Ich würde sagen ich bin ein Anfänger was Codes angeht.
Leider stehe ich seit einiger Zeit auf dem schlauch und komme nicht weiter. Auch durchs durchlesen diverser Anleitungen bin ich weitergekommen und hoffe auf diesem Wege, das mir jemand weiterhelfen kann. Vielleicht verfolge ich auch den falschen Lösungsansatz.

Erstmal zur aktuell verwendeten Hardware:

-Arduino Nano
-TB6560 Driver

alternativ hätte ich noch den FUYU driver
https://de.aliexpress.com/item/32589549569.htm

-FUYU Linearführung
CNC Linear Guide Bühne Schiene Bewegung Tisch Ball Schraube Antrieb Nema 23 Motor Modul für 3d Drucker Teile XYZ robotic Arm Kit|linear guide rail|guide raillinear guide - AliExpress 600mm

Ziel:
Durch einen Befehl vom Nextion display (hier jedoch gerade noch nicht relevant) soll der Schlitten mit einer Startrampe nach unten Fahren und mittels eines Gewichtssensor Stoppen, sobald dieser z.B. einen Wert von 1kg bekommt. Danach soll er noch eine Bremsrampe Fahren bis er zum stehen kommt.
Sobald die weiteren Abläufe Durgeführt sind, wird er wieder zum Ausgangspunkt hochgefahren.
Also Startrampe-Max Speed- und wenn das Signal vom Homebutton kommt wieder die Bremsrampe ausführen und dann stehen bleiben.

Zum Problem:
Die einzelnen Rampen zu fahren konnte ich ohne Library programmieren. Jedoch bringe ich nicht die gewünschte Geschwindigkeit des Schlitten hin. Dies hatte ich folgendermaßen gelöst:

#include <math.h>

int Mot1Step    = 4;    //Mot1 Step
int Mot1Dir     = 5;    //Mot1 DIR
int PulseDelay  = 2;   //Delay HIGH/LOW Mikrosekunden

//-----------------------------------------
//##### Anfang lineare Rampe ####
float BeschleunigungsFaktor = 3;
float Highspeed             = 300.0; //Mikrosekunden
float Rampenlaenge          = 400.0; //Rampenlaenge Steps
float Fahrtlaenge           = 3000.0; //Rampenlaenge Steps
float Bremslaenge          = 300.0; //Rampenlaenge Steps
float Beschleunigung        = Highspeed * BeschleunigungsFaktor;
float RampenCoeff           = float(Beschleunigung / Rampenlaenge); //Rampenkoeffizient
//##### Ende lineare Rampe ######
//-----------------------------------------

//###########################
void setup()
{
  pinMode(Mot1Dir,     OUTPUT); //Pin 5
  pinMode(Mot1Step,    OUTPUT); //Pin 4
}
//###########################

//###########################

void loop() 
{
  digitalWrite(Mot1Dir, LOW);  //Vorgabe Drehrichtung des Motors
  Startrampe();
  Fahrt();           // Fahrt hin
  Bremsen(); 
  delay(2000);
  digitalWrite(Mot1Dir, HIGH);   //Vorgabe Drehrichtung des Motors
  Startrampe();
  Fahrt();               //Fahrt zurueck
  Bremsen();
  delay(2000);
}
//###########################

//###########################
void Startrampe()
{
  //Echtzeit....................
  int StepCount         = 1; //Schrittzaehler
  int Geschwindigkeit   = 0;
  int indexCoeffAnfahrt = 0;
  //Echtzeit....................

   indexCoeffAnfahrt = int(Rampenlaenge);
  

  while (StepCount <= int(Rampenlaenge))
  { 
     Geschwindigkeit = Highspeed + round(indexCoeffAnfahrt * RampenCoeff);
     indexCoeffAnfahrt--; //Pausenzeit von lang --> kurz
   
   //Uebergabe der Geschwindigkeit an den Motor (PIN 4)
   digitalWrite(Mot1Step, HIGH);    //PIN on
   delayMicroseconds(PulseDelay);   //hier 80 Microsekunden s.o.
   digitalWrite(Mot1Step, LOW);     //PIN off
   delayMicroseconds(Geschwindigkeit);

   StepCount++;

  }//Ende: while-Schleife
}  //Ende: void Fahrt()


void Fahrt()
{
  //Echtzeit....................
  int StepCount         = 1; //Schrittzaehler
  int Geschwindigkeit   = 0;
  //Echtzeit....................

  while (StepCount <= int(Fahrtlaenge))
  {
   Geschwindigkeit = Highspeed;
   
   //Uebergabe der Geschwindigkeit an den Motor (PIN 4)
   digitalWrite(Mot1Step, HIGH);    //PIN on
   delayMicroseconds(PulseDelay);   //hier 80 Microsekunden s.o.
   digitalWrite(Mot1Step, LOW);     //PIN off
   delayMicroseconds(Geschwindigkeit);

   StepCount++;

  }//Ende: while-Schleife
}  //Ende: void Fahrt(int Steps)

void Bremsen()
{
  //Echtzeit....................
  int StepCount         = 1; //Schrittzaehler
  int Geschwindigkeit   = 0;
  int indexCoeffBremse  = 0;
  //Echtzeit....................

indexCoeffBremse  = 1;

  while (StepCount <= int(Bremslaenge))
  {
   Geschwindigkeit = Highspeed + round(indexCoeffBremse * RampenCoeff);
     indexCoeffBremse++; //Pausenzeit von kurz --> lang
   
   //Uebergabe der Geschwindigkeit an den Motor (PIN 4)
   digitalWrite(Mot1Step, HIGH);    //PIN on
   delayMicroseconds(PulseDelay);   //hier 80 Microsekunden s.o.
   digitalWrite(Mot1Step, LOW);     //PIN off
   delayMicroseconds(Geschwindigkeit);

   StepCount++;

  }//Ende: while-Schleife
}  //Ende: void Fahrt(int Steps)

Da ich die Geschwindigkeit nicht hinbekommen habe mit den delays ( sollte man ja so oder so nicht verwenden)
Habe ich diverse Anleitung zur AccelStepper.h gefunden. Und es schien mir, als währe es genau das was ich suche… Mit einem Standardcode habe ich dann die gewünschte Geschwindigkeit hinbekommen mit den Rampen. Jedoch muss ich da eine Fixe Position Anfahren (auch verständlich für die Rampenberechnung). Doch da ich eine Variable Endposition habe ist die leider nicht möglich. Ich habe noch ein Video gefunden mit einem Notschalter, jedoch wenn ich dies richtig verstanden habe Stop dieser den ganzen Code und kann nur auf PIN1,2 verwendet werden. Da Kahm mir die Überlegung, dass ich runSpeed() verwende und die Startrampe Manuel hochfahre, wie beim Code mit dem Delay.

Hier bin ich schon einige Zeit dran, der Code ist einfach, jedoch scheitere ich schon an der Fahrgeschwindigkeit. Da ich dies danach für die Rampe benötige habe ich auch die Fahrt mit einem Counter begrenzt. Wenn ich einfach z.B. setSpeed (-600) und runSpeed() in den Loop packe, läuft der Schlitten schön rund… wenn ich dies jedoch in die While Schleife im Void packe, Läuft dieser nur ganz kurz an. Um zu schauen, ob der Counter funktioniert, habe ich das SerialPrintIN integriert um zu sehen ob er hochzählt… dies macht er, jedoch läuft die Spindel dann nicht mehr rund und Ruckelt. Also stimmt dann die Geschwindigkeit nicht mehr. Ich vermute mal ich habe hier 3 verschiedene “while Durchlauf Geschwindigkeiten”

  1. nur setSpeed und runSpeed (Schlitten läuft rund)
  2. setSpeed und runSpeed mit counter (läuft nicht rund)
  3. setSpeed und runSpeed mit counter und Serial Print (stockt kurz) evt wegen der Baud 9600?

Anbei der Code:

#include <AccelStepper.h>


// Define stepper motor connections and motor interface type. Motor interface type must be set to 1 when using a driver:
#define dirPin 5
#define stepPin 4

#define motorInterfaceType 1

// Create a new instance of the AccelStepper class:

AccelStepper stepper = AccelStepper(motorInterfaceType, stepPin, dirPin);

float Fahrtlaenge          = 100.0; //Rampenlaenge Steps

void setup() {

  Serial.begin(9600);  // Start serial comunication at baud=9600
  
  // Set the maximum speed in steps per second:
  stepper.setMaxSpeed(1000);
  stepper.setAcceleration (100.0);
}
void loop() {

 Fahrt();
delay (2000);
}
void Startrampe()
{
  //Echtzeit....................
  int StepCount         = 1; //Schrittzaehler
  int Geschwindigkeit   = 0;
  int indexStartrampe  = 0;
  //Echtzeit....................


 indexStartrampe  = 1;

  while (StepCount <= 200)
  { 
     Geschwindigkeit = 0 - round(indexStartrampe * 3);
    indexStartrampe++; //Pausenzeit von kurz --> lang
   
   // Set the speed in steps per second:
  stepper.setSpeed(Geschwindigkeit);
  // Step the motor with a constant speed as set by setSpeed():
  stepper.runSpeed();

   StepCount++;
Serial.println(Geschwindigkeit);
Serial.write(0xff);
Serial.write(0xff);
Serial.write(0xff);
  }//Ende: while-Schleife
}  //Ende: void Fahrt()


void Fahrt()
{
  int StepCount         = 1; //Schrittzaehler

while (StepCount <= int(Fahrtlaenge))
  {
 Serial.println(StepCount);
   // Set the speed in steps per second:
  stepper.setSpeed(-600);
  // Step the motor with a constant speed as set by setSpeed():
  stepper.runSpeed();
  
  StepCount++;

  }//Ende: while-Schleife
}  //Ende: void Fahrt()

Da der Motor laut Datenblatt max 1200rpm hat also 20rps würde ich auch diese gerne fahren. Wenn ich richtig verstehe sollte ich bei 1,8° 200 Stepps für eine Umdreung haben. also sollte ich ein Maxspeed von 4000 fahren können . Ich habe irgend wo gelesen, das man nicht über 2000 sollte. Dies würde aber zur not auch gehen.

Ich habe hier schon alles versucht, auch mit Anleitungen usw. komme ich nicht weiter… evt versuche ich hier was, was gar nicht geht.

Es währe toll, wenn mir hier jemand einen Tip geben könnte.

Vielen Dank im Voraus für eure mühe.

Gruss Patrick

Setze Deinen Code bitte in Codetags (</>-Button oben links im Forumseditor oder [code] davor und [/code] dahinter ohne *).
Dann ist er auch auf mobilen Geräten besser lesbar.
Das kannst Du auch noch nachträglich ändern.

Gruß Tommy

Hallo,

ich hab das noch nicht ganz verstanden.

Du willst einen Schrittmotor mit einem "Taster" starten und runter fahren bis ein Sensor Signal kommt. Jeweils mit Rampe auf und ab. Dann soll es duch ein weiteres Signal irgendwann wieder hoch bis zu einem Endschalter gehen. Ebenfalls mit Rampe auf und ab.

warum überhaupt einen Schrittmotor , könnte doch auch ein DC Motor sein.

Heinz

Hallo Zusammen

Vielen dank für eure Antworten.

@Tommy56 wollte dies gerade ändern, es steht jedoch schon so mit davor und. Passt dies nicht?

@Rentner; Hallo Heinz. Genau dies ist die Idee dahinter. Dies mit dem DC Motor stimmt. Die Spindel wurde standardmäßig mit einem Schrittmotor geliefert und ich bin oder war der Ansicht, dass dies auch gehen würde. Möchte eigentlich die Linearführung nicht umbauen, schaue aber mal nach einem DC resp BLDC.. der passt. Vielleicht lässt sich ja was finden.

Ich habe mir noch überlegt dies mit dem Notaus schalter zu machen, jedoch würde dann der Sensor, den Pin 2 Auf High schalten..muss ich aber erst testen

Patrick

Hallo,

Na dann schau dir mal die Methoden stepper.move() und stepper.stop() der AcceStepper lib an. Bei move setzt Du einen Wert ein den grösser als der gesamte Weg ist. Mit Stop hälst Du an. Richtung und Speed mit Stepper.setSpeed(500) Stepper.setSpeed(-500). Stepper.run() nicht vergessen.

Doku lesen die liegt im Lib Ordner Doku als HTML vor

Heinz

Hallo Heinz

Vielen Dank für die Antwort. Ich war eigentlich der Meinung, dass mit move() oder moveTo() der Eingabe Wert immer gefahren wird. Also z.b. 2000 .Hab aber dies mal versucht:

#include "Q2HX711.h"
#include <AccelStepper.h>


// HX711 circuit wiring
Q2HX711 scale1(A0, A1);

// Define a stepper and the pins it will use
AccelStepper stepper(1, 4, 5); // pin 4 = step, pin 5 = direction


// Schalter
const int Anfangsschalter = 7; // Anfangsschlater Line

// Variablen
int buttonState = 0;         // variable for reading the pushbutton status
int weg = 2000;                // variable for Länge der Bewegung

void setup() {
  
//Serial.begin(115200);  // Start serial comunication at baud=9600

// Change these to suit your stepper if you want
  stepper.setMaxSpeed(2000);   // max 10 steps per second
  stepper.setAcceleration(2000);

// initialize the pushbutton pin as an input:
pinMode(Anfangsschalter, INPUT); 

}

void loop() {

 // Auslesen des Gewichtssensors

long reading1 = scale1.read();
// Serial.println(reading1);

if (digitalRead(Anfangsschalter) == HIGH) {     
    stepper.move(weg);
    stepper.setSpeed(2000);
  //Serial.println("motorfaehrt");
  }

  if (scale1.read () > 9000000) {
    stepper.stop();  // sofortigen Stop einleiten, siehe AccelStepper Classes
    Serial.println("motorstopt");
  }
stepper.run();   // run immer ausführen um Bewegung zu vollenden, siehe AccelStepper Classes
}

oder mit der while

void loop() {

 // Auslesen des Gewichtssensors

long reading1 = scale1.read();
// Serial.println(reading1);

if (digitalRead(Anfangsschalter) == HIGH) {     

  while (scale1.read () < 9000000) {
    stepper.move(weg);
    stepper.setSpeed(500);
    stepper.run();
  //Serial.println("motorfaehrt");
  }
    stepper.stop();  // sofortigen Stop einleiten, siehe AccelStepper Classes
    Serial.println("motorstopt");
  }

}

Bei beiden habe ich das Problem, das der Motor nur Ruckelt… Stop Funktioniert, jedoch fährt er immer die Strecke welches im weg eingegeben ist zu ende.

Das einzige, was bei mir funktioniert, ist, wenn ich nur folgendes im Loop habe

void loop() {
stepper.move(weg);
stepper.setSpeed(-500);
stepper.run(); 
 }

Dan läuft der Motor rund. Ich denke dies ist das selbe Problem wie oben, sobald ich im Loop andere Befehle habe stimmt die Ausgabe der “Taktgeschwindigkeit” nicht mehr. Hier nehme ich an, es liegt am auslesen/abfragen des Gewichtsensors.

Hi

Der Stepper macht nur was, wenn Du .run() aufrufst - bei JEDEM Aufruf wird entschieden, ob JETZT EIN Schritt gemacht werden soll - immer nur ein einziger Schritt! Das .move(x) legt das Ziel relativ zur aktuellen Position fest. das moveto(x) macht das Gleiche, ur absolut (von Null aus gesehen). Damit zuckt der Stepper aber kein einziges Mal - Du musst schon regelmäßig (und schnell) .run() aufrufen, nur hier wird überprüft, ob JETZT ein Schritt gemacht werden soll - mit Rampen und dem ganzen Kram drum herum.

Was sprechen die Beispiele zum HX711 - davon ein Beispiel genommen und gezählt, wie oft man durch loop() kommt, könnte zumindest schon Mal halbwegs zeigen, in wie fern der Sensor bremst. WENN Dieser bremst, suchen, ob's Das auch blockadefrei gibt.

Auch wäre Es schön, wenn man sich nicht aus 3 Posts Deine wohl aktuelle Version zusammen reimen müsste, zumindest lese ich in den Versionen, wo's sogar ein setup() drin gibt, Nichts von Deinem Sensor.

MfG

PS: Alternativ könnten Dir die MoBaTools (Lib vom Microbahner, in der IDE enthalten) die Stepper-Ansteuerung im Hintergrund (ohne dauerndes Aufrufen einer .run() Methode) abnehmen. Auf die Position reagieren musst Du aber weiterhin binnen einer Woche - sonst läuft Da nämlich auch Nichts mit.

Hi

vielen Dank für deine Antwort. Ich denke hier, dass das Problem im Loop liegt, sprich wie du schreibst, dass run() nicht regelmäßig und schnell aufgerufen wird ( wegen while, count oder was auch immer).

Zum HX711. der Sinn liegt darin, dass der Schlitten so weit Runterfährt, bis ein gewisser Gegendruck entsteht und erst wenn dieser erreich ist (z.B. 2 kg) stoppt der Motor. Da ich dies so in der Anwendung brauche, wollte ich dies gleich beim Test einbinden. Sorry. Ich habe diese 3 Codes aufgeführt, weil ich aufzeigen wollte, was ich schon getestet habe,

Habe gerade eine Option mit einem Interrupt auf Pin 2 getestet, dies funktioniert mit einem Schalter Perfekt, jedoch wohl nicht mit einem Sensorwert. Hardwaretechnisch könnte man dies sicherlich lösen oder evt Programmieren, hier währe ich als neuling wohl komplett überfordert.

Vielen Dank für den Tipp mit MoBaTools. Habe gerade die PDF gelesen. Wenn ich dies richtig verstehe, löst dies mein Problem.. Somit könnte ich z.B. eine Position 200000 anfahren und im loop weiterhin auf den Sensorbefehl warten und sobald dieser kommt, kann ich void mystepper.stop verwenden ( z.b. bei Possition 150000). Somit könnte ich die Fahrt unterbrechen wie beim Interrupt, jedoch über einen Sensorwert. Oder werden auch hier Fahrtwege immer zu ende gefahren?

Gruss

Hallo,

ich vermute es liegt an dem was wir nicht sehen und das ist das Einlesen des Sensors, vermutlich ist da noch ein schlimmes delay() drin. Lass das mal versuchsweise weg und ersetze es durch einen Taster. Vermutlich kommst Du nicht schnell genug über das Sepper.run()

Heinz

Hallo zusammen

@postmaster-ino

Habe das ganze mit MobaTools versucht und es Funktioniert.
Ich kann die Spindel mit per Knopfdruck starten und wenn ich den Gewichtssensor belaste Stoppt diese.
Das Auslesen der Geschwindigkeit funktioniert auch :slight_smile: . Versuche jetzt noch die Geschwindigkeit auf 4000Steps/sec hochzustellen… melde mich wieder :slight_smile:

Anbei noch der code:

#include "Q2HX711.h"
#include <MobaTools.h>

// HX711 circuit wiring
Q2HX711 scale1(A0, A1);

// Define a stepper and the pins it will use

byte pinStep = 4;
byte pinDir = 5;
uint16_t RPM = 0;

MoToStepper myStepper(200, A4988);  

// Schalter
const int Anfangsschalter = 7; // Anfangsschlater Line

void setup() {
  
Serial.begin(9600);  // Start serial comunication at baud=9600
myStepper.attach(pinStep, pinDir);
myStepper.setSpeedSteps(25000);       // = ?? U/Min
myStepper.setRampLen(100);

// initialize the pushbutton pin as an input:
pinMode(Anfangsschalter, INPUT); 
}

void loop() //method for the motor
{
if (digitalRead(Anfangsschalter) == HIGH)
  {myStepper.rotate(1); // 1=forwaerts/hoch, -1= zurück/runter
  }
RPM=myStepper.getSpeedSteps();
Serial.println(RPM);

if (scale1.read () > 9000000)
{myStepper.stop();
Serial.println(scale1.read());
}
}

Vielen dank im Voraus.

Gruss

Hallo zusammen.

Ich habe alle .h Files durchsucht und finde leider kein max 2500steps/sec. Weiss jemand wo ich dies auf 4000steps/sec hochstellen kann? Ich habe an einem anderen Ort gelesen, das max 5000 steps/sec möglich wären.

Vielen Dank

Gruss Patrick

Hey,

mit der LIB kenne ich mich nicht aus, bist du dir sicher das die 4000steps/sec vom Arduino Nano überhaupt ausgegeben werden können?

Ist die Taktfrequenz denn ausreichend vom Arduino Nano?

Gruß Mücke

ps. Willkommen in der Arduino Welt
Mich würde es Interessieren was du da genau baust.

Hallo Muecke

Dies sollte eigentlich gehen, ich habe dies mit dem Accelstepper auch hinbekommen. Ich kann zwar die Drehzahl nicht messen, aber es war def. schneller.

Also mein Ziel ist es eine Abfüllanlage für Bierflaschen zu machen. Durch den Gewichtsensor möchte ich erreichen, dass unterschiedliche Flaschen angefahren werden können. Gesteuert wird das Ganze über ein Nextion. Es wird alles mit FDA Zert. Materialien gemacht und was bis jetzt das schwierigste war, alles mit Mediengetrennten Ventilen und bezahlbar zu realisieren.. Hier verwende ich ein Quetschventiel für die Bierleitung. Wird aber noch lange dauern. :)

Hi

Also ein nachvollziehbar unterstützenswertes Projekt ... ;) Quetsch-Ventil - klingt nach Peristalik-Pumpe - mit den heutigen Möglichkeiten kann man Sich so was selber drucken. Du brauchst dann nur noch lebensmittelechten Schlauch.

MfG

Gasi: Ich habe alle .h Files durchsucht und finde leider kein max 2500steps/sec. Weiss jemand wo ich dies auf 4000steps/sec hochstellen kann? Ich habe an einem anderen Ort gelesen, das max 5000 steps/sec möglich wären.

Hallo Patrik, die maximale Steprate häng von der Zykluszeit des Interrupts ab, in dem die Steps erzeugt werden. Beim AVR sind das standardmäßig 200µs was zu den maximal 2500Steps/sec führt. Diese Grenze ist auch deshalb eingeführt, damit dies auch mit mehreren Stepper parallel funktioniert. Wenn Du nur einen Stepper ansteuerst, kannst Du die Zykluszeit bis auf 100µs reduzieren, dann kommst Du auf die 5000 Steps/sec. Da zu musst Du in src/MobaTools.h die Zeile 96

#define CYCLETIME       200     // Min. irq-periode in us ( default is 200 ),

ändern in

#define CYCLETIME       100     // Min. irq-periode in us ( default is 200 ),

Kleiner solltest Du die Zykluszeit bei einem AVR aber auf keinen Fall machen - das kann zu Problemen führen.

P.S. Willst Du wirklich dass der Stepper beim Sensorsignal schlagartig anhält? Die 'stop' Methode ist im Prinzip ein Notstop - da wird keine Rampe mehr gefahren. Wenn der Stepper mit Rampe stoppen soll, musst Du rotate(0) verwenden.

Hallo zusammen

Vielen dank für eure Antworten.

@postmaster-ino: Ja dies mit den Ventilen und vor allem Totraum ist ne "unendliche Geschichte". Vorallem wenn ich alles noch Preislich im Rahmen halten soll.Anfänglich wollte ich Edelstahlventile einsetzen, diese sind jedoch nicht Mediengetrennt... Neu hab ich für C02 und Abfluss mediengetrennte Verntile hier .. Da ich bei der Bierduchfluss Leitung mehr als 5,5mm Durchmesser haben möchte, habe ich mich für die Quetsch Variante entschieden, den ein Medien getrenntes Ventil mit dem Durchmesser FDA kostet richtig Geld.. Es geht hier aber nur um ein ON/OFF Qutschventil also keine Peristalik-Pumpe. Mein Ventil welches ich hier hab ist ein Schlauchklemmventil, Schlauch Ø6.4mm x 9.5mm, 2-Wege mit einer Klemmkraft von 1.400kg. :)

Dies mit den Schläuchen ist ein schweres Thema.. Laut Ventil sollte ich Shore50A Schlauch verwenden.. Da ich aber unter Druck arbeite und diese FDA sein müssen hab ich erstmal einen Silikonschlauch mit ID6.4mm für 1,4Bar und einen ID4.8mm für 2.4mm.. haben halt Shore A68, aber sollte hoffentlich auch gehen :). Mal schauen, ist noch ein weiter weg, bis ich den Durchfluss der Anlage testen kann.

@MicroBahne. Hallo Mark. Erstmal Vielen Dank für deine tolle Arbeit bei der Library. Ich hatte eben einen Post von dir gesehen, dass es möglich ist, wenn man nur einen verwendet. Da ich nicht mehr brauche werde ich dies so bald wie möglich noch testen. Vielen Dank für deine Hilfe. Da ich hier wirklich ein Anfänger bin, wollte ich nichts verändern wenn ich nicht genau weiß was resp. wo. Der Motor hat als max 1200rpm, 1,8° also 200 Steps/U bei 20 U/s währen dies 4000Stepps, dies passt. ( wenn ich hier nicht falsch rechne).

p.s.: Beim test mit dem Code oben, hält er mir auch nicht gleich an. Er dreht noch ein Paar U weiter.. nehme an dies liegt jedoch am Loop oder so.. Da ich dies später mit einer while schleife lösen möchte hoffe ich , dass er schneller stoppt. Dies mit dem rotate(0) habe ich in der Anleitung gesehen, jedoch hab ich die noch nicht getestet. sicherlich wäre eine Bremsrampe Toll, diese darf aber nur einige U machen. Anbei habe ich ein Bild mit dem Sensor.. Unten an den Schrauben wird der Füllkopf angebracht. Mit den Federn hab ich also noch Reserve ( zudem hab ich dann einen " Vorspanndruck" :) ). Kann man die Bremsrampe getrennt anpassen? Oder wird dies generell mit myStepper.setRampLen(100); gemacht..

Wenn ja, werde ich dies einfach testen müssen... also wie klein ich die Rampe fahren kann bei Max Geschwindigkeit.

Vielen Dank für eure Hilfe und Inputs

Gruss Patrick

20200308_001607[1].jpg|3024x4032

Hi

Gerade, wenn Du IMMER auf ALLES reagieren willst (oder noch schlimmer: MUSST), ist WHILE oder DELAY eine sehr sehr schlechte Idee. Schaue, daß Dein loop() schnell durchläuft - wenn Nichts zu tun ist: mache auch Nichts! Erst, wenn der Sensor ausgelöst hat, muß irgend etwas passieren - z.B. 'rotate(0);' - Was die Drehbewegung mit Rampe auf Null bringt. Wenn Dich dieses Überdrehen nicht stört - oder gar einen gewissen 'Anpressdruck' erzeugt - why not? Ein stupides STOP muß ja auch nicht wirklich heiße, daß der Stepper wirklich stehen bleibt - 'nur', weil die Ansteuerung so einen Mist erzählt, muß der Stepper ja nicht mit Seiner bewegten Masse direkt darauf anspringen ... meine: Du kannst Dir hier böse Schrittverluste einfangen. Sofern Du nicht nur EINE Flasche abfüllen willst, wäre Das zumindest nicht mein Weg.

... davon ab ... habe gerade einen Nano (und wohl einen A4988) per Rauchentwicklung in Rente geschickt ... oder Schlimmeres :/ gerade, wo der neue Stepper Mal Fahrt aufgenommen hat ...

MfG

Hi

vielen Dank für deine Antwort

Ich hab an ein while gedacht, da der Loop erst weiter gehen muss wenn die Linearführung die Flasche erreicht hat ( darin soll auch noch ein 2. Gewichtssensor der das Gewicht der Flasche misst dazu-> wenn jemand die Flasche entfernt, fährt die Anlage wieder hoch) Währen hier mehrer If Else besser?

Ja ich denke dies mit dem rotate währe dies bessere Lösung. Da ich jedoch alles mit Sensoren Fahre, spielen mir Schritt keine Rolle. Da er zudem immer wieder an einen Anfangspunkt mit Sensor fährt, könnte ich diesen da auch 0en. Klar hier benötige ich keinen Stepper, also ein BLDC währe hier wohl besser geeignet, aber ich hatte die Spindel so und wollte nichts umbauen. Ach ja Grund , dass ich keine Schritte ( Wege) fahre ist , da man mit dem Sensor unterschiedlich grosse Flaschen nehmen kann ohne was zu ändern. Zudem hab ich so eine gewisse Sicherheit, wenn mal was verklemmt oder so :slight_smile: Wobei es ja von Trinamic extra Module ( cool Stepp…stallguard usw) dafür gibt :wink: aber hier währe ich als Neuling überfordert

Ach nee, hätte noch welche rumligen… 8825 hätte ich auch noch… Kenn ich leider zu gut… :angry: deswegen auch auf vorart :stuck_out_tongue_closed_eyes: naja hab letzte Woche wieder n Nano in Rente geschickt.

Gruss

Hi

Wenn der Stepper klappt - warum nicht beim Stepper bleiben? Sofern die Flaschen nicht bunt gemischt werden, kann man So ggf. eine Havarie erkennen - wenn der Stepper zu tief gefahren ist, als das Da eine Flasche stehen kann, wird's wohl Bruch gegeben haben ...

Gerade, weil ja Jemand die Flasche auch während des Vorgang entfernen kann (... Flasche wird geklaut und Arduino füllt die Flasche auf, bis das Endgewicht erreicht ist ... 23,5 Kubikmeter später schaut vll. Mal Wer nach dem Rechten ...), würde ich auf DELAY und so Zeug DRINGEND verzichten!!

Du willst wirklich (glaube mir/uns) den Kram in verschiedene Status (was gleich die Mehrzahl von Status ist ... Deutsch ist halt so) aufteilen! Damit hast Du auch gleich eine nahezu unendlich oft durchlaufende loop() - wenn Nichts gemahct werden muß, machen wir halt Nichts. Wenn zwischenzeitlich ein Sensor irgend was ungewöhnliches meldet, können wir JEDERZEIT drauf reagieren!

Im Grunde ist (zumindest bisher) Alles mit einer State-Maschine zu erschlagen.

MfG

Gasi: Kann man die Bremsrampe getrennt anpassen? Oder wird dies generell mit myStepper.setRampLen(100); gemacht..

Es gibt generell nur das setRampLen, und das gilt für Beschleunigen und Bremsen. Allerdings kannst Du die Rampe jederzeit ändern, auch während der Motor läuft. Du könntest also nach dem Hochlauf die Rampe noch fur's Bremsen wieder verkürzen.

Edit: Im Prinzip kannst Du vor jedem rotate-Befehl mit setRampLen die gewünschte Rampe für den jeweiligen Anfahr- bzw. Bremsvorgang einstellen. Ich fände es aber auch sicherer, beim Starten der Bewegung eine Zielposition vorzugeben. Die kann ja dem Maximal zu erwartenden Weg entsprechen. Dann läuft der Stepper auch dann nicht endlos, wenn kein Sensor-Signal ankommt - aus welchen Gründen auch immer. Vorzeitig per Sensorsignal anhalten über rotate(0) kannst Du ja weiterhin.