Einführung

Ein 3D-Fräsbearbeitungszentrum soll in Gruppenarbeit realisiert werden. Neben der Konstruktion des Bearbeitungszentrums und dessen Montage sollen die drei Achsen mit unterschiedlichen Steuerungen und damit auch mit unterschiedlichen Programmiersprachen realisiert werden. Des Weiteren muss ein zentraler Steuerungs-Algorithmus die drei Steuerungen vereinen, um Zielvorgaben respektive Koordinaten auf die entsprechenden Achsen zu verteilen.

Fachthemen

Achsensteuerung mit SPS

Achsensteuerung mit µController

Aufgabenstellung

Innerhalb dieses HSHL-Wikipedia Eintrags wird die Automatisierung einer Achse mit µC „Arduino Mega“ als Steuerungskonzept vorgestellt.

Regelkreis

Als Regelkreis bezeichnet man ein Wirkungsgefüge, das aus einem Steuerungsprozess mit eingeschalteter Gegenkoppelung besteht.

In unserem Fall wird als Sollgröße ein zuvor definierter Weg vorgegeben, der innerhalb des Arduino-Programmes in digitale Signale übersetzt wird. Diese digitalen Signale bzw. Steps nutzt der Schrittmotorcontroller (Geckodrive G201X) um den Schrittmotor der Linearachse anzusteuern. Die rotatorische Bewegung des Antriebes wird mittels Inkrementalgeber erfasst und durch die Programmierung in absolute Distanzen umgerechnet, sodass diese Werte als Rückführgröße übergeben werden können. Die Regeldifferenz errechnet Abweichungen dieser Rückführgröße zum Sollwert, sodass ggf. der Arduino die Maßabweichung ausgleicht. Ziel ist es, dass die Regeldifferenz Null wird.

Belegungsplan

Bei der Ansteuerung der Bauteile muss zwischen einem Last- und einem Steuerkreis unterschieden werden. Der Steuerkreis besteht aus einem µc Arduino Mega welcher den Motorcontroller Geckodrive G201X mit den Signalen „step“ für die Schrittanzahl und „direction“ für die Richtungsvorgabe der Bewegung ansteuert. Die Spannungsversorgung des Arduino Megas wird über USB bzw. ein Festspannungsnetzteil sichergestellt. Der Geckodrive wird durch eine externe Spannungsquelle versorgt. Diese Nennspannung von 24 Volt wird durch den Geckodrive derart geschaltet, sodass der Schrittmotor nach Steuervorgaben betrieben wird. Die Bremsvorrichtung des Schrittmotors wird präventiv als Sicherheitseinrichtung bei Spannungsverlust eingesetzt. Deshalb wird diese bei Betrieb der Linieareinheit mit Energie versorgt und damit gelöst bzw. entriegelt.

Aus sicherheitstechnischen Gründen müssen beidseitig je ein Endschalter verwendet werden. Die Endschalter registrieren das Erreichen des maximalen Hubweges des Motorschlittens und erzeugen ein Steuersignal welches den Motorschlitten zum Stillstand zwingt und einen definierten Weg in die entgegengesetzte Richtung fahren lässt. Der Pulldown-Widerstand wird dazu verwendet um den Eingang bei Nichtbeschaltung auf GND zu „ziehen“ um damit Störsignale zu unterbinden. Zur Sicherheit wird beidseitig je ein weiterer Endschalter benötigt, der am Motorcontroller direkt, durch Verbinden der Anschlusspins 7 und 12, die Spannungsversorgung des Motors zu unterbindet. Hierbei wird allerdings keine Rückmeldung an die Steuerung geliefert, allerdings ist die Stromversorgung sofort unterbrochen, falls die davor installierten Endschlater nicht auslösen.

Nachfolgend ist eine mögliche Beschaltung der unterschiedlichen Komponenten detailliert aufgeführt.

Software

Kompatibilitätsermittlung für den Betrieb mit Geckodrive G201 REV-6

STEP AND DIRECTION INPUTS

TERMINAL 8: Direction Connect the DIRECTION line to this terminal.

TERMINAL 9: Step Connect the STEP line to this terminal.

TERMINAL 10: Common Connect the controller’s +3.3VDC, +5VDC or GND to this terminal.

These inputs are optically isolated from the rest of the drive. Terminal 10 is the common connection for the opto-isolators and must be connected to the +3.3VDC, +5VDC or GND of your indexer or pulse generator.

These inputs are meant to be driven by 3.3V to 5.5V logic capable of sourcing or sinking 2.5mA of current. The minimum logic “0” time is .5uS while the minimum logic “1” time is 3uS with 3.3V – 5V connected on the COMMON terminal. The minimum logic “0” time is 3uS while the minimum logic “1” time is 0.5uS when connected to GND on the COMMON terminal. Microstepping occurs on the falling edge of the step input when COMMON is a positive voltage and on the rising edge when COMMON is connected to GND and on the rising edge when connected to 3.3V – 5V.

Quelle: Datenblatt: Geckodrive Motor Controls, G201X / G210X User Manual, 2011, Tustin CA (USA)

Zusammenfassung: Eine Mindestperiodendauer von 3,5 µs wird durch die Festelegeung der Parameter im Programm eingehalten.

Analyse der Vorwärts- und Rückwärtsbewegung des Hubschlittens

Zusammenfassung: Wird ein Directionsignal high am Arduino Mega ausgegeben, so verfährt der Hubschlitten in positive Richtung (vorwärts). Wird hingegen ein Directionsignal low am Arduino Mega ausgegeben, so verfährt der Hubschlitten in negative Richtung (rückwärts).

Quellcode für die Ansteuerung der x-Achse

Statusübersicht des Quellcodes für die Ansteuerung der x-Achse:

• Kommunikation des Arduino Mega mit dem seriellen Monitor (RS232-Kommuniaktion) zur Eingabe des Sollweges. Hierbei wird eine Umwandlung von ASCII-Code in Dezimal durchgeführt.

• Es wird bei einer Referenzposition gestartet, auf welche sich alle weiteren Sollwegangeben in Relation beziehen. Das heißt, dass weitere Sollwegeingaben Vielfache der ursprünglich eingegebenen Sollwegangabe sind.

Beispiel: Eine Eingabe des Sollweges von 50 mm zu Beginn der Dateneingabe verfährt den Hubschlitten 50 mm in positive Richtung. Diese Sollposition "merkt" sich die Programmierung. Bei einer weiteren Sollwegeingabe von z.B. 40 mm verfährt der Hubschlitten 10 mm zurück.

• Einbindung Endschalter in Programmablauf. Bei der Auslösung der Endschalter wird ein kurzer Weg in inverse Richtung verfahren. Innerhalb des Monitors wird eine entsprechende Fehlermeldung ausgegeben.

Weiterführende Gedanken:

• Einbindung eines Inkrementalgebers zur Überprüfung des Sollweges

• Einbindung festen Referenzpunktes bei Programmstart:

Vorschlag: Bei Programmstart wird solange in eine Richtung verfahren, bis z.B. eine Lichtschranke ausgelöst wird. Damit ist der Referenzpunkt erreicht, z.B. Koordinatenursprung Null. Hierdurch ist gleichzeitig ein begrenztes Intervall zur Sollwegeingabe geschaffen.

Anbei ist der gesamte Quellcode für die Ansteuerung eines Linearmotors mit dem Mikrocontroller Arduino mega abgebildet. Der Quellcode ist mit ausreichenden Kommentaren versehen und wird deshalb nicht näher erläutert.

Angemerkt werden muss, dass die Bibliothek "Accelstepper" für die Arduino-Software vorinstalliert werden muss. Diese kann konstenfrei über das Internet bezogen werden.

Bibliothekseinbindung:

#include <AccelStepper.h> //vordefinierte Bibliothek

Parameter und Variablendefinition:

AccelStepper stepper(1,9,8);          // 1 = Treiberboard(definiert), Schritt, Richtung, (vorwärts fahren = 1, rückwärts fahren = 0 (über Directionsignal), autom. Umsetzung durch Bibliothek)

int EndschalterPinlinks = 22;         // Eingang 22 für Kontakt links
int EndschalterPinrechts = 23;        // Eingang 23 für Kontakt rechts
int sollweg = 0;                      // sollweg in mm
int zielweg = 0;
int Vorzeichen = 1;                   // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;               // Verhältnis, um absolute Distanzen anzufahren 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt, 
                                      // 200 = Auflösung bei 1,8° Schrittwinkel, Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahr = 0;                   // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg

Initilaisierung:

void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen  
        stepper.setAcceleration(24000000);     // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepper.setCurrentPosition(0);         // Referenzposition = 0 setzen   
        pinMode(EndschalterPinlinks,  INPUT); 
        pinMode(EndschalterPinrechts, INPUT);    
        Serial.println("Initialisierung abgeschlossen");  
}

Hauptprogramm:

void loop()
{              
    if(Serial.available()>0)                           // Koordinaten einlesen 
        {
          char ascii = Serial.read();
          //Serial.println(ascii, DEC);
          
          if (ascii == '-')                            // feststellen, ob Minusvorzeichen gesetzt wurde
          {
            Vorzeichen = -1;
          }
          
          if(isDigit (ascii))                          // Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {
           
            zielweg = (zielweg*10) + (ascii - '0');    // der ASCII Wert 48 entspricht der 0 (Synonym: 'ascii - 48') --> es wird aus dem ASCII Wert der Variablen ein Dezimalwert gebildet 
                                                       // die Multiplikation mit 10 erfolgt nach jeder zusätzlich eingegeben Zeichen in einer Zeile, um so auch mehrstellige Dezimalzahlen 
                                                       // darstellen zu können eine Zahleneingabe endet mit dem NewLine Befehl, dieser entspricht dem ASCII-Code '10'
          }
         
          else if(ascii == 10 ) //feststellen, ob Zahleneingabe komplett, d.h NewLine Befehl (ASCII=10)
          {
           zielweg = zielweg*Vorzeichen;               // Wert mit Vorzeichen multiplizieren
           Serial.print("Bekommener Wert: ");
           Serial.println(zielweg, DEC);
           sollweg = zielweg;
           zielweg = 0;
           Vorzeichen = 1;
          }
         }      
        
    if (digitalRead(EndschalterPinlinks) == LOW && digitalRead(EndschalterPinrechts) == LOW) // Sicherheitsabfrage
      {
        Verfahr = sollweg/Schritt;                     // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepper.moveTo(Verfahr);                       // Festlegen des Weges
        Verfahren();                                   // Unterprogramm Verfahren() ausführen
      }
      
    else if(digitalRead(EndschalterPinlinks) == HIGH)  // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_links");
         stepper.move(500);
         int diff =  stepper.currentPosition() + 500;         
         while(stepper.currentPosition() != diff)
         {
           stepper.run();
         }
           sollweg = stepper.currentPosition()*Schritt;
       } 
         
    else if(digitalRead(EndschalterPinrechts) == HIGH) // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_rechts");
         stepper.move(-500); 
         int diff =  stepper.currentPosition() - 500;         
         while(stepper.currentPosition() != diff)
         {
           stepper.run();
         }          
           sollweg = stepper.currentPosition()*Schritt;        
       }        
}

Funktion "Verfahren"

void Verfahren() 
{
   if (stepper.currentPosition() != Verfahr )      // solange bis Position erreicht "run"
   {
       stepper.run();
   }                
   stepper.setSpeed(0);
   stepper.moveTo(stepper.currentPosition());     // Beschreiben der aktuellen Position  
}

Quellcode für die die Duplizierung auf alle Achsen

Statusübersicht des Quellcodes für die Duplizierung der Programmierung auf alle drei Achsen (Zusatzaufgabe):

• Die Programmierung ist im Stande, alle drei Achsen anzusprechen

• Eine eindeutige Zeichenkette (z.B.: x2000y0000z0000e) muss dem Programm vorgegeben werden, um die Achsen anzusteuern

Weiterführende Gedanken:

• Die sich wiederholende Programmabschnitte können mit allgemeingültigen Funktionen umgesetzt werden

Programmablaufplan für die Ansteuerung von drei Achsen mit dem ArduinoMega

Repräsentativ bilden wir die wesentlichen Abschnitte des Programms ab. Hierbei konzentrieren wir uns auf die Abschnitte für die x-Achse. Die Abschnitte für die y- und z-Achse sind identisch, mit der Ausnahme der Beschriftung mit y- und z sowie dem Abbruchkriterium mit dem Buchstaben e für die z-Achse.

Bibliothekseinbindung:

#include <AccelStepper.h>                // vordefinierte Bibliothek

Parameter und Variablendefinition:

AccelStepper stepperx(1,9,8);           // 1 = Treiberboard(definiert), Schritt, Richtung 
int EndschalterPinlinksx = 22;          // Eingang 22 für Kontakt links
int EndschalterPinrechtsx = 23;         // Eingang 23 für Kontakt rechts
int sollwegx = 0;                       // Sollweg in mm
int Vorzeichen = 1;                     // wird bei der ASCII Umwandlung benötigt
double Schritt = 0.033;                 // Verhältnis, um absolute Distanzen anzufahren 
                                        // 66/200 = 0,33 (Übersetzung = 66 mm/Umdrehung -> ZLW/-OD-1040Basic Datenblatt, 
                                        // 200 = Auflösung bei 1,8° Schrittwinkel)
                                        // Gecko: Verhältnis 1 zu 10 --> 0,033
double Verfahrx = 0;                    // Zuordnen des Verfahrweg --> Verfahr = Anzahl der Schritte für den gewünschten Weg
int status_x = 0;
char ascii;

Initilaisierung:

void setup()
{
        Serial.begin(9600);                    // Port für serielle Kommunikation auf 9600 baud Rate Übertragungsgeschwindigkeit setzen  
        stepperx.setAcceleration(24000000);    // Beschleunigung,Geschwindigkeit --> Frequenzänderung
        stepperx.setCurrentPosition(0);        // Referenzposition = 0 setzen  
        pinMode(EndschalterPinlinksx,  INPUT); 
        pinMode(EndschalterPinrechtsx, INPUT);  
        Serial.println("Initialisierung abgeschlossen");
        Serial.flush();
}

Hauptprogramm (Ausschnitt):

 void loop()
{  
  if(Serial.available() > 0)                       // Koordinaten einlesen 
        {
          ascii = Serial.read();
          
     
          if (ascii == 'x')                         // feststellen, ob x gesetzt wurde
          {
            status_x = 1;
            while (status_x == 1)  
             {
               status_x = UmrechnungplusBerechnung(); 
             }
          }           

          if (ascii == 'y')
          {
           Serial.print("Bekommener Wertx: ");
           Serial.println(zielweg, DEC);
           sollwegx = zielweg;
           zielweg = 0;    
          }

Weiterführender Hauptteil (Ausschnitt):

if (digitalRead(EndschalterPinlinksx) == LOW && digitalRead(EndschalterPinrechtsx) == LOW)     // Sicherheitsabfrage
      {
        Verfahrx = sollwegx/Schritt;                   // Umrechnen des eingegebenen Koordinatenwertes in Anzahl von Schritten
        stepperx.moveTo(Verfahrx);                     // Festlegen des Weges
        Verfahrenx();                                  // Unterprogramm Verfahren() ausführen
      }        
    else if(digitalRead(EndschalterPinlinksx) == HIGH)           // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_linksx");
         stepperx.move(500);
         int diff =  stepperx.currentPosition() + 500;         
         while(stepperx.currentPosition() != diff)
         {
           stepperx.run();
         }
           sollwegx = stepperx.currentPosition()*Schritt;
       } 
         
    else if(digitalRead(EndschalterPinrechtsx) == HIGH)           // wenn Schalter belegt - rückfahren
       { 
         Serial.println("Endschalter_rechtsx");
         stepperx.move(-500); 
         int diff =  stepperx.currentPosition() - 500;         
         while(stepperx.currentPosition() != diff)
         {
           stepperx.run();
         }          
           sollwegx = stepperx.currentPosition()*Schritt;        
       }

Funktion Verfahren():

void Verfahrenx() 
{
 if (stepperx.currentPosition() != Verfahrx ) //solange bis Position erreicht "run"
 {
   stepperx.run();
 }                
  stepperx.setSpeed(0);
  stepperx.moveTo(stepperx.currentPosition()); //Beschreiben der aktuellen Position       
}

Funktion Umrechnen():

  int UmrechnungplusBerechnung()
{
     ascii = Serial.read();
     if(isDigit(ascii))           //Prüfen, ob ASCII-Zeichen zw. 0 und 9 liegt (Dezimalzahlen 48 bis 57)
          {                     
             zielweg = (zielweg*10) + (ascii - '0'); // Erklärung siehe Quelltext oben
             return 1;
          }
          else 
          {
               return 0;
          }
}

Achsensteuerung mit LabView

LabView: Einleitung

Das Programm LabView des Herstellers National Instruments ermöglicht die Programmierung von Simulationsmodellen und/oder Eingabe/Ausgabe- Programmen mittels einer graphischen Oberfläche. Dabei ist die Handhabung ähnlich den Produkten Matlab Simulink oder LEGO Mindstorms BricX.

Installation der Hardware

Um mit der Programmierung zu starten, muss zunächst ein leeres Projekt erstellt werden. Dieses enthält später alle Informationen, Schnittstellen und graphischen Oberflächen, die man für ein Programm benötigt.

Möchte man das Projekt mit einem Eingabe/Ausgabegerät verwenden, muss dieses zunächst hinzugefügt werden. Die folgenden Schritte wird beschrieben, wie ein I/O Controller cRIO 9024 in ein Projekt eingebunden werden kann.

Im Project-Explorer befindet sich ein leeres Projekt, dem nun die Hardware hinzugefügt wird:

• Rechtsklick auf das Projekt => Neu => Ziele und Geräte

• Im Ordner Real-Time CompactRIO befindet sich die über das Netzwerk verbundene HSHL-CRIO-CPU02 und wird über einen Doppelklick zum bestehenden Projekt hinzugefügt.

• Anschließend erscheint im Project-Explorer die Hardware Chassis (CRIO-9114). Das im Slot 1 befindliche Modul zeigt alle DIO´s welche über ein Rechtsklick auf Mod1 konfiguriert werden können, d.h. die jeweiligen DIO´s können als Input oder Output definiert werden.

• Um potenzielle Fehler zu vermeiden, ist es sinnvoll den verwendeten Input bzw. Output direkt umzubenennen.

Erstellt man jetzt ein neues VI, erscheint dies zunächst nur in Mein Computer. Für eine einwandfreie Übertragung auf die Hardware muss das VI über drag and drop in die Hardware gezogen werden. Genaueres dazu ist in Problembehebung zu finden.

Screenshots

Die Hardware wurde nun mit dem Programm "bekannt gemacht" und kann verwendet werden.

Grundlegendes: VI und Blockdiagramm

In ein erstelltes leeres Projekt kann nun ein "Visual Interface", kurz VI genannt, eingefügt werden. Dazu muss auf das weiße-Blatt-Symbol oben links geklickt werden:

Es erscheint daraufhin ein leeres VI. Dieses stellt ein graphic user interface für die Interaktion mit dem späteren Programm dar. Das eigentliche Programm wird in einem "Blockdiagramm" genannten Fenster erzeugt und editiert. Das Blockdiagramm wird folgendermaßen geöffnet:

"Fenster" => "Blockdiagramm"

VI und Blockdiagramm stehen in direkter Beziehung. Es können Eingaben im VI gemacht werden, die das Blockdiagramm beeinflussen und es können Ausgaben des Blockdiagramms auf dem VI dargestellt werden.

Erste Schritte: Programmieren im Blockdiagramm

In das leere Blockdiagramm können nun Schleifen, Variablen und Funktionsbausteine per drag&drop aus dem "Funktionsmenü" eingefügt und miteinander verknüpft werden. Die Verbindungen zwischen Bausteinen werden grafisch durch Linien gebildet, die mit der Computermaus gezogen werden:

Screenshot

Die Funktionspalette enthält eine Vielzahl an Elementen, die unterschiedlichste Möglichkeiten von Berechnungen, Umformungen, Vergleichen etc. bieten. Besonders beachtet werden muss, dass nicht jeder Baustein mit jedem verknüpft werden kann, da teilweise die verwendeten Datentypen nicht kompatibel sind. Am sinnvollsten ist es, wenn man einen neuen Baustein einsetzen möchte, diesen zunächst anzuklicken und unter "Hilfe" die Beschreibung zu studieren. Dort sind alle Eingangs-und Ausgangsgrößen, die Funktion und die benötigten Datentypen des Bausteins beschrieben:

Screenshot

Als Start kann zunächst eine endlose (while-) Schleife eingefügt werden. Als Abbruchbedingung kann beispielsweise ein Bedienelement auf dem VI dienen, welches man folgendermaßen einfügt:

Screenshot

In die äußere Schleife können nun die benötigten Bausteine hineingezogen werden und laufen dann solange wie die äußere Schleife.

Eine Eingabemöglichkeit im VI, die dann auf das Programm Einfluss nimmt, lässt sich folgendermaßen umsetzen: Man fügt zunächst einen "Eingabebaustein" im Blockdiagramm ein. Dieser erscheint dann gleichzeit auch im VI und kann dort beliebig platziert werden.

Beispielprogramm

Es soll nun ein Beispielprogramm erstellt werden, welches einen im VI vom Benutzer eingegebenen Wert für eine Berechnung nutzt und diesen dann wieder an das VI ausgibt.

Zunächst wird die Endlos-while-Schleife eingefügt:

Screenshot

In die Schleife wird dann ein Eingabebaustein eingefügt und im VI entsprechend platziert:

Screenshot

Der Eingabewert kann dann im Blockdiagramm für beliebige Berechnungen/Steuerungen verwendet werden. In diesem Fall wird der Wert mit der Konstanten Zahl 1000 Multipliziert. Dafür wird ein mathematischer Funktionsbaustein (Multiplikation) aus der Palette "Mathematik" eingefügt:

Screenshot

Beide Bausteine werden dann durch eine Linie miteinander verbunden. Die Farbe der Linie gibt an, um was für einen Datentyp es sich handelt. In diesem Fall ist es ein Datentyp "double", der stets die Farbe orange hat.

Dieser Wert soll dann auf einem Anzeigefeld im VI dargestellt werden. Dafür fügt man ein Anzeigelement aus der Funktionspalette ein und verbindet es mit dem Ausgang des Multiplikator-Bausteins.

Screenshot

Ansteuerung eines Schrittmotors mit LabView

Grundsätzlich gibt es mehrere Möglichkeiten über LabView einen Schrittmotor anzusteuern. Voraussetzung dazu ist eine Art Pulsweitenmodulation (PWM) zu erhalten. Eine Option ist einen von LabView bereits fertigen "Signalgenerator" zu wählen. Dieser ist einfach und übersichtlich aufgebaut. Jedoch führte es schnell zu Problemen sobald man einen Zähler oder ein Abbruchkriterium hinzufügen möchte. In dem folgenden Programm wird dies über eine "flache Sequenz" realisiert.

Befindet man sich im Blockdiagramm, so können über die von LabView gestellte Funktionspalette die gewünschten Bausteine mittels Drag and Drop in die Arbeitsfläche gezogen werden. Unter "Programmierung" => "Strukturen" befindet sich der Baustein "Flache Sequenz". Nachdem diese auf die Arbeitsfläche gefügt wird, besteht dieses Bauteil nur aus einer Sequenz. Da wir für die Ansteuerung des Schrittmotors jedoch zwei unterschiedliche Zustände (1/0) benötigen, kann man über ein Rechtsklick der Sequenz "einen Rahmen danach einfügen" wählen. Um die Zustände der jeweiligen Sequenz zu definieren, wird über "Programmierung" => "Boolesch" eine "True"- bzw. "False-Konstante" eingefügt. Die Länge der einzelnen Zustände werden über Wartezeiten ("Warten auf ein Vielfaches von…") bestimmt ("Programmiereung" => "Timing"). Um den Output des Signals festzulegen, muss über den Projekt-Explorer der gewünschte DIO in das Blockdiagramm gefügt werden. Wichtig: Der gleiche DIO muss in jeder der Beiden Sequenzen vorhanden sein. Anschließen muss die True- bzw. False-Konstante mit dem jeweiligen DIO verbunden werden (Hier DIO0). Somit ändert sich der Zustand nach der definierten Wartezeit von z.B. 20ms von 1 (5V) auf 0(0V). Dieser Ablauf würde einem Step entsprechen. Um dies zu duplizieren, wird das Programm in eine While-Schleife gefügt ("Programmierung" => "Strukturen" => "While-Schleife"). Damit werden die Sequenzen so oft wiederholt, bis über ein Abbruchkriterium die Schleife gestoppt wird. Anfangs ist es sinnvoll dies über einen Schalter o.ä. zu realisieren (Rechtsklick auf das Abbruchkriterium der Schleife=> "Erstellen" => "Bedienelement").

Damit auch vom Front-Panel Einfluss auf diese Zeiten und damit die Fahrgeschwindigkeit des Schrittmotors genommen werden kann, ist ein Regler einzufügen, welcher außerhalb der „flachen Sequenzen“ liegt. Dieser kann mit beiden Warteelementen verbunden werden, da die Wartezeiten beider Zustände immer identisch sein sollte. (High- / Low-flanken jeweils 50%)

Verfahren einer vorgegebenen Wegstrecke

Einfügen eines Zählers:

Um mit dem Schrittmotor eine definierte Strecke zu verfahren, müssen vorab die tatsächlichen Zustandsänderungen gezählt werden. Auch hierbei gibt es mehrere Möglichkeiten. Eine einfache wie funktionelle Lösung wird im Folgenden beschrieben:

• Vorab muss eine Konstante erstellt werden, welche für den Startwert des Zählers steht (Programmierung => Numerisch => Num. Konstante) Diese muss für diesen Fall vor der ersten Sequenz positioniert werden.

• Sobald das Programm in die erste Sequenz springt soll der Zähler um 1 gesteigert werden. Dazu dient der Baustein Programmierung => Numerisch => Inkrementieren.

• Der Feedback-Node dient hierbei als Speicher und Rückkopplungselement.

• Um sich den aktuellen Zählerwert ausgeben zu lassen muss ein numerisches Anzeigeelement eingefügt werden, welches den Zählerstand nach dem Inkrementieren abgreift.

• Das eingefügte Anzeigeelementes erscheint ebenso automatisch im Front-Panel und kann dort jederzeit abgelesen werden.

Jedoch werden in diesem Fall nur die Anzahl der Steps angezeigt. Für die Ausgabe in Millimeter ist vorab eine kleine Rechenoption nötig. Aus dem Datenblatt des Schrittmotors lässt sich entnehmen, dass ein Schritt 0,033mm entspricht. Daher muss die Anzahl der Schritte mit 0,033 multipliziert werden. Ein weiteres Anzeigeelement ermöglicht die Ausgabe der aktuell verfahrenen Strecke in Millimeter. . Fügt man ein Eingabeelement hinzu, um die gewünschte Strecke im Millimeter einzugeben, muss dieser daher mit 30 multipliziert werden um die nötige Anzahl der Steps zu ermitteln. Um ein Abbruchkriterium der While-Schleife zu erzeugen, greift man den aktuellen Zählerwert der bereits gefahrenen Schritte ab und vergleicht („größer/gleich“) dieses Ergebnis mit der Anzahl an Steps, welche für die vorgegebene Wegstrecke nötig sind. Sobald dieser Vergleich „True“ ist, ist die Bedingung erfüllt um die While-Schleife zu verlassen. Mit diesem Vorgehen ist ein Verfahren einer vorgegebenen Wegstrecke möglich.

Richtungsänderung des Schrittmotors

Um die Verfahrrichtung des Schrittmotors zu ändern, muss zunächst ein Schalter, welches anschließend über das Frontpanel zu bedienen ist, in das Blockdiagramm eingefügt werden. Für die Übergabe des Signals an die Hardware ist der jeweilige DIO-Port (Hier DIO-1) aus dem Projekt-Explorer in das bestehende Programm zu involvieren. Da dies eine einmalige Abfrage beim Start des Programmes ist, ist der Befehl außerhalb der While-Schleife zu positionieren. Je nach Schaltlage gibt dieser ein Highpegel(5V) oder Lowpegel (0V) an den zuvor definierten Output des Hardwaremoduls. Damit ist die Drehrichtung des Motors definiert. In diesem Beispiel wird mittels LED´s die aktuell gefahrene Richtung visualisiert.

VORSICHT: In dem oben genannten Modus ist keine Real-time Übertragung an die Hardware möglich, d.h. im laufenden Programm kann keine Richtungsänderung mehr durchgeführt werden. Ist dies erwünscht, muss vorab das VI im Real-time Modus angelegt werden: VERWEIS

Einbindung der Endlagenschalter

Um eine unbeabsichtigte Kollision des Schlittens der Linearachse mit den mechanischen Endanschlägen zu vermeiden, werden Endlagenschalter eingesetzt, welche softwareseitig den Verfahrweg begrenzen. Es handelt sich dabei um Mikroschalter, welche als Schließerkontakt mit der Hardware verbunden werden. Dabei wird pro Schalter ein Ausgang der Hardware permanent auf High (5V) gesetzt und mit einem Kontakt des Schalters verbunden. Der andere Kontakt wird mit einem Eingang der Hardware verbunden, sodass bei betätigen des Schalters ein High-Signal auf einem Eingang festgestellt und entsprechend in der Software verarbeitet werden kann.

Die Umsetzung des Endlagen-Stops erfolgt durch die Verbindung mit der Abbruchbedingung der While-Schleife. Als Visualisierung können im Frontpanel LED´s eingefügt werden, die die Betätigung der Schalter anzeigen.

Auch hier gilt, dass das VI im Real-time Modus angelegt werden muss, um in Echtzeit durch die Endlagenschalter das Programm beeinflussen zu können.

Eine hundertprozentige Sicherheit gegen einen Crash bietet diese Lösung nicht! Es empfielt sich daher, um auch Softwarefehler auszuschließen, zusätzlich pro Seite der Linearachse einen Öffnerkontakt zu platzieren, welcher bei Betätigung die Stromzufuhr des Motors unterbricht und so ein weiteres Verfahren unmöglich macht.

Die softwareseitig eingebundenen Endschalter bieten auch die Möglichkeit, diese als Positionierhilfen zu verwenden. Denn auch wenn der Speicher der Software gelöscht worden sein könnte und daher die Ist-Position der Achse unbekannt ist, kann durch Verfahren bis zum Endschalter eine neue bekannte Ist-Position angelernt werden. Dabei muss jedoch sichergestellt sein, dass die Achse auf ihrem Weg zum Endschalter keinen Schaden anrichten kann (beispielsweise Bearbeitungswerkzeug NICHT im Eingriff).

Zentraler Steueralgorithmus

Konstruktion

Aufgabe im Fachthema

Das Fachthema Konstruktion im Rahmen des Praktikums „Produktionstechnik“ umfasst die mechanische Planung und den Aufbau einer CNC-Maschine. Es geht hierbei um die Zusammenstellung von Anforderungen bezüglich einer 3-Achs-CNC-Maschine sowie die konstruktive Planung mittels CAD-Modellen und technischen Zeichnungen und die Umsetzung dieser Planung durch die Montage der Maschine.

Erste Überlegungen

Im ersten Schritt wurden Anforderungen an die Maschine, an den Werkzeughalter sowie den Werkstückhalter gesammelt und ein erster Entwurf der Maschine erstellt.

Anforderungen

Um eine präzise Ausführung der Bewegungen zu realisieren, muss der Aufbau sowohl leichtgängig als auch verwindungssteif sein. Da die Maschine von mehreren Generationen von Studenten genutzt werden soll, sollte die Bedienung einfach und intuitiv sein. Um eine Flexibilität des Gebrauchs zu gewährleisten, sollte die Maschine möglichst leicht im Gewicht sein sowie (ggf. durch teilweise einfache Demontierbarkeit) gut transportierbar. Das verwendete Material sollte korrosionsbeständig, preisgünstig sowie mit einfachen Mitteln zu bearbeiten sein. Das Material war zum großen Teil bei Projektaufnahme bereits vorhanden.

Der Werkzeughalter sollte erweiterbar sein, sodass keine Beschränkung auf zuvor geplante Werkzeuge vorliegt. Der Werkzeughalter sollte entsprechend entweder kompatibel oder leicht zu wechseln sein. Durch eine gute Abriebfestigkeit soll eine hohe Genauigkeit sowie eine hohe Haltbarkeit erreicht werden.

Der Werkstückhalter sollte flexibel sein, sodass Werkstücke unterschiedlicher Form und Größe eingespannt werden können. Außerdem muss er nach Gebrauch leicht zu reinigen und gut transportierbar sein.

Erster Entwurf

In einem ersten Entwurf wurden zunächst verschiedene Möglichkeiten aufgezeigt, um eine 3-Achs-CNC-Maschine zu konzipieren. Generell gibt es die Möglichkeit, einen Tisch unterhalb eines Portalbalkens zu verfahren. Der Tisch stellt dabei die X-Achse dar. An dem Portalbalken sitzt die zweite Achse, welche im 90 Grad-Winkel zur X-Achse verfährt und die Y-Achse darstellt. Auf dieser Y-Achse sitzt wiederum im 90 Grad-Winkel die Z-Achse, welche senkrecht zur X-Achse steht.

Alternativ kann man ein in X-Richtung fahrbares Portal erzeugen, welches an einem feststehenden Tisch entlangfährt. Vorteil bei dieser Variante ist der geringere Platzbedarf und damit die bessere Ausnutzung der Linearachsen für die X-Achse. Nachteil ist, dass für eine ausreichende Steifigkeit das Portal stabiler ausgeführt werden muss, als dies bei einem feststehenden Portal nötig wäre. Da sämtliche Linearachsen bereits vorhanden waren und möglichst gut ausgenutzt werden sollten, entschied man sich für ein fahrbares Portal, bei welchem dieses an einem rechteckigen Grundrahmen vorbeifährt und damit die X-Achse darstellt.

Detaillierung

CNC-Maschine

Der beschriebene Aufbau wurde im Weiteren detailliert und ergänzt. Der generelle Aufbau der Maschine wurde in einem CAD-Modell erstellt. Mit hochkant angeordneten Aluminiumprofilen mit den Außenabmessungen 160x40mm wurde ein kastenförmiger Grundrahmen zusammengesetzt. Seitlich an den Längsseiten sitzen die Linearantriebe für die x-Achse. Diese sind an beiden Seiten angeordnet, um ein Verkanten des Portalbalkens bei außermittiger Krafteinwirkung zu verhindern. Der Kasten wird durch zwei weitere Aluminiumprofile versteift. Seitlich an den beiden X-Achsen-Linearantrieben werden senkrechte Aluminiumprofile montiert, welche einen waagerechten Portalbalken aufnehmen. Auf diesem ist der Linearantrieb der Y-Achse montiert, welcher wiederum den Linearantrieb der Z-Achse aufnimmt.

Als Arbeitsfläche dient eine Holzplatte, die bündig auf dem Tisch angebracht wird.

Die Konstruktion wurde um Haltewinkel für Endschalter sowie um eine Halterung für die benötigte E-Kette ergänzt. Es wurden für jede Achse vier Endschalter-Haltewinkel vorgesehen, wobei jeweils zwei an jedem Ende der Achsen hintereinander angebracht sind. Der jeweilige innere Endschalter wird von der jeweiligen Steuerung ausgelesen und kann beispielsweise als Referenzschalter verwendet werden. Der jeweilige äußere Endschalter dient als Not-Aus und geht direkt auf den Disable Eingang des Gecko-Drive. So wird der Gecko hardware-seitig ausgeschaltet, um einen mechanischen Schaden zu verhindern.

Werkzeug- und Werkstückhalter

Als Werkzeughalter wurden zwei Platten mit unterschiedlich großen Aussparungen zur Aufnahme zwei verschiedener Werkzeuge konstruiert. Die Platten sind mittels zwei Schrauben befestigt und so leicht zu wechseln. Als Werkstückhalter bieten sich die Holzplatte und eine ergänzte Nutenplatte. Hier kann das Werkstück auf der Holzplatte festgeschraubt werden beziehungsweise im Profil der Nutenplatte befestigt werden.

Platte für Steuerungseinheiten

Da für die Maschine die Steuerungseinheiten mit Treibern, Kühlern und Netzteilen benötigt werden, wurde eine Platte konzipiert, die genügend Platz für alle benötigten Elemente bietet. Es handelt sich hierbei um eine 80x50cm große Holzplatte. Um einen optimalen Wärmetransport zu realisieren, wurden die wärmsten Bauteile am oberen Ende der Platte angebracht. Die Geckos wurden mit entsprechendem Kühler über einen Aluminiumwinkel befestigt, darunter die Netzteile und am unteren Ende der Platte die Steuereinheiten und eine Mehrfachsteckdose. Eine Darstellung der Platte inklusive aller zu montierenden Elemente ist der Abbildung zu entnehmen

Stückliste & Montageanleitung

Stückliste

Bezeichnung	Anzahl
"Opferplatte"	1
"Adapter"	12
"Adapter2"	2
"AdapterYZAchse_kurz"	1
"AdapterYZAchse_kurz2"	1
"Elektroplatte"	1
"E_Kettenblech"	1
"E_Kettenblech2"	1
"E_Kettenblech3"	1
"E_Kettenblech4"	1
"Haltewinkel"	1
"Haltewinkel_Endschalter"	8
"Werkzeughalter"	1
"Z-Achse_kurz"	1
"Z-Achse_kurz_Adapter"	1
Profil 8 leicht 160x40 L1000	2
Profil 8 leicht160x40 L1126	1
Profil 8 leicht160x40 L920	2
Profil 8 leicht160x40 L520	2
Profil 8 leicht 160x40 1250	2
Zahnriemenantrieb ZLW-1040-02-B-100-R-300	1
MK-0089 Motorkit	1
Zahnriemenantrieb ZLW-1040-02-B-100-R-1000	3
MK-0089 Motorkit	3
Führungsschiene WS-20, 1120	1
Gehäuselager WJ200UM-01-20	2
Anschlußelementsatz 117.4.12PZ.A2	2
Winkel S208W40S	16
Kritec Winkel (80x80x80)Zn, Art.-Nr. 11355	12
Energiekette E16.4.060.0 Länge 1830mm	2
Nutenstein 8 St M8	118++
Gummifüße	6
Senkschraube DIN 7991-M8x14	32
Senkkopf-Holzschraube 4x20	19
Senkkopf-Holzschraube 2,5x25	4
Senkkopf-Holzschraube 3x20	6
Schraube M3x8 DIN912	30
Schraube M3x16 DIN912	12
Schraube M8x25 DIN912	24
Schraube M6x16 DIN912	24
Schraube M8x16 DIN912	16
Schraube M3x10 DIN912	16
Bohrschleifer IBS/E, Inkl. 34tlg. Einsatzwerkzeugeset und 6 Spannzangen	1
Steckerleiste, Conrad Best.-Nr.: 611856 - 62	1

Montageanleitung

Zunächst wird der Grundrahmen, wie unten abgebildet, zusammengebaut. Benötigt werden dafür Aluminiumprofile mit dem Querschnitt 160x40mm, je zwei Stück in den Längen 1250mm, 1000mm sowie 920mm. Die 1250mm langen Profile dienen als Längsprofil. Quer verbunden werden diese über die 1000mm langen Profile. Verbunden werden die Ecken mittels acht Aluminium-Druckgusswinkeln und passenden M8-Innensechskant-Schrauben. Der Rahmen wird innen durch die beiden 920mm langen Aluminiumprofile in drei gleich große Bereiche unterteilt. Montiert werden diese Profile mittels 16 schwarz lackierter Stahlwinkel, 32 passenden M8-Senkkopf-Innensechskant-Schrauben sowie 32 Nutensteinen.

An den beiden langen Seiten des Grundrahmens werden je Seite 4 "Adapter" mit Hilfe von je zwei M8x25-Innensechskantschrauben, zwei U-Scheiben M8 sowie zwei Nutensteinen montiert (blaue Markierungen). Dabei ist auf einen gleichmäßigen Abstand der vier "Adpater" zu achten.

Anschließend werden die beiden langen Linearachsen vom Typ Igus xxx mit insgesamt acht Befestigungsschellen und acht M6x16-Innensechskantschrauben mit den Adaptern formschlüssig verschraubt (blaue Markierung).