Zentraler Steuerungsalgorithmus für ein 3-Achs-CNC-Bearbeitungszentrum: Unterschied zwischen den Versionen
| Zeile 3: | Zeile 3: | ||
===Einleitung=== | ===Einleitung=== | ||
Das | Das Praktikum Produktionstechnik ist eine Veranstaltung des Mechatronikstudienganges im siebten Semester unter Leitung von Professor Dr.-Ing Mirek Göbel. | ||
In diesem Praktikum wird das Ziel verfolgt eine 3D-Bearbeitungsmaschine zu entwickeln und zu bauen. | |||
In diesem Kapitel wird ein zentraler Steuerungsalgorithmus erstellt und beschrieben. | |||
Mittlerweile wird dieser Algorithmus im dritten Semester fortlaufend bearbeitet und erweitert. | |||
Angefangen von [[Benutzer: Lukas Hurrelmeyer| Lukas Hurrelmeyer]] und [[Benutzer: Tim Menke| Tim Menke]] (WS 13/14), [[Benutzer: Fabian Bokel| Fabian Bokel]] und [[Benutzer: Mathias Tanger| Mathias Tanger]] (WS 14/15) wurde es nun von [[Benutzer: Lars Osthoff| Lars Osthoff]] (WS 15/16) fortgeführt. | |||
=== Aufgabenstellung === | === Aufgabenstellung === | ||
Version vom 11. Februar 2016, 07:50 Uhr
Einleitung
Das Praktikum Produktionstechnik ist eine Veranstaltung des Mechatronikstudienganges im siebten Semester unter Leitung von Professor Dr.-Ing Mirek Göbel. In diesem Praktikum wird das Ziel verfolgt eine 3D-Bearbeitungsmaschine zu entwickeln und zu bauen. In diesem Kapitel wird ein zentraler Steuerungsalgorithmus erstellt und beschrieben. Mittlerweile wird dieser Algorithmus im dritten Semester fortlaufend bearbeitet und erweitert. Angefangen von Lukas Hurrelmeyer und Tim Menke (WS 13/14), Fabian Bokel und Mathias Tanger (WS 14/15) wurde es nun von Lars Osthoff (WS 15/16) fortgeführt.
Aufgabenstellung
Die Aufgabe des Steuerungsalgorithmus soll es sein, aus einer CAM-Datei die benötigten Informationen zu lesen um damit Sollbahnen des Fräsers zu generieren und die Achsen der Maschine so anzusteuern, dass das CAD-Modell Maßstabsgetreu erzeugt wird.
Um den Umfang der Aufgabe übersichtlicher zu machen haben wir die Aufgabe in fünf Phasen unterteilt.
- In Phase eins soll eine manuelle Verfahrweise der Maschine erstellt werden, um einen ersten Einstieg zu bekommen und den möglichen Signalfluss zu testen. Dazu sollen von Hand die Koordinaten jeder Achse eingestellt und diese dann auf einen Befehl an die Maschine gesendet werden. Dies soll als Grundgerüst für alle weiteren Arbeiten an dem Steuerungsalgorithmus dienen.
- Wenn das Versenden einzelner Koordinaten gelingt, wird in Phase zwei die Umsetzung einer mit Excel erstellten Probesollbahn angestrebt. Hier soll ein möglichst schnelles Versenden der Koordinaten an die Maschine erreicht werden.
- In Phase drei werden die Sollbahnen aus einer CAM-Datei generiert. Die Datei soll mit Hilfe von Matlab eingelesen werden. Der Inhalt muss vom Steuerungsalgorithmus immer richtig interpretiert werden, um ein maßstabsgetreues Erzeugnis zu erhalten.
- Wenn die Sollbahngenerierung funktioniert, müssen die Werkzeuge der Maschine (Frässpindel, Werkzeugmagazin) noch in den Steuerungsalgorithmus eingebunden werden. Es muss während des Bearbeitungsvorgangs unterschieden werden, ob der Fräser momentan im Eingriff ist oder nicht. Dies geschieht in Phase vier.
- Sollten diese Funktionen alle gegeben sein, wird in Phase fünf die komplette Automatisierung der Maschine angestrebt. Es muss dabei eine Überwachung der Achsen (Position erreicht/nicht erreicht, Störungen, …) eingebunden werden. Darüber hinaus müssen auch alle Endschalter und sonstige Sicherheitseinrichtungen mit in der Überwachung eingebunden werden.
Manuelle Verfahrweise
In den Überlegungen zur manuellen Ansteuerung der Achsen wurden verschiedene Methoden angedacht. Es gab die Idee, mit Hilfe eines Arduinos drei analoge Eingänge an denen je ein Potenziometer angeschlossen ist einzulesen. Die eingelesenen Werte repräsentieren dabei je eine Koordinate. Diese wären dann zu der definierten Koordinatenform (z.B. x00100y00125z00045e) zusammengefasst worden und als String über die serielle Schnittstelle an die Achsen versendet worden. Diese Idee wurde aber wegen mangelnder Flexibilität für spätere Aufgaben verworfen.
Für die manuelle Verfahrweise haben wir uns für eine mit Matlab erstellte grafische Benutzeroberfläche entschieden. Diese bietet den Vorteil, eines sehr einfachen Aufbaus. Es wird lediglich ein USB- Kabel für die Verbindung des PCs mit der entsprechenden Hardware an der Maschine benötigt.
Beim Start der grafischen Benutzeroberfläche wird mit einem Mausklick auf einen Pushbutton die serielle Kommunikation zwischen PC und der Hardware der Maschine gestartet. Danach kann mit der Maus über drei Slider die gewünschte Koordinate eingestellt werden. Diese wird zu Kontrolle der eigenen Einstellungen in einem Schriftfeld angezeigt. Durch einen Mausklick auf einen zweiten Pushbutton wird aus den drei einzelnen Koordinaten die oben erwähnte Koordinatenform gebildet und dieser String dann über die serielle Schnittstelle an die Achsen gesendet. Dieser Vorgang kann beliebig oft wiederholt werden. Mit einem Mausklick auf einen dritten Pushbutton wird die serielle Kommunikation mit den Achsen gestoppt und die grafische Benutzeroberfläche geschlossen.
Handhabung der grafischen Benutzeroberfläche
Für den Gebrauch der grafischen Benutzeroberfläche (GUI) müssen folgenden Vorraussetzungen erfüllt sein.
- Der PC muss über ein USB- Kabel mit der Achssteuerung an der Maschine (z.B. Arduino Mega) verbunden sein.
- Für eine serielle Verbindung müssen beide Geräte eingeschaltet sein.
- Der entsprechende COM- Port an dem die Achsteuerung angeschlossen ist, muss mit dem zu öffnenden COM- Port im Quellcode der GUI übereinstimmen. Die Nummer des COM- Ports kann im Gerätemanager des PCs eingesehen werden.
Wenn diese Bedingungen erfüllt sind kann eine serielle Kommunikation zwischen PC und Achssteuerung hergestellt werden.
Um die GUI zu öffnen, muss die entsprechende Matlab- Funktion unter der die GUI ausgeführt wird mit dem Befehl „run Dateiname“ im Command window von Matlab oder mit dem Runbutton direkt aus dem Editor von Matlab aufgerufen werden.
Nach dem Aufruf der Datei öffnet sich die GUI. Die GUI ist in drei Bereiche unterteilt.
- Im oberen Bereich befinden sich zwei Pushbutton zum Starten und Stoppen der seriellen Kommunikation bzw. schließen der GUI.
- Im mittleren Bereich befinden sich drei Slider für das manuelle Einstellen der Koordinaten der drei Achsen. Rechts neben den Slidern befindet sich auf gleicher Höhe je ein Schriftfeld, welche die aktuell eingestellt Koordinate anzeigt.
- Im unteren Bereich der GUI befindet sich ein weiterer Pushbutton, der bei einer Betätigung durch einen Mausklick die eingestellten Koordinaten an die Achsen der Maschine sendet.
Bevor eine Koordinate eingestellt und zur Maschine geschickt werden kann, muss die serielle Kommunikation gestartet werden. Dazu genügt ein Mausklick auf die grüne Schaltfläche mit der Aufschrift „Start“.
Nach einer vom Programm vorgegebenen Wartezeit zum Verbinden der Kommunikationspartner und zur Initialisierung der Achssteuerung werden die vorher ausgeblendeten Slider nun angezeigt. Mit einem Mausklick auf die Pfeile an den Enden der Slider kann der Wert um +1 oder -1 verstellt werden. Mit einem Mausklick rechts oder links vom Balken auf dem Slider kann der Wert um +100 bzw. -100 verstellt werden. Der Wert der Slider kann aber auch per drag and drop mit der Maus über die gesamte Breite der Slider verstellt werden.
Nachdem die Koordinaten eingestellt sind, können mit einem Mausklick auf der blauen Schaltfläche mit der Aufschrift „senden“ die Koordinaten an die Maschine verschickt werden.
Achtung:
Wenn der/die Benutzer/in die GUI nicht mehr verwenden möchte, so muss die GUI unbedingt mit einem Mausklick auf der roten Schaltfläche mit der Aufschrift „Stop“ beendet werden. Damit wird nicht nur die GUI geschlossen, sondern auch die Verbindung zu der Achssteuerung ordnungsgemäß getrennt.
Matlab Quellcode der grafischen Benutzeroberfläche
Die grafische Benutzeroberfläche (GUI) ist als eigene Matlabfunktion geschrieben worden. Die wichtigsten Inhalte im Quellcode werden hier Stück für Stück von oben nach unten erläutert.
Alle Erläuterungen finden Sie auch in der Matlab- Hilfe unter: Matlab/Functions/GUI Development
Am Anfang der Funktion werden die üblichen Befehle zum Löschen von Variablen, Schließen von offenen Fenstern und Bereinigen des Command windows ausgeführt. Danach werden drei Variablen angelegt, die den Wertebereich der Slider in der GUI festlegen.
%Einstellen des Wertebereichs der Slider
Max_Slider_x = 1000;
Max_Slider_y = 1000;
Max_Slider_z = 200;
In folgenden Schritt werden die Variablen "s" und "f" angelegt. "s" stellt hier die die Variable für die serielle Kommunikation und "f" die Variable der aktuellen figure dar.
%Definition des COM-Ports und der Größe und Position der figure
s = serial('COM7','baudrate',9600);
f = figure('Visible','off','Position',[360,500,500,400],'NumberTitle','off');
Der Befehl serial('COM7','baudrate',9600); stellt die serielle Kommunikation auf den COM-Port "COM7" mit einer Übertragungsrate von 9600 Bits pro Sekunde ein.
Der Inhalt der Klammer hinter figure stellt die Parameter für das Fenster der GUI ein. Es bleibt beim Start der Funktion noch unsichtbar, die Position der linken unteren Ecke des Fensters wird auf Pixel 360 vom linken Bildrand und 500 vom unteren Bildrand eingestellt, die Größe des Fensters wird mit 500 x 400 Pixel definiert und die Nummer in der Titelzeile des Fensters wird ausgeschaltet.
Die nun folgenden Zeilen im Quellcode sind lediglich Kosmetik für die GUI. Ihr Größter Nutzen besteht darin das Fenster sauber in drei Bereiche mit eigener Überschrift zu unterteilen.
%Panel für Slider, Anzeige und Beschriftungen
%Panel_1 stellt die Bedienelemente für die Sollwertvorgabe bereit
%Panel_2 stellt die Bediebelemente zum Starten und Stoppen der Seriellen
%Kommunikation bereit
%Panel_3 stellt den Pushbutton zum senden der Koordinaten an die Serielle
%Schnittstelle bereit.
Panel_1 = uipanel('Title','Sollwertvorgabe','Position',[0 .33 1 .33]);
Panel_2 = uipanel('Title','Kommunikation Starten/Stoppen','Position',[0 .66 1 .33]);
Panel_3 = uipanel('Title','Koordinaten senden','Position',[0 0 1 0.33]);
Die Variablen "Panel_1", "Panel_2" und "Panel_3" werden mit dem Befehl uipanel zu farblich vom Hintergrund abgehobenen Flächen mit eigenem Titel, definierter Größe und Position im Fenster.
Als Nächstes folgt der Aufbau einer der wichtigsten Komponenten der GUI. Hier werden die Slider für die Einstellung der Sollwerte bzw. der Soll-Koordinaten aufgebaut.
Der Aufbau erfolgt, indem einer Variablen mit dem Befehl uicontrol ein neues Bedienelement zugeordnet wird. Die Parameter in der Klammer dahinter haben folgende Bedeutung:
- Mit dem Parameter 'Parent' wird jeweils eines der oben angelegten Panels ausgewählt. Damit bleibt der Slider immer innerhalb dieses Panels.
- Der Parameter 'Style' mit dem nachfolgenden Befehl 'slider' bewirkt, dass das Bedienelement als Slider angelegt wird.
- Mit dem Parameter 'String' wird der Titel des Bedienelements festgelegt. In diesem Fall "XYZ-Achse".
- Mit dem Parameter 'Position' wird die Position im Panel und die Größe des Sliders bestimmt.
- Die Parameter 'Min' und 'Max' stellen den Wertebereich der Silder ein. Für den Maximalwert der Slider ist die oben angelegte Variable (z.B. "Max_Slider_x") wiederzufinden.
- Mit dem Parameter 'SliderStep' wird eingestellt wie die Wertänderung der Slider bei Betätigung der Pfeile und beim Klicken neben dem Balken ablaufen soll.
- Der Parameter 'Callback' definiert den Namen der Funktion, die ausgeführt werden soll, wenn eine Wertänderung am Slider vorgenommen wird.
%Aufbau der Slider
Achse_x = uicontrol('Parent',Panel_1,'Style','slider','String','X-Achse',...
'Position',[100,80,300,20],...
'Min',0,'Max',Max_Slider_x,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_x_callback});
Achse_y = uicontrol('Parent',Panel_1,'Style','slider','String','Y-Achse',...
'Position',[100,50,300,20],...
'Min',0,'Max',Max_Slider_y,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_y_callback});
Achse_z = uicontrol('Parent',Panel_1,'Style','slider','String','Z-Achse',...
'Position',[100,20,300,20],...
'Min',0,'Max',Max_Slider_z,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_z_callback});
Es folgen weitere Bedienelemente und Anzeigen die in Ähnlicher Weise wie die Slider aufgebaut und parametriert werden. Diese Elemente dienen der besseren Übersicht und zur Visualisierung der eingestellten Werte an den Slidern.
%Aufbau der Beschriftungen der Slider
text_1 = uicontrol('Parent',Panel_1,'Style','Text','String','X-Achse',...
'Position',[25,80,60,20]);
text_2 = uicontrol('Parent',Panel_1,'Style','Text','String','Y-Achse',...
'Position',[25,50,60,20]);
text_3 = uicontrol('Parent',Panel_1,'Style','Text','String','Z-Achse',...
'Position',[25,20,60,20]);
%Aufbau der Koordinatenanzeige
Koor_x = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,80,50,20],...
'BackgroundColor','w');
Koor_y = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,50,50,20],...
'BackgroundColor','w');
Koor_z = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,20,50,20],...
'BackgroundColor','w');
Die nun folgenden Bedienelemente werden zum Starten bzw. Stoppen der seriellen Kommunikation und zum Senden der Koordinate verwendet. Es wird hier für jede Funktion jeweils ein Pushbutton angelegt. Die Parametrierung erfolgt auf ähnliche Weise wie oben beschrieben.
%Aufbau der Bedienelemente zum Starten und Stoppen der Seriellen
%Kommunikation
Starten = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Start',...
'Position',[25,30,100,50],...
'BackgroundColor','green','FontWeight','bold','FontSize',10,...
'Callback',{@starten_callback});
Stoppen = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Stop',...
'Position',[150,30,100,50],...
'BackgroundColor','red','FontWeight','bold','FontSize',10,...
'Callback',{@stoppen_callback});
%Aufbau des Pushbuttons zum Senden der Koordinaten an die Serielle
%Schnittstelle.
Senden = uicontrol('Parent',Panel_3,'Style','Pushbutton','String','senden',...
'Position',[25,30,100,50],...
'BackgroundColor',[0.5 0.7 1],'FontWeight','bold','FontSize',10,...
'Callback',{@senden_callback});
Nach dem Aufbau der Bedienelemente wird die GUI nun Initialisiert. Dazu wird mit dem Befehl set, einem Vektor mit den benötigten Variablen als Inhalt, einem Parameter z.B. 'Units' und dem dazugehören Wert (hier 'normalized' ) die aktuellen Eigenschaften der Bedienelemente verändert.
%Initialisierung der GUI
set([f,Panel_1,Achse_x,Achse_y,Achse_z,...
text_1,text_2,text_3,...
Koor_x,Koor_y,Koor_z,...
Starten,Stoppen,...
Senden],...
'Units','normalized');
set(f,'Name','Sollwertvorgabe mit Slider')
movegui(f,'center')
set(f,'Visible','on');
set(Achse_x,'Visible','off');
set(Achse_y,'Visible','off');
set(Achse_z,'Visible','off');
set(Senden,'Visible','off');
Die weiteren Funktionen der Befehle sorgen dafür, dass das Fenster sichtbar ist und sich in der Mitte des Monitors befindet (movegui), dass das Fenster einen Namen bekommt und dass die Slider unsichtbar sind (zu welche Zweck wird später erklärt).
In den nun folgenden Zeilen befinden sich die Callback-Funktionen der Slider, des Startbuttons und des Stopbuttons. Jede Callback-Funktion ist wie eine normale Funktion in Matlab aufgebaut. Sie starten mit function, dem Funktionsnamen und den Inputargumenten in Klammern dahinter. Da es sich hier um Callback-Funktionen von Bedienelementen einer Benutzeroberfläche handelt, müssen als Inputargumente source und eventdata eingetragen werden um die Funktion zu ermöglichen. Das Inputargument source repräsentiert dabei die Werte des Sliders.
Innerhalb der Callback-Funktionen der Slider wird mit dem Befehl get aus source der aktuelle Wert des Sliders entnommen. Dieser Wert wird standardmäßig als Datentyp double ausgeführt. Da wir aber ausschließlich mit positiven ganzen Zahlen arbeiten wollen, wird dieser Wert in einen 16 bit integer umgewandelt. Dieser wird anschließend von einer Zahl in einen String umgewandelt. Der Zahlenwert wird zu Schluss der Callback-Funktion in dem neben dem Slider befindlichen Schriftfeld angezeigt.
Die Callback-Funktion des Startbuttons bewirkt bei Ausführung, dass die serielle Schnittstelle mit fopen(s) geöffnet wird, eine Systempause von sieben Sekunden erfolgt und dass die Slider und der Sendenbutton nach der Pause sichtbar sind.
Die Callback-Funktion des Stopbuttons bewirkt bei Ausführung, dass die serielle Schnittstelle geschlossen wird (fclose(s)), das die Variable der seriellen Schnittstelle gelöscht wird (delete(s), clear s) und nach einer Pause von zwei Sekunden das Fenster geschlossen wird (close(f)).
%Slider-Callbackfunktionen
function achse_x_callback(source,eventdata)
I = get(source,'Value');
Koordinate = int16(I);
Wert = num2str(Koordinate);
set(Koor_x,'String',Wert);
end
function achse_y_callback(source,eventdata)
I = get(source,'Value');
Koordinate = int16(I);
Wert = num2str(Koordinate);
set(Koor_y,'String',Wert);
end
function achse_z_callback(source,eventdata)
I = get(source,'Value');
Koordinate = int16(I);
Wert = num2str(Koordinate);
set(Koor_z,'String',Wert);
end
%Pushbutton-Callbackfunktionen für Serielle Kommunikation.
function starten_callback(source,eventdata)
fopen(s);
pause(7);
set(Achse_x,'Visible','on');
set(Achse_y,'Visible','on');
set(Achse_z,'Visible','on');
set(Senden,'Visible','on');
end
function stoppen_callback(source,eventdata)
fclose(s);
delete(s);
clear s;
pause(2);
close (f);
end
Die Callback-Funktion des Sendenbuttons beinhaltet einige Zeil mehr. Deshalb wird diese separat behandelt.
Um den String der drei eingestellten Koordinaten in die definierte Form zu bringen, werden zuerst drei Grundvariablen (XKoor, YKoor, ZKoor) als String mit dem Inhalt 00000 angelegt. In nächsten Schritt werden die aktuell eingestellten Werte aus den Slidern ausgelesen und vom double Datentyp in einen 16 bit integer umgewandelt (x, y, z). Danach wird diese Zahl mit dem Befehl num2str in einen String umgewandelt (xchar, ychar, zchar). Das ist nötig, damit aus den nun als String gespeicherten Zahlen später die definierte Koordinatenform hergestellt werden kann.
Im anschließenden Schritt werden die drei Strings der Grundvariablen mit der Strings der umgewandelten Werte überschrieben. Dazu wird die Länge der Wertestrings (xchar, xchar, zchar) bestimmt, von der festen Zahl 5 subtrahiert und mit eins addiert und das Ergebnis in einer Variable (jx, jy, jz) gespeichert. Die dann folgenden drei for-Schleifen überschreiben elementweise die Grundvariablen mit den umgewandelten Werten, beginnend mit der ersten Stelle der Wertestrings.
Zum Ende der Funktion werden die drei Wertestrings in einem Vektor zu der definierten Koordinatenform zusammengefügt und in der Variablen zusenden abgelegt. Diese wird im Command window angezeigt und mit dem Befehl fprintf(s,zusenden) an die serielle Schnittstelle versandt. Die Gesamtkoordinate wird als ASSCII-Zeichkette gesendet.
%Pushbutton-Callbackfunktion zum senden der Koordinaten an die Serielle
%Schnittstelle.
function senden_callback(source,eventdata)
XKoor = '00000';
YKoor = '00000';
ZKoor = '00000';
x = int16(get(Achse_x,'Value'));
y = int16(get(Achse_y,'Value'));
z = int16(get(Achse_z,'Value'));
xchar = num2str(x);
ychar = num2str(y);
zchar = num2str(z);
jx = 5-length(xchar)+1;
jy = 5-length(ychar)+1;
jz = 5-length(zchar)+1;
for i=1:length(xchar)
XKoor(jx) = xchar(i);
jx = jx+1;
end
for i=1:length(ychar)
YKoor(jy) = ychar(i);
jy = jy+1;
end
for i=1:length(zchar)
ZKoor(jz) = zchar(i);
jz = jz+1;
end
zusenden = ['x',XKoor,'y',YKoor,'z',ZKoor,'e'];
disp(zusenden);
fprintf(s,zusenden);
end
end
Automatische Verfahrweise
Für die automatische Verfahrweise der Maschine haben wir uns ebenfalls für Matlab entschieden. Mit der Funktion "xlsread" lassen sich Excel-Tabellen einlesen, welche eine Sollbahn in Form von mehreren Koordinatenpaaren beinhalten können. Mit dem Ausführen sollen diese Koordinatenpaare Schritt für Schritt an die Hardware der Maschine übertragen werden. Hier ist wie bei der manuellen Verfahrweise nur ein USB-Kabel notwendig. Bei der Erstellung der Koordinaten muss beachtet werden, dass die Positionspaare möglichst eng gesetzt werden. Die Positionen müssen zu der gewählten Auflösung passen. Vorteilhaft ist ein Abstand von einer Längeneinheit zwischen den Positionen einer Achse, da sich so die zeitliche Verzögerung zwischen dem Versenden der Positionspaare optimal ausnutzen lässt. Bei einer Auflösung von beispielsweise 1mm darf die anschließend zu übermittelnde Position einer Achse um 1mm abweichen oder sich nicht ändern.
% s = serial('COM7','baudrate',9600); Variable für serielle Kommunikation
% Einlesen der x-y-Koordinaten aus Excel-Tabelle
xpos=xlsread('Koordinaten_einfach.xlsx','Tabelle1','b3:b23');
ypos=xlsread('Koordinaten_einfach.xlsx','Tabelle1','c3:c23');
%zpos=xlsread('Koordinaten_einfach.xlsx','Tabelle1','d3:d23');
n=21; %Anzahl Zeilen
A=zeros(n,3); %Erzeugung einer Matrix mit n Zeilen und 3 Spalten
A(:,1)=xpos; %Überschreiben der Matrix mit X-Positionsdaten
A(:,2)=ypos; %Überschreiben der Matrix mit Y-Positionsdaten
%A(:,3)=zpos; %Überschreiben der Matrix mit Z-Positionsdaten
figure(1);
plot(xpos,ypos)
xlabel('xpos')
ylabel('ypos')
%fopen(s);
for i=1:22
string = [A(i,1),A(i,2),A(i,3),'e']; %setzt String zusammen
%disp(string); %zeigt aktuellen String im Command-Window an
%fprintf(s,string); %string senden
pause(1); %Zeit für das Verfahren der Achsen
end
%fclose(s);
%delete(s);
%clear s;
Mit der Funktion "fopen" lassen sich in Matlab Textdateien einlesen, welche generierten G-Code enthalten. Mit Matlab lassen sich die Bestandteile des G-Codes sortieren, sodass Sollbahnen im Anschluss generiert werden können. Die Sollbahnen können anschließend an die Maschine übertragen werden.
clear all
% s = serial('COM7','baudrate',9600); Variable für serielle Kommunikation
fid=fopen('Viereck.txt'); %öffnet Textfile
tline=fgetl(fid);
A=cell(1,1); %erstellt Array mit einer Spalte
Mat=cell(100,6); %Erzeugt ein Aerray mit Nullen
i=1;
while ischar(tline) %prüft Jede Zeile auf char-Datentyp und liest die betroffene Zeile ein
%disp(tline) %zeigt aktuelle Zeile im Command Window
A{i,1}=tline; %überträgt aktuelle Zeile aus der Datei in i-te Zeile im Array A
i=i+1; %mit jeden Durchlauf wird i erhöht
tline=fgetl(fid);
end
fclose(fid); % schließt Textfile
Der G-Code ist nun eingelesen und kann mit Matlab bearbeitet werden. Vorrangig sind die enthaltenen Koordinaten, welche in ein neues Array einsortiert werden. Die Reihenfolge der Koordinaten wird dabei eingehalten.
% for j=1:22 % Zeile für Zeile
%
% Mat{j,1}=regexp(A{j,1},'\S*N0\S*','match'); % schneidet übereinstimmenden String aus
% end
for j=1:22
Mat{j,2}=regexp(A{j,1},'\S*X\S*','match');
end
for j=1:22
Mat{j,3}=regexp(A{j,1},'\S*Y\S*','match');
end
for j=1:22
Mat{j,4}=regexp(A{j,1},'\S*Z\S*','match');
end
for j=1:22
Mat{j,5}=regexp(A{j,1},'\S*G0\S*','match');
end
Hier müssen noch die aus den extrahierten Koordinaten kleinere Sollbahnen erzeugt werden Die generierten Koordinaten werden mit folgender for-Schleife verschickt:
%fopen(s);
for k=1:22
string = [Mat{k,2},Mat{k,3},Mat{k,4},'e']; % setzt String zusammen
%disp(string);
%fprintf(s,string); %string senden
pause(1); %Zeit für das Verfahren der Achsen
end
%fclose(s);
%delete(s);
%clear s;
% Befehle für die Serielle Kommunikation
% fopen(s); %eröffnet die Kommunikation
% fprintf(s,zusenden); %sendet Daten
% fclose(s); %schließt Kommunikation
% delete(s);
% clear s;
Automatisches Verfahren durch G-Code Auswertung WS14/15
Dieser Abschnitt beschäftigt sich mit der Arbeit von Fabian Bokel und Mathias Tanger. Aus den Vorgängerergebnissen wurde die Definition und Einbindung der Schnittstelle übernommen. Im folgenden wird der G-Code kurz erläutert und die Funktionsweise unseres Programms erläutert.
Automatisches Verfahren WS14/15 - G-Code Allgemein
G-Code ist eine allgemeine CNC-Maschinensprache, die nicht nur im professionellen, sondern auch immer mehr im Hobby-Bereich zum Einsatz kommt. G-Codes können von jeder CNC-Maschine verarbeitet werden und die Codes sind größtenteils identisch. Einzelne Hersteller wie z.B. Haidenhain oder Siemens haben den von der Din definierten Funktionsumfang jeweils noch um einige Befehle erweitert allerdings ohne gegebene Funktionen zu überschreiben. Der G- Code besteht aus Funktionsbefehlen, der der Maschine die als nächstes zu bearbeitenden Schritte übermittelt. Es gibt G-Funktionen und M-Funktionen. Die G-Funktionen sind Beispielsweise für die Verfahrwege, die Zyklen, Bahnkorrekturen, oder zur Ebenenauswahl zuständig. Die M- Funktionen regeln, Beispielsweise, das An- und Abschalten des Kühlwassers, werden aber auch für Werkzeugwechselfunktionen benötigt.
Übersicht über vorhandene G-Code Befehle.
Weitere Informationen zum Thema G-Code finden sich in der Online Bibliothek der Hochschule. Besonders in "Werkzeugmaschinen 4 Automatisierung von Maschinen und Anlagen" von Manfred Weck und Christian Brecher ab Kapitel 6.3 Buchlink[1].
Automatisches Verfahren WS14/15 - Einlesen der G-Code Datei
Zunächst werden Variablen Definiert, die Schnittstelle geöffnet und die Datei wird eingelesen.
clear
close all
DEBUG=0;
%Anlegen von Variablen
XKoor = '00000';
YKoor = '00000';
ZKoor = '00000';
VVelo = '00000';
X=0;
Y=0;
Z=0;
F=0;
J=0;
I=0;
zeile =0;
spalte=0;
Abbruch = 0;
%Definieren der Schnittstelle für die Kommunikation
s = serial('COM1','baudrate',9600);
% Öffnen der Textdatei
fid = fopen('new2.txt'); %Beispieldatei
%Öffnen der Schnittstelle
% fopen(s);
% pause(2);
Dann wird die Länge des G-Codes gesucht und die Zeilennummerierung wird abgeschnitten:
z=0; %Zeilendurchlauf
a = {}; % cell array;
tline = fgetl(fid);
%Auslesen der G-Code Datei
while ischar(tline)
z = z+1;
a{length(a)+1} = tline;
c = strsplit(a{1,z},' ');
for k=1:length(c)
%neue Formatierung der Parameter
Spaltenaufteilung{z,k} = c{k};
end
tline = fgetl(fid);
end
Nachdem die Größe jetzt bekannt ist, wird mit einer Switch-Case Anweisung nach G-Codes (lediglich nach dem Aufruf, nicht nach den Parametern) gesucht. Ein Funktionsaufruf der jeweiligen Unterfunktion erfolgt. Bis jetzt sind die Aufrufe für Eilgang, Geradeausfahrt und beide Kreisfunktionen vorhanden.
%Der konvertierte G-Code wird Spalten-Zeilenweise durchlaufen.
%Jeder G-Code Befehl bekommt einen eigenen Case
dimensionen=size(Spaltenaufteilung);
clear i;
for i_zeile=1:dimensionen(1)
zeile=zeile+1;
spalte=1;
for j_spalte=1:dimensionen(2)
%spalte=spalte+1;
Abbruch =0;
aktuell=Spaltenaufteilung{i_zeile,j_spalte};
if isempty(aktuell)==0;
switch(aktuell)
case 'G00' %Eilgang, maximale Verfahrgeschwindigkeit von Punkt A nach Punkt B
G00(i_zeile, zeile, j_spalte, spalte, Spaltenaufteilung, Abbruch, dimensionen, X, Y, Z)
case 'G01' %Geradeninterpolation mit Vorschub
G01(i_zeile, zeile, j_spalte, spalte, Spaltenaufteilung, Abbruch, dimensionen, X, Y, Z, F)
case 'G02' %Kreisinterpolation im Uhrzeigersinn (rechtsdrehend)
G02(s, i_zeile, zeile, j_spalte, spalte, Spaltenaufteilung, Abbruch, dimensionen, X, Y, Z, F, J, I);
case 'G02.2'
G=4;
case 'G03' %Kreisinterpolation im Gegenuhrzeigersinn (linksdrehend)
G03(s, i_zeile, zeile, j_spalte, spalte, Spaltenaufteilung, Abbruch, dimensionen, X, Y, Z, F, J, I);
case 'G03.2'
G=6;
case 'G04' %Verweilzeit
[...]
case 'G98' %Rückkehr auf Positionierebene in Bohrzyklus
G=38;
case 'G99' %Rückkehr auf Referenzebene in Bohrzyklus
G=39;
case 'G96' %Konstante Schnittgeschwindigkeit
G=44;
case 'G97' %Festdrehzahl
G=45;
case 'M00' %Unbedingter Halt
M=1;
case 'M01' %Optionaler Halt
M=2;
case 'M02' %Ende des Hauptprogramms
M=3;
case 'M03' %M03 Spindel ein rechtslaufend
M=4;
case 'M04' %Spindel ein linkslaufend
M=5;
case 'M05' %Spindel stopp nicht orientiert
M=6;
case 'M06'
M=7;
case 'M07' %Kühlmittel ein
M=8;
case 'M08'
M=9;
case 'M09'
M=10;
case 'M30' %Ende des Hauptprogramms
M=11;
case 'M97'
M=12;
case 'M98'
M=14;
case 'M99'
M=14;
end
end
end
end
Ausblick
Die Manuelle Verfahrweise wurde an der Maschine getestet und funktioniert einwandfrei. Die automatische Verfahrweise muss noch ergänzt und getestet werden. Hier muss noch die Unterteilung der Sollbahnen in kürzere Sollbahnen durchgeführt werden. So können Kurven gefahren werden. Wenn der Steueralgorithmus soweit arbeitet und die Maschine komplett montiert ist, kann die Kommunikation zwischen der Hardware und Matlab erweitert werden. Die Achsen können ein Signal an Matlab senden, wenn sie die Sollposition erreicht haben, sodass Matlab sofort die nächsten Koordinaten versendet. Außerdem kann der Motor in den Steueralgorithmus aufgenommen werden, sodass dieser bei Bedarf automatisch ein- und ausgeschaltet wird. Hierzu können weitere Bestandteile des G-Codes verwendet werden. Erste G-Code Funktionen wurden mit Matlab umgesetzt. Weitere mögliche Funktionen zu integrieren erhöht die Vielseitigkeit der Maschine.
Anhang
Matlab .m -File mit der grafischen Benutzeroberfläche zur manuellen Sollwertvorgabe: Medium:GUI_Slider_Sollwert.m
Matlab .m -File zur automatischen Sollwertvorgabe: Medium:GCodeAuslesen.m
Subfunktionen für die Automatische Sollwertvorgabe: Medium:G00.m Medium:G01.m Medium:G02.m(Nicht lauffähig)
Literatur
Steuerungsalgorithmus WS15/16
→ zurück zum Hauptartikel: Hauptseite 3-D Bearbeitungszentrum
Autor : Lars Osthoff
Betreuer: Prof. Göbel
Einleitung
Wie auf der Seite oben beschrieben, ist das Ziel des Praktikums Produktionstechnik des siebten Semesters Mechatronik -Schwerpunkt Global Production Engineering- eine schrittweise Erstellung einer 3-D-Bearbeitungsmaschine. Die Konstruktion ist weitestgehend in den letzten Semestern erfolgt und auch die elektrische Versorgung ist durch unsere Vorgänger erledigt worden. Im diesjährigen Wintersemester, welches nur von drei Studierenden im Schwerpunkt dünn besetzt wurde, ist es Aufgabe, die zuvor schon erarbeiten Aufgabenpunkte aufzunehmen und zu verbessern.
Aufgabenstellung
- Ansteuerung einer Schrittmotor-Achse mit dem Arduino Mikrocontroller [hier]
- Ansteuerung einer Schrittmotor-Achse mit NI LabView [hier]
- Steuerungsalgorithmus, um die Ansteuerungen mit Koordinaten zu versorgen ↓↓folgender Artikel↓↓
Genaue Aufgabenbeschreibung
In diesem Artikel wird der Steuerungsalgorithmus mit Hilfe von Matlab beschrieben. Aufgabe ist es einen G-Code ([Erklärung]), der auf der ganzen Welt erstellt werden kann, umzuwandeln und damit die die Ansteuerungen zu versorgen. Ausgabeformat ist, das von uns festgelegte, "X1111Y2222Z3333F4444". X,Y,Z sind Absolutkoordinatenangaben, die auf 0,1mm genau übergeben werden müssen. Somit ist klar, dass die Fräse einen Arbeitsbereich von 999,9mm in X und Y Richtung besitzt und in Z-Richtung ist durch die Konstruktion eine Reichweite von 220mmzu realisieren. Der letzte Übergabeparameter ist der Vorschub. Der Vorschub wird in mm/min übergeben. Folgende Schritte sind bei der Durchführung zu klären und zur berücksichtigen:
- Welche G-Codes sind für die erste Bearbeitung notwendig?
- Wie sollen die G-Funktionen programmiert werden?
- Welche Problemstellungen sind im Vorfeld klar?
- Es soll eine Visualisierung des Abfahrweges zur Überprüfung erstellt werden
- Es soll eine Referenzposition mit U1234V1234W1234 übergeben werden
Stand der Technik
Auch die vorherigen Semester haben sich bereits dem Thema des Steuerungsalgorithmus' angenommen, wie man diesem fortgeführten Artikel entnehmen kann. Als Basis dient die grafische Oberfläche, in der die erste Ansteuerung hinterlegt ist. Sowohl die Kommunikation über die serielle Schnittstelle, als auch eine manuelle Fräseransteuerung ist mit ihr durchführbar (siehe Punkt 5). Eine Auslesefunktion, die G-Code aus einer .txt lesen kann, war ebenfalls vorhanden und musste dementsprechend nur den neuen Daten angepasst werden (siehe Punkt 7).
Durchführung
Zusammenstellung der notwendigen G-Code-Funktionen
Die erste Aufgabe bestand darin, notwendigen G-Code zusammenzustellen. Es wurde sich entschieden zuerst nur die Funktionen G00, G01 und G02 umzusetzen, da die meisten CAM-Softwares sich auf diese Grundfunktionen beschränken. Im folgenden werden die G-Befehle erläutert:
- G00: Die G00-Funktion ist die Funktion für das reine Verfahren der Werkzeugspindel um schnell von einem zum anderen Punkt zu gelangen. Da diese Verfahrweise im Eilgang vollzogen wird ist es zu empfehlend diese Funktion nur zum Positionieren und nicht zum Fräsen zu benutzen. Zusätzlich ist es ratsam einen Sicherheitsabstand zu benutzen.
→Benutzung: G00(X,Y,Z); Beispiel: G00(5,5,0.5) Die Übergabeparameter sind die Absolutkoordinaten in X-Richtung, Y-Richtung und Z-Richtung. Diese Parameter werden aus der Matrix gelesen.
- G01: Die G01-Funktion ist die Funktion um die Spindel im gewünschten Vorschub (F) von einem zum anderen Punkt zu fahren. Diese Funktion ist zum Fräsen gedacht, wo der Fräser gerade Strecken abfahren soll. Es ist empfohlen, um den Fräser zu schützen, eine maximale Frästiefe von 1mm nicht zu überschreiten. Sollte tiefer gefräst werden muss so ist es ratsam mehrfach diese Stelen zu überfahren.
→Benutzung: G01(X,Y,Z,F); Beispiel: G01(5,5,0.5,30) Die Übergabeparameter sind die Absolutkoordinaten in X-Richtung, Y-Richtung und Z-Richtung. Zusätzlich wird jetzt aber noch der Vorschubwert in mm/min angegeben. (F = 1000 entspräche dem Eilgang). Diese Parameter werden aus der Matrix gelesen.
- G02: Die G02-Funktion ist die Funktion um einen Radius im Uhrzeigersinn abzufahren. Es ist empfohlen, um den Fräser zu schützen, eine maximale Frästiefe von 1mm nicht zu überschreiten. Sollte tiefer gefräst werden muss so ist es ratsam mehrfach diese Stelen zu überfahren.
→Benutzung G02 (X,Y,Z,I,J); Beispiel: G02(5,3,0.5,3,-2.5) Die Übergabeparameter sind die Absolutkoordinaten in X-Richtung, Y-Richtung und Z-Richtung. Zusätzlich werden jetzt in I und J die Koordinaten des Mittelpunktes des Kreises festgelegt. Wichtig ist hier zu beachten, dass bei dieser Funktion die Werte von I und J immer relativ zum aktuellen Fräserstandort angegeben werden müssen.
Programmierung der G-Funktionen
Nachdem die ersten Funktionen abgestimmt waren, wurde mit der Programmierung begonnen.
- G00
function G00 (X,Y,Z)
%% Funktion für Verfahren im Eilgang G00
% Autor: Lars Osthoff
% Hochschule Hamm-Lippstadt
% Produktionstechnik Praktikum WS15/16
% Prof. Dr. -Ing Göbel
%%
% GOO Positionieren im Eilgang
X;
Y;
Z;
%Da Eilgang Vorschub auf Maximum
F = 100;
Ausgabe(X, Y, Z, F);
end
Dem Quellcode ist zu entnehmen, dass die Funktion lediglich die X,Y,Z Koordinaten aus der Matrix übernimmt und diese direkt an die Ausgabe weiterschiebt. Der Vorschub wird, aufgrund des Eilganges auf 100 % gestellt. Die Übergabeparameter sind dementsprechend nur die Koordinatenangaben.
- G01
%% Funktion für Verfahren mit Vorschubangabe
% Autor: Lars Osthoff
% Hochschule Hamm-Lippstadt
% Produktionstechnik Praktikum WS15/16
% Prof. Dr. -Ing Göbel
%%
function G01 (X,Y,Z,F,X1,Y1)
V_Start = [X1;Y1];
V_Ziel = [X;Y];
V_Strecke = V_Ziel-V_Start;
% X_Laenge = X-X1;
% Y_Laenge = Y-Y1;
%% Verfahrlänge auf 0,1mm
Hyp = sqrt(power(V_Strecke(1),2)+ power(V_Strecke (2),2));
Anzahl = round (Hyp/0.1);
V_Delta = V_Strecke / Anzahl;
%% Schleife für Abfahren "schräger" Bahnen
for I = 1:Anzahl
V_Fraeser = V_Start + V_Delta*I;
X = V_Fraeser(1);
Y = V_Fraeser (2);
Ausgabe(X, Y, Z, F);
end
end
Die G01-Funktion funktioniert ähnlich, wie die G00-Funktion. Als Übergabeparameter kommt nun auch der Vorschub hinzu, da dieser hier vorher bestimmt werden kann. Zusätzlich ist eine Schleife einprogrammiert worden, da sonst eine geplante Strecke nicht hätte abgefahren werden können. Problem wären Verfahrwege gewesen, in der der Weg zum Ziel in X-Richtung schneller erreicht wäre als in Y-Richtung oder andersherum. Die Schleife garantiert, dass der Fräser mit einer Abweichung von 0,1mm jegliche linearen Strecken abfahren kann. Zusätzlich werden mit X1 und Y1 die aktuellen Fräserdaten an die Funktion übergeben. Diese sind für die zuvor genannte Schleife wichtig.
- G02
function G02 (X,Y,Z,I,J,X1,Y1,F)
% X,Y,Z Werte = Werte für Zielposition
% I,J Werte = Abstandswert des Mittelpunktes relativ zum Startwert
Radius = sqrt(I.^2+J.^2);
A = tan(J/I);
Alpha = atand(A);
%Mittelpunktkoordinaten absolut
Mx = (X1-I);
My = (Y1-J);
B = tan((Y-My)/(X-Mx));
Endwinkel = atand(B);
Winkel = Alpha;
X_Alt = X;
Y_Alt = Y;
%% Schleife für Abfahren bzw. Abbruch Kreisbahn
for Alpha=Winkel:0.2:Endwinkel
XI = Radius * cosd(Alpha);
YI = Radius * sind(Alpha);
X_Ist = round(XI,1);
Y_Ist = round(YI,1);
Ausgabe(X_Ist, Y_Ist, Z, F);
X_Alt = X_Ist;
Y_Alt = Y_Ist;
end
end
Die G02-Funktion errechnet aus den Übergabeparametern die abzufahrende Kreisbahn. In dieser ist über die Schleife, wie zuvor auch, gewährleistet das die Kreisbahn exakt abgefahren werden kann und über die schrittweise Winkelerweiterung die Genauigkeit gewährleistet wird.
Erklärung der GUI
Auf der linken Seite ist ein Screenshot der GUI angefügt. Die GUI ist so aufgebaut, dass im oberen Bereich die Kommunikation mit der seriellen Schnittstelle gestartet und gestoppt werden kann. In der Zeile darunter ist die Einbindung des Textdokumentes (Öffnen), Übertragung an die Fräse (Start Fräse), Starten der Visualisierung als plot (Simulation) und ein Not-Aus Knopf angesiedelt. Darunter befindet sich die manuelle Steuerung über Slider, mit der die Fräse manuell bewegt werden kann. Im unteren Bereich sind die Fenster für die Koordinatenangaben für die Referenzposition und der Button für die Übertragung an die Schnittstelle.
Im nachfolgenden ist der Programmcode der Hauptanwendung hinterlegt.
%% GUI für CNC-Fräse
% Autor: Lars Osthoff
% Hochschule Hamm-Lippstadt
% Produktionstechnik Praktikum WS15/16
% Prof. Dr. -Ing Göbel
% in Anlehnung an vorherige Semester
%% Start
clear;
close all;
clc;
addpath Callbacks
%Einstellen des Wertebereichs der Slider
Max_Slider_x = 1000;
Max_Slider_y = 1000;
Max_Slider_z = 200;
global Daten;
Daten = [];
% Ausgabe-Figure definieren = 2
Daten.figure_Ausgabe = 2;
%% Definition des COM-Ports und der Größe und Position der figure
Daten.s = serial('COM5','baudrate',115200);
%Daten.s = 1; % Kommandofenster
Daten.handles.f = figure('Visible','off','Position',[360,500,500,400],'NumberTitle','off');
%% Panel für Slider, Anzeige und Beschriftungen
%Panel_1 stellt die Bedienelemente für die Sollwertvorgabe bereit
%Panel_2 stellt die Bediebelemente zum Starten und Stoppen der Seriellen
%Kommunikation bereit
%Panel_3 stellt den Pushbutton zum senden der Koordinaten an die Serielle
%Schnittstelle bereit.
Panel_1 = uipanel('Title','Sollwertvorgabe','Position',[0 .33 1 .33]);
Panel_2 = uipanel('Title','Kommunikation Starten/Stoppen','Position',[0 .8 1 .2]);
Panel_3 = uipanel('Title','Koordinaten ','Position',[0 0 1 0.33]);
Panel_4 = uipanel('Title','Öffnen,Start,Not-Aus-------------Neues Txt-Dokument: erneut Öffnen drücken','Position',[0 .66 1 .133333]);
%% Aufbau der Slider
Daten.handles.Achse_x = uicontrol('Parent',Panel_1,'Style','slider','String','X-Achse',...
'Position',[100,80,300,20],...
'Min',0,'Max',Max_Slider_x,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_x_callback});
Daten.handles.Achse_y = uicontrol('Parent',Panel_1,'Style','slider','String','Y-Achse',...
'Position',[100,50,300,20],...
'Min',0,'Max',Max_Slider_y,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_y_callback});
Daten.handles.Achse_z = uicontrol('Parent',Panel_1,'Style','slider','String','Z-Achse',...
'Position',[100,20,300,20],...
'Min',0,'Max',Max_Slider_z,...
'SliderStep',[0.001 0.1],...
'Callback',{@achse_z_callback});
%% Aufbau der Beschriftungen der Slider
text_1 = uicontrol('Parent',Panel_1,'Style','Text','String','X-Achse',...
'Position',[25,80,60,20]);
text_2 = uicontrol('Parent',Panel_1,'Style','Text','String','Y-Achse',...
'Position',[25,50,60,20]);
text_3 = uicontrol('Parent',Panel_1,'Style','Text','String','Z-Achse',...
'Position',[25,20,60,20]);
%Aufbau der Koordinatenanzeige
Daten.handles.Koor_x = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,80,50,20],...
'BackgroundColor','w');
Daten.handles.Koor_y = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,50,50,20],...
'BackgroundColor','w');
Daten.handles.Koor_z = uicontrol('Parent',Panel_1,'Style','Text','String','',...
'Position',[420,20,50,20],...
'BackgroundColor','w');
%% Aufbau der Bedienelemente Starten und Stoppen der Seriellen
%Kommunikation
Daten.handles.Starten = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Start',...
'Position',[25, 30, 70, 25],...
'BackgroundColor','green','FontWeight','bold','FontSize',10,...
'Callback', @starten_callback);
Daten.handles.Stoppen = uicontrol('Parent',Panel_2,'Style','Pushbutton','String','Stop',...
'Position',[150,30,70,25],...
'BackgroundColor','red','FontWeight','bold','FontSize',10,...
'Callback', @stoppen_callback);
%% Aufbau des Pushbuttons zum Senden der Koordinaten an die Serielle
%Schnittstelle.
Daten.handles.Senden = uicontrol('Parent',Panel_3,'Style','Pushbutton','String','senden',...
'Position',[25,30,100,50],...
'BackgroundColor',[0.5 0.7 1],'FontWeight','bold','FontSize',10,...
'Callback', @senden_callback);
%% Aufbau Pushbutton Referenz senden und Referenz eingeben
Daten.handles.Referenz_Senden = uicontrol('Parent',Panel_3,'Style','Pushbutton','String','Referenz senden',...
'Position',[300,50,50,50],...
'BackgroundColor',[0.5 0.7 1],'FontWeight','bold','FontSize',10,...
'Callback', @Funk_Referenz);
%% Aufbau der Beschriftungen der Referenz
Daten.handles.Ref_x = uicontrol('Parent',Panel_3,'Style','edit','String','',...
'Position',[400,80,50,20],...
'BackgroundColor','w');
Daten.handles.Ref_y = uicontrol('Parent',Panel_3,'Style','edit','String','',...
'Position',[400,50,50,20],...
'BackgroundColor','w');
Daten.handles.Ref_z = uicontrol('Parent',Panel_3,'Style','edit','String','',...
'Position',[400,20,50,20],...
'BackgroundColor','w');
%% Aufbau des Öffnen-/Start-/ Not-Aus-Button
Daten.handles.Oeffnen = uicontrol('Parent',Panel_4,'Style','Pushbutton','String','Öffnen',...
'Position',[25, 5, 70, 25],...
'BackgroundColor','white','FontWeight','bold','FontSize',10,...
'Callback', 'Funk_Oeffnen;');
Daten.handles.Start_Programm = uicontrol('Parent',Panel_4,'Style','Pushbutton','String','Start Fräse',...
'Position',[150, 5, 85, 25],...
'BackgroundColor','green','FontWeight','bold','FontSize',10,...
'Callback', 'Funk_Start_Programm(Daten);');
Daten.handles.Simulation = uicontrol('Parent',Panel_4,'Style','Pushbutton','String','Simulation',...
'Position',[250, 5, 85, 25],...
'BackgroundColor','blue','FontWeight','bold','FontSize',10,...
'Callback', 'Funk_Simulation;');
Daten.handles.Not_Aus = uicontrol('Parent',Panel_4,'Style','Pushbutton','String','Not-Aus',...
'Position',[400, 5, 70, 25],...
'BackgroundColor','red','FontWeight','bold','FontSize',10,...
'Callback', 'Funk_Not_Aus;');
%Initialisierung der GUI
set([Daten.handles.f ,Panel_1,Daten.handles.Achse_x,Daten.handles.Achse_y,Daten.handles.Achse_z,...
text_1,text_2,text_3,...
Daten.handles.Koor_x,Daten.handles.Koor_y,Daten.handles.Koor_z,...
Daten.handles.Starten,Daten.handles.Stoppen,...
Daten.handles.Senden],...
'Units','normalized');
set(Daten.handles.f ,'Name','Sollwertvorgabe mit Slider')
%%
movegui(Daten.handles.f,'center')
set(Daten.handles.f ,'Visible','on');
set(Daten.handles.Achse_x,'Visible','off');
set(Daten.handles.Achse_y,'Visible','off');
set(Daten.handles.Achse_z,'Visible','off');
set(Daten.handles.Senden,'Visible','off');
Zu den "Daten.____" ist zu sagen, dass dies die einzige globale Variable ist, in der jegliche Informationen hinterlegt sind.
Hier können die kompletten Matlab-Dateien heruntergeladen werden: [hier] Um die Benutzeroberfläche zu starten muss die GUI.m geöffnet werden.
Fazit und Ausblick
Die Bearbeitung des obigen Projektes war mit viel Programmierarbeit umsetzbar. Positiv ist, dass es über verschiedene Praktikumsveranstaltungen eine voll funktionsfähige CNC-Fräse ein realisierbares Ziel ist. Am Anfang war die Bearbeitung sehr undurchsichtig und es entstanden sehr viele Fragen. Über die Zeit und die tieferen Einblicke konnten die Funktionen immer weiter verbessert und verstanden werden. Lauffähig ist die GUI mit ihren Hinterfunktionen. Für weitere Bearbeitungen ist es ratsam die Auslesefunktion noch stabiler und unabhängiger zu programmieren und bei Erweiterung von weiteren G-Funktionen sind so gut wie keine Grenzen gesetzt. Auch die M-Funktionen sind nur als Textbefehl hinterlegt und könnten mit Funktionen hinterlegt werden (z.B.: Staubsauger ein/aus).
→ zurück zum Hauptartikel: Hauptseite 3-D Bearbeitungszentrum