Arduino 3D-draadbuigmachine
In deze tutorial laat ik je zien hoe ik een op Arduino gebaseerde 3D-draadbuigmachine heb gebouwd. Dit is eigenlijk een typisch mechatronisch systeem omdat het mechanische, elektrische en computertechniek omvat. Daarom denk ik dat veel technische studenten of iedereen die nieuw is in mechatronica dit project interessant vonden.
Je kunt de volgende video bekijken of de schriftelijke tutorial hieronder lezen.
Overzicht
Hier is het werkingsprincipe van deze 3D-draadbuigmachine. Dus eerst gaat de draad door een reeks rollen of stijltangen. Met behulp van een stappenmotor wordt de draad nauwkeurig naar het draadbuigmechanisme geleid, dat ook een stappenmotor en een kleine servo gebruikt voor het buigproces.
Er is ook een andere stappenmotor, de Z-as, die de machine in staat stelt om driedimensionale vormen te creëren. Het brein van de machine is natuurlijk een Arduino-bord dat samen met de andere elektronische componenten op een speciaal ontworpen PCB is bevestigd.
Wat het programma betreft, ik heb enkele aangepaste functies gemaakt voor het maken van verschillende vormen, zoals een ster, een kubus en een eenvoudige standaard, evenals een handmatige modus waarin we de draadvormen kunnen maken door opdrachten in te voeren via de seriële monitor.
DIY 3D-draadbuigmachine 3D-model
Zoals gewoonlijk begon ik met het maken van het project met behulp van een 3D-modelleringssoftware. U kunt het 3D-model hieronder downloaden.
Ontwerpinspiratie:YouTube-video
U kunt dit 3D-model vinden en downloaden, en het ook verkennen in uw browser op Thangs.
U kunt het montage 3D-model downloaden op Thangs.
STL-bestanden voor 3D-printen:
Voor sommige onderdelen, zoals de tandwielen, de lagerkussenblokken en enkele askoppelingen heb ik een 3D-printer gebruikt om ze te maken. De STL-bestanden van deze onderdelen, die worden gebruikt voor 3D-printen, kunnen worden gedownload van de bovenstaande bestanden.
Mijn nieuwe 3D-printer, Creality CR-10, heeft geweldig werk geleverd en de onderdelen met geweldige kwaliteit geprint. Hier is een link naar deze 3D-printer voor het geval je hem wilt bekijken.
De draadbuigmachine bouwen
Ik ging verder met het voorbereiden van de andere onderdelen, waarvoor ik MDF en multiplex gebruikte. Dus toen ik met een cirkelzaag alle afmetingen uit het 3D-model had gehaald, zaagde ik de stukken op maat. Ik gebruikte 8 mm tick MDF en 18 mm tick multiplex. Toen ik ze klaar had, begon ik met de montage. Eerst maakte ik de basis van twee MDF-platen en 4 multiplex kolommen. Om ze vast te zetten heb ik houtlijm en wat schroeven gebruikt.
Vervolgens heb ik op het bovenpaneel de 3D-geprinte lagerkussenblokken bevestigd met behulp van 8 mm bouten en moeren. We kunnen hier opmerken dat ik 3 mm tick MDF-platen heb toegevoegd tussen de bovenkant en de kussenblokken zodat ik de juiste hoogte krijg. Nu kunnen we in deze blokken de 6202 lagers passen.
Hun buitendiameter is 35 mm en de binnendiameter is 15 mm. Dus nu, door deze lagers, moeten we een holle as van 15 mm plaatsen zodat de draad er doorheen kan. Deze as is eigenlijk de Z-as, waardoor het buigmechanisme rond de draad kan draaien en op die manier driedimensionale vormen kan maken. Ik heb daarvoor een koperen buis gebruikt en de lengte moet ongeveer 30 cm zijn.
Tussen de twee lagers heb ik ook een 3D-geprint tandwiel gestoken met module van 1,5 en 30 tanden. Het tandwiel heeft speciaal ontworpen sleuven waar we M3-moeren kunnen plaatsen en met behulp van M3-bouten kunnen we het tandwiel op de as vastzetten.
Vervolgens moeten we de Z-as stappenmotor installeren. Voor dat doel heb ik een op maat gemaakte montagebeugel 3D geprint. Dus ik bevestigde de stepper aan de beugel met behulp van M3-bouten en plaatste vervolgens het 18-tands tandwiel op de motoras. Ik heb dezelfde methode gebruikt om het tandwiel aan de as te bevestigen, zoals eerder getoond.
Vervolgens heb ik met een boor van 6 mm aan de bovenzijde twee gaatjes gemaakt waarop de montagebeugel wordt vastgezet. We kunnen zien dat de beugel in plaats van gaten sleuven heeft waardoor de twee versnellingen goed kunnen worden gekoppeld.
Ik ging verder met het installeren van de stappenmotor voor het feedermechanisme. Deze motor wordt direct op de bovenplaat gemonteerd, dus ik heb er de juiste gaten in geboord. Vervolgens heb ik de stepper met vier bouten aan de plaat vastgemaakt, en voor het geval je je afvraagt wat die moeren hier doen, ze fungeren eigenlijk als afstandsmoeren omdat de bouten die ik had langer waren en niet in de schroefdraad van de motor pasten.
Dus nu op de as van deze stepper moeten we de feeder plaatsen. Voor dat doel heb ik een aangepaste askoppeling in 3D geprint waarop ik een koperen buis heb geplaatst die feitelijk het contactoppervlak van de feeder zal zijn.
Vervolgens heb ik aan de andere kant van de motor een hendel geplaatst, waarop ik een lager heb bevestigd dat tegen de feeder zal drukken. Om voldoende grip te krijgen zodat de feeder de draad kan verplaatsen, bevestig ik een stuk triplex met een T-moer erop, en dan kunnen we met een bout de grip van de feeder regelen.
De volgende stap is het maken van het draadrichtsysteem. Met behulp van drie M8-bouten heb ik een stuk triplex vastgezet dat ik eerder volgens het 3D-model had geboord. Nu heb ik er de rollers bovenop gestoken. Ik heb de rollen gemaakt van lagers en 3D-geprinte gegroefde buitenringen.
Aan deze kant gaan drie rollen en aan de andere kant twee rollen. Voor de andere kant maakte ik een gleuf in het stuk multiplex zodat de bouten gelijk met het stuk blijven. Met slechts twee bouten kunnen we nu de twee kanten koppelen, en met behulp van de moeren kunnen we de stijltangen op de juiste manier vastdraaien.
Toen ik klaar was met deze stap, voegde ik nog twee stukken triplex toe aan de voorkant en na de stijltangen die als draadgeleiders zullen dienen.
Ok, dus nu kunnen we verder gaan met het maken van het draadbuigmechanisme. Eerst op een stuk MDF moeten we de buigmotor bevestigen. Voordat ik dat deed, had ik het MDF-stuk dat ik moest vormen, dus met een handzaag, een copingzaag en een rasp kreeg ik gemakkelijk de gewenste vorm. Vervolgens heb ik met een 38 mm gatenzaag een opening gemaakt voor de grotere stappenmotor die we gaan gebruiken voor het buigen, een NEMA 23 stappenmotor. Ook heb ik wat kleinere gaten geboord die nodig zijn voor het bevestigen van de andere onderdelen.
Ik heb de NEMA 23-stepper vastgezet met M4-bouten en -moeren en op de uitgaande as heb ik een tandwiel met module van 2,5 en 18 tanden bevestigd. Deze versnelling wordt gecombineerd met een groter tandwiel met 30 tanden, een op maat ontworpen tandwiel met geïntegreerde plaat voor het monteren van een MG996R-servo. Deze servo zal een tandheugelmechanisme verplaatsen, wat eigenlijk een pen is die uit het tandwiel springt en zal dienen voor het buigen van de draad. Met behulp van een epoxy van 5 minuten heb ik een lager op het tandwiel bevestigd en ook een stuk koperen buis op het rek toegevoegd, dat het contactoppervlak zal zijn bij het buigen van de draad.
Nadat de epoxy was opgedroogd, heb ik de twee tandwielen gekoppeld door het grotere tandwiel op zijn plaats te bevestigen met een M8-bout en een moeren. Vervolgens heb ik het rek en de servo op hun plaats gestoken en vastgezet met de schroeven die in het servo-pakket zijn meegeleverd. Daarna heb ik het rondsel op de ronde hoorn van de servo bevestigd met twee M3-bouten en moeren.
Ten slotte heb ik de hoorn op de servo bevestigd en hiermee was het buigmechanisme voltooid.
Wat u nu nog moet doen, is de buigmachine aan de Z-as bevestigen. Ik deed dat met behulp van de twee 3D-geprinte asklemmen. Eerst heb ik ze met M6-bouten en -moeren aan de buigplaat bevestigd en vervolgens in de Z-as gestoken. Ik heb de twee moeren op hun plaats gestoken en met behulp van de bouten heb ik de klemmen op de as vastgedraaid. Dus nu werken alle bewegende delen naar behoren.
Eigenlijk moeten er nog twee kleine details worden toegevoegd. Dat is dit mondstuk van 3 mm op de as waar de draad uitkomt.
En aan de onderkant van de buigmachine heb ik een micro-eindschakelaar geplaatst die zal worden gebruikt voor het instellen van de beginpositie van de buigmachine.
En dat is alles, onze 3D-draadbuigmachine is bijna klaar. Ik zeg bijna, want nu moeten we deze machine tot leven brengen, of de elektronische componenten aansluiten en programmeren.
Circuitdiagram
Hier is het schakelschema van dit project.
Dus de drie stappenmotoren worden aangestuurd met behulp van de drie DRV8825 stappenmotoren. Voor het voeden van de steppers en het hele project gebruiken we een 12V-voeding met een stroomsnelheid van minimaal 3A.
Voor het aandrijven van de servo kunnen we de 5V van de Arduino gebruiken, maar de MG996R-servo kan veel stroom verbruiken en de 5V-spanningsregelaar van de Arduino kan het misschien niet aan. Daarom besloot ik een aparte 5V-spanningsregelaar te gebruiken, de LM7805, die goed genoeg is om de servo voor dit project van stroom te voorzien. Er is ook een eindschakelaar voor de bender die een pull-up-weerstand heeft die is verbonden met een digitale pin van het Arduino-bord.
U kunt de benodigde componenten voor dit project vinden via de onderstaande links:
- Stappenmotor – NEMA 17………
- Stappenmotor – NEMA 23 ……..
- DRV8825 Stepper-stuurprogramma…….….
- Micro-eindschakelaar ………..………
- 12V 2A-adapter………………..….
- Stroomaansluiting………….………….……
- Arduino-bord ……………………
PCB-ontwerp
Vervolgens heb ik, om van de bedradingsrommel af te komen en de elektronische componenten georganiseerd te houden, een aangepaste PCB ontworpen met behulp van de gratis EasyEDA-software voor online circuitontwerp. Het circuit heeft veel verbindingen, dus ik heb zowel de bovenste als de onderste lagen gebruikt om ze te ordenen. Ik heb ook pinnen toegevoegd voor het selecteren van de resolutie van de steppers, nog een limietschakelaarverbinding toegevoegd en extra digitale en analoge pinnen van de Arduino voorzien voor het geval we ze ergens voor nodig hebben.
Hier is een link naar de projectbestanden van dit PCB-ontwerp. Dus toen ik klaar was met dit ontwerp, heb ik het Gerber-bestand gegenereerd dat nodig is voor het maken van de PCB.
Gerber-bestand:
Toen bestelde ik de PCB bij JLCPCB, die eigenlijk de sponsor van dit project is.
Hier kunnen we eenvoudig het Gerber-bestand slepen en neerzetten en eenmaal geüpload, kunnen we onze PCB bekijken in de Gerber-viewer. Als alles in orde is, kunnen we doorgaan, de eigenschappen selecteren die we voor onze PCB willen, en dan kunnen we onze PCB tegen een redelijke prijs bestellen. Houd er rekening mee dat als het uw eerste bestelling bij JLCPCB is, u tot 10 PCB's kunt krijgen voor slechts $ 2.
Na enkele dagen zijn de PCB's gearriveerd. De kwaliteit van de PCB's is geweldig en alles is precies hetzelfde als in het ontwerp.
Dus nu kunnen we verder gaan en de elektronische componenten op de printplaat installeren. Ik begon met het solderen van pin-headers op de printplaat. Dit maakt het gemakkelijker om de componenten aan te sluiten en los te koppelen wanneer dat nodig is. Wat betreft de kleinere componenten, zoals de condensatoren, de weerstanden, de spanningsregelaar en de aansluitblokken, heb ik ze rechtstreeks op de print gesoldeerd.
Als we klaar zijn met deze stap, kunnen we nu de stepper-stuurprogramma's en de Arduino op hun plaats plaatsen. Vervolgens moeten we de stekker en de aan / uit-schakelaar op de klemmenblokken aansluiten, de kabels aan de ene kant op de stappenmotoren aansluiten en aan de andere kant op de printplaat. De servo is aangesloten op digitale pin nummer 2 en gevoed met de 5V afkomstig van de LM7805 spanningsregelaar. Eindelijk kunnen we de stepper-resolutie selecteren door de resolutiepinnen onder de stuurprogramma's aan te sluiten.
Ik heb besloten om de resolutie van de 16e stap te gebruiken, dus we moeten de juiste pinnen aansluiten in plaats van de middelste, zoals te zien is op de bovenstaande foto. Dus de elektronische componenten zijn nu klaar en we kunnen verder met het programmeren van de draadbuigmachine.
Arduino-code voor 3D-draadbuigmachineproject
Omdat de code wat langer is, zal ik voor een beter begrip de broncode van het programma in secties plaatsen met een beschrijving voor elke sectie. En aan het einde van dit artikel zal ik de volledige broncode posten.
Voor het aansturen van de stappenmotoren zal ik de AccelStepper-bibliotheek van Mike McCauley gebruiken. Dus we moeten deze bibliotheek opnemen, evenals de servobibliotheek voor het besturen van de servomotor. Vervolgens moeten we de pinnen definiëren waarop de steppers zijn aangesloten en enkele variabelen die nodig zijn voor het onderstaande programma.
#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;Code language: Arduino (arduino)In het setup-gedeelte stellen we de beginpositie van de servo of de buigpen in en stellen we ook de beginpositie van het buigtandwiel in. Dit gebeurt met behulp van de eindschakelaar. De stepper draait in de richting van de schakelaar en zodra deze is ingedrukt, begint de motor de stappen te tellen vanaf nul en positioneert zichzelf tot nul graden, klaar om te buigen.
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);
}Code language: Arduino (arduino)Nu, in de loop-sectie, wachten we op commando's die van de seriële monitor komen. Als we handmatig typen, gaan we naar de handmatige buigmodus of als we bijvoorbeeld ster typen, wordt de aangepaste functie start() uitgevoerd en maakt de machine automatisch een stervorm voor ons.
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();
}
}Code language: Arduino (arduino)Laten we eens kijken naar deze aangepaste functie.
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++;
}
}Code language: Arduino (arduino)Dus hier komen we in een while-lus die 5 keer wordt uitgevoerd, omdat de ster duidelijk 5 punten heeft. We beginnen met het instellen van de invoerwaarde, oftewel hoeveel draad er wordt ingevoerd in millimeters. Deze waarde wordt vervolgens vermenigvuldigd met 48, wat de voedingswaarde vertaalt in geschikte stappen voor de stappenmotor om te bewegen. Vervolgens gebruiken we de functie run() om de aanvoermotor te draaien met een snelheid die is ingesteld door de functie setSpeed(). We stoppen wanneer de bovenstaande feedDistance-waarde is bereikt en direct daarna stellen we de huidige positiewaarde van de stepper op nul.
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 0Code language: Arduino (arduino)In de volgende stap buigen we de draad 52 graden. Dit gebeurt op dezelfde manier als hierboven uitgelegd. Hier hebben we ook een hoekconstante die wordt vermenigvuldigd met de gewenste hoek. Zodra die waarde door de motor is bereikt, stopt de motor, reset de huidige positie naar 0 en voert dan hetzelfde aantal stappen in de tegenovergestelde richting uit, waardoor de motor daadwerkelijk terugkeert naar zijn oorspronkelijke positie.
// 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);Code language: Arduino (arduino)Daarna voeren we weer dezelfde draadlengte in en zetten we de pen neer zodat de buiger naar een nieuwe beginpositie kan bewegen die wordt gebruikt om in de andere richting te buigen. De buigpen wordt dan omhoog gebracht, en dus buigen we de draad 105 graden in de tegenovergestelde richting. De commando's worden 5 keer herhaald en zo krijgen we de stervorm.
Op dezelfde manier als hierboven uitgelegd, maken we de kubusvorm of eigenlijk elke andere vorm die we kunnen bedenken. Wat de handmatige modus betreft, is het werkingsprincipe van de commando's hetzelfde, behalve dat we nog een paar regels hebben voor het lezen van de commando's die van de seriële monitor komen. Voor het invoeren van de draad moeten we bijvoorbeeld "f" typen, plus de afstand in millimeters, voor het buigen van de draad moeten we "b" typen, plus de hoek in graden, en voor het roteren van de Z-as hebben we om "z" te typen, plus de hoek in graden.
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);
}Code language: Arduino (arduino)Dus zo werkt het programma dat ik heb gemaakt, maar er zijn natuurlijk veel andere manieren om dit te coderen. Hier is de volledige Arduino-code voor deze 3D-draadbuigmachine:
/*
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;
}
}
Code language: Arduino (arduino)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. Ik hoop dat je deze video leuk vond en iets nieuws hebt geleerd. Stel gerust een vraag in de opmerkingen hieronder en bekijk mijn Arduino Projects-collectie.
Productieproces
- Naaimachine
- Prikkeldraad
- Zeshoekige gaasmachine
- Hoe kan een draadknipmachine helpen?
- Wat is de plaatbuigmachine?
- Draadvonken:een glimp van de metaalindustrie in Taiwan
- Ultieme draadvonkmachine in Taiwan
- De geweldige CNC-buisbuigmachine
- Een beknopte handleiding voor het buigen van vierkante buizen
- Hydraulische buisbuigmachine voor werkplaatsen
- Wat is een elektrische pijpbuigmachine?