ExtruAndWinder/fr

Introduction

Les machines comme Filabot, Filastruder ou encore Filamaker produise un filament mais n'assure par un filament de diametre constant.

Filastruder propose une seconde machine nommé Filawinder, sont tarif est plutôt abordable. Elle permet d'avoir une certaine constante dans la fabrication du filament.

Apres étude avec TheFredaxe (fas83), du travaille de Hugh Lyman, de Filawinder mais aussi de quelque photo trouvé sur internet de machine induststrielle, je me suis décider à crée une version de cette machine avec des éléments facilement trouvable dans le commerce et communément utilisé dans l'impresion 3D des RepRapeur.

Pourquoi une extrudeuse seul ne remplit pas son role ?

FilaWinder

Le filament est extrudé la gravité attire naturelement le filament vers le sol, sur les 50 premier centimetres pas de probleme, puis la masse tire sur le filament et change le diametres du filament. Quand le filament entre en contact avec le sol, la tension redevient plus faible mais cella crée des irégularité dans le filament.

La technique de Fas83 et de la Filawinder pour compenser ce probleme est d'enroulé le filament en continue pour avoir une certaine "tension" et continuité dans la production du filament.

Un autre probléme sur la machine de Filawinder est la régularité dans le moteur d'extrusion. En effet lors de la chauffe de la bande chauffante pour monter à la bonne température le moteur tourne réguliérement, par contre des que la machine est à bonne temperature, le PID maintient la bonne température d'extrusion en stoppant et relancant la chauffe, ce qui à pour effet de faire varié la vitesse du moteur.

Construction de la machine

Cette machine est construite aux maximum avec des éléments facilement trouvable dans le commerce et standardisé (Pas de sur-messure).

La machine est constitué de plusieur ensembles que voici :

1. Extrudeuse de filament
2. Controleuse de diametre
3. Moteur de traction
4. Controleur de tension
5. Enrouleur de filament

Extrudeuse de filament

Extrudeuse made in Blumax

L'extrudeuse est constitué de plusieur sous-ensembles :

1. Une motorisation
2. Le chargement du pellets
3. L'entrainement
4. La chauffe
5. La buse de sortie

BOM

• Téflon (0,95€ chez LeRoyMerlin réf.60029095)
• 2 Raccords Té en laiton à visser F20X27 (5,60€ les 2 chez LeRoyMerlin)
• 1 Mammelons en laiton à visser M20X27 (2,29€ les 2 chez LRM)
• 2 Manchons en laiton à visser F20X27 (4€ les 2 chez LRM)
• 4 Bobine + 2 contre écrous en laiton à visser M20X27 (62€ les 4 chez LRM)
• 2 Mammelons réducteur en laiton à visser M20X27 vers M12X17 (3€ les 2 chez LRM)
• 1 Coude femelle 20x27mm/femelle 20x27mm (3,95€ les 2 chez LRM)
• 1 Bouchons en laiton à visser F12X17 (1.39€ chez LRM réf.65816044)
• Ruban adhésif aluminium (5,1€ chez LRM)
• 1 meche a simple spirale Lewis de 18mm de diamétre et 450 de long (La spirale Lewis est vraiment importante, la longeur aussi) (42,30€ chez www.sesatools.com réf.12010818450)
• 1 PID REX-C100 (En lot avec le SSR sur eBay 14€)
• 1 SSR (En lot avec le PID sur eBay 14€)
• 1m Thermocouple K-type (Doit supporter jusqu'a 300°C (1,7€ sur eBay)
• Bande chauffante (Band Heater) AC 220V 110W 30mmx30mm (5,5€ sur Aliexpress)
• Un planche en bois
• Quellque vise
• Equere (imprimable)
• Isolant (Optionel mais conseiller pour ne pas perdre de la chaleur et avoir une témpérature au mieux stabilisé).
• Moteur, courroie et engrenage à venire
• Ecrous de xxx
• Roulement a bille axiale (5,8€ sur eBay)

Outil :

• 1 foret fer de 2.8mm
• 1 foret fer entre 5 et 8mm

Source

ExtruAndWinder.ino

// Décompenter pour debugger
#define DEBUG


#define _Digole_Serial_I2C_  // To tell compiler compile the special communication only
#include <DigoleSerial.h>
#include <Wire.h>
#include <TimerOne.h>
#include <Servo.h>

#include "picto.h"

#define PIN_ELONGATION_STEP 11
#define PIN_ELONGATION_DIR 10
unsigned int elongationDelayEnMicros = 2000;
unsigned long elongationDernierMillis = micros();
unsigned long elongationNombreDePas = 0;
byte elongationActiver = 0;

#define PIN_ENROULEUSE_STEP 13
#define PIN_ENROULEUSE_DIR 12
unsigned int enrouleuseDelayEnMicros = 500;
unsigned long enrouleuseDernierMillis = micros();
unsigned long enrouleuseNombreDePas = 0;
byte interneEnrouleuseTendu = 0;

#define PIN_STEP 13
#define PIN_DIR 12

// Définition des PINs
#define PIN_TSL1401_ANALOG 0
#define PIN_TSL1401_SI 3
#define PIN_TSL1401_CLK 2

#define PIN_BOUTON_MOINS 4
#define PIN_BOUTON_PLUS 6
#define PIN_BOUTON_SELECT 5

// Définition des parametres
#define PARAM_TEMP_MAX 300
#define PARAM_LCD_ACTUALISATION 500 // Frequence d'actualisation de l'écran

// ENDSTOP de tension (enrouleuse)
#define PIN_ENDSTOP 7

// Je ne sais pas à quoi sert ce truc mais il sert pour le TCL1401
#define FASTADC 1
#define cbi(sfr, bit) (_SFR_BYTE(sfr) &= ~_BV(bit))
#define sbi(sfr, bit) (_SFR_BYTE(sfr) |= _BV(bit))

DigoleSerialDisp ecran(&Wire, '\x27');  // I2C sur Arduino Mega : SDA = 20 et SCL = 21

byte menuPosition = 0;
unsigned long menuMillisSelect = millis();
unsigned long menuMillisPlusMoin = millis();

byte choixMoteurExtrudeuseActiver = 0;
bool choixEnrouleuseActiver = false;
unsigned int choixTemperature = 0;

unsigned int diametreActuelle = 0;
int temperatureActuelle = 0;
unsigned long ecranDerniereActualisation = millis();

Servo servoGuide;

// Identique à createTemperatureLookupMarlin.py --r0=100000 --t0=25 --r1=0 --r2=4700 --beta=4066 --max-adc=1023
#define T_R0 100000          // stated resistance, e.g. 100K
#define T_T0 25
#define T_BETA 4066          // stated beta, e.g. 3500
#define T_R1 0
#define T_R2 4700

double T_THIST0 = (T_T0 + 273.15);               // temperature at stated resistance, e.g. 25C                
#define T_THISADC 5.0                     // ADC reference
#define T_THISVCC 5.0                      // supply voltage to potential divider
#define T_THISK (T_R0 * exp(-T_BETA / T_THIST0))   // constant part of calculation

#if R1 > 0
   double T_THISVS = T_R1 * T_THISVCC / (T_R1 + T_R2); // effective bias voltage
   double T_THISRS = T_R1 * T_R2 / (T_R1 + T_R2);       // effective bias impedance
#else
   double T_THISVS = T_THISVCC;                    // effective bias voltage
   double T_THISRS = T_R2;                         // effective bias impedance 
#endif





















int servoAngleMax = 140;                  // Angle maximum que peux avoir le moteur pour bobiner, ce trouve normalement sur la gauche de la bobine
int servoAngleMin = 45;                   // Angle minimum que peux avoir le moteur pour bobiner, ce trouve normalement sur la droite de la bobine
int bobineAnglePremierTour = 125;         // Angle que doit avoir le servo pour le premier tour, liér à la position de l'orifice permetant de maintenire le filament
// TODO : Verifier que si bobineAnglePremierTour = servoAngleMax ou servoAngleMin cella ne crée pas de BUG dans les calcules

float filamentDiametreSouhaiter = 1.70;    // En mm
int bobineLargeur = 65;                    // En mm

// Variable interne mais a définir pour éviter les beuges
// TODO: Trouver une solution a la définition du tableau
int interneServoDifferentePosition[38] = {}; // Le chiffre entre [] est à définir par un entier correspondant à (bobineLargeur / filamentDiametreSouhaiter), il faut mieux trop que pas assez

int bobineDiametreCentre = 91;             // En mm
int bobineDiametreExterieur = 200;         // En mm

int bobineTempsArreter = 5000;             // En milliseconde
int bobineVitesseMin = 50;                 // En pas par seconde
int bobineTempsInterAcceleration = 2000;   // En milliseconde Temps enetre les acceleration
int bobineVitesseMax = 150;                // En pas par seconde
int bobinePasAugmentationVitesse = 10;     // En pas par seconde

bool bobinePremiereDirection = false; // En regardant la machine du coter de l'arrivé du fil en direction de la bobine, 0 si le trou qui bloque le filament est à gauche, 1 si il est à droite, si le trou est à gauche on bobinera de gauche à droite, sinon l'inverse

// (Step par tour d'enrouement est égale à "pas par tour du moteur * démultiplication d'engrenage * résolution du driver (1 = full step, 2 = 1/2 pas, 4 = 1/4 de pas, 8 = 1/8 de pas et 16 = 1/16 de pas)" 200*2.5*4
// L'enregrane actuelle à 21 dents pour la petite roue et 53 pour la grande
long enroulementStepParTour = 12800;

int tour = 0;

float interneBobineDernierMillis = millis();                 
float interneTmpCalcule;                         
float interneDegreEntreFilament;                 
int internetLargeurBobineEnDegree;               
long interneNemaDernierPositionValideTour = 0;
unsigned int interneNombreTourSurBobine = 0;                  
unsigned int interneServoPosition;                        
bool interneServoDirection;                       
unsigned int interneEndStopStatue;                        // Le end stop est il enclencher























// "Convert ADC reading into a temperature in Celcius"
double analog2degre(int analog) {
  double v = analog * T_THISADC / 1024;          // convert the 10 bit ADC value to a voltage
  double r = T_THISRS * v / (T_THISVS - v);     // resistance of thermistor
  return ((T_BETA / log(r / T_THISK)) - 273.15);        // temperature
}











void actualiserAffichage(void) {
  
  // Efface toutes les informations a actualiser
  ecran.setColor(0);
  // Emplacement des curseurs
  ecran.drawBox(119, 4, 7, 7);
  ecran.drawBox(119, 22, 7, 7);
  ecran.drawBox(83, 22, 7, 7);
  ecran.drawBox(49, 22, 7, 7);
  ecran.drawBox(119, 40, 7, 7);
  // Ligne complet de la temperature actuelle
  ecran.drawBox(0, 0, 96, 13);
  // Ligne de la vitesse actuelle
  ecran.drawBox(0, 20, 47, 13);
  // Diametre actuelle
  ecran.drawBox(0, 40, 50, 23);
  
  // Affiche les infos
  ecran.setColor(1);
  
  switch(menuPosition) {
  case 0:
    ecran.drawBitmap(119, 4, 8, 8, pictoSelection);
    break;
  case 1:
    ecran.drawBitmap(119, 22, 8, 8, pictoSelection);
    break;
  case 2:
    ecran.drawBitmap(83, 22, 8, 8, pictoSelection);
    break;
  case 3:
    ecran.drawBitmap(49, 22, 8, 8, pictoSelection);
    break;
  case 4:
    ecran.drawBitmap(119, 40, 8, 8, pictoSelection);
    break;
  }
  
  // Affiche la temperature actuelle et le température choisie
  ecran.setFont(18);
  if(temperatureActuelle < 10) {
    ecran.setTextPosAbs(49, 13);
  } 
  else {
    if(temperatureActuelle < 100) {
      ecran.setTextPosAbs(40, 13);
    } 
    else {
      ecran.setTextPosAbs(31, 13);
    } 
  }
  ecran.print(temperatureActuelle);
  ecran.setTextPosAbs(60, 13);
  ecran.print("/");
  if(choixTemperature < 10) {
    ecran.setTextPosAbs(87, 13);
  } else {
    if(choixTemperature < 100) {
      ecran.setTextPosAbs(78, 13);
    } else {
      ecran.setTextPosAbs(69, 13);
    } 
  }
  ecran.print(choixTemperature);

  if(elongationDelayEnMicros < 10) {
    ecran.setTextPosAbs(36, 31);
  } else {
    if(elongationDelayEnMicros < 100) {
      ecran.setTextPosAbs(27, 31);
    } else {
      if(elongationDelayEnMicros < 1000) {
        ecran.setTextPosAbs(18, 31);
      } else {
        ecran.setTextPosAbs(9, 31);
      } 
    } 
  }
  ecran.print(elongationDelayEnMicros);
  
  // Affiche les cases cocher ou decocher suivant leur état
  if(elongationActiver) {
    ecran.drawBitmap(60, 22, 8, 8, pictoCocher);
  } else {
    ecran.drawBitmap(60, 22, 8, 8, pictoNonCocher);
  }
  if(choixMoteurExtrudeuseActiver) {
    ecran.drawBitmap(94, 22, 8, 8, pictoCocher);
  } else {
    ecran.drawBitmap(94, 22, 8, 8, pictoNonCocher);
  }
  if(choixEnrouleuseActiver) {
    ecran.drawBitmap(94, 41, 8, 8, pictoCocher);
  } else {
    ecran.drawBitmap(94, 41, 8, 8, pictoNonCocher);
  }
  
  // Ecrit le diametre actuelle
  ecran.setFont(120);
  ecran.setTextPosAbs(0, 63);
  ecran.print(diametreActuelle);
}

// Demande au capteur les valeurs et renvoi les pixels les plus claire.
int lireCapteur(void){
  byte pixel[128]; // Field for measured values <0-255>
  byte blanc = 0;

  // Initilise le capteur
  digitalWrite(PIN_TSL1401_CLK, LOW);
  digitalWrite(PIN_TSL1401_SI, HIGH);
  digitalWrite(PIN_TSL1401_CLK, HIGH);
  digitalWrite(PIN_TSL1401_SI, LOW);
  
  for(int i = 0; i < 128; i++) {
    analogRead(PIN_TSL1401_ANALOG)/4; // 8-bit is enough
    digitalWrite(PIN_TSL1401_CLK, LOW);
    digitalWrite(PIN_TSL1401_CLK, HIGH);
    delayMicroseconds(80);
  }
  
  digitalWrite(PIN_TSL1401_CLK, LOW);
  digitalWrite(PIN_TSL1401_SI, HIGH);
  digitalWrite(PIN_TSL1401_CLK, HIGH);
  digitalWrite(PIN_TSL1401_SI, LOW);

  int maxValue = pixel[0];
  for(int i = 0; i < 128; i++) {
    pixel[i] = analogRead(PIN_TSL1401_ANALOG)/4; // 8-bit is enough
    digitalWrite(PIN_TSL1401_CLK, LOW);
    digitalWrite(PIN_TSL1401_CLK, HIGH);
    maxValue = max(maxValue, pixel[i]);
  }

  maxValue = maxValue * 0.9;
  for(int i = 0; i < 128; i++) {
    if(pixel[i] < maxValue) {
      blanc++;
    }
  }
  
  return blanc;
}

void setup() {
  #ifdef DEBUG
    Serial.begin(115200);
  #endif
  
  
  
  
  interneServoDirection = bobinePremiereDirection;

// Calcule les differents pas que prendra le servo pour bobiner
  interneNombreTourSurBobine = ((bobineLargeur / filamentDiametreSouhaiter));
  internetLargeurBobineEnDegree = servoAngleMax - servoAngleMin;
  interneDegreEntreFilament = ((float)internetLargeurBobineEnDegree / ((float)interneNombreTourSurBobine-1));

  for (int i = 0; i < interneNombreTourSurBobine; i++) {
    interneServoDifferentePosition[i] = (int)(servoAngleMin + (i * interneDegreEntreFilament));
  }
  
  // Definit le pas le plus proche du l'emplacement du début de filament
  if(interneServoDirection == false) {
    for(int i = 0; i < interneNombreTourSurBobine; i++) {
      if(bobineAnglePremierTour > interneServoDifferentePosition[i]) {
        interneServoPosition = i;
      } else {
         break;
      }
    }
  } else {
    for(int i = 0; i < interneNombreTourSurBobine; i++) {
      if(bobineAnglePremierTour < interneServoDifferentePosition[i]) {
        interneServoPosition = i;
        break;
      }
    }
  }
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  Timer1.initialize(100);
  Timer1.attachInterrupt(timerIsr);
  
  // "Initialise" les stepper
  pinMode(PIN_ENROULEUSE_STEP, OUTPUT);
  pinMode(PIN_ENROULEUSE_DIR, OUTPUT);
  digitalWrite(PIN_ENROULEUSE_DIR, HIGH);
  pinMode(PIN_ELONGATION_STEP, OUTPUT);
  pinMode(PIN_ELONGATION_DIR, OUTPUT);
  digitalWrite(PIN_ELONGATION_DIR, HIGH);
  
  // Définit le ENDSTOP de l'enrouleuse comme un INPUT
  pinMode(PIN_ENDSTOP, INPUT);
  
  //Initialise le TSL1401
  pinMode(PIN_TSL1401_SI, OUTPUT);
  pinMode(PIN_TSL1401_CLK, OUTPUT);
  digitalWrite(PIN_TSL1401_SI, LOW);   // IDLE state
  digitalWrite(PIN_TSL1401_CLK, LOW);  // IDLE state

  // Définit les ports en temps que entré et active le pull-up interne
  pinMode(PIN_BOUTON_MOINS, INPUT);
  digitalWrite(PIN_BOUTON_MOINS, HIGH);
  pinMode(PIN_BOUTON_PLUS, INPUT);
  digitalWrite(PIN_BOUTON_PLUS, HIGH);
  pinMode(PIN_BOUTON_SELECT, INPUT);
  digitalWrite(PIN_BOUTON_SELECT, HIGH);
  
  // Commence la communication avec le controleur de l'écran
  ecran.begin();
  ecran.clearScreen();    // Efface l'écran
  ecran.disableCursor();  // Désactive le curseur
  delay(1000);
  // Affiche tous les elements perseistant
  ecran.drawBitmap(97, 1, 4, 4, pictoDegre);
  ecran.drawBitmap(104, 2, 12, 12, pictoChaud);
  ecran.drawBitmap(104, 20, 12, 12, pictoMoteurExtrusion);
  ecran.drawBitmap(69, 20, 12, 12, pictoEtirement);
  ecran.drawBitmap(104, 39, 12, 12, pictoEnrouleuse);
  ecran.setFont(18);
  ecran.setTextPosAbs(52, 63);
  ecran.print("mm");
  delay(1000);
  
  servoGuide.attach(9, 1000, 2000); 
  servoGuide.write(90);
}

const int analogInPin0 = A1; // Analog input pin
int sensorValue0 = 0;
 
 
void repossitionerServo() {
 #ifdef DEBUG
    Serial.print("NEMA : \t");
    Serial.print(enrouleuseNombreDePas);
    Serial.print("\t SERVO : \t");
    Serial.print(servoGuide.read());
    Serial.print("\t DIR : \t");
    if(interneServoDirection == false) {
      Serial.print("->");
    } else {
      Serial.print("<-");
    }
    Serial.print("\t TOUR : \t ");
    Serial.print(tour);
    Serial.print("\t SERVO R : \t ");
    Serial.print(interneServoPosition);
    Serial.print("\t NB TOUR : \t ");
    Serial.print(interneNombreTourSurBobine);
    
    Serial.println();
  #endif
  
    
  if((interneNemaDernierPositionValideTour + enroulementStepParTour) <= enrouleuseNombreDePas) {
    interneNemaDernierPositionValideTour = interneNemaDernierPositionValideTour + enroulementStepParTour;

    if(interneServoDirection == false) {
      interneServoPosition--;
    } else {
      interneServoPosition++;
    }
    
    if(interneServoPosition <= 0) {
       interneServoPosition = 0;
       interneServoDirection = !interneServoDirection;
    }
    
    if(interneServoPosition > interneNombreTourSurBobine-1) {
      interneServoPosition = interneNombreTourSurBobine-1;
      interneServoDirection = !interneServoDirection;
    }

      tour++;
  }

// Partie qui s'occupe de bloquer la roue quand le end-stop est enclenché et reprend de plus en plus rapidement
/*
  interneEndStopStatue = digitalRead(PIN_ENDSTOP);
  if(interneEndStopStatue == LOW) {
    digitalWrite(PIN_LED, LOW);
    
    nemaEnroulement.setSpeed(0);
    interneBobineDernierMillis = millis();

  } else {
    if((nemaEnroulement.speed() < bobineVitesseMin) && (interneBobineDernierMillis+bobineTempsArreter) < millis()) {
        nemaEnroulement.setSpeed(bobineVitesseMin);
        interneBobineDernierMillis = millis();
    }

    if(((nemaEnroulement.speed() >= bobineVitesseMin) || (nemaEnroulement.speed() <= bobineVitesseMax)) && (interneBobineDernierMillis+bobineTempsArreter) < millis()) {
      interneTmpCalcule = nemaEnroulement.speed() + bobinePasAugmentationVitesse;
      nemaEnroulement.setSpeed(interneTmpCalcule);
      interneBobineDernierMillis = millis();
    }
    digitalWrite(PIN_LED,HIGH);
  }
  */
}
 
void loop(){
  
  repossitionerServo();

  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  // Recupere le diametre du filament en valeur "system"
  diametreActuelle = lireCapteur();
  
  sensorValue0 = analogRead(analogInPin0);
  temperatureActuelle = analog2degre(sensorValue0);
  
  
  
  
  
  
  // Si le bouton select est pressé
  if(digitalRead(PIN_BOUTON_SELECT) == LOW && (menuMillisSelect < millis() - 250)) {
    menuPosition++;
    if(menuPosition > 4) {
      menuPosition = 0;
    }
    menuMillisSelect = millis();
  }

  // Si le bouton plus est pressé
  if(digitalRead(PIN_BOUTON_PLUS) == LOW && (menuMillisPlusMoin < millis() - 75)) {
    switch(menuPosition) {
    case 0:
      if(choixTemperature < PARAM_TEMP_MAX) {
        choixTemperature++;
      }
      break;
    case 1:
      choixMoteurExtrudeuseActiver = 1;
      break;
    case 2:
      elongationActiver = 1;
      break;
    case 3:
      elongationDelayEnMicros = elongationDelayEnMicros + 10;
      break;
    case 4:
      choixEnrouleuseActiver = 1;
      break;
    }
    menuMillisPlusMoin = millis();
  }

  // Si le bouton moins est pressé
  if(digitalRead(PIN_BOUTON_MOINS) == LOW && (menuMillisPlusMoin < millis() - 75)) {
    switch(menuPosition) {
    case 0:
      if(choixTemperature > 0) {
        choixTemperature--;
      }
      break;
    case 1:
      choixMoteurExtrudeuseActiver = 0;
      break;
    case 2:
      elongationActiver = 0;
      break;
    case 3:
      if(elongationDelayEnMicros > 0) {
        elongationDelayEnMicros = elongationDelayEnMicros - 10;
      }
      break;
    case 4:
      choixEnrouleuseActiver = 0;
      break;
    }
    menuMillisPlusMoin = millis();
  }
  
  // Rafréchie l'écran suivant à la fréquence de la constante PARAM_LCD_ACTUALISATION
  if((ecranDerniereActualisation < millis() - PARAM_LCD_ACTUALISATION)) {
    actualiserAffichage();
    ecranDerniereActualisation = millis();
  }
  
  
  if(digitalRead(PIN_ENDSTOP) == LOW) {
    interneEnrouleuseTendu = 0;
  } else {
    interneEnrouleuseTendu = 1; 
  }
  
  
  servoGuide.write(interneServoDifferentePosition[interneServoPosition]);
  

}




// timer1 interrupt function
void timerIsr() {
  unsigned long microsMainteant = micros();
  
  if((microsMainteant - elongationDernierMillis >= elongationDelayEnMicros)) {
    if(elongationActiver) {
      PORTB |= B00100000; // = digitalWrite(PIN_ELONGATION_STEP, HIGH);
      PORTB &= B11011111; // = digitalWrite(PIN_ELONGATION_STEP, LOW);
      
      elongationNombreDePas++;
      elongationDernierMillis = microsMainteant;
    }
  }
  
  if((microsMainteant - enrouleuseDernierMillis >= enrouleuseDelayEnMicros)) {
    if(interneEnrouleuseTendu && choixEnrouleuseActiver) {
      PORTB |= B10000000; // = digitalWrite(PIN_ELONGATION_STEP, HIGH);
      PORTB &= B01111111; // = digitalWrite(PIN_ELONGATION_STEP, LOW);
      enrouleuseNombreDePas++;
      enrouleuseDernierMillis = microsMainteant;
    }
  }
}

picto.h

static const unsigned char PROGMEM pictoEnrouleuse[] = {
  B00011111, B10000000, B00111111, B11000000, B01100110, B01100000, B11000110, B00110000,
  B11000110, B00110000, B10001111, B00010000, B10011111, B10010000, B11111001, B11110000,
  B11110000, B11110000, B01100000, B01100000, B00111001, B11000000, B00011111, B10000000
};

static const unsigned char PROGMEM pictoSelection[] = {
  B00100100, B00100100, B01111110, B11011011, B11011011, B11111111, B11111111, B10100101
};

static const unsigned char PROGMEM pictoNonCocher[] = {
  B00000000, B01111110, B01000010, B01000010, B01000010, B01000010, B01111110, B00000000
};

static const unsigned char PROGMEM pictoCocher[] = {
  B00000000, B01111110, B01111110, B01111110, B01111110, B01111110, B01111110, B00000000
};

static const unsigned char PROGMEM pictoDegre[] = {
  B01100000, B10010000, B10010000, B01100000
};

static const unsigned char PROGMEM pictoChaud [] = {
  B00100010, B00100000, B00010001, B00010000, B00010001, B00010000, B00100010, B00100000,
  B01000100, B01000000, B10001000, B10000000, B10001000, B10000000, B01000100, B01000000,
  B00100010, B00100000, B00000000, B00000000, B11111111, B11110000, B11111111, B11110000
};

static const unsigned char PROGMEM pictoMoteurExtrusion [] = {
  B01111000, B00000000, B00111100, B00010000, B00011100, B00110000, B00001110, B01110000,
  B00001111, B11110000, B00011001, B11100000, B01111001, B10000000, B11111111, B00000000,
  B11100111, B00000000, B11000011, B10000000, B10000011, B11000000, B00000001, B11100000
};

static const unsigned char PROGMEM pictoEtirement [] = {
  B00000110, B00000000, B00001111, B00000000, B00011111, B10000000, B00011111, B10000000,
  B00001111, B00000000, B00000110, B00000000, B00000110, B00000000, B00001111, B00000000,
  B00011111, B10000000, B00011111, B10000000, B00001111, B00000000, B00000110, B00000000
};

Coloration et modification du filament

Colorant alimentaire : La teinte obtenue trop légère, a peine visible dans le filament et invisible une fois imprimé.

Toner d'imprimante : Excellent résultat mais reste translucide

Je vais tester le dioxyde de titane qui à un pouvoir opacifiant ainsi que de la poudre de laiton (risque d’érodé la buse d’impression) mélange de minimum 5g pour 100g.

Pour avoir un effet crais platre, il faut utiliser du mortier ou du pilon, fin dans les deux cas.

Ne pas essayer de mélanger du carbone avec du PLA, ABS, risque d'explosion ! Ne pas essayer le fulmicoton, risque d'explosion, évaluer les risque de la cellulose

Pour aider au dossage du toner dans le but d'avoir une couleur précise utiliser ces cercles chromatique :

Remerciment

Je remercie gaston_ et boboss pour leur soutient et aide.

Je remercie fas83 pour le partage de ses connaisances.

Je remerci Viproz pour l'aide au développement sur Arduino

Je remerci gregorio pour ces informations sur la chimie

Je remerci jerome- du chan IRC irc://irc.freenode.net/arduino-fr

Je remercie l'ensemble des membres du chan IRC irc://irc.freenode.net/reprap-fr

Je remercie xxxx pour la correction de cette article