Final Project

I have two final project ideas. My initial idea was to design a modular light controller, which I described in Week 01b. Over the weeks, and after discussions with my local instructor Ferdi, I developed the idea of creating a "smart" filament holder for the Prusa XL. This holder would measure the weight of the spools and indicate how much filament remains. This feature is particularly useful because loading and unloading filament on the Prusa XL can be cumbersome—especially when printing with five different materials, as it requires unloading, weighing, and reloading five spools. Integrating this with a filament drying box would be a great addition. For this aspect, I found some inspiration on YouTube with the Sicco Box, which is also available on Printables.

The weight measurement should be implemented using individual load cells for each spool holder. My first approach was to use the same or similar load cells that are already integrated into the hotends, but I couldn't find any specific information about them. The typical Δm will be 1 kg, with a range from 220 g to 1220 g, which corresponds to the weight of a 1 kg Prusament spool. Adafruit recommends using load cells rated for double the maximum expected weight for optimal measurement precision. With this in mind, the Adafruit 5 kg load cells could be a good choice, as they would also support 2 kg spools, which we occasionally use with our Prusa MK4S (formerly MK3.9). For optimal precision, a high-quality ADC such as the HX711 is essential. In week 09 I tested the usage of an HX711 in combination with an ESP32C3.
Beside the HX711 I looked for integrated ADC on the available microcontroller from the FabInventory and the Xiao ESP32C6.

Other useful information from inside the box are temperature and humidity. For that I also did some experiments in week 09 with the conclusion that the BME688 will over achieve the job, it is still easy to use and implement why I'll want to integrated it in to the project even if the price is still high, specially for the module if its not bought separately.

The project will include multiple sensors and actors so I need a display and some way to navigate to a menu. Beside the load cells and a environment sensor I want to use a rotary encoder as a human input, which I experiment in week 9. To get an visual output I plan to use a display. For that I reason I experiment with a small and a bigger OLED display in week 10.

To realize the active drying feature I came up with two ideas.
1. Fan heaters which can be found as open, relatively small modules.
2. Dehumidifier membranes like these ones, which I found in a youtube video, while researching for already designed solutions for similar problems.

The first option have the problem that they have a high power consumption and that you don't want to use them unsupervised because they could easily start a fire. Cause of the heating elements in an closed and small room. The second option can fast be expensive but they don't use active heating, so there are less potential fire hazards. In the Sicco box which was an inspiration a fan heater from a Sunlu S4 is used.

It would be nice to have some kind of modularity so I can start with one spool holder in the box with a load cell, a display and a rotary encoder. The next iteration will conclude multiple spool holders and in the last iteration some kind of active drying solution can be added. I don't want to replace always the pcb and make some new wiring, so I plan to use multiple microcontroller. One microcontroller on each spool holder, so they will be modular, one main microcontroller where the display and rotary encoder is connected and optional one for the active drying solution, otherwise that could probably done by the main microcontroller. For that reason I tried out some simple networking in week 11.

System Integration

The thoughts about the system integration are documented in week 15.

Electronics

BOM

The prices will be calculated without shipping, with german taxes in €. For easier reproduction I'll try to minimize quantity of different shops even if it cost more.

Mainboard

2 sided pcb

The first big challenge is to mill a 2 sided board. In preparation for this I build a vacuum clamp with bowel pins in week 07.
I did in the first try following steps:
1. drill 4 holes for positioning
2. mill the top side
3. flip the board along the x axis
4. mill the bottom side
5. mill vias, holes and the outline

Before I can drill the four holes in the double sided pcb stock in the same distance to each other then the dowel pins on the vacuum clamp, in my case 117 mm in x and 91,6 mm in y. I need to generate g-code for that. The first attempted was to use mods but with that I couldn't generate g-code for 2 mm holes with a 2 mm end mill. It was only possible with a 1,6 mm endmill. Ferdi could generate g-code for a 1,9 mm endmill for a 2 mm hole but with only 96 dpi instead of 999 dpi. We couldn't reproduce this, so I just let Fusion 360 generate the g-code for the 4 holes using the "Drill" tool with a 2 mm drill.

To prepare the png files for milling I have to make sure that I could use the same 0 point without any offset between the layers after flipping. Normally I exported the top layer and the outlines/holes as a pdf load them in Inkscape, make some small adjustments and then exported it as png to uploaded it into mods. For this pcb I decided to try gerber2png. For that I exported a gerber file from easyeda with following setting:

✅ Top Layer
✅ Bottom Layer
✅ Board Outline Layer
✅ Mechanical Layer
✅ Export Object

I then ended up with following seven files:

Which I drag and drop into Gerber2Png except the "How-to-order-PCB" file.

This generates the following different png files:

To only need two g-codes I opened the outline file and the hole file in gimp and lay them over each other to make one png file out of them. I will not drill completely through my stock material why I also flipped a copy of the drilling file to also drill the holes from the bottom side.

To make sure that I don't have any offsets while flipping the stock I loaded all files in to Inkscape and put them on a canvas with the size that matches the hole distance for the bowel pins. So as long as the coordinates from the front left dowel pin are correct I can easily flip the board and don't need to correct the origin.

Before I started the actual milling I tried the g-code in midair to make sure that the endmill not collide with the dowel pins, which are slightly raised.

While doing the test I came up with the idea to remove the critical pin on the front left, which is also the 0 point for the g-code. Later Ferdi told me, that I can adjust the jog height in mods. I then raise the jog height to 5 mm to make sure that it is definitely higher than the dowel pin.

But I was still a little bit scared and after I already broke one of the good endmills from Ferdi accidentally in a dump situation.

While milling the bottom I recognized that the png files gerber2png generates flips the board over the short side, while in my case I need it to flip the board along the long side, which result in a not usable pcb. But that gave me the chance to fix some small errors that I found. For example one trace thats handle the serial communication has a 90° angle on a via and I didn't put my name or "Fab Academy 25" on the board.

The results was still impressive and the difference between cheap and expensive endmills are definitely visible. Over the last weeks I used the cheap ones and for the final project I came in the pleasures situation to use the good ones. Thank you Ferdi for let me borrowing your endmills.

To ensure that the coordinates from the origin are correct I put the wrong milled pcb back in the machine and milled the bottom side with the correct flipped file. Which wasn't a success because I used the wrong png file. The result itself looks promising and for the holes and outline I used the correct file which results in a good enough result. The y coordinate could be slightly of by a few μm which is good enough. All in all it took me 4 tries until everything works. The third try looks promising but I forgot to check the mill bit positions, so the mill used the wrong endmill for milling the holes, which results in bigger holes and without any pads.

PCB test

After soldering the pcb I began testing the different components. Firstly the Neopixels for that I used following test code:

#include <Adafruit_NeoPixel.h>                                               // library for NeoPixels

#define PIN_NEO_PIXEL D3                                                     // Xiao pin that connects to NeoPixel
#define NUM_PIXELS 5                                                         // The number of LEDs

Adafruit_NeoPixel NeoPixel(NUM_PIXELS, PIN_NEO_PIXEL, NEO_GRB + NEO_KHZ800); // set the NeoPixel initialization

void setup() {
  NeoPixel.begin();                                                          // initialize the NeoPixel strip object
}

void loop() {
  for (int i = 0; i < 256; i++) {                                            // color cycling
    byte r = (i < 85) ? i * 3 : (i < 170) ? 255 - (i - 85) * 3 : 0;
    byte g = (i < 85) ? 255 - i * 3 : (i < 170) ? 0 : (i - 170) * 3;
    byte b = (i < 85) ? 0 : (i < 170) ? (i - 85) * 3 : 255 - (i - 170) * 3;

    for (int j = 0; j < 5; j++) {
      NeoPixel.setPixelColor(j, r, g, b);                                    // set color
    }

    NeoPixel.setBrightness(100);                                             // reduce brightness to 100 from 255, only for filming otherwise not need it
    NeoPixel.show();                                                         // output the color
    delay(10);                                                               // short delay for the color change
  }
}

Secondly I integrated the rotary encoder into the test.

#include <Adafruit_NeoPixel.h>    // library for NeoPixels
#include <Encoder.h>              // library for rotary encoder

#define PIN_NEO_PIXEL D3          // Xiao pin that connects to NeoPixel
#define NUM_PIXELS 5              // number of LEDs
#define dt D7                     // Xiao pin that connects to rotary encoder dt
#define clk D9                    // Xiao pin that connects to rotary encoder clk
#define sw D8                     // Xiao pin that connects to rotary encoder sw

Adafruit_NeoPixel NeoPixel(NUM_PIXELS, PIN_NEO_PIXEL, NEO_GRB + NEO_KHZ800); // set the NeoPixel initialization
Encoder brightness(dt,clk);                                                  // initiate object rotary encoder with the name brightness

int encoder_value = 0;            // value of rotary encoder
int brightness_value = 255;       // brightness value for the NeoPixel
int brightness_value_old = 255;   // previous brightness value for the NeoPixel
bool sw_control = false;

void setup() {
  Serial.begin(115200);            // initial serial communication with a baud rate of 115200
  NeoPixel.begin();                // initialize the NeoPixel strip object
  pinMode(sw, INPUT);              // set pin for rotary encoder button as an input
}

void IRAM_ATTR fallout()
{
  if (sw_control == false){
    brightness_value = brightness_value_old;
    sw_control = true;
  }
  else if (sw_control == true){
    brightness_value_old = brightness_value;
    brightness_value = 0;
    sw_control = false;
  }
}

void loop() {
  for (int i = 0; i < 256; i++) {                                             // go through all possible values to control a Neopixel
    byte r = (i < 85) ? i * 3 : (i < 170) ? 255 - (i - 85) * 3 : 0;           // set first set of number ranges for a color cycle 
    byte g = (i < 85) ? 255 - i * 3 : (i < 170) ? 0 : (i - 170) * 3;          // set second set of number ranges for a color cycle 
    byte b = (i < 85) ? 0 : (i < 170) ? (i - 85) * 3 : 255 - (i - 170) * 3;   // set third set of number ranges for a color cycle 

    if (encoder_value != brightness.read()){
      encoder_value = brightness.read();
      brightness_value = encoder_value;
    }
    Serial.println(brightness_value);

    for (int j = 0; j < 5; j++) {
      NeoPixel.setPixelColor(j, r, g, b);             // set color
    }
    NeoPixel.setBrightness(brightness_value);
    NeoPixel.show();                                   // output the color
    attachInterrupt(sw, fallout, HIGH);
    delay(10);                                         // short delay for the color change
  } 
}

Thirdly I integrated the OLED display to make sure that everything works together.

#include <Adafruit_NeoPixel.h>                                               // library for NeoPixels
#include <Encoder.h>                                                         // library for rotary encoder
#include <Wire.h>                                                            // include wire library need it for the Adafruit_GFX library
#include <Adafruit_GFX.h>                                                    // include Adafruit_GFX library need it for the Adafruit_SSD1306 library
#include <Adafruit_SSD1306.h>                                                // include Adafruit_SSD1306 library tp control the OLED display

#define PIN_NEO_PIXEL D3                                                     // Xiao pin that connects to NeoPixel
#define NUM_PIXELS 5                                                         // number of LEDs
#define dt D7                                                                // Xiao pin that connects to rotary encoder dt
#define clk D9                                                               // Xiao pin that connects to rotary encoder clk
#define sw D8                                                                // Xiao pin that connects to rotary encoder sw
#define SCREEN_WIDTH 128                                                     // set OLED display width
#define SCREEN_HEIGHT 64                                                     // set OLED display height
#define OLED_RESET -1                                                        // set the reset pin

Adafruit_NeoPixel NeoPixel(NUM_PIXELS, PIN_NEO_PIXEL, NEO_GRB + NEO_KHZ800); // set the NeoPixel initialization
Encoder brightness(dt,clk);                                                  // initiate object rotary encoder with the name brightness

Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);    // initialize an Adafruit_SSD1306 object called display with the parameters from above

int encoder_value = 0;                                                       // value of rotary encoder
int brightness_value = 255;                                                  // brightness value for the NeoPixel
int brightness_value_old = 255;                                              // previous brightness value for the NeoPixel
bool sw_control = false;

void setup() {
  Serial.begin(115200);                                                      // initial serial communication with a baud rate of 115200
  NeoPixel.begin();                                                          // initialize the NeoPixel strip object
  pinMode(sw, INPUT);                                                        // set pin for rotary encoder button as an input

  if (!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {                          // checked if a display is available  
    Serial.println(F("SSD1306 allocation failed"));                          // if no display is available send an error message to the serial monitor  
    for(;;);
  }

  display.clearDisplay();                                                    // clear the display --> set every pixel to black  
}

void displayMessage(int message) {                                           // function to visualize a message on the display
  display.clearDisplay();                      
  display.setTextSize(1);                                                    // set text size
  display.setTextColor(SSD1306_WHITE);                                       // set the text color
  display.setCursor(0,0);                                                    // set the position where the text is shown on the display
  display.println("Encoder Value:");                                         // send the input from the function to the display
  display.setCursor(0,10);                                                   // set the position where the text is shown on the display
  display.println(message);                                                  // send the input from the function to the display
  display.display();                                                         // show data on the display with the parameters from above
}

void IRAM_ATTR fallout()
{
  if (sw_control == false){
    brightness_value = brightness_value_old;
    sw_control = true;
  }
  else if (sw_control == true){
    brightness_value_old = brightness_value;
    brightness_value = 0;
    sw_control = false;
  }
}

void loop() {
  for (int i = 0; i < 256; i++) {                                             // go through all possible values to control a Neopixel
    byte r = (i < 85) ? i * 3 : (i < 170) ? 255 - (i - 85) * 3 : 0;           // set first set of number ranges for a color cycle 
    byte g = (i < 85) ? 255 - i * 3 : (i < 170) ? 0 : (i - 170) * 3;          // set second set of number ranges for a color cycle 
    byte b = (i < 85) ? 0 : (i < 170) ? (i - 85) * 3 : 255 - (i - 170) * 3;   // set third set of number ranges for a color cycle 

    if (encoder_value != brightness.read()){
      encoder_value = brightness.read();
      brightness_value = encoder_value;
    }
    displayMessage(encoder_value);                                            // display the encoder value on the display

    for (int j = 0; j < 5; j++) {
      NeoPixel.setPixelColor(j, r, g, b);                                     // set color
    }
    NeoPixel.setBrightness(brightness_value);
    NeoPixel.show();                                                          // output the color
    attachInterrupt(sw, fallout, HIGH);
    delay(10);                                                                // short delay for the color change
  } 
}

And it didn't worked because I mixed up SDA and CLK on the display. So I have to mill and solder a new pcb but now I know how it works, so it should work alot faster. After I fix this I used the test code again and it works.

Before fixing the mixed up sda and clk pins I tried out the last functionality, if the serial communication between the xiao's works or if there is also a problem. I asked CHatGPT for some basic code to test the communication between the two boards with following prompt:

"Write a code which coud be compiled in the arduino ide for two xiao esp 32c3 which allows them to communicated over a serial communication on pin pin d0 and d1. The result should be visible in a serial monitor."

Which result after some small modification in the following code for the transmitter:

void setup() {
  Serial.begin(115200);        // Debug monitor
  Serial1.begin(9600, SERIAL_8N1, 2, 3);  // TX only on GPIO3 (D1)
  // Note: RX pin is set to -1 because we're only transmitting here
  Serial.println("Sender ready.");
}

void loop() {
  String message = "Hello";
  Serial1.println(message);    // Send to receiver
  Serial.println("Sent: " + message);
  delay(1000);
}

And for the receiver:

void setup() {
  Serial.begin(115200);         // Debug monitor
  Serial1.begin(9600, SERIAL_8N1, 2, 3);  // RX only on GPIO1 (D0)
  // Note: TX pin is set to -1 because we're only receiving
  Serial.println("Receiver ready.");
}

void loop() {
    String received = Serial1.readStringUntil('\n');
    Serial.println("Received: " + received);
}

Distributionboard

Out of time concerns I desided to use cables to connect the HX711 modules with the mainboard. To collect all the neccessary connections to the mainboard I designed a small distribution pcb which then connect all signals bundled to the mainboard. For that reason the board is located on the inside of the Eurobox close to the mainboard. To make the schemativ a little bit easier to read I used different small connectors, at the pcb they are put together as one connector for less cable chaos.

Adapterboard

The Adapterboard is nothing more than a 90° bracket to connect the HX711 module to the cable that runs to the Distributionboard.

Mechanics

BOM

The prices will be calculated without shipping, with german taxes in €. For easier reproduction I'll try to minimize quantity of different shops even if it cost more.

The main enclosure for the project will be a Eurobox, because our shelf system is configured to fit Euroboxes and it makes it easy and cheap to reassemble. To fit different sizes of filament spools inside without going to big I decided to use a Box with the size 60 x 40 x 43,5 mm. To make sure that my design will fit with the existing components I reverse engineer a few by myself like the load cell or the filament spools. Others like the Eurobox I search for 3D models online.

Spool holder

Spool holder side

The spool holder side is printed which results in a okayisch surface quality. For the first iteration it is ok but needs to be improved for the finished product. The bearings will be snap fit in to position and only needs slightly pressure to slide in the correct position. The first printed version already works good but need some bigger distance to ensure that the outer ring of the bearing are not rubbing against the spool holder side, which result in unnecessary friction which could compromise the functionality. Better bearings would also a good improvement but for now I'll use the one that are momentary available.

Spool holder baseplate

To ensure that the spool holder sides fits perfectly in to the spool holder baseplate, I make some test with the conclusion that 4,9 mm will works the best because 4,8 mm fits better for just one connection but because I have two I wanted a little bit more of play at the connection, why I choose 4,9 mm.

The first plate looks like that.

There is still no sliding movement possible because the connection clamps a little bit together between the two connections. It feels more like a good fit, if the parts shouldn't move at all. The biggest challenge is that the parts need some room to slide from right to left but on the other side also make sure that the parts didn't jam.
Out of aesthetics reasons I decided to use counter sink screes to make a clean, even finish without any unnecessary disturbance. To realize the counter sink I use a drill pressed and a countersink drill.

For the next iteration I increase the widthenes a little bit, that I could also fit the bigger 2 kg spools from DAS FILAMENT which we also use. It is still enough space in between the plates that they are still not touching eachother to make sure that the measurements are correct.

Screw cover

To ensure easy variation of the position from the Spool holder sides but still secure them safely in place. I decided to use some type of thumbscrews which can get fast expensive and four for each spool holder is needed so all in all 20 to make it cheaper but still allows a similar easy handling I chosen to make them on my own. To make it easy and fast to manufacture I used ISO 4017 screws as a base and add some cover around it which is comfortable and easy to turn. For that reason I needed the hexagon head screw to ensure screw propulsion a form fit between the hexagon head and the Screw cover is used. To ensure a good fit I added some dogbones to the hexagon hole because with 3D printing the holes will not have perfect inner corners.

Load cell

Load cell spacer small

To connect the load cell with spool holder the load cell spacer small is inserted between the spool holder base plate and the load cell together with two DIN EN ISO 10642 - M4x12 screes to hold everything in place.

Load cell spacer big

The first idea was to make this part as simple as the load cell spacer small but confronted with the problem that I need to place the HX711 modules somewhere close to the load cell. I decided that it would be best to combine the spool holder spacer big with a small case for the HX711 module. That required some type of locking mechanism for the pcb. To realize this I choose a small lid over the pcb. The pcb itself can be slide inside from the side. I couldn't use any clips because the board didn't have any mounting holes.

Load cell spacer big cover

To cover the HX711 module a small cover is need it. The idea to mount this on the load cell spacer big I wanted to use a sliding mechanism. This needed some trails to find the perfect fit. To hold it in place I wanted to add some small holes and pins which snap in place. The corresponding geometries was to small to got a reasonable result. For now I'll not using it and try to print it on the SLA printer or to design the geometry bigger.

Printing it on a SLA printer didn't improve the situation it still similar tide probaply a little bit worst and looks ugly, not that the 3d print with a FFF printer looks nice but defnetli better than the SLA version.

Baseplate

To put the baseplate sandwitch together I used DIN EN ISO 10642 M3x8 screws. Which I screw in from the top. They are secured into cuttet thread in the Baseplate bottom.

Baseplate top

The Baseplate connect everything together mechanical and electrical wise. All five load cells are mounted on to the Baseplate to ensure a secure positioning inside the box. The baseplate itself is out of multiple plates which are sandwitched, which allows me to run cables inside the baseplate. The three layers are screwed together to hold everything in place. To make sure that it will fit inside the box i laser cut a mockup out of cardboard. Which was a good idea, because the 3d model wasn't that accurate and it reveal some problems. Also the walls of the box are condionend to the manufacturing procces. While deep drawing the walls get streched, which results in case of these thin polymere in some tension, which bow the walls inside. Its not a big problem but the baseplate has to push a little bit harder into position because the walls need to be bend straight.

I tried to fix these problems to has a perfect fit. The second mock up fixed the general dimension issues but still have some minor problems with the radius.

The third try went well enough, the general dimension are fixed and the radius also looks nice.

Baseplate spacer

The Baseplate spacer allows to insert cables into the baseplate and also holds the adapterboards and the distributionboard in place.

Baseplate bottom

The bottom part of the baseplate is similar to the Baseplate top, just without the cutouts for the HX711 modules and with some countersunk holes at the bottom, to allow a flush positionig inside the Eurobox.

Silica box

To allow an easy exchange of the silica pearls I deceided to use one box one at the back to contain all of them, so if you wanted to exchange them, you only need to remove the silica box from the Eurobox, dry the pearls and put them back in or use new pearls.

Mainboard housing

Mainboard back cover

The installation of the mainboard should be realized with two clamps that snap into two mounting holes into the pcb.

The display is directly soldered to the pcb and lack some type of mechanical support because its only connection to the pcb is on the top left corner. To fix this problem I implement two pins with small flanges to support the display into this part. They are going through a 4 mm hole in the pcb where the display can rest on the flange, to secure it in x and y axis a smaller 2,5 mm pin goes from flange to the display pcb.

The first print looks ugly, has a lot of stringing which came probaply from the age from the filament. It also represent the major design flaws. The pcb stands was to instable because of there heights.

The second version got some design improvements.

And also the print looks a lot more promising.

Last problem that has to be eliminated are that the clips that secure the board in place are to small, to be printed nicely, so I increased them slightly and at some support in the remainig corners because they are the ones that see any force, if the rotary encoder is pushed.

It's probaply not that neccessary because there is still the form fit but it will not make the part less good, if the support is added.

With these improvements that parts looks a lot better and more stable.

The snap in feature has some small problems in the corners because I printed everything on nominal size. To fix this problem I put a small chamfer on the corners that act like a undercut or recess.

Mainboard front cover

The cover will snap in place with one positive small radius on the right and left inside. That make sure that the geometry is hidden and nice finish is applied. For a nice surface finish the part will be printed with a SLA printer. On the inside some small channels are added to make sure that on each hole only the corresponding Neopixel is visible and no scattered light interrupt the aesthetics.

The first iteration of the part came with some mixed up coordinate systems which result in an general offset of the hole pcb inside the front cover.

This got fixed in the second iteration from this specific part. I also improvent the snap mechanism from a radius on both parts to a radius with a small champher which allows for easier assembly.

After the mechanical assembly works I go one step back and find out that the display cover is not mounted straight on to the pcb from the oled module and is crucet, which results in alignment issues. To fix this I put a bigger tolerance on to the part, to make sure that even if the display is a little bit croocket it will still fit inside the housing.

Mainboard holder

The Mainboard holder is responsible to connect the Mainboard back cover to the Eurobox. To make sure the parts together screes are use for the easy application. For that I want to use threaded insert, why I print them out of pla. A thermoplastic in needed to melt the thread inserts in to the part. To make this a little bit more easier I added 0,5 mm chamfer to the holes, so the threaded insert will self center it into the hole. The part also make sure that the User Interface is on an angle for easier usage.

For the first iteration two of these are used. For later spirals one wider holder with a hidden cable channel would be nice.

3D Models

Eurobox
Bearing 608

Software

Menu

Design Files

The final files will be added later.

To create this page, I used ChatGPT to check my syntax and grammar.

🅭🅯🄎 Filament Scale Box © 2025 by Benedikt Feit is licensed under CC BY-SA 4.0.

Source code hosted at gitlab.fabcloud.org