{"id":3862,"date":"2018-06-28T10:17:00","date_gmt":"2018-06-28T09:17:00","guid":{"rendered":"https:\/\/telefab.fr\/?p=3862"},"modified":"2026-04-30T17:33:59","modified_gmt":"2026-04-30T15:33:59","slug":"realisation-dune-brodeuse-numerique-a-partir-dune-machine-a-coudre","status":"publish","type":"projet","link":"https:\/\/hub.imt-atlantique.fr\/fablab\/projet\/realisation-dune-brodeuse-numerique-a-partir-dune-machine-a-coudre\/","title":{"rendered":"R\u00e9alisation d’une brodeuse num\u00e9rique \u00e0 partir d’une machine \u00e0 coudre"},"content":{"rendered":"

Le but de ce projet est de cr\u00e9er un module sur une machine \u00e0 coudre afin de la transformer en brodeuse num\u00e9rique. Ce module peut s\u2019ajouter et s\u2019enlever de la machine afin qu\u2019elle puisse garder sa fonction premi\u00e8re. Notre travail a donc premi\u00e8rement \u00e9t\u00e9 de construire la partie physique du module.<\/p>\n

\"\"<\/a>
figure 1 : module final<\/figcaption><\/figure>\n

Le tambour, qui permet de tendre le tissu \u00e0 broder, est reli\u00e9 \u00e0 un rail dent\u00e9. Celui-ci est entra\u00een\u00e9 en translation par un moteur reli\u00e9 \u00e0 un pignon. Les trois autres pignons permettent au rail de tenir sa trajectoire. Les pignons et le rail reposent sur une plateforme en bois qui est la partie sup\u00e9rieure d’un bo\u00eetier.<\/p>\n

\"\"<\/a>
figure 2 : bo\u00eetier et tiges m\u00e9talliques<\/figcaption><\/figure>\n

Deux tiges m\u00e9talliques passant dans des roulements \u00e0 billes traversent ce bo\u00eetier. Une courroie est reli\u00e9e au moteur et permet le d\u00e9placement selon la direction perpendiculaire \u00e0 celle du rail dent\u00e9. Ce syst\u00e8me est contraint \u00e0 beaucoup moins de frottement que celui \u00e0 base de rouages et d’une cr\u00e9maill\u00e8re en bois, il est donc plus facile pour le moteur d\u2019entra\u00eener le bo\u00eetier. Le bo\u00eetier abrite la carte Arduino qui est reli\u00e9e aux moteurs.<\/p>\n

La seconde partie du projet a \u00e9t\u00e9 de convertir une image num\u00e9rique en commandes pour les moteurs. Nous avons tout d’abord t\u00e9l\u00e9vers\u00e9 sur la carte Arduino un code qui permet d’interpr\u00e9ter un G-code, et donc de transformer ce Gcode en commande de rotation des moteurs. Ce code est commun \u00e0 n’importe quel motif \u00e0 broder. Il nous a alors fallu convertir le motif \u00e0 broder en G-code et envoyer ce code \u00e0 la carte Arduino. Nous pouvons faire cette conversion \u00e0 l’aide du logiciel Inkscape. Pour ce faire, un certain nombre d\u2019\u00e9tapes sont \u00e0 suivre :<\/p>\n

    \n
  1. Il faut effectuer une sym\u00e9trie centrale sur l’image du motif \u00e0 broder, car le G-code obtenu est celui dans le cas o\u00f9 l’aiguille de la machine \u00e0 coudre se d\u00e9place, or dans notre cas c’est le module qui se d\u00e9place tandis que l’aiguille garde une position fixe.<\/li>\n
  2. Il faut choisir des \u00ab Points d\u2019orientation \u00bb, c\u2019est-\u00e0-dire fixer un rep\u00e8re sur l\u2019image afin de s\u2019assurer que les d\u00e9placements vont s\u2019effectuer dans le sens voulu et \u00e0 partir du point de d\u00e9part voulu. Ils servent aussi \u00e0 g\u00e9rer les diff\u00e9rentes transformations de l\u2019image (sym\u00e9trie, translations, etc…).<\/li>\n
  3. Une fois cette \u00e9tape r\u00e9alis\u00e9e, Inkscape poss\u00e8de l\u2019outil \u00ab Objet en chemin \u00bb qui permet \u00a0de pr\u00e9parer l\u2019utilisation de Gcodetools en posant le chemin \u00e0 suivre.<\/li>\n
  4. Enfin il faut utiliser \u00ab Chemins vers G-code \u00bb qui convertit effectivement le chemin calcul\u00e9 en la suite de commandes voulues. Des fl\u00e8ches indiquent le chemin trac\u00e9.<\/li>\n<\/ol>\n

    Un logiciel permet ensuite d’envoyer le fichier vers la carte Arduino, et les moteurs r\u00e9agissent instantan\u00e9ment aux commandes re\u00e7ues.<\/p>\n

     <\/p>\n

    Elodie Derringer, Charles Rivi\u00e8re et Alexandre Ly<\/p>\n

     <\/p>\n

    [learn_more caption=\u00a0\u00bbCode t\u00e9l\u00e9vers\u00e9 sur la carte Arduino\u00a0\u00bb]<\/p>\n

    [cpp]
    \n#code pour une d\u00e9coupeuse laser, l'axe z ne sert \u00e0 rien.<\/p>\n

    #include <Servo.h>
    \n#include <AFMotor.h><\/p>\n

    #define LINE_BUFFER_LENGTH 512<\/p>\n

    char STEP = MICROSTEP ;<\/p>\n

    \/\/ Servo position for Up and Down
    \nconst int penZUp = 115;
    \nconst int penZDown = 83;<\/p>\n

    \/\/ Servo on PWM pin 10
    \nconst int penServoPin =10 ;<\/p>\n

    \/\/ Should be right for DVD steppers, but is not too important here
    \nconst int stepsPerRevolution = 200;<\/p>\n

    \/\/ create servo object to control a servo
    \nServo penServo;<\/p>\n

    \/\/ Initialize steppers for X- and Y-axis using this Arduino pins for the L293D H-bridge
    \nAF_Stepper myStepperY(stepsPerRevolution,2);
    \nAF_Stepper myStepperX(stepsPerRevolution,1);<\/p>\n

    \/* Structures, global variables *\/
    \nstruct point {
    \nfloat x;
    \nfloat y;
    \nfloat z;
    \n};<\/p>\n

    \/\/ Current position of plothead
    \nstruct point actuatorPos;<\/p>\n

    \/\/ Drawing settings, should be OK
    \nfloat StepInc = 1;
    \nint StepDelay = 0;
    \nint LineDelay =0;
    \nint penDelay = 50;<\/p>\n

    \/\/ Motor steps to go 1 millimeter.
    \n\/\/ Use test sketch to go 100 steps. Measure the length of line.
    \n\/\/ Calculate steps per mm. Enter here.
    \nfloat StepsPerMillimeterX = 100.0;
    \nfloat StepsPerMillimeterY = 100.0;<\/p>\n

    \/\/ Drawing robot limits, in mm
    \n\/\/ OK to start with. Could go up to 50 mm if calibrated well.
    \nfloat Xmin = 0;
    \nfloat Xmax = 40;
    \nfloat Ymin = 0;
    \nfloat Ymax = 40;
    \nfloat Zmin = 0;
    \nfloat Zmax = 1;<\/p>\n

    float Xpos = Xmin;
    \nfloat Ypos = Ymin;
    \nfloat Zpos = Zmax;<\/p>\n

    \/\/ Set to true to get debug output.
    \nboolean verbose = false;<\/p>\n

    \/\/ Needs to interpret
    \n\/\/ G1 for moving
    \n\/\/ G4 P300 (wait 150ms)
    \n\/\/ M300 S30 (pen down)
    \n\/\/ M300 S50 (pen up)
    \n\/\/ Discard anything with a (
    \n\/\/ Discard any other command!<\/p>\n

    \/**********************
    \n* void setup() – Initialisations
    \n***********************\/
    \nvoid setup() {
    \n\/\/ Setup<\/p>\n

    Serial.begin( 9600 );<\/p>\n

    penServo.attach(penServoPin);
    \npenServo.write(penZUp);
    \ndelay(100);<\/p>\n

    \/\/ Decrease if necessary
    \nmyStepperX.setSpeed(1000);<\/p>\n

    myStepperY.setSpeed(1000);<\/p>\n

    \/\/ Set & move to initial default position
    \n\/\/ TBD<\/p>\n

    \/\/ Notifications!!!
    \nSerial.println("Mini CNC Plotter alive and kicking!");
    \nSerial.print("X range is from ");
    \nSerial.print(Xmin);
    \nSerial.print(" to ");
    \nSerial.print(Xmax);
    \nSerial.println(" mm.");
    \nSerial.print("Y range is from ");
    \nSerial.print(Ymin);
    \nSerial.print(" to ");
    \nSerial.print(Ymax);
    \nSerial.println(" mm.");
    \n}<\/p>\n

    \/**********************
    \n* void loop() – Main loop
    \n***********************\/
    \nvoid loop()
    \n{<\/p>\n

    delay(100);
    \nchar line[ LINE_BUFFER_LENGTH ];
    \nchar c;
    \nint lineIndex;
    \nbool lineIsComment, lineSemiColon;<\/p>\n

    lineIndex = 0;
    \nlineSemiColon = false;
    \nlineIsComment = false;<\/p>\n

    while (1) {<\/p>\n

    \/\/ Serial reception – Mostly from Grbl, added semicolon support
    \nwhile ( Serial.available()>0 ) {
    \nc = Serial.read();
    \nif (( c == '\\n') || (c == '\\r') ) { \/\/ End of line reached
    \nif ( lineIndex > 0 ) { \/\/ Line is complete. Then execute!
    \nline[ lineIndex ] = '\0'; \/\/ Terminate string
    \nif (verbose) {
    \nSerial.print( "Received : ");
    \nSerial.println( line );
    \n}
    \nprocessIncomingLine( line, lineIndex );
    \nlineIndex = 0;
    \n}
    \nelse {
    \n\/\/ Empty or comment line. Skip block.
    \n}
    \nlineIsComment = false;
    \nlineSemiColon = false;
    \nSerial.println("ok");
    \n}
    \nelse {
    \nif ( (lineIsComment) || (lineSemiColon) ) { \/\/ Throw away all comment characters
    \nif ( c == ')' ) lineIsComment = false; \/\/ End of comment. Resume line.
    \n}
    \nelse {
    \nif ( c <= ' ' ) { \/\/ Throw away whitepace and control characters
    \n}
    \nelse if ( c == '\/' ) { \/\/ Block delete not supported. Ignore character.
    \n}
    \nelse if ( c == '(' ) { \/\/ Enable comments flag and ignore all characters until ')' or EOL.
    \nlineIsComment = true;
    \n}
    \nelse if ( c == ';' ) {
    \nlineSemiColon = true;
    \n}
    \nelse if ( lineIndex >= LINE_BUFFER_LENGTH-1 ) {
    \nSerial.println( "ERROR – lineBuffer overflow" );
    \nlineIsComment = false;
    \nlineSemiColon = false;
    \n}
    \nelse if ( c >= 'a' && c <= 'z' ) { \/\/ Upcase lowercase
    \nline[ lineIndex++ ] = c-'a'+'A';
    \n}
    \nelse {
    \nline[ lineIndex++ ] = c;
    \n}
    \n}
    \n}
    \n}
    \n}
    \n}<\/p>\n

    void processIncomingLine( char* line, int charNB ) {
    \nint currentIndex = 0;
    \nchar buffer[ 64 ]; \/\/ Hope that 64 is enough for 1 parameter
    \nstruct point newPos;<\/p>\n

    newPos.x = 0.0;
    \nnewPos.y = 0.0;<\/p>\n

    \/\/ Needs to interpret
    \n\/\/ G1 for moving
    \n\/\/ G4 P300 (wait 150ms)
    \n\/\/ G1 X60 Y30
    \n\/\/ G1 X30 Y50
    \n\/\/ M300 S30 (pen down)
    \n\/\/ M300 S50 (pen up)
    \n\/\/ Discard anything with a (
    \n\/\/ Discard any other command!<\/p>\n

    while( currentIndex < charNB ) {
    \nswitch ( line[ currentIndex++ ] ) { \/\/ Select command, if any
    \ncase 'U':
    \npenUp();
    \nbreak;
    \ncase 'D':
    \npenDown();
    \nbreak;
    \ncase 'G':
    \nbuffer[0] = line[ currentIndex++ ]; \/\/ \/!\\ Dirty – Only works with 2 digit commands
    \n\/\/ buffer[1] = line[ currentIndex++ ];
    \n\/\/ buffer[2] = '\0';
    \nbuffer[1] = '\0';<\/p>\n

    switch ( atoi( buffer ) ){ \/\/ Select G command
    \ncase 0: \/\/ G00 & G01 – Movement or fast movement. Same here
    \ncase 1:
    \n\/\/ \/!\\ Dirty – Suppose that X is before Y
    \nchar* indexX = strchr( line+currentIndex, 'X' ); \/\/ Get X\/Y position in the string (if any)
    \nchar* indexY = strchr( line+currentIndex, 'Y' );
    \nif ( indexY <= 0 ) {
    \nnewPos.x = atof( indexX + 1);
    \nnewPos.y = actuatorPos.y;
    \n}
    \nelse if ( indexX <= 0 ) {
    \nnewPos.y = atof( indexY + 1);
    \nnewPos.x = actuatorPos.x;
    \n}
    \nelse {
    \nnewPos.y = atof( indexY + 1);
    \nindexY = '\0';
    \nnewPos.x = atof( indexX + 1);
    \n}
    \ndrawLine(newPos.x, newPos.y );
    \n\/\/ Serial.println("ok");
    \nactuatorPos.x = newPos.x;
    \nactuatorPos.y = newPos.y;
    \nbreak;
    \n}
    \nbreak;
    \ncase 'M':
    \nbuffer[0] = line[ currentIndex++ ]; \/\/ \/!\\ Dirty – Only works with 3 digit commands
    \nbuffer[1] = line[ currentIndex++ ];
    \nbuffer[2] = line[ currentIndex++ ];
    \nbuffer[3] = '\0';
    \nswitch ( atoi( buffer ) ){
    \ncase 300:
    \n{
    \nchar* indexS = strchr( line+currentIndex, 'S' );
    \nfloat Spos = atof( indexS + 1);
    \n\/\/ Serial.println("ok");
    \nif (Spos == 30) {
    \npenDown();
    \n}
    \nif (Spos == 50) {
    \npenUp();
    \n}
    \nbreak;
    \n}
    \ncase 114: \/\/ M114 – Repport position
    \nSerial.print( "Absolute position : X = " );
    \nSerial.print( actuatorPos.x );
    \nSerial.print( " – Y = " );
    \nSerial.println( actuatorPos.y );
    \nbreak;
    \ndefault:
    \nSerial.print( "Command not recognized : M");
    \nSerial.println( buffer );
    \n}
    \n}
    \n}<\/p>\n

    }<\/p>\n

    \/*********************************
    \n* Draw a line from (x0;y0) to (x1;y1).
    \n* int (x1;y1) : Starting coordinates
    \n* int (x2;y2) : Ending coordinates
    \n**********************************\/
    \nvoid drawLine(float x1, float y1) {<\/p>\n

    if (verbose)
    \n{
    \nSerial.print("fx1, fy1: ");
    \nSerial.print(x1);
    \nSerial.print(",");
    \nSerial.print(y1);
    \nSerial.println("");
    \n}<\/p>\n

    \/\/ Bring instructions within limits
    \nif (x1 >= Xmax) {
    \nx1 = Xmax;
    \n}
    \nif (x1 <= Xmin) {
    \nx1 = Xmin;
    \n}
    \nif (y1 >= Ymax) {
    \ny1 = Ymax;
    \n}
    \nif (y1 <= Ymin) {
    \ny1 = Ymin;
    \n}<\/p>\n

    if (verbose)
    \n{
    \nSerial.print("Xpos, Ypos: ");
    \nSerial.print(Xpos);
    \nSerial.print(",");
    \nSerial.print(Ypos);
    \nSerial.println("");
    \n}<\/p>\n

    if (verbose)
    \n{
    \nSerial.print("x1, y1: ");
    \nSerial.print(x1);
    \nSerial.print(",");
    \nSerial.print(y1);
    \nSerial.println("");
    \n}<\/p>\n

    \/\/ Convert coordinates to steps
    \nx1 = (int)(x1*StepsPerMillimeterX);
    \ny1 = (int)(y1*StepsPerMillimeterY);
    \nfloat x0 = Xpos;
    \nfloat y0 = Ypos;<\/p>\n

    \/\/ Let's find out the change for the coordinates
    \nlong dx = abs(x1-x0);
    \nlong dy = abs(y1-y0);
    \nint sx = x0<x1 ? StepInc : -StepInc;
    \nint sy = y0<y1 ? StepInc : -StepInc;<\/p>\n

    long i;
    \nlong over = 0;<\/p>\n

    if (dx > dy) {
    \nfor (i=0; i<dx; ++i) {
    \nmyStepperX.onestep(sx,STEP);
    \nover+=dy;
    \nif (over>=dx) {
    \nover-=dx;
    \nmyStepperY.onestep(sy,STEP);
    \n}
    \ndelay(StepDelay);
    \n}
    \n}
    \nelse {
    \nfor (i=0; i<dy; ++i) {
    \nmyStepperY.onestep(sy,STEP);
    \nover+=dx;
    \nif (over>=dy) {
    \nover-=dy;
    \nmyStepperX.onestep(sx,STEP);
    \n}
    \ndelay(StepDelay);
    \n}
    \n}<\/p>\n

    if (verbose)
    \n{
    \nSerial.print("dx, dy:");
    \nSerial.print(dx);
    \nSerial.print(",");
    \nSerial.print(dy);
    \nSerial.println("");
    \n}<\/p>\n

    if (verbose)
    \n{
    \nSerial.print("Going to (");
    \nSerial.print(x0);
    \nSerial.print(",");
    \nSerial.print(y0);
    \nSerial.println(")");
    \n}<\/p>\n

    \/\/ Delay before any next lines are submitted
    \ndelay(LineDelay);
    \n\/\/ Update the positions
    \nXpos = x1;
    \nYpos = y1;
    \n}<\/p>\n

    \/\/ Raises pen
    \nvoid penUp() {
    \npenServo.write(penZUp);
    \ndelay(penDelay);
    \nZpos=Zmax;
    \ndigitalWrite(15, LOW);
    \ndigitalWrite(16, HIGH);
    \nif (verbose) {
    \nSerial.println("Pen up!");<\/p>\n

    }
    \n}
    \n\/\/ Lowers pen
    \nvoid penDown() {
    \npenServo.write(penZDown);
    \ndelay(penDelay);
    \nZpos=Zmin;
    \ndigitalWrite(15, HIGH);
    \ndigitalWrite(16, LOW);
    \nif (verbose) {
    \nSerial.println("Pen down.");<\/p>\n

    }
    \n}<\/p>\n

    [\/cpp]<\/p>\n

    [\/learn_more]<\/p>\n

    Lien vers un github utile\u00a0<\/a><\/p>\n

     <\/p>\n","protected":false},"author":1,"featured_media":3864,"parent":0,"menu_order":0,"template":"","meta":{"_acf_changed":false,"footnotes":""},"categories":[22,20],"type_projet":[],"class_list":["post-3862","projet","type-projet","status-publish","has-post-thumbnail","hentry","category-evenements","category-projets"],"acf":{"objectifs":"","categorie":false,"fichiers_associes":null},"_links":{"self":[{"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/projet\/3862","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/projet"}],"about":[{"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/types\/projet"}],"author":[{"embeddable":true,"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/users\/1"}],"version-history":[{"count":1,"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/projet\/3862\/revisions"}],"predecessor-version":[{"id":10485,"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/projet\/3862\/revisions\/10485"}],"wp:attachment":[{"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/media?parent=3862"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/categories?post=3862"},{"taxonomy":"type_projet","embeddable":true,"href":"https:\/\/hub.imt-atlantique.fr\/fablab\/wp-json\/wp\/v2\/type_projet?post=3862"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}