Hallo wollte einen 3D Drucker bauen bekomme es aber nicht hin das SpeedRamping zu überspringen also das auf null abbremsen und danach wieder auf MaxVelocity zu beschleunigen und dann mit den neuen Koordinaten weiter zu verfahren.

Ein kontinuierlicher vorschub ist somit nicht möglich.

Hat jemand eine lösungs Richtung für dieses Problem?

Hallo!

 

Also bei mir funktioniert das ohne Probleme mit VB.NET.

 

Kannst du mal den Code zeigen den du geschrieben hast?

 

Ich ändere die Variablen for jedem aufruf mit neuen Werten aus einer Text datei.

...

G1 X175.745 Y36.637

G1 X176.547 Y38.792

G1 X176.657 Y40.000

....

 

Der aufruf einer neuen Zeile geschieht durch den callback stepper_Y.PositionReached.

 

stepper_X.SetSpeedRamping(Variablen.FFW_X * 3, Variablen.FFW_X * 3);

stepper_Y.SetSpeedRamping(Variablen.FFW_Y * 3, Variablen.FFW_Y * 3);

stepper_Z.SetSpeedRamping(Variablen.FFW_Z * 3, Variablen.FFW_Z * 3);

           

stepper_X.SetMaxVelocity(Variablen.FFW_X); // Velocity 2000 steps/s

stepper_Y.SetMaxVelocity(Variablen.FFW_Y);

stepper_Z.SetMaxVelocity(Variablen.FFW_Z);

 

stepper_Y.SetTargetPosition(Variablen.Y_Pos);

stepper_X.SetTargetPosition(Variablen.X_Pos);

stepper_Z.SetTargetPosition(Variablen.E_Pos);

 

wenn Ich SpeedRamping ausklammer nimmt der Stepper aber die letzten Werte.

stepper_X.SetSpeedRamping(Variablen.FFW_X * 3, Variablen.FFW_X * 3);

 

Du weisst aber schon, dass der zweite Wert die Verzögerung ist. Man soll es normalerweise nicht machen, aber schreib doch als zweiten Wert einfach 0 rein.

 

Ja 2ter Wert ist Verzögerung.

1ter und 2ter Wert auf 0 ist auch keine abhilfe, da die Motoren auch zwieschen den neuen Werten auch stoppen.

Also eine Lösung wo die neuen TargetPositionen mit den neuen MaxVelocity Werten von dem Stepper verarbeitet werden ohne unterbrechung gibt es so nicht?

Ohne jetzt deinen genauen Code zu kennen, kann es sein das danach nochmal irgendwo SetSpeedRamping gesetzt wird mit anderen Daten?

Oder ist die Berechnung falsch?

Hast du dein Programm mal debuggt?

Es wird noch bei dem Befehl G28 SpeedRamping aufgerufen.(nur beim Programm start)

Das verfahren wird mit G1 ausgeführt was nach jedem erreichen der Endposition prinzipiel vom Callback aufgerufen wird.(und da habe Ich das problem).G1 bekommt immer neue Positions Werte aus einer Text Datei.

 

 public void G1(int X_Wert, int Y_Wert, int Z_Wert, int E_Wert, int FFW, bool F_sprung)
        {
            IPConnection ipcon = new IPConnection();
            BrickStepper stepper_Y = new BrickStepper(Variablen.STUID_1, ipcon);
            BrickStepper stepper_X = new BrickStepper(Variablen.STUID_2, ipcon);
            BrickStepper stepper_Z = new BrickStepper(Variablen.STUID_3, ipcon);
            //BrickletLCD20x4 lcd = new BrickletLCD20x4(Variablen.LCDUID, ipcon);

            //byte StepMode_X = 8; //1/8 step mode 8000  1/4 step mode 5200  1/2 step mode 2600 1/1 step mode 1000
            Variablen.XDec_Wert = X_Wert / Variablen.X_DECIP;
            Variablen.YDec_Wert = Y_Wert / Variablen.Y_DECIP;
            Variablen.ZDec_Wert = Z_Wert / Variablen.Z_DECIP;
            Variablen.EDec_Wert = E_Wert / Variablen.E_DECIP;
            Variablen.FFW_Dec = FFW / Variablen.F_DECIP;
            double XT_Pos = X_Wert * Variablen.X_Ratio, YT_Pos = Y_Wert * Variablen.Y_Ratio, ZT_Pos = Z_Wert * Variablen.Z_Ratio, ET_Pos = Variablen.EDec_Wert * Variablen.E_Ratio, FFW_AKT = Variablen.FFW_Dec * Variablen.F_Ratio;
            //double XT_Pos = X_Wert, YT_Pos = Y_Wert;

            ipcon.Connect(Variablen.HOST, Variablen.PORT); // Connect to brickd

            double X_Aktpos = (stepper_X.GetCurrentPosition());
            double Y_Aktpos = (stepper_Y.GetCurrentPosition());
            double Z_Aktpos = (stepper_Z.GetCurrentPosition());
            if (FFW_AKT > Variablen.MaxSpeed) { FFW_AKT = Variablen.MaxSpeed;}

            FFW_Calc(X_Aktpos, Y_Aktpos, Z_Aktpos, XT_Pos, YT_Pos, ZT_Pos, ET_Pos, FFW_AKT);//Vorschübe berechnen aus Gcode Tabelle

            System.Console.WriteLine(Variablen.Zeile + " F_X= " + Variablen.FFW_X + " F_Y= " + Variablen.FFW_Y + " E=" + E_Wert);
            System.Console.WriteLine("     -----------------------------------");

            //stepper_X.SetSpeedRamping(Variablen.FFW_X * 3, Variablen.FFW_X * 3);
            //stepper_Y.SetSpeedRamping(Variablen.FFW_Y * 3, Variablen.FFW_Y * 3);
            //stepper_Z.SetSpeedRamping(Variablen.FFW_Z * 3, Variablen.FFW_Z * 3);
            stepper_X.SetSpeedRamping(0,0);
            stepper_Y.SetSpeedRamping(0,0);
            stepper_Z.SetSpeedRamping(0,0);
            
            stepper_X.SetMaxVelocity(Variablen.FFW_X); // Velocity 2000 steps/s
            stepper_Y.SetMaxVelocity(Variablen.FFW_Y);
            stepper_Z.SetMaxVelocity(Variablen.FFW_Z);

            stepper_Y.SetTargetPosition(Variablen.Y_Pos);
            stepper_X.SetTargetPosition(Variablen.X_Pos);
            stepper_Z.SetTargetPosition(Variablen.E_Pos);

            Variablen.X_run = false;
            Variablen.Y_run = false;
            
            int RS_Y = stepper_Y.GetRemainingSteps();
            int RS_X = stepper_X.GetRemainingSteps();
            int absY = Math.Abs(RS_Y);
            int absX = Math.Abs(RS_X);

            if (absY > 0)
            {
                Variablen.Y_run = true;
            }
            else
            {
                Variablen.Y_run = false;
            }
            if (absX > 0)
            {
                Variablen.X_run = true;
            }
            else
            {
                Variablen.X_run = false;
            }

            if (Variablen.X_run == false & Variablen.Y_run == false)
            {
                System.Console.WriteLine("  ----- kein Verfahrweg ----");
                GCodeinterpreter();
            }

            ipcon.Disconnect();
        }

Warum machst du bei jedem Sprung in die Funktion G1 eine neue Verbindung auf, und schließt die wieder am Ende?

 

Ich erkenne jetzt auf die schnelle nichts.

 

Um aber einen Logikfehler ausschließen zu können, eine Frage noch bzw. einen Tipp (ich habe so was ähnliches gebaut, allerdings nur mit 2 Achsen).

Um von der "alten"/momentanen Position auf die neue zu fahren, musst du den zu verfahrenden Weg ermitteln, also TargetPosition - CurrentPosition. Daraus ergibt sich dann der Weg, und je nachdem wie du es machen willst, muss entweder die Achse mit dem weitesten Weg schneller fahren, oder die mit dem kürzesten Weg halt langsamer. Un die Achse die schneller fährt, braucht eine höhere Beschelunigung, um halt schneller auf die Geschwindigkeit zu kommen.

Man kann das bestimmt noch anders lösen, so hab ich es gemacht und es hat gepasst.

Die Differenz für den Vorschub wird für alle drei Achsen berechnet, diese werden bei Diagonalen bis auf 5-10 Stepps exact zur selben Zeit ereicht.

Warum Ich bei jedem Sprung in die Funktion G1 eine neue Verbindung aufbaue? Da Ich sonst die Stepper nicht ansprechen kann.