Wie programmiert man nun sowas?
Nun, ich programmiere sowas in C, weil ich finde, daß C von der Logik her die beste Programmiersprache ist.
Sie ist zwar veraltet, was die Features angeht, und der devc++ Compiler ist "old and buggy", aber die Programme laufen hervorragend. Man hat nur keine grafische Ausgabe. Das erreicht man, indem man den errechneten Code in ISO-Code umformt und der Maschinensteuerung vorsetzt. Dann hat man den ISO-Code in 3D auf dem Bildschirm.
So, jetzt mal zur Programmierung, c-Programm in Auszügen:
// Fräsung einer Steigung in ein Außenrohr zur Bewegung des Magnetkolbens
char buffer[80];
std::ofstream out ("2010_magnet.tap"); // Datei anlegen und zum Schreiben öffnen
for (int i=0;i<anz_schritte;i++)
{
schlepp_y=schlepp_y+strecke_y/anz_schritte*1.0; // y = lineare Bewegung
x1=exp(i);
// falsch //
richtig x1=exp(1+i*steilheit); //
Der Faktor Steilheit dämpft die E-Funktion wie gewünscht x1=1/x1; // Kehrwert bilden
// x Reihenfolge umkehren:
xy_data[anz_schritte-i-1].x=x1; xy_data[i].y=schlepp_y;// Werte ablegen
} //Zählschleife 1
korrekturwert=steigung_x/xy_data[anz_schritte-1].x;
Wir sehen den Kommentar //falsch. Das ist die ungehemmte e-Funktion, aus dem ersten Bild. Die können wir nicht benötigen, wir müssen die Funktion überlagern, also dämpfen. Dazu gibt es mathematisch unendlich viele Möglichkeiten, ich habe hier eine sehr einfache Variante gewählt, um von Bild1 auf Bild 2 zu gelangen, nämlich
// richtig x1=exp(1+i*steilheit); // Der Faktor entspricht der Steigung
Wir erhöhen also den exponenten zur Eulerschen Zahl (=E-Funktion) nicht mit der Zählschleife jeweils um 1, sondern nur um einen Bruchteil von 1. Das drücken wir aus mit dem Produkt aus den 1*Steilheit. Die Steilheit hat in dem zweiten Bild, was schon der Absicht sehr nahe kommt, den Wert 0.02, also zwei Hunderstel. Man kann damit experimentieren, bis man den richtigen Wert gefunden hat.
Ich habe in Bild 2 nur 300 Programmschritte gewählt. Man kann natürlich auch 500.000 g1-Befehle schreiben, indem man einfach die Konstante anz_schritte von 300 auf 500.000 setzt. Die Mach3 Steuerung frißt auch ohne weiteres soviele Programmzeilen. Es ist natürlich unsinnig, die G1-Befehle von der Schrittweite her kleiner zu legen als die mechanische Auflösung der Maschine zuläßt. Bzw. sieht man es ja am fertige Werkstück, ob die Auflösung "paßt".
Wir erhalten die Progression als Kehrwert des Exponenten, nur die Reihenfolge ist verkehrt, daher weisen wir die Werte für die x-Koordinate in umgekehrter Reihenfolge ein nach dem bekannten Spruch aus der Bibel: die Ersten werden die Letzten sein.
Wir müssen nun die Progression noch mit einem Korrekturwert beschicken, damit wir in x am Ende die gewünschte Gesamtsteigung von 30 mm haben. Der Korrekturwert errechnet sich aus der Division der Gesamtsteigung absolut durch den letzten ermittelten Wert in x, also:
korrekturwert=steigung_x/xy_data[anz_schritte-1].x;
Hier werden die Werte damit beschickt:
for (int i=0;i<anz_schritte;i++)
{
xy_data[i].x=xy_data[i].x*korrekturwert*(-1);
} // Zählschleife 2
Wie erzeugen wir nun den ISO-Code?
Das sieht man hier (das Programm ist wirklich ganz winzig, dauert wenige Minuten, sowas zu programmieren, zeitaufwendig ist die Modellation des Grafen, bis er paßt):
Wir schreiben quasi mit der Hand die ersten beiden Befehle:
1. Z-Sicherheitshöhe
2. Gehe Nullpunkt aber bleibe in y etwas weg, damit bei der ersten Zustellung in x kein Querversatz entsteht.
// Datei schreiben
sprintf(buffer,"G0 Z20 \n");out<<buffer; //
1. datensatz der ISO-Datei sprintf(buffer,"G0 X0 Y-6 \n");out<<buffer; // in y Abstand lassen vom Startpunkt
for (int i=0;i<anz_schritte;i++)
{
//die Koordinaten in ISO-Code umformen:
sprintf(buffer,"N%4i G1 X%8.4f Y%8.4f \n",i+1, xy_data[i].x,xy_data[i].y);
out<<buffer; // in datei ablegen
} // Zählschleife 3
sprintf(buffer,"G1 Y%8.4f \n",strecke_y+6);out<<buffer; // Die "Sicherheitsrast 6mm"
sprintf(buffer,"M30 \n");out<<buffer; //
eigentlich letzter datensatz der ISO-Datei sprintf(buffer,"(Ende der Datei) \n"); out<<buffer; /
/nur zur Lese-Sicherheit noch drangehängt }; // Funktion
Dann folgt die Umformung der Koordinaten in G1-Befehlen. Diese sind wie folgt deklariert:
{ double x, y; };
xy_koordinaten xy_data[anz_schritte];
Es wird also Speicherplatz bereitgestellt abhängig von der gewünschten Anzahl der Datensätze = anz_schritte.
Die Programmierung der Z-Werte erspare ich hier dem geneigten Leser, kann sie bei Interesse aber nachreichen.
Zum Schluß schreiben wir mit der Hand die M30 rein und eine letzte Textzeile (Ende der Datei), damit der Mach-3Kontroller nicht vergißt, den letzten Datensatz auch zu fressen.
Wie sieht die Datei dann aus?
Dateianfang:
G0 Z20
G0 X0 Y-6
N 1 G1 X -0.0759 Y 0.1333
N 2 G1 X -0.0774 Y 0.2667
N 3 G1 X -0.0790 Y 0.4000
N 4 G1 X -0.0806 Y 0.5333
N 5 G1 X -0.0822 Y 0.6667
N 6 G1 X -0.0838 Y 0.8000
N 7 G1 X -0.0855 Y 0.9333
N 8 G1 X -0.0873 Y 1.0667
N 9 G1 X -0.0890 Y 1.2000
N 10 G1 X -0.0908 Y 1.3333
N 11 G1 X -0.0927 Y 1.4667
N 12 G1 X -0.0945 Y 1.6000
...
Dateiende:
N 292 G1 X-25.5643 Y 38.9333
N 293 G1 X-26.0807 Y 39.0667
N 294 G1 X-26.6076 Y 39.2000
N 295 G1 X-27.1451 Y 39.3333
N 296 G1 X-27.6935 Y 39.4667
N 297 G1 X-28.2529 Y 39.6000
N 298 G1 X-28.8237 Y 39.7333
N 299 G1 X-29.4060 Y 39.8667
N 300 G1 X-30.0000 Y 40.0000
G1 Y 46.0000
M30
(Ende der Datei)
Wie gesagt, um hier keine Verwirrung zu stiften, hab ich die Programmierung der Z-Werte (wenn der Fräser um das feststehende Rohr herumläuft) zunächst mal weggelassen. Im Prinzip geht das auch mit gleichmäßiger Absenkung in Z, sieht allerdings nicht so elegant aus.
Gruß Sharky
Der Beitrag wurde von sharky bearbeitet: 27.05.2010, 17:26 Uhr