Zentraler Steuerungsalgorithmus für ein 3-Achs-CNC-Bearbeitungszentrum

Einleitung

Das Fachthema des zentralen Steuerungsalgorithmus ist ein Teilbereich eines Projektes im Rahmen der Lehrveranstaltung Produktionstechnik Praktikum. Bei diesem Praktikum wurde das Ziel verfolgt, eine 3D-Bearbeitungsmaschnine von Grund auf zu entwickeln und zu bauen ( 3-D-Bearbeitungsmaschine (Projekt des Schwerpunkts GPE im Studiengang MTR) ). Das Thema des zentralen Steuerungsalgorithmus wurde von Lukas Hurrelmeyer und Tim Menke bearbeitet.

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.

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. Vorteilhaft ist eine Schrittlänge von einer Längeneinheit, da sich so die zeitliche Verzögerung zwischen dem Versenden der Positionspaare optimal ausnutzen lässt.

% 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;

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.