Arduino 3D Drahtbiegemaschine
In diesem Tutorial zeige ich Ihnen, wie ich eine Arduino-basierte 3D-Drahtbiegemaschine gebaut habe. Das ist eigentlich ein typisches mechatronisches System, weil es Mechanik, Elektrotechnik und Informatik umfasst. Daher glaube ich, dass viele Ingenieurstudenten oder alle, die neu in Mechatronik sind, dieses Projekt interessant fanden.
Sie können sich das folgende Video ansehen oder das schriftliche Tutorial unten lesen.
Hier ist das Arbeitsprinzip dieser 3D-Drahtbiegemaschine. Also geht der Draht zuerst durch eine Reihe von Walzen oder Richtmaschinen. Über einen Schrittmotor wird der Draht präzise dem Drahtbiegemechanismus zugeführt, der ebenfalls einen Schrittmotor sowie einen kleinen Servo für den Biegevorgang verwendet.
Es gibt auch einen weiteren Schrittmotor namens Z-Achse, der es der Maschine tatsächlich ermöglicht, dreidimensionale Formen zu erstellen. Natürlich ist das Gehirn der Maschine ein Arduino-Board, das zusammen mit den anderen Elektronikkomponenten auf einer kundenspezifischen Leiterplatte angebracht ist.
Was das Programm betrifft, habe ich einige benutzerdefinierte Funktionen zum Erstellen verschiedener Formen erstellt, wie z. B. einen Stern, einen Würfel und einen einfachen Ständer, sowie einen manuellen Modus, in dem wir die Drahtformen erstellen können, indem wir Befehle über den seriellen Monitor eingeben.
Wie üblich begann ich damit, das Projekt mit einer 3D-Modellierungssoftware zu erstellen. Sie können das 3D-Modell unten herunterladen.
Designinspiration:YouTube-Video
Sie können dieses 3D-Modell finden und herunterladen sowie es in Ihrem Browser auf Thangs erkunden.
Sie können das 3D-Montagemodell bei Thangs herunterladen.
STL-Dateien für den 3D-Druck:
Für einige der Teile, wie die Zahnräder, die Lagerböcke und einige Wellenkupplungen, habe ich einen 3D-Drucker verwendet, um sie herzustellen. Die STL-Dateien dieser Teile, die für den 3D-Druck verwendet werden, können von den Dateien oben heruntergeladen werden.
Mein neuer 3D-Drucker, Creality CR-10, hat großartige Arbeit geleistet und die Teile in hervorragender Qualität gedruckt. Hier ist ein Link zu diesem 3D-Drucker, falls Sie ihn ausprobieren möchten.
Ich fuhr mit der Vorbereitung der anderen Teile fort, für die ich MDF und Sperrholz verwendete. Nachdem ich alle Maße aus dem 3D-Modell genommen hatte, schneide ich die Stücke mit einer Kreissäge auf die richtige Größe. Ich habe 8 mm Tick MDF und 18 mm Tick Sperrholz verwendet. Sobald ich sie fertig hatte, begann ich mit der Montage. Zuerst habe ich die Basis aus zwei MDF-Platten und 4 Sperrholzsäulen gemacht. Zur Befestigung habe ich einen Holzleim und einige Schrauben verwendet.
Als nächstes befestigte ich auf der oberen Platte die 3D-gedruckten Lagerblöcke mit einigen 8 mm Schrauben und Muttern. Wir können hier feststellen, dass ich 3 mm dicke MDF-Platten zwischen der Oberseite und den Lagerblöcken hinzugefügt habe, damit ich die richtige Höhe bekomme. Jetzt können wir in diese Blöcke die 6202-Lager einbauen.
Ihr Außendurchmesser beträgt 35 mm und der Innendurchmesser 15 mm. Also müssen wir jetzt durch diese Lager eine 15 mm Hohlwelle einführen, damit der Draht hindurchgehen kann. Diese Welle ist eigentlich die Z-Achse, die es einem Biegemechanismus ermöglicht, sich um den Draht zu drehen und auf diese Weise dreidimensionale Formen herzustellen. Ich habe zu diesem Zweck ein Kupferrohr verwendet, dessen Länge etwa 30 cm betragen muss.
Zwischen den beiden Lagern habe ich auch ein 3D-gedrucktes Zahnrad mit einem Modul von 1,5 und 30 Zähnen eingefügt. Das Zahnrad hat kundenspezifische Schlitze, in die wir M3-Muttern einsetzen und dann mit M3-Schrauben das Zahnrad an der Welle befestigen können.
Als nächstes müssen wir den Schrittmotor der Z-Achse installieren. Zu diesem Zweck habe ich eine benutzerdefinierte Halterung in 3D gedruckt. Also befestigte ich den Stepper mit M3-Schrauben an der Halterung und steckte dann das 18-Zahn-Zahnrad auf die Motorwelle. Ich habe die gleiche Methode zum Befestigen des Zahnrads an der Welle verwendet, wie zuvor gezeigt.
Dann habe ich mit einem 6 mm Bohrer zwei Löcher auf der Oberseite gemacht, an denen die Montagehalterung befestigt wird. Wir können feststellen, dass die Halterung anstelle von Löchern Schlitze hat, wodurch die beiden Zahnräder richtig gepaart werden können.
Ich ging weiter mit der Installation des Schrittmotors für den Zuführmechanismus. Dieser Motor wird direkt auf der oberen Platte montiert, also habe ich die entsprechenden Löcher darauf gebohrt. Dann habe ich den Stepper mit vier Schrauben an der Platte befestigt, und falls Sie sich fragen, was diese Muttern hier tun, sie wirken tatsächlich als Distanzmuttern, weil die Schrauben, die ich hatte, länger waren und nicht in die Motorgewinde passen konnten.
Also müssen wir jetzt auf der Welle dieses Steppers den Feeder einsetzen. Zu diesem Zweck habe ich eine benutzerdefinierte Wellenkupplung in 3D gedruckt, in die ich ein Kupferrohr eingeführt habe, das tatsächlich die Kontaktfläche des Feeders sein wird.
Dann habe ich auf der gegenüberliegenden Seite des Motors einen Hebel eingesetzt, an dem ich ein Lager befestigt habe, das gegen den Feeder drückt. Um genügend Halt zu bekommen, damit der Feeder den Draht bewegen kann, befestige ich ein Stück Sperrholz mit einer T-Mutter darauf, und dann können wir mit einer Schraube den Griff des Feeders kontrollieren.
Der nächste Schritt ist die Herstellung des Drahtrichtsystems. Mit drei M8-Schrauben befestigte ich ein Stück Sperrholz, das ich zuvor gemäß dem 3D-Modell gebohrt hatte. Darauf habe ich nun die Rollen eingesetzt. Ich habe die Rollen aus Lagern und 3D-gedruckten genuteten Außenringen hergestellt.
Drei Rollen gehen auf dieser Seite und zwei Rollen auf der anderen Seite. Für die andere Seite habe ich einen Schlitz im Sperrholzstück gemacht, damit die Bolzen bündig mit dem Stück bleiben. Jetzt können wir mit nur zwei Schrauben die beiden Seiten paaren und mit den Muttern die Richtmaschinen entsprechend festziehen.
Nachdem ich mit diesem Schritt fertig war, fügte ich zwei weitere Sperrholzstücke vor und nach den Glätteisen hinzu, die als Drahtführungen dienen.
Ok, jetzt können wir mit der Herstellung des Drahtbiegemechanismus fortfahren. Zuerst müssen wir auf einem Stück MDF den Biegemotor befestigen. Bevor ich das tat, musste das MDF-Stück, das ich hatte, etwas formen, so dass ich mit einer Handsäge, einer Laubsäge und einer Raspel leicht die gewünschte Form bekam. Dann habe ich mit einer 38-mm-Lochsäge eine Öffnung für den größeren Schrittmotor gemacht, den wir für das Biegen verwenden werden, einen NEMA 23-Schrittmotor. Außerdem habe ich einige kleinere Löcher gebohrt, die für die Befestigung der anderen Teile benötigt werden.
Ich befestigte den NEMA 23-Stepper mit M4-Schrauben und Muttern und befestigte an seiner Ausgangswelle ein Zahnrad mit Modul von 2,5 und 18 Zähnen. Dieses Zahnrad wird mit einem größeren 30-Zähne-Zahnrad gepaart, bei dem es sich um ein kundenspezifisches Zahnrad mit integrierter Platte zur Montage eines MG996R-Servos handelt. Dieses Servo bewegt einen Zahnstangenmechanismus, der eigentlich ein Stift ist, der aus dem Zahnrad herausspringt und zum Biegen des Drahtes dient. Mit einem 5-Minuten-Epoxidharz befestigte ich ein Lager auf dem Zahnrad und fügte auch ein Stück Kupferrohr auf das Gestell, das die Kontaktfläche beim Biegen des Drahtes sein wird.
Nachdem das Epoxid getrocknet war, paarte ich die beiden Zahnräder, indem ich das größere Zahnrad mit einer M8-Schraube und einer Mutter befestigte. Dann habe ich das Gestell und das Servo eingesetzt und mit den im Servopaket enthaltenen Schrauben befestigt. Dann befestigte ich das Ritzel auf dem runden Horn des Servos mit zwei M3-Schrauben und Muttern.
Schließlich befestigte ich das Horn am Servo und damit war der Biegemechanismus fertig.
Jetzt muss nur noch der Bieger an der Z-Achse befestigt werden. Ich habe das mit den beiden 3D-gedruckten Wellenklemmen gemacht. Zuerst habe ich sie mit M6-Schrauben und Muttern an der Biegeplatte befestigt und dann in die Z-Achse eingeführt. Ich setzte die beiden Muttern ein und zog die Klemmen mit den Schrauben an der Welle fest. Jetzt funktionieren also alle beweglichen Teile einwandfrei.
Eigentlich müssten noch zwei kleine Details hinzugefügt werden. Das ist diese 3-mm-Düse am Schaft, wo der Draht herauskommt.
Und an der Unterseite des Biegers habe ich einen Mikro-Endschalter platziert, der zum Einstellen der Anfangsposition des Biegers verwendet wird.
Und das war's, unsere 3D-Drahtbiegemaschine ist fast fertig. Ich sage fast, denn jetzt müssen wir dieser Maschine Leben einhauchen oder die elektronischen Komponenten anschließen und programmieren.
Hier ist der Schaltplan dieses Projekts.
Die drei Schrittmotoren werden also mit den drei Schritttreibern DRV8825 gesteuert. Für die Stromversorgung der Stepper und des gesamten Projekts verwenden wir eine 12-V-Stromversorgung mit mindestens 3 A Stromstärke.
Für die Stromversorgung des Servos könnten wir die 5 V vom Arduino verwenden, aber das MG996R-Servo kann stromhungrig sein und der 5-V-Spannungsregler des Arduino kann möglicherweise nicht damit umgehen. Daher habe ich mich entschieden, einen separaten 5-V-Spannungsregler, den LM7805, zu verwenden, der gut genug ist, um das Servo für dieses Projekt mit Strom zu versorgen. Es gibt auch einen Endschalter für den Bieger, der einen Pull-up-Widerstand hat, der mit einem digitalen Pin des Arduino-Boards verbunden ist.
Die für dieses Projekt benötigten Komponenten erhalten Sie über die folgenden Links:
Als nächstes entwarf ich eine kundenspezifische Leiterplatte mit der kostenlosen Online-Schaltungsdesign-Software EasyEDA, um Kabelsalat zu beseitigen und die elektronischen Komponenten zu organisieren. Die Schaltung hat viele Verbindungen, also habe ich sowohl die obere als auch die untere Ebene verwendet, um sie zu organisieren. Ich habe auch Pins zur Auswahl der Auflösung des Steppers hinzugefügt, eine weitere Endschalterverbindung hinzugefügt und zusätzliche digitale und analoge Pins bereitgestellt, die vom Arduino kommen, falls wir sie für etwas brauchen.
Hier ist ein Link zu den Projektdateien dieses PCB-Designs. Nachdem ich mit diesem Design fertig war, habe ich die Gerber-Datei generiert, die für die Herstellung der Leiterplatte benötigt wird.
Gerber-Datei:
Dann bestellte ich die Platine bei JLCPCB, das eigentlich der Sponsor dieses Projekts ist.
Hier können wir die Gerber-Datei einfach per Drag-and-Drop ziehen und nach dem Hochladen können wir unser PCB im Gerber-Viewer überprüfen. Wenn alles in Ordnung ist, können wir weitermachen, die Eigenschaften auswählen, die wir für unsere Leiterplatte wünschen, und dann können wir unsere Leiterplatte zu einem günstigen Preis bestellen. Beachten Sie, dass Sie bei Ihrer ersten Bestellung bei JLCPCB bis zu 10 PCBs für nur 2 $ erhalten können.
Nach einigen Tagen sind die Leiterplatten eingetroffen. Die Qualität der Leiterplatten ist super und alles ist genau so wie im Design.
Jetzt können wir also weitermachen und die Elektronikkomponenten auf der Leiterplatte installieren. Ich begann mit dem Löten von Stiftleisten auf die Platine. Dies ermöglicht bei Bedarf ein einfacheres Verbinden und Trennen der Komponenten. Was die kleineren Komponenten betrifft, wie die Kondensatoren, die Widerstände, den Spannungsregler und die Klemmleisten, habe ich sie direkt auf die Platine gelötet.
Sobald dieser Schritt abgeschlossen ist, können wir nun die Stepper-Treiber und den Arduino einsetzen. Dann müssen wir den Netzstecker und den Netzschalter an die Klemmleisten anschließen, die Kabel an den Schrittmotoren auf der einen Seite anschließen und sie auf der anderen Seite mit der Platine verbinden. Das Servo ist mit dem digitalen Pin Nummer 2 verbunden und wird mit den 5 V versorgt, die vom Spannungsregler LM7805 kommen. Schließlich können wir die Schrittauflösung auswählen, indem wir die Auflösungsstifte unter den Treibern verbinden.
Ich habe mich entschieden, die 16. Schrittauflösung zu verwenden, also müssen wir die richtigen Pins anstelle der mittleren verbinden, wie auf dem Foto oben zu sehen ist. Die elektronischen Komponenten sind also fertig und wir können mit der Programmierung der Drahtbiegemaschine fortfahren.
Da der Code etwas länger ist, werde ich zum besseren Verständnis den Quellcode des Programms in Abschnitten mit Beschreibung für jeden Abschnitt veröffentlichen. Und am Ende dieses Artikels werde ich den kompletten Quellcode posten.
Zur Steuerung der Schrittmotoren verwende ich die AccelStepper-Bibliothek von Mike McCauley. Daher müssen wir diese Bibliothek sowie die Servobibliothek zur Steuerung des Servomotors einbeziehen. Dann müssen wir die Pins definieren, an die die Stepper angeschlossen sind, und einige Variablen, die für das folgende Programm benötigt werden.
Im Setup-Bereich stellen wir die Anfangsposition des Servos oder des Biegestifts ein und stellen auch die Anfangsposition des Biegegetriebes ein. Dies geschieht mit Hilfe des Endschalters. Der Stepper dreht sich in Richtung des Schalters und sobald er gedrückt wird, beginnt der Motor, die Schritte von Null zu zählen und positioniert sich auf Null Grad, bereit zum Biegen.
Jetzt warten wir im Schleifenabschnitt auf Befehle, die vom seriellen Monitor kommen. Wenn wir manuell eingeben, gelangen wir in den manuellen Biegemodus oder wenn wir zum Beispiel Stern eingeben, wird die benutzerdefinierte Funktion start() ausgeführt und die Maschine erstellt automatisch eine Sternform für uns.
Werfen wir einen Blick auf diese benutzerdefinierte Funktion.
Hier treten wir also in eine While-Schleife ein, die 5 Mal ausgeführt wird, da der Stern offensichtlich 5 Punkte hat. Wir beginnen mit der Einstellung des Vorschubwerts, oder so viel Draht wird in Millimetern zugeführt. Dieser Wert wird dann mit 48 multipliziert, was den Vorschubwert in geeignete Schritte für die Bewegung des Schrittmotors übersetzt. Dann drehen wir mit der Funktion run() den Feeder-Motor mit einer Geschwindigkeit, die durch die Funktion setSpeed() eingestellt wird. Wir stoppen, wenn der obige feedDistance-Wert erreicht ist, und setzen direkt danach den aktuellen Positionswert des Steppers auf Null.
Im nächsten Schritt biegen wir den Draht um 52 Grad. Dies geschieht auf ähnliche Weise wie oben erläutert. Auch hier haben wir eine Winkelkonstante, die mit dem gewünschten Winkel multipliziert wird. Sobald dieser Wert vom Motor erreicht wird, stoppt der Motor, setzt seine aktuelle Position auf 0 zurück und führt dann die gleiche Anzahl von Schritten in die entgegengesetzte Richtung aus, wodurch der Motor tatsächlich in seine Ausgangsposition zurückkehrt.
Dann führen wir wieder die gleiche Drahtlänge zu und setzen den Stift ab, damit der Bieger in eine neue Ausgangsposition fahren kann, die zum Biegen in die andere Richtung verwendet wird. Der Biegestift wird dann angehoben, und so biegen wir den Draht um 105 Grad in die entgegengesetzte Richtung. Die Befehle werden 5 Mal wiederholt und so erhalten wir die Sternform.
Auf ähnliche Weise wie oben erklärt, machen wir die Würfelform oder eigentlich jede andere Form, die uns einfällt. Wie beim manuellen Modus ist das Funktionsprinzip der Befehle das gleiche, außer dass wir einige Zeilen mehr zum Lesen der Befehle haben, die vom seriellen Monitor kommen. Zum Beispiel müssen wir zum Zuführen des Drahtes „f“ plus den Abstand in Millimetern eingeben, zum Biegen des Drahtes müssen wir „b“ plus den Winkel in Grad eingeben und zum Drehen der Z-Achse benötigen wir um „z“ plus den Winkel in Grad einzugeben.
So funktioniert das von mir erstellte Programm, aber natürlich gibt es viele andere Möglichkeiten, dies zu codieren. Hier ist der vollständige Arduino-Code für diese 3D-Drahtbiegemaschine:
At the end I would like to point out that the wire straightening system of the wire bending machine is actually not working like it should work, because if I tighten it more, the feeder loses grip and the wire doesn’t move.
For solving this issue you could try to use different, stronger material than the copper tube or make a different feeder system.
So that’s it. Ich hoffe, dir hat dieses Video gefallen und du hast etwas Neues gelernt. Fühlen Sie sich frei, Fragen im Kommentarbereich unten zu stellen und sehen Sie sich meine Arduino-Projektsammlung an.Übersicht
DIY 3D-Drahtbiegemaschine 3D-Modell
Bau der Drahtbiegemaschine
Schaltplan
PCB-Design
Arduino Code for 3D Wire Bending Machine Project
#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
// Define the stepper motors and the pins the will use
AccelStepper feederStepper(1, 5, 6); // (Type:driver, STEP, DIR)
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;
String dataIn = "";
String manualStatus = "";
int count = 0;
int dist; Codesprache:Arduino (arduino) void setup() {
Serial.begin(9600);
pinMode(limitSwitch, INPUT_PULLUP);
servo01.attach(2);
servo01.write(40); // Initial position, bending pin up
// Stepper motors max speed
feederStepper.setMaxSpeed(2000);
zAxisStepper.setMaxSpeed(2000);
benderStepper.setMaxSpeed(2000);
// Homing
while (digitalRead(limitSwitch) != 0) {
benderStepper.setSpeed(1200);
benderStepper.runSpeed();
benderStepper.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
}
delay(40);
// Move 1400 steps from the limit switch to starting position
while (benderStepper.currentPosition() != -1400) {
benderStepper.setSpeed(-1200); // if negative rotates anti-clockwise
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
} Codesprache:Arduino (arduino) void loop() {
String mode = Serial.readString();
if (mode.startsWith("manual")) {
manual();
}
if (mode.startsWith("star")) {
star();
}
if (mode.startsWith("cube")) {
cube();
}
if (mode.startsWith("stand")) {
stand();
}
} Codesprache:Arduino (arduino) void star() {
while (count != 5) {
int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0
servo01.write(40); // Set the bender pin up
delay(200);
int angleConst = 18; // angle constant
// Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Feed the same distance again
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
servo01.write(130); // Set the bender pin down
delay(200);
// Set bender to new initial position, for bending in the other direction
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(200);
servo01.write(40); // Bender pin up
delay(200);
while (benderStepper.currentPosition() != 105 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(50);
while (benderStepper.currentPosition() != -63 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
delay(100);
servo01.write(130);
benderStepper.setCurrentPosition(0);
count++;
}
} Codesprache:Arduino (arduino) int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0 Codesprache:Arduino (arduino) // Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100); Codesprache:Arduino (arduino) if (dataIn.startsWith("f")) {
dataInS = dataIn.substring(1, dataIn.length()); // reads the feed value
dist = dataInS.toInt();
Serial.print("Feed ");
Serial.print(dist);
Serial.println("mm wire.");
dist = dist * 48;
while (feederStepper.currentPosition() != dist) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
} Codesprache:Arduino (arduino) /*
Arduino 3D Wire Bending Machine
by Dejan Nedelkovski
www.HowToMechatronics.com
Library - AccelStepper by Mike McCauley:
http://www.airspayce.com/mikem/arduino/AccelStepper/index.html
*/
#include <AccelStepper.h>
#include <Servo.h>
#define limitSwitch 11
// Define the stepper motors and the pins the will use
AccelStepper feederStepper(1, 5, 6); // (Type:driver, STEP, DIR)
AccelStepper zAxisStepper(1, 7, 8);
AccelStepper benderStepper(1, 9, 10);
Servo servo01;
String dataIn = "";
String manualStatus = "";
int count = 0;
int dist;
void setup() {
Serial.begin(9600);
pinMode(limitSwitch, INPUT_PULLUP);
servo01.attach(2);
servo01.write(40); // Initial position, bending pin up
// Stepper motors max speed
feederStepper.setMaxSpeed(2000);
zAxisStepper.setMaxSpeed(2000);
benderStepper.setMaxSpeed(2000);
// Homing
while (digitalRead(limitSwitch) != 0) {
benderStepper.setSpeed(1200);
benderStepper.runSpeed();
benderStepper.setCurrentPosition(0); // When limit switch pressed set position to 0 steps
}
delay(40);
// Move 1400 steps from the limit switch to starting position
while (benderStepper.currentPosition() != -1400) {
benderStepper.setSpeed(-1200); // if negative rotates anti-clockwise
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
}
void loop() {
String mode = Serial.readString();
if (mode.startsWith("manual")) {
manual();
}
if (mode.startsWith("star")) {
star();
}
if (mode.startsWith("cube")) {
cube();
}
if (mode.startsWith("stand")) {
stand();
}
}
void star() {
while (count != 5) {
int feed = 38; // mm
int feedDistance = feed * 48; // 48- constats that map the mm value to number of steps the stepper show move
while (feederStepper.currentPosition() != feedDistance) { // run until it reaches the distance value
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0); // reset the current position to 0
servo01.write(40); // Set the bender pin up
delay(200);
int angleConst = 18; // angle constant
// Bend the wire 52 degrees
while (benderStepper.currentPosition() != -52 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Go back 52 degrees to initial position
while (benderStepper.currentPosition() != 52 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Feed the same distance again
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
servo01.write(130); // Set the bender pin down
delay(200);
// Set bender to new initial position, for bending in the other direction
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(200);
servo01.write(40); // Bender pin up
delay(200);
while (benderStepper.currentPosition() != 105 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(50);
while (benderStepper.currentPosition() != -63 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
delay(100);
servo01.write(130);
benderStepper.setCurrentPosition(0);
count++;
}
}
void cube() {
int feed = 40; // mm
int feedDistance = feed * 48;
int angleConst = 16;
// Step 1
while (count != 3) {
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
// Step 2
while (zAxisStepper.currentPosition() != 88 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
//Step 3
while (count != 2) {
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
// Step 4
while (zAxisStepper.currentPosition() != 85 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
// Step 5
servo01.write(130);
delay(200);
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
while (count != 3) {
delay(100);
servo01.write(40);
delay(200);
// Step 6
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
count++;
}
count = 0;
}
void stand() {
int feed = 20; // mm
int feedDistance = feed * 48;
int angleConst = 16;
// Step 1
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 2
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -70 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 70 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 3
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
// Step 4
servo01.write(130);
delay(200);
while (benderStepper.currentPosition() != -42 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(40);
delay(200);
while (benderStepper.currentPosition() != 108 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -66 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
//Step 5
servo01.write(130);
delay(200);
// Step 6
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
servo01.write(40);
delay(200);
// Step 7
while (zAxisStepper.currentPosition() != -90 * angleConst) {
zAxisStepper.setSpeed(-500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
// Step 8
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 6
feed = 45; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
// Step 10
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 48 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 11
while (zAxisStepper.currentPosition() != 90 * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
// Step 12
while (benderStepper.currentPosition() != 110 * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != -68 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
//Step 13
servo01.write(130);
delay(200);
feed = 80; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
servo01.write(40);
delay(200);
// Step 14
while (benderStepper.currentPosition() != -70 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 70 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
//Step 15
feed = 25; // mm
feedDistance = feed * 48;
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
// Step 16
while (benderStepper.currentPosition() != -90 * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != 90 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
// Step 17
while (feederStepper.currentPosition() != feedDistance) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
}
void manual() {
int sign;
String dataInS;
int angle;
int angleConst;
Serial.println(" // MANUAL MODE //");
while (!dataIn.startsWith("end")) {
servo01.write(130);
delay(200);
dataIn = Serial.readString();
if (dataIn.startsWith("f")) {
dataInS = dataIn.substring(1, dataIn.length()); // reads the feed value
dist = dataInS.toInt();
Serial.print("Feed ");
Serial.print(dist);
Serial.println("mm wire.");
dist = dist * 48;
while (feederStepper.currentPosition() != dist) {
feederStepper.setSpeed(1200);
feederStepper.run();
}
feederStepper.setCurrentPosition(0);
delay(100);
}
if (dataIn.startsWith("b")) {
if (dataIn.charAt(1) == '-') {
dataInS = dataIn.substring(2, dataIn.length()); ///reads the angle value
angle = dataInS.toInt();
Serial.print("Bend -");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
// Set "negative" bending initial position
while (benderStepper.currentPosition() != -43 * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(40);
delay(200);
// Bend the wire
while (benderStepper.currentPosition() != angle * angleConst) {
benderStepper.setSpeed(700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != (-1) * angle * angleConst) {
benderStepper.setSpeed(-1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
servo01.write(130);
delay(200);
// Get back to original "positive" bending initial poistion
while (benderStepper.currentPosition() != 43 * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
else {
dataInS = dataIn.substring(1, dataIn.length());
angle = dataInS.toInt();
Serial.print("Bend ");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
servo01.write(40);
delay(200);
while (benderStepper.currentPosition() != (-1) *angle * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != angle * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
dataInS = dataIn.substring(2, dataIn.length());
angle = dataInS.toInt();
angleConst = 16;
while (benderStepper.currentPosition() != sign * angle * angleConst) {
benderStepper.setSpeed(-700);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
while (benderStepper.currentPosition() != sign * angle * angleConst) {
benderStepper.setSpeed(1200);
benderStepper.run();
}
benderStepper.setCurrentPosition(0);
delay(100);
}
// Z-Axis Control
if (dataIn.startsWith("z")) {
if (dataIn.charAt(1) == '-') {
dataInS = dataIn.substring(2, dataIn.length());
angle = dataInS.toInt();
Serial.print("Move Z-Axis -");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
while (zAxisStepper.currentPosition() != angle * angleConst) {
zAxisStepper.setSpeed(500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
}
else {
dataInS = dataIn.substring(1, dataIn.length());
angle = dataInS.toInt();
Serial.print("Move Z-Axis ");
Serial.print(angle);
Serial.println(" degrees.");
angleConst = 16;
while (zAxisStepper.currentPosition() != (-1) *angle * angleConst) {
zAxisStepper.setSpeed(-500);
zAxisStepper.run();
}
zAxisStepper.setCurrentPosition(0);
delay(100);
}
}
manualStatus = dataIn;
}
}
Codesprache:Arduino (arduino) 
Herstellungsprozess
- Nähmaschine
- Stacheldraht
- Sechseckige Drahtgeflechtmaschine
- Wie kann eine Drahtschneidemaschine helfen?
- Was ist die Blechbiegemaschine?
- Drahterodieren:Ein Einblick in die taiwanesische Metallindustrie
- Ultimative Drahterodiermaschine in Taiwan
- Die fantastische CNC-Rohrbiegemaschine
- Eine Kurzanleitung zur Vierkantrohrbiegemaschine
- Hydraulische Rohrbiegemaschine für Werkstätten