Machine à cintrer les fils Arduino 3D
Dans ce tutoriel, je vais vous montrer comment j'ai construit une machine à cintrer les fils 3D basée sur Arduino. Il s'agit en fait d'un système mécatronique typique car il implique une ingénierie mécanique, électrique et informatique. Je pense donc que de nombreux étudiants en ingénierie ou toute personne novice en mécatronique ont trouvé ce projet intéressant.
Vous pouvez regarder la vidéo suivante ou lire le didacticiel écrit ci-dessous.
Voici le principe de fonctionnement de cette cintreuse de fil 3D. Alors d'abord, le fil passe par une série de rouleaux, ou redresseurs. À l'aide d'un moteur pas à pas, le fil est acheminé avec précision vers le mécanisme de pliage du fil qui utilise également un moteur pas à pas ainsi qu'un petit servo pour le processus de pliage.
Il existe également un autre moteur pas à pas, appelé l'axe Z, qui permet en fait à la machine de créer des formes en trois dimensions. Bien sûr, le cerveau de la machine est une carte Arduino qui, avec les autres composants électroniques, est fixée sur un PCB conçu sur mesure.
En ce qui concerne le programme, j'ai créé quelques fonctions personnalisées pour créer diverses formes, comme une étoile, un cube et un support simple, ainsi qu'un mode manuel où nous pouvons créer les formes de fil en entrant des commandes via le moniteur série.
Comme d'habitude, j'ai commencé par réaliser le projet à l'aide d'un logiciel de modélisation 3D. Vous pouvez télécharger et le modèle 3D ci-dessous.
Inspiration de conception :vidéo YouTube
Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs.
Vous pouvez télécharger le modèle 3D d'assemblage sur Thangs.
Fichiers STL pour l'impression 3D :
Pour certaines pièces, comme les engrenages, les paliers à semelle et certains coupleurs d'arbre, j'ai utilisé une imprimante 3D pour les fabriquer. Les fichiers STL de ces pièces, qui sont utilisées pour l'impression 3D, peuvent être téléchargés à partir des fichiers ci-dessus.
Ma nouvelle imprimante 3D, Creality CR-10, a fait un excellent travail et a imprimé les pièces avec une grande qualité. Voici un lien vers cette imprimante 3D au cas où vous voudriez la vérifier.
J'ai continué avec la préparation des autres pièces, pour lesquelles j'ai utilisé du MDF et du contreplaqué. Donc, une fois que j'ai pris toutes les dimensions du modèle 3D, à l'aide d'une scie circulaire, j'ai coupé les pièces à la bonne taille. J'ai utilisé du MDF de 8 mm et du contreplaqué de 18 mm. Une fois que je les ai préparés, j'ai commencé l'assemblage. J'ai d'abord fabriqué la base à partir de deux plaques de MDF et de 4 colonnes en contreplaqué. Pour les fixer, j'ai utilisé une colle à bois et des vis.
Ensuite, sur le panneau supérieur, j'ai fixé les paliers à roulement imprimés en 3D à l'aide de boulons et d'écrous de 8 mm. On peut remarquer ici que j'ai rajouté des plaques de MDF de 3 mm entre le plateau et les paliers afin d'avoir la bonne hauteur. Maintenant, dans ces blocs, nous pouvons monter les roulements 6202.
Leur diamètre extérieur est de 35 mm et le diamètre intérieur est de 15 mm. Alors maintenant, à travers ces roulements, nous devons insérer un arbre creux de 15 mm pour que le fil puisse passer à travers. Cet arbre est en fait l'axe Z, qui permet au mécanisme de cintrage de tourner autour du fil et ainsi de créer des formes tridimensionnelles. J'ai utilisé un tube de cuivre à cet effet et sa longueur doit être d'environ 30 cm.
Entre les deux roulements, j'ai également inséré un engrenage imprimé en 3D avec un module de 1,5 et 30 dents. L'engrenage a des fentes de conception personnalisées où nous pouvons insérer des écrous M3, puis à l'aide de boulons M3, nous pouvons serrer l'engrenage à l'arbre.
Ensuite, nous devons installer le moteur pas à pas de l'axe Z. À cette fin, j'ai imprimé en 3D un support de montage personnalisé. J'ai donc fixé le stepper au support à l'aide de boulons M3, puis j'ai inséré l'engrenage à 18 dents sur l'arbre du moteur. J'ai utilisé la même méthode pour fixer l'engrenage à l'arbre comme indiqué précédemment.
Ensuite, à l'aide d'une perceuse de 6 mm, j'ai fait deux trous sur le dessus sur lesquels le support de montage sera fixé. On peut remarquer que le support au lieu de trous, a des fentes qui permettent aux deux engrenages d'être correctement appariés.
Je suis passé à l'installation du moteur pas à pas pour le mécanisme d'alimentation. Ce moteur sera directement monté sur la plaque supérieure, j'ai donc percé les trous appropriés dessus. Ensuite, à l'aide de quatre boulons, j'ai fixé le stepper à la plaque, et au cas où vous vous demanderiez ce que ces écrous font ici, ils agissent en fait comme des écrous d'écartement car les boulons que j'avais étaient plus longs et ne pouvaient pas rentrer dans les filetages des moteurs.
Alors maintenant, sur l'arbre de ce stepper, nous devons insérer le chargeur. Pour cela, j'ai imprimé en 3D un coupleur d'arbre personnalisé sur lequel j'ai inséré un tube de cuivre qui sera en fait la surface de contact du chargeur.
Puis sur le côté opposé du moteur j'ai inséré un levier, sur lequel j'ai fixé un roulement qui viendra appuyer contre le chargeur. Pour obtenir une prise suffisante pour que le chargeur puisse déplacer le fil, je vais attacher un morceau de contreplaqué avec un écrou en T dessus, puis à l'aide d'un boulon, nous pourrons contrôler la prise du chargeur.
L'étape suivante consiste à fabriquer le système de redressement de fil. À l'aide de trois boulons M8, j'ai fixé un morceau de contreplaqué que j'ai préalablement percé selon le modèle 3D. Maintenant, au-dessus, j'ai inséré les rouleaux. J'ai fabriqué les rouleaux à partir de roulements et de bagues extérieures rainurées imprimées en 3D.
Trois rouleaux vont de ce côté et deux rouleaux de l'autre côté. Pour l'autre côté, j'ai fait une fente dans la pièce de contreplaqué afin que les boulons restent au ras de la pièce. Maintenant, en utilisant seulement deux boulons, nous pouvons coupler les deux côtés, et en utilisant les écrous, nous pouvons serrer les redresseurs de manière appropriée.
Une fois cette étape terminée, j'ai ajouté deux autres morceaux de contreplaqué devant et après les lisseurs qui serviront de passe-fils.
Ok, nous pouvons maintenant passer à la fabrication du mécanisme de pliage du fil. D'abord sur un morceau de MDF, nous devons fixer le moteur de la cintreuse. Avant de faire cela, la pièce en MDF dont j'avais besoin d'être façonnée, donc à l'aide d'une scie à main, d'une scie à chantourner et d'une râpe, j'ai facilement obtenu la forme souhaitée. Ensuite, à l'aide d'une scie cloche de 38 mm, j'ai fait une ouverture pour le plus gros moteur pas à pas que nous utiliserons pour le pliage, un moteur pas à pas NEMA 23. J'ai également percé des trous plus petits nécessaires pour fixer les autres pièces.
J'ai fixé le stepper NEMA 23 à l'aide de boulons et d'écrous M4 et sur son arbre de sortie j'ai fixé un engrenage avec module de 2,5 et 18 dents. Cet engrenage sera associé à un engrenage plus grand de 30 dents qui est un engrenage conçu sur mesure avec une plaque intégrée pour le montage d'un servo MG996R. Ce servo déplacera un mécanisme à crémaillère et pignon, qui est en fait une goupille qui sortira de l'engrenage et servira à plier le fil. À l'aide d'un époxy de 5 minutes, j'ai fixé un roulement sur l'engrenage et j'ai également ajouté un morceau de tube de cuivre sur la crémaillère qui sera la surface de contact lors de la flexion du fil.
Une fois l'époxy séché, j'ai jumelé les deux engrenages en fixant le plus gros engrenage en place avec un boulon M8 et un écrou. Ensuite, j'ai inséré la crémaillère et le servo en place, et je l'ai fixé à l'aide des vis fournies dans l'emballage des servos. Ensuite, j'ai fixé le pignon sur le cornet rond du servo à l'aide de deux boulons et écrous M3.
Enfin, j'ai attaché le klaxon au servo et avec cela le mécanisme de flexion a été complété.
Il ne reste plus qu'à attacher la cintreuse à l'axe Z. Je l'ai fait en utilisant les deux pinces d'arbre imprimées en 3D. Je les ai d'abord fixés à la plaque de cintrage à l'aide de boulons et d'écrous M6, puis je les ai insérés dans l'axe Z. J'ai inséré les deux écrous en place et, à l'aide des boulons, j'ai serré les pinces sur l'arbre. Alors maintenant, toutes les pièces mobiles fonctionnent correctement.
En fait, il y a encore deux petits détails à ajouter. C'est cette buse de 3 mm sur l'arbre où le fil sort.
Et au bas de la cintreuse, j'ai placé un micro-interrupteur de fin de course qui sera utilisé pour définir la position initiale de la cintreuse.
Et voilà, notre machine à cintrer les fils 3D est presque terminée. Je dis presque, car maintenant il faut donner du live à cette machine, ou brancher les composants électroniques et la programmer.
Voici le schéma de circuit de ce projet.
Ainsi, les trois moteurs pas à pas sont contrôlés à l'aide des trois pilotes pas à pas DRV8825. Pour alimenter les steppers et l'ensemble du projet, nous utiliserons une alimentation 12V avec au moins 3A de courant.
Pour alimenter le servo, nous pourrions utiliser le 5V provenant de l'Arduino, mais le servo MG996R peut être gourmand en énergie et le régulateur de tension 5V de l'Arduino pourrait ne pas être en mesure de le gérer. Par conséquent, j'ai décidé d'utiliser un régulateur de tension 5V séparé, le LM7805, qui est assez bon pour alimenter le servo pour ce projet. Il y a aussi un interrupteur de fin de course pour la cintreuse qui a une résistance de rappel, il est connecté à une broche numérique de la carte Arduino.
Vous pouvez obtenir les composants nécessaires à ce projet à partir des liens ci-dessous :
Ensuite, afin de me débarrasser du désordre de câblage et de garder les composants électroniques organisés, j'ai conçu un circuit imprimé personnalisé à l'aide du logiciel de conception de circuits en ligne gratuit EasyEDA. Le circuit a de nombreuses connexions, j'ai donc utilisé les couches supérieure et inférieure pour les organiser. J'ai également ajouté des broches pour sélectionner la résolution des pas à pas, ajouté une autre connexion de fin de course et fourni des broches numériques et analogiques supplémentaires provenant de l'Arduino au cas où nous en aurions besoin pour quelque chose.
Voici un lien vers les fichiers de projet de cette conception de PCB. Une fois cette conception terminée, j'ai donc généré le fichier Gerber nécessaire à la fabrication du PCB.
Fichier Gerber :
Ensuite, j'ai commandé le PCB à JLCPCB, qui est en fait le sponsor de ce projet.
Ici, nous pouvons simplement faire glisser et déposer le fichier Gerber et une fois téléchargé, nous pouvons revoir notre PCB dans la visionneuse Gerber. Si tout va bien, nous pouvons continuer, sélectionner les propriétés que nous voulons pour notre PCB, puis nous pouvons commander notre PCB à un prix raisonnable. Notez que s'il s'agit de votre première commande auprès de JLCPCB, vous pouvez obtenir jusqu'à 10 PCB pour seulement 2 $.
Après plusieurs jours, les PCB sont arrivés. La qualité des PCB est excellente et tout est exactement comme dans la conception.
Nous pouvons donc maintenant passer à autre chose et installer les composants électroniques sur le PCB. J'ai commencé par souder des en-têtes de broches sur le PCB. Cela facilite la connexion et la déconnexion des composants en cas de besoin. Quant aux composants plus petits, comme les condensateurs, les résistances, le régulateur de tension et les borniers, je les ai soudés directement sur le PCB.
Une fois cette étape terminée, nous pouvons maintenant insérer les pilotes pas à pas et l'Arduino en place. Ensuite, nous devons connecter la prise d'alimentation et l'interrupteur d'alimentation aux borniers, connecter les câbles aux moteurs pas à pas d'un côté et les connecter au PCB de l'autre côté. Le servo est connecté à la broche numérique numéro 2 et alimenté avec le 5V provenant du régulateur de tension LM7805. Enfin, nous pouvons sélectionner une résolution pas à pas en connectant les broches de résolution sous les pilotes.
J'ai décidé d'utiliser la résolution de 16e étape, nous devons donc connecter les bonnes broches au lieu de celles du milieu, comme on le voit sur la photo ci-dessus. Les composants électroniques sont maintenant prêts et nous pouvons passer à la programmation de la machine à plier les fils.
Comme le code est un peu plus long, pour une meilleure compréhension, je posterai le code source du programme dans des sections avec une description pour chaque section. Et à la fin de cet article, je posterai le code source complet.
Pour contrôler les moteurs pas à pas, j'utiliserai la bibliothèque AccelStepper de Mike McCauley. Nous devons donc inclure cette bibliothèque, ainsi que la bibliothèque d'asservissement pour contrôler le servomoteur. Ensuite, nous devons définir les broches auxquelles les steppers sont connectés et certaines variables nécessaires au programme ci-dessous.
Dans la section de configuration, nous définissons la position initiale du servo ou de la goupille de flexion, ainsi que la position initiale de l'engrenage de cintrage. Cela se fait à l'aide de l'interrupteur de fin de course. Le stepper tourne vers l'interrupteur et une fois qu'il est enfoncé, le moteur commence à compter les pas à partir de zéro et se positionne à zéro degré, prêt pour la flexion.
Maintenant, dans la section boucle, nous attendons les commandes provenant du moniteur série. Si nous tapons manuel, nous entrerons dans le mode de pliage manuel ou si nous tapons par exemple étoile, la fonction personnalisée start() sera exécutée et la machine créera automatiquement une forme d'étoile pour nous.
Jetons un coup d'œil à cette fonction personnalisée.
On rentre donc ici dans une boucle while qui est exécutée 5 fois, car évidemment l'étoile a 5 pointes. Nous commençons par définir la valeur d'alimentation, ou c'est la quantité de fil qui sera alimentée en millimètres. Cette valeur est ensuite multipliée par 48, ce qui traduit la valeur d'alimentation en étapes appropriées pour que le moteur pas à pas se déplace. Ensuite, en utilisant la fonction run(), nous faisons tourner le moteur du chargeur à une vitesse définie par la fonction setSpeed(). Nous nous arrêtons lorsque la valeur feedDistance ci-dessus est atteinte, et juste après cela, nous définissons la valeur de position actuelle du stepper zéro.
Dans l'étape suivante, nous plions le fil à 52 degrés. Cela se fait de la même manière que celle expliquée ci-dessus. Ici, nous avons également une constante d'angle qui est multipliée par l'angle souhaité. Une fois que cette valeur est atteinte par le moteur, le moteur s'arrête, réinitialise sa position actuelle à 0, puis effectue le même nombre de pas dans la direction opposée, ce qui ramène en fait le moteur à sa position initiale.
Là encore, nous alimentons la même longueur de fil et nous posons la goupille pour que la plieuse puisse se déplacer vers une nouvelle position initiale qui est utilisée pour plier dans l'autre sens. La broche de cintrage est alors relevée, et nous plions donc le fil de 105 degrés dans la direction opposée. Les commandes sont répétées 5 fois et c'est ainsi que nous obtenons la forme en étoile.
De la même manière qu'expliqué ci-dessus, nous créons la forme du cube ou en fait toute autre forme que nous pouvons créer. Quant au mode manuel, le principe de fonctionnement des commandes est le même, sauf que nous avons quelques lignes de plus pour lire les commandes provenant du moniteur série. Par exemple, pour alimenter le fil, nous devons taper "f", plus la distance en millimètres, pour plier le fil, nous devons taper "b", plus l'angle en degrés, et pour faire pivoter l'axe Z, nous avons besoin pour taper "z", plus l'angle en degrés.
C'est ainsi que fonctionne le programme que j'ai créé, mais bien sûr, il existe de nombreuses autres façons de le coder. Voici le code Arduino complet pour cette cintreuse de fils 3D :
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. I hope you enjoyed this video and learned something new. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et à consulter ma collection de projets Arduino.Aperçu
Modèle 3D de machine à cintrer les fils 3D DIY
Construire la machine à cintrer les fils
Schéma du circuit
Conception de circuits imprimés
Code Arduino pour le projet de machine à cintrer les fils 3D
#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)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)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)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)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)// 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)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)/*
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)
Processus de fabrication
- Machine à coudre
- Fil barbelé
- Machine à treillis métallique hexagonale
- Comment une machine à couper le fil peut-elle aider?
- Qu'est-ce que la machine à cintrer les feuilles ?
- Wire EDM:Un aperçu de l'industrie métallurgique de Taiwan
- Machine d'électroérosion à fil ultime à Taiwan
- L'incroyable machine à cintrer les tubes CNC
- Un guide rapide de la machine à cintrer les tubes carrés