Nettoyage mécanique :

Dans le passé, j'avais déjà tenté de nettoyer la buse de la tête d'impression, mais je l'avais cassée, car je l'ai dévissée à froid. J'ai dû la changer en rachetant toute la tête d'impression.

Cette fois, je n'ai pas pris de risque, et après avoir démonté la tête sans dévisser la buse, je l'ai simplement mais sérieusement nettoyée. Cela a été d'autant plus facile que, depuis son changement, la buse est protégée par une chaussette en silicone qui réduit l'accroche des coulures de filament sur la tête.

Mise-à-jour matériel :

La base :

J'avais déjà acquis le caisson Dagoma :

Un petit graissage des axes ne fait pas de mal :

!((/blog/techno/userfiles/images/5/65/IMG_20250111_235129_389.jpg)

J'avais aussi quelques soucis avec la courroie d'entraînement du plateau, qui avait tendance à se détendre. La courroie ne semblait pas avoir de défaut, et il se peut que le plastique qui pince cette courroie se soit déformé sur sa partie interne. Après quelques tests j'ai finalement trouvé la solution, insérer un morceau de mécano pour que la courroie soit bien coincée :

Bien que cela n'est jamais eu d'incidence, j'ai profité de l'occasion pour re-imprimer une des pièces latérale qui s'est brisée en morceau :

L'accroche :

Pour l'accroche, je suis très tôt passé du scotch bleu 3M à une accroche un peu plus simple à gérer et plus durable, un support d'accroche bon marché acheté chez LetMeKnow.

Je voulais encore monter d'un cran en achetant un plateau magnétique amovible; et par un heureux hasard j'avais en stock deux grands magnets de pub type calendrier de serrurier. Je suis donc passé cher Leroy Merlin et j'ai trouvé un morceau de tôle acier lisse galvanisé 250x500mm-0.5mm pour moins de 5€ ! Ni une, ni deux, deux petits coups de scie sauteuse et de la glu pour coller les magnets découpés sur le plateau alu d'origine de l'imprimante, et une nouvelle accroche à coller sur le morceau de tôle; la force des magnet et suffisante pour bien tenir la tôle et le tout accroche très bien :

Au passage, j'ai eu du mal à dévisser mon plateau d'origine pour y coller les magnets, et j'ai cassé une des pièces en plastique, mais elle est encore utilisable ce qui m'a permis de la re-imprimer avant qu'elle ne lâche complètement :

La webcam :

Pour surveiller mes impressions j'ai installé une webcam devant le plateau, et pour cela j'ai modélisé un support minimaliste, et j'ai imprimé une nouvelle façade de webcam qui permet de régler le focus de ma Logitech C270 :

Mais ce système ne permet pas une vue totale de la zone d'impression, et ce n'est pas très stable car on touche souvent le devant du plateau et la webcam tombe. J'ai donc modélisé un autre système qui permet de mettre la webcam dans un des coins du caisson Dagoma :

j'ai aussi mis en place un petit bandeau de led RGB avec un contrôleur à base de PicoDuino, qui me permet de régler la couleur, l'intensité lumineuse, le nombre de leds et la position de la lumière :

#include <Adafruit_NeoPixel.h>
#include <avr/power.h>
#include <RotaryEncoder.h>

#define LED_DATA 0
#define LED_NUMBER 31
#define ROTARY_BUTTON 5
#define ROTARY_CLOCK 1
#define ROTARY_DATA 2

#define ACTIVATED_DELAY 3000

Adafruit_NeoPixel pixels(LED_NUMBER, LED_DATA, NEO_GRB);
RotaryEncoder encoder(ROTARY_DATA, ROTARY_CLOCK/*, RotaryEncoder::LatchMode::FOUR3*/);

bool led_activated = false;
unsigned long start_press; 

int led_width = LED_NUMBER / 2;
int led_power = 5;
int led_hue = 0;
int led_center = LED_NUMBER / 2;
enum class ModeSetting {width, power, hue, center, last} mode_setting;

bool dirty = true;
float display_power;
int display_hue;

int hue[7][3] = {
  {254, 254, 254},
  {254, 0, 0},
  {0, 254, 0},
  {0, 0, 254},
  {254, 254, 0},
  {254, 0, 254},
  {0, 254, 254},
};

void setup() {
  pinMode(LED_DATA, OUTPUT);
  pinMode(ROTARY_BUTTON, INPUT_PULLUP);

  pixels.begin();

  mode_setting = ModeSetting::power;
  encoder.setPosition(led_power);      
}

void loop() {
  if (digitalRead(ROTARY_BUTTON) == LOW) {
    start_press = millis();
    while (digitalRead(ROTARY_BUTTON) == LOW)
      delay(100);
    if (millis() - start_press > ACTIVATED_DELAY) {
      led_activated = !led_activated;
    } else {
      switch (mode_setting) {
        case ModeSetting::width :
          mode_setting = ModeSetting::power;
          encoder.setPosition(led_power);      
          break;
        case ModeSetting::power :
          mode_setting = ModeSetting::hue;
          encoder.setPosition(led_hue);      
          break;
        case ModeSetting::hue :
          mode_setting = ModeSetting::center;
          encoder.setPosition(led_center);      
          break;
        case ModeSetting::center :
          mode_setting = ModeSetting::width;
          encoder.setPosition(led_width);      
          break;
      }
    }
  }

  if (led_activated) {
    encoder.tick();
    switch (mode_setting) {
      case ModeSetting::width :
        if (led_width != constrain(encoder.getPosition(), 0, LED_NUMBER)) {
          led_width = constrain(encoder.getPosition(), 0, LED_NUMBER);
          encoder.setPosition(led_width);
          dirty = true;
        }
        break;
      case ModeSetting::power :
        if (led_power != constrain(encoder.getPosition(), 0, 100)) {
          led_power = constrain(encoder.getPosition(), 0, 100);
          encoder.setPosition(led_power);
          dirty = true;
        }
        break;
      case ModeSetting::hue :
        if (led_hue != constrain(encoder.getPosition(), 0, 6)) {
          led_hue = constrain(encoder.getPosition(), 0, 6);
          encoder.setPosition(led_hue);
          dirty = true;
        }
        break;
      case ModeSetting::center :
        if (led_center != constrain(encoder.getPosition(), 0, LED_NUMBER - 1)) {
          led_center = constrain(encoder.getPosition(), 0, LED_NUMBER - 1);
          encoder.setPosition(led_center);
          dirty = true;
        }
        break;
    }

    if (dirty) {
      pixels.clear();
      pixels.setPixelColor(led_center, pixels.Color(hue[led_hue][0] * led_power / 100.0, hue[led_hue][1] * led_power / 100.0, hue[led_hue][2] * led_power / 100.0));
      for (int led = 1; led < led_width; led++) {
        display_power = float(led_power) * float(led_width - led) / float(led_width) / 100.0;
        pixels.setPixelColor(led_center + led, pixels.Color(hue[led_hue][0] * display_power, hue[led_hue][1] * display_power, hue[led_hue][2] * display_power));
        pixels.setPixelColor(led_center - led, pixels.Color(hue[led_hue][0] * display_power, hue[led_hue][1] * display_power, hue[led_hue][2] * display_power));
      }
      pixels.show();
    }
  } else {
    delay(100);
  }
}

et en vidéo :

Mise-à-jour du firmware :

Le firmware de la Dagoma DiscoEasy200 est basée sur le firmware Marlin v1.1RC6 avec quelques patchs de Dagoma. Bien que parfaitement fonctionnel, il commence un peu à dater et ne contient pas les dernières améliorations de qualité pour imprimer au mieux.

Heureusement la communauté a fait une fusion des particularités de ce firmware avec une version plus récente.

Et pour les plus curieux et aventureux il existe un bon fil de discussion à propos de la mise-à-jour du firmware Marlin pour les imprimantes de Dagoma.

La procédure de mise-à-jour du firmware n'est pas très compliquée :

Installation de l'IDE Arduino.
Récupération des sources patchées sur github.
Modification des fichiers Configuration.h et Configuration_adv.h pour activer les options qui correspondent à mon imprimante (#define DE200_EXTRUDER_PLUS pour l'extrudeur+, #define DE200_ZSCREWS_EXPERT pour le pack expert), et quelques options supplémentaires (#define GRID_MAX_POINTS_X 5 pour 25 points de mesure du niveau du plateau (au lieu de 9), #define ABL_BILINEAR_SUBDIVISION pour affiner le maillage du plateau).
Compilation du firmware et export du binaire (résultat dans MarlinDE200/Marlin/Marlin/build/arduino.avr.mega/Marlin.ino.hex).
Upload du firmware sur l'imprimante à l'aide de l'application DagomaApp.

Notes :

Les sources Marlin parlent des cartes MKS Base à partir de la v1.5, mais mon imprimante est basée sur la MKS Base v1.0 qui a été intégrée aux premières Dagoma DiscoEasy200. Pas de soucis le firmware correspond aussi car Dagoma a un câblage particulier (utilisation des broches Heater-1 pour le ventilateur avant, et détection de butée sur un autre broche).
L'IDE Arduino ne m'a pas permis d'uploader directement le firmware, car le firmware officiel n'installe pas de bootloader Arduino sur la carte Marlin. Et même si les sources de Marlin génèrent un firmware avec bootloader, j'ai eu une erreur en essayant de l'uploder (problème de taille ?). Mais l'application DagomaApp permet d'uploader le firmware compilé sans problème.
J'ai activé la langue en 'fr' mais l'affichage de l'écran est toujours en anglais, pas grave.

Amélioration de l'impression :

D'entrée de jeux, sans faire de calibrage, j'ai vu que mes impressions étaient un peu plus nettes. L'accroche neuve du plateau m'a permis de repartir immédiatement sur de bonnes bases. En revanche, le plateau magnétique ne m'a pas été d'une grande utilité, car j'ai imprimé de petites pièces; à revoir sur des objets plus larges.

Amélioration de l'usage :

Le nouveau firmware offre plus de réglage depuis l'écran LCD; dont entre autres le réglage de l'offset Z (Z Offset Wizard, Tune/Z Offset) sans passer par l'application DagomaApp.

Mise-à-jour du logiciel de tranchage :

Je suis déjà passé de Cura by Dagoma au Cura officiel, car ce dernier intègre maintenant les définitions des imprimantes Dagoma.

Dans Cura, j'ai activé les plug'ins suivants :

Arc Welder
Octoprint Connexion
Auto tower generator

Et grâce au changement de firmware de l'imprimante, il est possible d'activer des paramètres d'impression plus performants :

modification du G-Code de démarrage pou l'imprimante : G29 suivi de M402 S1 (pour profiter du nivellement bi-linéaire).
activation de l'Arc Welding.

Mise-à-jour du serveur d'impression :

Il y a un certains, j'ai connecté en USB mon imprimante à mon serveur et j'utilise OctoPrint pour soumettre les travaux; ce qui m'évite les manipulations répétées avec la carte MMC, et surtout je peux gérer mes impressions depuis ma station de travail (PC sous Debian GNU Linux).

J'ai installé les plugin's suivants :

Bed Visualizer
DisplayLayerProgress
Fullscreen

Impression de test :

J'ai tenté de calibrer mon imprimante avec la génération de sous Cura, mais ça n'a pas eu vraiment d'effet :

Ceci dit, le réglage du plateau est presque parfait avec le nivellement bi-linéaire, et la remise au propre mécanique associé au nouveau firmware donne de bons résultats :

A suivre; car il y a tout une procédure de calibrage a effectuer (revoir la génération des tours), certainement des valeurs à peaufiner dans le firmware (fréquence de résonance...), et des options à tester dans Cura.

A bientôt

Antoine