Ansteuerung einer Schrittmotor-Achse mit Mikrocontrollern am Beispiel eines Arduino-Mega
Aufgabenstellung
Die Aufgabe bestand zu Beginn darin, eine der drei Achsen unserer CNC Maschine anzusteuern, indem ein String ausgelesen wird welcher die Koordinaten sowie die Geschwindigkeit enthalten, und mithilfe eines über den Ardunino angesteuerten Schrittmotors ausgeführt werden. Dann wurde die Aufgabe ausgeweitet, alle drei Achsen anzusteuern und die fertige Programmierung durch zusammenfassen mit Funktionen übersichtilicher zu gestalten.
Innerhalb dieses HSHL-Wikipedia Eintrags wird nun die Automatisierung einer Achse mit dem Mikrocontroller(µC) „Arduino Mega“ als Steuerungskonzept vorgestellt. Auch wird ein Konzept zur Ansteuerung aller drei Achsen mit einem Programm und einem Arduino Mega vorgestellt.
Autoren: Stefan, Hünemeier; Mario, Saake; Christoph, Dörner;
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. Die folgende Abbildung visualisiert die beschriebenen Zusammenhänge.
Belegungsplan
Belegungsplan für eine Achse
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. Die Datei des Schaltplans liegt zur weiteren Bearbeitung der angefühten zip-Datei bei.
Belegungsplan für drei Achsen
Bei dem Anschluss aller drei Achsen an einen Arduino Mega ist der Plan außer kleinerer Abweichungen gleich. In dieser Variante werden noch zusätzlich zwei GeckoDrives angeschlossen auf die Selbe Art und Weise wie auch der erste Geckodrive. Ein weiterer kleiner Unterschied ist das wir noch drei Zusätzliche Paare mit Endschaltern für die Software anbringen müssen, diese werden direkt an dem Mikrocontroller angeschlossen. Wir benötigen drei weitere Endschalter, da wir in X-Richtung auf beiden Seiten eine Achse haben welche das obere Gestell mit der Y und Z Achse und das Werkzeug bewegen.
Aufbau
Der Aufbau des Projektes besteht aus vier Hauptkomponenten welche die eigentliche Achse mit dem Schrittmotor ist, einem GeckoDrive, einem Mikrocontroller (dem Arduino MEGA) und einem Netzteil. Jedes dieser Komponenten spielt eine wichtige Rolle. Sie müssen alle miteinander verbunden sein und nur durch den richtigen Aufbau und Anschluss dieser Teil kann das Projekt so funktionieren wie es von uns geplant wurde.
Mikrocontroller
Den Mikrocontroller welchen wir verwenden ist der Arduino MEGA er hat sowohl Analoge als auch Digitale Ein- und Ausgänge, eine externe Stromversorgung, eine ,,Reset Taste und einen Anschluss für eine USB-Schnittstelle. Auf den Arduino MEGA wird unser Programm welches mit Hilfe der dazugehörigen Software ,,Arduino, welche aus dem Opensource Bereich stammt und daher kostenlos ist aufgespielt. Den Mikrocontroller könnte man als das ,,Gehirn unseres Aufbaus nennen, da von hier alles gesteuert wird. Der Arduino Mega wurde mit dem Shield von SparkFun versehen um auch flexible Kabel mit ihm verbinden zu können.
Arduino MEGA mit montiertem SparkFun Shield
GeckoDrive
Der GeckoDrive ist ein zwischen Stück welches zwischen dem Arduino MEGA und dem Schrittmotor so wie zwischen dem Netzteil und dem Schrittmotor ist. Man kann es sich wie ein Verteiler vorstellen welches die Informationen und den Stromfluss wie durch Ventile für den Schrittmotor aufteilt und ihn so vorgibt wie er sich bewegen soll (Richtung und Geschwindigkeit).
GeckoDrive
Netzteil
Das Netzteil versorgt unseren Versuchsaufbau mit Strom. Die einzige Komponente die nicht vom Netzteil mit Strom versorgt wird, ist unser Arduino MEGA, da dieser über die USB-Schnittstelle schon mit Strom versorgt wird.
220V Netzteil
Achse mit Schrittmotor
Unsere Achse besteht aus einer Aluschiene mit einer Führungsschiene oben und unten worauf der Schlitten entlang fährt. Der Schlitten wird mit einem Gummiriemen in Bewegung gesetzt welcher von einem Schrittmotor gezogen wird. Der Schrittmotor ist am Ende der Achse montiert.
Achse mit montiertem Schrittmotor
Kombinieren der Komponenten
Alle Komponenten müssen miteinander verbunden werden. Zur besseren Erklärung fangen wir die Verbringung unserer Komponenten von hinten an. Am Ende steht unsere Achse mit dem montierten Schrittmotor welcher über den mit ihm Verbundenen Geckodrive mit Strom und Befehlen versorgt wird. Der GeckoDrive welcher die Befehle und den Strom an unseren Schrittmotor weiterleitet wird einerseits mit dem Netzteil verbunden welches die Stromversorgung darstellt. Auf der anderen Seite ist der GeckoDrive mit dem Arduino MEGA verbunden die von ihm gesendeten Befehle werden vom GeckoDrive umgewandelt und an den Schrittmotor weitergegeben.
Kompletter Aufbau bestehend aus der Achse, dem Schrittmotor, dem GeckoDrive und dem Arduino MEGA
Software
Kompatibilitätsermittlung für den Betrieb mit Geckodrive G201 REV-6
Mittels Oszilloskop muss zunächst die Schrittweite des Ausgangssignals vom Ardunio analysiert werden. Mit Betracht auf den folgenden Auszug des Datenblattes vom Geckodrive, kann festgestellt werden, ob die angegebende Mindestperiodendauer von 3,5us (mit der Annahme, dass GND am Common-Terminal des Geckodrives angeschlossen ist) einhalten wird.
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, was mit den oben gezeigten Abbildungen visualisiert wird.
Analyse der Vorwärts- und Rückwärtsbewegung des Hubschlittens
Die folgenden Abbildungen zeigen die Ermittlung des Vorwärts- Rückwärtssignals mittels Oszilloskop.
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
Die in diesem Kapitel vorgestellten Quellcodes werden zur weiteren Bearbeitung mit der angefügten zip-Datei zur Verfügung gestellt. Es werden zunächst die Aspekte und der Umfang des Programmes aufgelistet und im Folgenden durch weiterführende Gedanken ergänzt.
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, welche jeweilige Programmzeilen nachhaltig erläutern.
Angemerkt werden muss, dass die Bibliothek "Accelstepper" für die Arduino-Software vorinstalliert werden muss. Die Bibliothek liegt der zip-Datei dieses Artikels bei oder kann kostenfrei aus dem Internet geladen werden. Der Order „AccelStepper“ wird komplett in das Verzeichnis der Ardunino Software unter „libraries“ kopiert. Die Bibliothek kann nach Neustart der Software im Ardunio Programm genutzt 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 Duplizierung des Programmes auf alle Achsen hat zunächst Priorität gegenüber der Einbindung eines Inkrementalgebers. Es damit soll ein Ansprechen der gesamten Maschine per Steuerungsalgortihmus zum Ardunio realisiert werden. Folgende erreichte Aspekte lassen sich festhalten:
• Die Programmierung ist im Stande, alle drei Achsen anzusprechen
• Das Programm ist im Stande per Steuerungsalgorithmus angesprochen zu werden
• 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 --> Idee: Einbinden von Switch-Case Anweisungen
Programmablaufplan für die Ansteuerung von drei Achsen mit dem ArduinoMega
Das im Programm eingesetzte Vorgehen, zum Einlesen und Verarbeiten der Koordinaten, soll mit dem abgebildeten Ablaufdiagramm verdeutlicht werden:
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 Umrechnung plus Berechnung:
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;
}
}
Ausblick & Verbesserungen
Momentan ist es möglich den Schlitten auf der Achse zu bewegen und die Aktuelle Position in Echtzeit im Seriellen Monitor auszugeben. Die Bewegung können wir durch manuelle Eingabe eines Wertes in dem Seriellen Monitor starten oder durch auslesen eines Strings. Hierbei müssen die ausgelesenen Werte jedoch noch für die Distanz in die Korrekte Millimeter umgerechnet werden. Die Formel dazu steht schon im Programm bereit und muss jetzt noch auf unseren extrahierten Wert angewendet werden. Des weiteren kann noch die Geschwindigkeit aus dem String gelesen werden, welches aber nicht zwingend notwendig ist, da wir alle drei Achsen mit dem selben Mikrocontroller ansteuern und somit die Geschwindigkeit vorher im Programm festlegen können. Es ist auch möglich einzelne Abschnitte aus dem String auszulesen und diese dann an eine bestimmte Achse zu senden. Hierzu steht schon die Grundprogrammierung welche aber noch überarbeiten werden muss.
Folgende Punkte sind noch offen um das Projekt vollständig abzuschließen:
- Die Werte, welche der Schrittmotor fahren soll, sowie die Geschwindigkeit mit welcher er dies tuen soll, müssen Korrekt umgerechnet und angewendet werden.
- Die Endschalter welche das Programm Anhalten sollen und ein kleines Notfallprogramm starten sollen müssen überarbeitet und Korrekt in das Programm eingebunden werden.
- Alle GeckoDrives sowie auch die nötigen Software- und Hardware Endschalter anbauen, und bei der fertigen CNC-Maschine dann mit passendem Kabelbaum versehen.
- Ein Befehl in die Programmierung einfügen, der unsere Fräse oder 3D-Druckkopf nach vollenden der Aufgabe wieder an einen Definierten Ausgangspunkt fahren lässt.
- Das Fertige Programm muss ganz zum Schluss mit Hilfe von Funktionen gekürzt und Zusammengefasst werden, um es übersichtlicher und auch Professioneller zu gestalten.
- Sobald alle Komponenten fest an der CNC-Maschine verbaut sind, muss ein endgültiger Kabelbaum geschaffen werden. Dieser sollte die Längen (Spielraum für die Endschalter an den Achsen) sowie eine bestimmte Beweglichkeit und ein Schutz (Kabelummantlungen oder verstauen in einem Kabelschacht) berücksichtigen.
- Der Mikrocontroller muss mit den GeckoDrives und Netzteilungen im Schaltschrank fest verbaut werden.
- Auf dem Mikrocontroller muss das SparkFun Shield für den drei Achsen Belegungsplan dementsprechend angepasst werden.
Zusammenfassung
Den einzelnen Teilkapiteln dieses Artikels sind die aktuellen Status der betrachteten und bearbeiteten Aspekte zu entnehmen. Insgesamt wurde es realisiert, Komponenten, deren Kompatibilität zueinander zunächst unbekannt war, miteinander kommunizieren zu lassen und mit diesen Komponenten schließlich das errichtete Bearbeitungsportal in Bewegung zu setzen. Das Ansprechen des Programms über den, von einem anderen Team entwickelten Steuerungsalgorithmus, konnte ebenfalls umgesetzt werden. Weiterführende Gedanken und Vorschläge sind bereits in den Teilkapiteln vorzufinden. Eine Weiterentwicklung des aktuellen Standes ist mit den bereitgestellten Dateien zu diesem Fachthema umsetzbar.
Anhang:
- Aktueller Anhang mit dem neuen Programm und dazugehörigen Dokumenten wird noch angehängt
- Aktuellstes Programm noch auf dem HSHL Rechner und SVN (Status:10.02.15)