Poblem mit V-Plotter und GRBL

Hallo zusammen,
Ich bin jetzt dabei,mir einen V-Plotter zu basteln.
So in etwa wie der Kritzler

Die Software hab ich auch schon auf meinem UNO drauf (GRBL GitHub - grbl/grbl: An open source, embedded, high performance g-code-parser and CNC milling controller written in optimized C that will run on a straight Arduino )

Gelaufen ist das Maschinchen auch schon, allerdings nicht richtig. Jetzt kommt ihr ins spiel :wink:
Die daten (g-code) erstelle ich mit Inkscape.
Die erstellten Koordinaten werden mit dem Universal-G-Code-Sender ( GitHub - winder/Universal-G-Code-Sender: A cross-platform G-Code sender for GRBL, Smoothieware, TinyG and G2core. )
auf den Arduino geladen.
Die Treiber fĂŒr die Stepper sind die A4988, welche auf dem Arduino CNC Shield ( http://blog.protoneer.co.nz/arduino-cnc-shield/ ) gesteckt sind.
Allerdings bekomme ich das Bild nie so “gedruckt”, wie ich es auf dem Monitor sehe. Es ist nicht ganz rund, sondern Oval
und im Winkel verschoben.
Wisst ihr vielleicht, wie man das GRBL einstellen muss, das das richtig lÀuft? Oder könnte es noch woanders Fehler geben?

Wenn ihr mehr infos braucht, dann nur sagen. Ich weiß jetzt nicht ob ich alles erwĂ€hnt habe :slight_smile:

Ich habe jetzt noch ein paar Bilder von einem Druck gemacht. Hoffe es hilft zum besseren VerstÀndniss.

MfG Matze

Push :wink:

Hat denn wirklich noch niemand einen v-plotter (vertikal-plotter) oder wall plotter oder hanging plotter gebaut?
Oder vielleicht kommt mit der such Funktion jemand besser zurecht als ich :frowning:

Mfg

Hallo,

fĂŒr mich sehen die Bilder so aus, als ob einer Deiner Motoren in die falsche Richtung lĂ€uft (also z.B. nach rechts, wenn er nach links soll und umgekehrt). Dein Koordinatensystem scheint auf dem Bildschirm einen anderen Ursprung zu haben als im Ausdruck und die Anpassung des SeitenverhĂ€ltnisses stimmt nicht.

Probier doch mal, Dein Bild mit Inkscape zu spiegeln, in die entsprechende Richtung zu dehnen und so zu drehen, dass der Ursprung stimmt.

Wie mit Deiner weiter erwĂ€hnten Software die Fehler zu beheben sind, weiß ich nicht. Aber sicherlich ist zumindest das SeitenverhĂ€ltnis (Aspect Ratio) einstellbar.

Gruß,
Ralf

Das verzerren des Bildes hÀngt auch von der LÀnge der 2 Seile/Riemen ab, die den Schreibkopf halten. Sind sie LÀnger wird das Bild bei gleicher Einzug des Seiles ovaler.
GrĂŒĂŸe Uwe

bluebravo:
Allerdings bekomme ich das Bild nie so "gedruckt", wie ich es auf dem Monitor sehe. Es ist nicht ganz rund, sondern Oval
und im Winkel verschoben.

Das ist doch eigentlich völlig logisch: Ein V-Plotter hat ja eine ganz andere Kinematik als eine XY-CNC FrÀse.

WÀhrend bei einer XY-CNC Maschine die X- und Y-Achse immer einen rechten Winkel zueinander bilden, bildet Dein V-Plotter mit den beiden Seil-Achsen einen V-Winkel, den Du zwar an einem einzigen Punkt auf 90° einstellen kannst, aber sobald am Seil-V auf der einen Seite Seil nachgegeben und auf der anderen Seite Seil eingeholt wird, Àndern sich die WinkelverhÀltnisse und die beiden Achsen stehen nicht mehr senkrecht zueinander.

Die Steuerung kann dann nur verzerrt werden.

Ich sehe an Deinem Projekt nirgends, dass Du den Zwischenschritt machst, um die XY-Steuerbefehle, die fĂŒr rechtwinklige CNC-Achsen gelten, auf die Kinematik Deines V-Plotters mit im Betrieb verĂ€nderlichen Achsenwinkeln umzurechnen.

Hallo, danke fĂŒr die Antworten!
@Schachmann,
Die sache mit Bild drehen hatte ich schonmal gemacht, das klappt auch. aber ans strecken/dehnen hab ich nich gedacht.
Hatte gehofft, das es da was "fertiges" gibt.

@uwe,
Das ist eine gute ErklÀrung. Danke.

@jurs,
Das die Kinematik anders ist, ist mir bewusst, dachte aber, das das bei den Videos, wie z.b. von "Der Kritzler" auch so geht.
Das du keinen Zwischenschritt siehst ist klar, ich mache ja auch keinen :wink:
Kann man das denn irgendwie berechnen, oder gibts dafĂŒr ne Software?

Beste GrĂŒĂŸe!!!

bluebravo:
Kann man das denn irgendwie berechnen, oder gibts dafĂŒr ne Software?

Ich sagen mal: ja, das kann man berechnen!
Software mußt Du vermutlich selbst schreiben.
Wenn Du nichts fertiges fĂŒr V-Plotter findest.
Die Umrechnung selbst ist keine Raketenwissenschaft.

Mal angenommen, der Punkt B sei der linke obere Seilpunkt und A der rechte obere Seilpunkt Deines Plotters und C der Punkt, an dem sich der Plotterstift befindet. Dann kannst Du Dir ein Koordinatensystem darĂŒbergelegt denken mit dem Koordinatenursprung 0, und fĂŒr jeden beliebigen zu plottenden Punkt C kannst Du Dir die SeitenlĂ€ngen a und b des Seildreiecks ausrechnen.

Wie lang die SeillĂ€ngen a und b zu jedem Punkt C mit den Koordinaten x,y sein mĂŒssen, kannst Du mit Vektorsubstraktion ermitteln. Es seien die Vektoren (eigentlich wĂŒrde der Strich darĂŒber gehören, das unterstĂŒtzt die Forensoftware nicht, deshalb unterstreiche ich die Vektoren zwischen zwei Punkten mal.
0A Vektor vom Koordinatenursprung 0 zum Seilpunkt A
0B Vektor vom Koordinatenursprung 0 zum Seilpunkt B
0C Vektor vom Koordinatenursprung 0 zum Plotpunkt C

Seite a: BC = OB-OC vom resultierenden Vektor den Betrag bilden: SeillÀnge a

Seite b: AC = OA-OC vom resultierenden Vektor den Betrag bilden: SeillÀnge b

Also um aus Koordinaten x und y die SeillĂ€ngen a und b auszurechnen, ist jeweils eine Vektorsubstraktion notwendig und eine Berechnung des Vektorbetrags. DafĂŒr braucht man zum Ausrechnen nicht mehr als die vier Grundrechenarten und die Quadratwurzel. Vektorrechnung ist allerdings Mathematikthema der gymnasialen Oberstufe. Ist das ein Problem?

Wenn Du Dir einmalig ausgerechnet hast, wie groß die SeillĂ€ngen fĂŒr den Plotpunkt am Koordinatenursprung O sind, kannst Du diesen Wert fĂŒr Deine Stepmotoren als Nullpunkt setzen, von dem dann Plus oder Minus geplottet wird. Und ob der Steppermotor dann rechtwinklige x- und y-Koordinaten ansteppt oder mit V-Winkel a- und b-SeillĂ€ngen einstellt, ist der Hardware dann egal. Nur muß eben von rechtwinkligen x-y-Koordinaten auf nicht-rechtwinklige a-b-SeillĂ€ngen umgerechnet werden, sonst erfolgt die Ausgabe verzerrt.

Guten morgen
es ist ein Problem in so fern, das ich n normalen Realschul Abschluss habe.
Aber so an sich hast du das ja gut beschrieben, das man das vielleicht noch hinbekommt.

Hab ich das denn richtig verstanden, das ich die Berechnung fĂŒr jede Koordinate neu
Vornehmen muss?

Mfg

bluebravo:
es ist ein Problem in so fern, das ich n normalen Realschul Abschluss habe.

Ja, in der Realschul-Mathematik kommt Vektorrechnung nicht vor.

Aber in der Geometrie kommt dran:

  • x-y-Koordinatensystem
  • Dreiecke
  • Satz des Pythagoras
    Viel mehr braucht es kaum.

bluebravo:
Hab ich das denn richtig verstanden, das ich die Berechnung fĂŒr jede Koordinate neu
Vornehmen muss?

Ja. Die rechtwinkligen Koordinaten x und y fĂŒr jeden einzelnen anzufahrenden Plotpunkt mĂŒssen in entsprechende SeillĂ€ngenwerte a und b umgerechnet werden.

Ich zeige mal, wie ich mir die Kinematik Deines V-Plotters vorstelle und bezeichne mal ein paar Punkte und Strecken.
Punkte immer mit Großbuchstaben, Strecken mit Kleinbuchstaben. Dazu habe ich mal eine Skizze gemacht und hĂ€nge sie dran.

Du mußt jeden Punkt C(x|y) anfahren, indem Du an den Seilpunkten entweder Seil zugibst (a oder b wird lĂ€nger) oder Seil einholst (a oder b wird kĂŒrzer). Die SeillĂ€ngen, die Du jeweils nachgeben oder einholen mußt, sind nicht identisch mit den x und y Werten im Koordinatensystem.

Soweit verstanden und die Skizze klar?

Hallo jurs,
Soweit verstanden und alles klar :slight_smile: .

bluebravo:
Soweit verstanden und alles klar :slight_smile: .

OK, dann weiter.

Damit wir im Bereich Realschul-Mathematik bleiben lasse ich Vektoren weg und rechne alles mit rechtwinklingen Dreiecken und dem Satz des Pythagoras. Dieser besagt grob:
In einem rechtwinkligen Dreieck ist das Quadrat der lĂ€ngsten Seite gleich der Summe der Quadrate der beiden kĂŒrzeren Seiten. Mathematisch oft geschrieben als a2+b2=c2

Nun zum nÀchsten Bild. Deine Seilpunkte A und B haben im Koordinatensystem eigene Koordinaten
A(xA|yA)
B(-xB|yB)

Wenn Du den Plotter symmetrisch aufgebaut hast, dann sind die LĂ€ngen der Koordinaten bei beiden Punkten gleich, also
xA = xB
und
yA = yB
Auch wenn diese Werte bei Dir wohl gleich sind, bezeichne ich sie mal unterschiedlich, damit es immer klar ist, wo ich wann mit welchem Wert rechne.

Wenn der Plotter in Nulllage ist, also Plotpunkt x=0 und y=0, dann liegt der Plotpunkt C genau im Koordinatenursprung. Das Seil zwischen dem Koordinatenursprung und Punkt B habe dann die LĂ€nge a0.

Mit Hilfe des rechtwinkligen Dreiecks BDO und des Pythagoras lĂ€ĂŸt sich die LĂ€nge a0 ausrechnen. FĂŒr das Dreieck BDO gilt nĂ€mlich:
yB2+xB2 = a02
bzw. aufgelöst nach a0:
a0 = sqrt(yB2+xB2 )
(mit “sqrt” = Quadratwurzelfunktion)
Auf der rechten Seite des Gleichheitszeichens stehen nur bekannte Werte, die sich aus den Abmessungen Deines Plotters ergeben.

Unter der Voraussetzung eines symmetrischen Aufbaus wĂ€re die SeillĂ€nge b0 (habe ich im Bild nicht eingezeichnet), exakt genau so groß wie a0.

Und zum Plotten mußt Du dann zu jedem Plotpunkt C(x|y) herausbekommen:
Wieviel Seil muß an jeder Seite zugegeben oder eingeholt werden, damit der Plotter den Punkt C(x|y) anfĂ€hrt?

Im Bild habe ist außer der SeillĂ€nge in Nulllage a0 auch die SeillĂ€nge “a” eingetragen, die sich an Punkt C ergibt.

Diesen Wert a werde ich dann im nÀchsten Beitrag ausrechnen.
Die Differenz a-a0 wĂ€re dann der umgerechnete Wert, um den das Seil verstellt werden muß.
(Fortsetzung folgt voraussichtlich morgen)

Hallo jurs,
Danke schon wieder :wink:
Ich hab dir mal n Bild angehÀngt, wie die Koordinaten aussehen.
Das wĂŒrde ja bedeuten, das ich dann wirklich fĂŒr jeden einzelnen Punkt, der angefahren wird, die Koordinaten Ă€ndern mĂŒsst?!
So sehen sie aus, damit man die nicht rausschreiben muss.

G00 Z2.000000
G00 X45.181447 Y-21.101924

G01 Z2.000000 F100.0(Penetrate)
G01 X44.534150 Y28.481148 Z2.000000 F400.000000
G01 X63.305812 Y28.481148 Z2.000000
G01 X66.024464 Y19.289507 Z2.000000
G01 X63.046893 Y12.169226 Z2.000000
G01 X50.100919 Y12.169226 Z2.000000
G01 X64.988788 Y-22.267078 Z2.000000
G01 X46.087665 Y11.651377 Z2.000000
G01 X45.181447 Y-21.101924 Z2.000000
G00 Z2.000000

LG

bluebravo:
Das wĂŒrde ja bedeuten, das ich dann wirklich fĂŒr jeden einzelnen Punkt, der angefahren wird, die Koordinaten Ă€ndern mĂŒsst?!

Ja, mindestens. Wenn nicht noch mehr.
Eventuell musst Du sogar noch zusĂ€tzliche StĂŒtzpunkte zwischen den vorhandenen Punkten interpolieren und hinzufĂŒgen.
Nur am Koordinatenursprung (0|0) muss nicht umgerechnet werden, da sind die Werte identisch gleich mit 0.

Im einzelnen; Ein V-Plotter Àndert genau so zwei Werte wie ein XY-Plotter,
Beim XY-Plotter sind es der Rechtswert X und der Hochwert Y.
Beim V-Plotter nenne ich die SeillĂ€ngenĂ€nderung mal da und db (fĂŒr "Delta a" und "Delta b").

Die Koordinatensysteme kannst Du ĂŒbereinanderlegen, so dass in der Bildmitte am Koordinatenursprung (und nur dort!) gilt
x = y = da = db = 0

D.h. die xy-Koordinate am Koordinatenursprung entspricht C(0|0) und die da/db-Koordinate ebenfalls.

Es gibt also zwei Werte, die jeweils in den Plus- und den Minusbereich gefahren werden, soweit ist es mit XY- und V-Plotter gleich. Nicht gleich ist allerdings die LinearitÀt: Beim XY-Plotter liegen zwischen C1(100|100) und C2(100|200) exakt 0mm Differenz in x-Richtung und 100 mm in y-Richtung, und das ist zwischen C2(100|200) und C3(100|300) genau so der Fall.

Beim V-Plotter sind die Seildifferenzen da und db zwischen den Punkten C1 und C2 bzw. C2 und C3 NICHT dieselben. Der Plotter hat nichtlineare Achsen. Wenn Du zwischen C1 und C2 mit einem XY-Plotter eine Linie plottest, ist es eine gerade Strecke. Aber machst Du das mit dem V-Plotter, dann werden es zwischen den Punkten jeweils leicht gekrĂŒmmte Parabelabschnitte.

D.h. wenn Du mit dem V-Plotter zwei weit entfernte Punkte anfÀhrst und beide Stellmotoren linear verfÀhrst, wird es auf dem V-Plotter eine Kurve und keine Gerade. Je weiter zwei Punkte auseinander liegen, desto krummer wird es.

Aber zurĂŒck zur Ausgangsfrage, wie und wo Du es im Programm einbauen kannst. Ich sehe da zwei Möglichkeiten:

  1. Möglichkeit: Umrechnen nach dem Einlesen der Daten
  2. Möglichkeit: Umrechnen der Datei mit vorherigem Erzeugen einer umgerechneten Datei

Das mußt Du sehen, wie es besser passt. Wenn Du zum Steuern eine Library verwendest, mĂŒĂŸtest Du Dir heraussuchen, wo die X- und Y-Werte eingelesen werden und könntest diese dann nach dem Einlesen direkt umrechnen. So dass die Library dann zwar X und Y Werte einliest, aber da und db Seilwerte plottet.

Die andere Möglichkeit wĂ€re, die Datei vorab zu verarbeiten: Vorhandene Datei einlesen, X- und Y-Werte umrechnen und umgerechnete Werte in eine andere Datei (z.B. mit anderer Dateiendung) zurĂŒckschreiben. Die verabeitende Library braucht dann nicht geĂ€ndert zu werden, man fĂŒttert sie einfach mit der vorher umgerechneten Datei.

jurs:

bluebravo:
Das wĂŒrde ja bedeuten, das ich dann wirklich fĂŒr jeden einzelnen Punkt, der angefahren wird, die Koordinaten Ă€ndern mĂŒsst?!

Ja, mindestens. Wenn nicht noch mehr.

Wenn du was aus Geraden Linien zeichnen willst, hat dein Arduino eben Pech: Wie jurs schon angedroht hat: Wenn die Schrittmotoren mit konstanter Sechwindigkeit fahren, macht ein xy-Plotter gerade Linien, deiner aber schöne Bögen.
Meine Idee: wÀhrend die Motoren einen Schritt machen (oder warten, dass der andere seinen Schritt gemacht hat) , hat der Arduino genug Zeit, den nÀchsten Schritt auszurechnen.

Mal sehen wie jurs Kurs "Angewandte Realschulgeometrie" weitergeht. Ich bin gespannt, auch wenn ich eigentlich so einen V-Plotter bisher nie wirklich gebraucht habe. :wink:

Nachdem ich gestern die Berechnung der LÀnge a0 hergeleitet habe, zwischen Seilpunkt B und dem Koordinatenursprung 0, folgt heute nun die Berechnung der LÀngen a und b in AbhÀngigkeit von den rechtwinkligen Koordinaten x und y.

Einfach zwei weitere Striche in der Zeichnung hinzugefĂŒgt und die Punkte E und F dazugemalt, und schon haben wir zwei neue rechtwinklige Dreiecke, mit denen wir rechnen können.

Dreieck BEC und Dreieck CFA

Zuerst zum Dreieck BEC und dessen Seiten:
Strecke BE = yB-y (erste kurze Seite)
Strecke EC = xB+x (zweite kurze Seite)
Strecke BC = a (die gesuchte SeillÀnge a als lange Seite)

Pythagoras zum Dreieck BEC:
a2 = (xB+x)2 + (yB-y)2

SeillÀnge a:
a = sqrt((xB+x)2 + (yB-y)2) ==> “a-Formel”

Danach das Dreieck CFA und dessen Seiten
Strecke CF = xA-x (erste kurze Seite)
Strecke FA = yA-y (zweite kurze Seite)
Strecke AC = b (die gesuchte SeillÀnge b als lange Seite)

Pythagoras dazu:

b2 = (xA-x)2 + (yA-y)2

SeillÀnge b:
b= sqrt((xA-x)2 + (yA-y)2) ==> “b-Formel”

FĂŒr die VerĂ€nderung der LĂ€nge a-a0 definiere ich die Variable “da” (“da” fĂŒr “Delta a”):
da = a-a0

FĂŒr die VerĂ€nderung der LĂ€nge b-b0 definiere ich die Variable “db” (“db” fĂŒr “Delta b”):
db = b-b0

Die Werte a und b werden wie in diesem Beitrag beschrieben berechnet, die Werte a0 und b0 wie im Beitrag gestern beschrieben. Differenz bilden und man hat die Werte da und db, die man anstelle von x und y zum Verstellen verwenden muss.

Das ganze noch in eine Arduino-Funktion “calc_ab” gegossen und die Koordinaten der Seilrollen als Konstanten definiert:

// V-Plotter calculations by 'jurs' for German Arduino Forum
// Details: http://forum.arduino.cc/index.php?topic=226277.0

#define XB 500.0
#define XA XB
#define YB 600.0
#define YA YB

void calc_ab(float x, float y, float &da, float &db)
{
  // db = b - b0
  db= sqrt((XA-x)*(XA-x) + (YA-y)*(YA-y)) - sqrt(YA*YA+XA*XA);
  // da = a - a0
  da= sqrt((XB+x)*(XB+x) + (YB-y)*(YB-y)) - sqrt(YB*YB+XB*XB);
}

void plotPunkt(float x, float y)
{
  float da, db;
  calc_ab(x,y,da,db);
  Serial.print("x=");Serial.println(x);
  Serial.print("y=");Serial.println(y);
  Serial.print("da=");Serial.println(da);
  Serial.print("db=");Serial.println(db);
  Serial.println();
}


void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  float x,y;
  plotPunkt(-100,-100);
  plotPunkt(100,-100);
  plotPunkt(100,100);
  plotPunkt(-100,100);
}

void loop() {
}

Und schon kann man aus rechtwinkligen x-y-Plotterwerten die schiefwinkligen V-Plotterwerte da und db errechnen und die Umrechnungsfunktion in einem Sketch verwenden.

Hallo jurs,
Ich kann dir garnicht so viel Karma geben, wie ich es gerne wĂŒrde.
Ich hab da aber noch eine frage: Hast du dir die GRBL Software runtergeladen und angesehen?
Hier nochmal der Link zu der Seite GitHub - grbl/grbl: An open source, embedded, high performance g-code-parser and CNC milling controller written in optimized C that will run on a straight Arduino
Kann man das da nicht irgendwie, Irgendwo einbauen?
Ein ganz großes DANKE auch fĂŒr den Arduino Code!

Mfg

bluebravo:
Ich kann dir garnicht so viel Karma geben, wie ich es gerne wĂŒrde.

Danke fĂŒr die großartige Anerkennung!

bluebravo:
Ich hab da aber noch eine frage: Hast du dir die GRBL Software runtergeladen und angesehen?
Hier nochmal der Link zu der Seite GitHub - grbl/grbl: An open source, embedded, high performance g-code-parser and CNC milling controller written in optimized C that will run on a straight Arduino
Kann man das da nicht irgendwie, Irgendwo einbauen?

Ich habe mir den Code mal angesehen. Und auch, was die G-Code Daten eigentlich sind.

Offenbar ganz etwas anderes als HPGL-Daten, d.h. da sind nicht nur die zu plottenden XY-Werte in den Daten enthalten, sondern auch höhere Geometriedaten wie z.B. Kreisbogenbeschreibungen, die dann erst noch interpretiert werden mĂŒssen. An den G-Code Daten, mit denen Dein Plotter gefĂŒttert wird, kann man also nicht so einfach ansetzen. Die Kreisbögen wĂŒrden sich einer Umrechnung entziehen.

Nachdem ich mal in den Code geschaut habe, kommt fĂŒr eine Umrechnung der Koordinaten wohl die Datei "planner.c" in Frage und dort die Funktion "plan_buffer_line". Das scheint die Funktion zu sein, in der die Koordinaten in Steps fĂŒr die Stepper-Motoren umgerechnet werden. Und dort könnte man am Anfang der Funktion, bevor die Umrechnung in Stepper-Schritte erfolgt, noch die Umrechnung der Koordinaten einfĂŒgen.

Statt Code in Datei planner.c:

void plan_buffer_line(float x, float y, float z, float feed_rate, uint8_t invert_feed_rate) 
{
  // Prepare to set up new block
  block_t *block = &block_buffer[block_buffer_head];

  // Calculate target position in absolute steps
...

Da tue ich mal so als wenn die Funktion noch gar nicht die richtigen Koordinaten ĂŒbergeben bekommt, sondern falsche Koordinaten, die ich mal xx und yy nenne und dann erst in X- und Y- umrechne (die hergeleiteten Werte fĂŒr da und db), womit dann die Stepper-Schritte ermittelt werden:

Setze Code in Datei planner.c:

// V-Plotter calculations by 'jurs' for German Arduino Forum
// Details: http://forum.arduino.cc/index.php?topic=226277.0

#define XB 500.0
#define XA XB
#define YB 600.0
#define YA YB

void calc_ab(float x, float y, float &da, float &db)
{
  // db = b - b0
  db= sqrt((XA-x)*(XA-x) + (YA-y)*(YA-y)) - sqrt(YA*YA+XA*XA);
  // da = a - a0
  da= sqrt((XB+x)*(XB+x) + (YB-y)*(YB-y)) - sqrt(YB*YB+XB*XB);
}

void plan_buffer_line(float xx, float yy, float z, float feed_rate, uint8_t invert_feed_rate) 
{
  // Prepare to set up new block
  block_t *block = &block_buffer[block_buffer_head];
  float x,y;
  calc_ab(xx, yy, x, y);
  // Calculate target position in absolute steps
...

FĂŒr die Geometriedaten Deines V-Plotters mĂŒĂŸtest Du dann natĂŒrlich Deine tatsĂ€chlichen Werte fĂŒr XA und XB direkt in die Library-Datei einsetzen, so dass die geĂ€nderte Library dann nur fĂŒr Deine V-Plotter-Abmessungen verwendbar ist. Am besten sicherst Du Dir die Originaldatei, bevor Du sie fĂŒr Dich verĂ€nderst.

Ob das die optimale Stelle zum Patchen der Library ist und ob das wirklich alles ist, was gemacht werden mĂŒĂŸte und ob es ĂŒberhaupt so funktioniert, mĂŒĂŸtest Du mal ausprobieren. Ich kann es hier bei mir nicht testen, ich habe keinen V-Plotter.

Du kannst ja mal posten, wie es dann mit diesem Patch aussieht.

Die große Anerkennung steht dir ja auch zu.
FĂŒr dich ist das vielleicht alles einfach, aber fĂŒr einen RealschĂŒler, der schon lange aus der Schule raus ist und Elektroinstallation gelehrnt hat, ist das schon n riesen neues Gebiet.

Ich hab die planner.c Datei jetzt mal geÀndert, ich hoffe richtig. Ist im Anhang.
In dem Bild hab ich XA und XB mal bemessen.

Jetzt mal angenommen, ich habe die planer Datei richtig geÀndert, wie bekomm ich dann alles,also alle Datein, die da mit in dem Ordner sind in eine .hex Datei?

Dann ist mir ebend noch was eingefallen.
Undzwar, wenn ich im gcode sender (also dem Programm) einen X-Schritt mache, fÀhrt ja nur ein Motor.
MĂŒsste da nicht eigentlich dann der linke Motor einen Schritt vorwĂ€rts machen und gleichzeitig der rechte einen zurĂŒck, um eine gerade X-Linie zu machen?
Oder habe ich da einen Denkfehler?

MfG

planner.h (4.53 KB)

bluebravo:
Ich hab die planner.c Datei jetzt mal geÀndert, ich hoffe richtig. Ist im Anhang.
In dem Bild hab ich XA und XB mal bemessen.

Da fehlt noch der Y-Wert.

Und Vorsicht: Zentimeter ist ein Maß fĂŒr Handwerker auf dem Bau. Fraglich, ob Zentimeter richtig ist.
Meine Vermutung: Die Einheit fĂŒr Deinen Plotter lautet eher Millimeter.
Du mußt XA und XB in derselben Einheit angeben, die fĂŒr die Daten in Deiner G-Code Plotdatei verwendet wird. D.h. wenn in der Plotdatei x und y in Zentimeter stehen, mußt Du XA in Zentimeter angeben, wenn in der Plotdatei Millimeter fĂŒr x und y stehen, mußt Du XA in Millimetern angeben, und wenn in der Plotdatei x und y in Inches angegeben sind, mußt Du XA in Inches angeben.

bluebravo:
Jetzt mal angenommen, ich habe die planer Datei richtig geÀndert, wie bekomm ich dann alles,also alle Datein, die da mit in dem Ordner sind in eine .hex Datei?

Ich denke, Du hast die Library bereits in Deiner Arduino-Software installiert und das Programm fĂŒr Deinen V-Plotter selbst kompiliert, oder woher kommt das Arduino-Programm, mit dem Du den verdrehten und verzerrten Probeausdruck gemacht hast?

Dann brauchst Du jetzt eigentlich nur:

  • Arduino-Software beenden
  • die Library.Datei mit einem geeigneten Editor bearbeiten (z.B. unter Windows mit Wordpad.exe)
  • Arduino-Software neu starten, Programm neu kompilieren und hochladen

bluebravo:
Dann ist mir ebend noch was eingefallen.
Undzwar, wenn ich im gcode sender (also dem Programm) einen X-Schritt mache, fÀhrt ja nur ein Motor.
MĂŒsste da nicht eigentlich dann der linke Motor einen Schritt vorwĂ€rts machen und gleichzeitig der rechte einen zurĂŒck, um eine gerade X-Linie zu machen?
Oder habe ich da einen Denkfehler?

Die notwendige Umrechnung der Kinematik macht die gepatchte Library.
Du sendest wie bisher XY-Plotterdaten.
Die gepatchte Library rechnet dann die XY-Plotterdaten auf V-Plotterdaten um
Und steuert die Motoren entsprechend.
So dass beim Verfahren auf der X-Achse beide Motoren angesteuert werden.
Und beim Verfahren auf der Y-Achse ebenfalls.
Aber nur, wenn das Steuerprogramm mit der gepatchten Library kompiliert und auf den Arduino geladen wird.

Schau Dir das am besten mal an, was mit dem geĂ€nderten Programm geplottet wird. Bitte darauf achten, dass XB und YB als Zahlwert im richtigen Massstab eingegeben werden (vermutlich Millimeter und nicht Zentimeter), und dann mĂŒĂŸte man mal sehen, ob es das war oder ob noch nachgearbeitet werden muß.

Also ich hab jetzt mal gemessen und die Werte geÀndert.
XA=XB = 330mm
YA=YB = 660mm

In Inkscape mache ich auch alles in mm.

Und Vorsicht: Zentimeter ist ein Maß fĂŒr Handwerker auf dem Bau

^^ genau da komm ich her :wink:

FĂŒr den Arduino hab ich keine Library, ich habe von der github Seite die fertige .hex Datei fĂŒr GRBL runtergeladen.
Die 0.8c (findest du, wenn du weiter runter Scrollst).
Und die habe ich dann mit dem ArduinoUnoUploaderTool rlangoy/Arduino-Uno-Uploader-Tool @ GitHub
auf den Arduino geflasht.

Im Anhang sind noch mal die planner.c und das Bild mit den Daten.

Ich glaube ich hab schon ne möglichkeit gefunden, die Datein wieder in ne .hex zu bekommen. Kann ich mir aber erst morgen angucken.
Da werde ich mich dann nochmal zu Ă€ußern.

Weil, wenn ich die planner.c Àndere, muss ja die ganze .hex bzw grbl software neu Kompiliert werden. Oder versteh ich da was falsch?

MfG

planner.c (25.1 KB)