Reviving a Large-Format 3D Printer With Off-the-Shelf Electronics

For some time now, we had a large, defective 3D printer sitting unused in our workshop: a Sidl BigBox that was built over six years ago by a local company. After commissioning, the printer only worked for a short time before the first misprints occurred, reliability decreased dramatically, and the manufacturer closed its additive manufacturing division. Instead of writing off the printer for good, I wanted to make it functional again with new, modern hardware. In the following steps, I will explain how I approached the project. This project is intended as an example: the recommissioning of defective electronics using standardized, easily obtainable hardware.

A quick note: since I have been working on the project for more than two years now and have gone through several iterations, especially with regard to the hotend, extruder, part cooling fan, and more, the images may not be in chronological order.

Below is everything you need to replicate (or adapt) this retrofit. I’ve grouped the items so you can tick through electronics, power, wiring/consumables, software, files, and tools at a glance.

Electronics & Motion

1. Mainboard: BIGTREETECH Octopus (STM32F446)
2. Host & UI: Raspberry Pi 3B+ with micro-SD, 7" touch display (KlipperScreen)
3. X/Y drives: 2× closed-loop stepper systems with HBS57 drivers (STEP/DIR/ENA)
4. Z axis: 4× NEMA 23 stepper motors (one per Z lead/ballscrew)
5. Linear motion: IGUS linear rail system for X/Y (or equivalent)
6. Extruder: E3D Titan (3:1) & NEMA 17 stepper motor
7. Hotend: E3D SuperVolcano with 1.4 mm nozzle
8. Bed probe: BLTouch (with known X/Y offset)
9. Fans: Hotend heatsink fan, part-cooling fan(s), electronics/case fans

Power

1. PSUs:
2. 36 V (closed-loop X/Y drives)
3. 24 V (mainboard, Z steppers, peripherals)
4. 12 V (Electric Housing Fan)
5. Heated bed: Existing 230 V AC bed
6. Bed switching: SSR-25DA (DC control → AC load) on heatsink, with airflow

Wiring, Connectors & Consumables

1. Silicone wire in appropriate gauges (separate runs for mains, motor, and signal)
2. Ferrules (assorted sizes) + crimp contacts (JST-XH, Dupont, ring/fork lugs)
3. Terminal blocks / WAGO lever connectors
4. Cable management: cable ducts, cable ties/Velcro, grommets/strain reliefs, wire labels
5. Heat-shrink tubing, electrical tape
6. Ferrite cores for sensitive signal lines (e.g., probe)
7. Custom mini PCB (adapter in stepper-driver footprint to break out STEP/DIR/ENA via JST for HBS57)
8. Printed or metal mounts/brackets for board, PSUs, SSR, fans (STL/STEP)

Software

1. Klipper (firmware)
2. Moonraker (API/updates)
3. Mainsail (web UI)
4. KlipperScreen (touch UI)
5. Slicer profiles tuned for 1.4 mm nozzle (wide line widths, tall layers)

Tools

1. Multimeter (continuity & voltage), optional series test lamp for first power-on
2. Crimpers: JST-XH/AMP, ferrule crimper; wire stripper, flush cutters
3. Screwdrivers, hex key set, nut drivers
4. Calipers, steel ruler, marker
5. Drill/Dremel and files/deburrer (for panels/mounts)
6. Isopropyl alcohol for cleaning, lint-free wipes
7. 
   

Note: The SSR-25DA is for AC beds only (DC-controlled, AC-switched). If your bed is DC, use a DC-rated SSR or a MOSFET module instead.

Safety Note — Mains Voltage & SSR

This build uses a 230 V AC heated bed switched by an SSR-25DA. Work on mains wiring only when the machine is unplugged, bond all exposed metal parts to PE, enclose live terminals, and provide airflow to the SSR heatsink. Remember that SSRs can fail closed; keep firmware temperature limits enabled and consider a hardware E-stop. Separate mains, motor, and signal runs physically. If your bed is DC, do not use an SSR-25DA; use a DC-rated SSR or a MOSFET module instead.

The first step was to dismantle the printer piece by piece. In this step, I gradually disassembled various components of the printer, examined them, and decided whether I wanted to reuse them or replace them in the improvement process.

The printer was based on an Arduino Mega with RAMPS 1.4 Shield and an accompanying LCD display. Pololu A4988 motor drivers were used to control the extruder and Z-axes, and closed-loop stepper motors from an unknown company were used for the X and Y axes. The X and Y axes were moved by a belt driven system, which had lost a significant amount of tension over the years. Nema 23 motors with ball screws were used for the Z-axes. The heating bed, measuring approximately 80 cm wide and 1.60 m long, was also built in-house by the company. The extruder and hot end were also designed in-house.

After examining all the components, I decided to reuse only the frame construction made of aluminum profiles, the Nema 23 motors of the Z axes, the ball screws, and the heating bed. All other components either had serious defects or were so outdated that I had no choice but to replace them.

I have added some pictures above to give an impression of the condition of the components.

Once I was sure which components I wanted to replace, I started researching. The goal was to set up a robust, stable, and modern system that could handle large prints. I also wanted to add some features that the old printer didn't have:

1) Automatic bed leveling: manually leveling the print bed was impossible with such a large size and was no longer practical.

2) Larger nozzle and material throughput: in order to be able to produce large prints in a reasonable amount of time, I wanted to install a large nozzle and a hot end that could melt enough material in a short time.

3) Quad gantry leveling: since the printer already had four individual Z-axes, which were previously connected in parallel, I wanted to operate them individually to enable quad gantry leveling.

In addition, the following components were to be replaced:

1) Mainboard + firmware

2) Motor drivers for all axes

3) Stepper motors for X and Y

4) Axes for X and Y

5) Extruder

6) Hot end

Below is a list of all the components I chose:

1) BigTreeTech Octopus as the mainboard

2) Klipper as the firmware

3) TMC2209 motor drivers for the Z axes

4) HBS57 motor drivers and closed-loop stepper motors for the X and Y axes

5) A linear guide system from Igus as X and Y axes

6) E3D Titan extruder

7) E3D SuperVulcano hot end

8) E3D SuperVulcano hardened steel nozzle 1.4 mm

9) BLTouch

The first step after dismantling the 3D printer was to build a new X/Y gantry. Instead of trying to come up with a completely custom solution, I opted for a ready-made linear guide system from Igus. After quickly measuring the dimensions, I was able to enter them into the configurator, add the intended motor, and have the complete system generated for me.

Once this system had arrived and been installed, I started designing the mount for the extruder, hot end, BLTouch, and fan. This step probably involved the most iterations. I uploaded different versions as images for comparison so that the development process is easy to follow. You can clearly see the different designs for the part cooling fan, as the inefficient cooling of the printed parts was one of the biggest problems to come by.

After finishing the mechanical installation I started with the planning of the electrical setup.

For my first draft, I took another close look at all the components and thought about how each component needed to be connected and which power supply each component required.

Essentially, there were four separate circuits for the different components:

1) 12V for the fans in the electronics housing

2) 24V for the BigTreeTech Octopus board and everything connected to it

3) 36V for the HBS57 closed-loop stepper motor

4) 230V for the heating bed, which is switched via a solid-state relay

Then I thought about the general wiring of the individual components:

- The Raspberry Pi is powered via the mainboard and also requires a USB connection to control the mainboard

- The display is connected directly to the Raspberry Pi.

- All other components are connected to the mainboard, including the HBS57, the four Nema 23s of the Z-axes, the extruder, the hot end, the BLTouch, the fan for the hot end and the part cooling fan, the end stops, and all others.

All electronic components should be housed in a control cabinet.

To make planning easier, I created a sketch in Fusion 360 and tried to arrange the individual components so that the cabling could be as neat as possible. In the images above you can clearly see the evolving steps.

After finishing my first draft I started adding the individual components into the control cabinet. After fixing everything in place, I started adding power to all the components, as listet in Step 5.

Afterwards I started conncting the individuall components. To connect the HBS57 to the mainboard, which needed Step / Direction/ Enable and GND, I design a custom pcb for the stepper driver footprint, to allow an easy and secure connection. I then connected the four different Z-Stepper to the corresponding plug, connected the extruder, the BLTouch, the thermistor and heater cardridge of the hotend, the hotend-fan and the part-cooling-fan aswell as the endstops for X and Y axis.

I've uploaded an image of the wiring plan for better understanding.

With the wiring finished, I moved on to the firmware. I’m running Klipper on a Raspberry Pi 3B+ with Moonraker (API/updates), Mainsail (web UI), and KlipperScreen on the 7″ touch display. The motion controller is the BIGTREETECH Octopus (STM32F446), which Klipper treats as the MCU.

I started by flashing the Octopus with the correct Klipper build (STM32F446 target, USB interface). After connecting the board to the Pi via USB, I noted the stable serial “by-id” path and placed it in the [mcu] section so the connection survives reboots and USB re-enumeration. With the MCU online, the printer appears in Mainsail and I can edit and restart the config from the browser.

The base configuration defines a cartesian machine with conservative motion limits suitable for a heavy gantry and a large Z assembly. X and Y are driven by external closed-loop HBS57 drivers, so I set longer step timing than with on-board drivers: a 6 µs step pulse and 5 µs dir setup/hold. These values make life easy for the opto-isolated inputs on the HBS57 and eliminate edge-detection hiccups. The four Z motors are declared as separate steppers ([stepper_z] … [stepper_z3]) so Klipper can correct each one independently. For the on-board Z drivers (TMC2209 via UART) I began with modest run currents and worked up in small increments while checking motor temperature and holding strength. Endstops are mapped for X/Y, while Z uses the probe as a virtual endstop.

Next, I added the BLTouch. The measured X/Y offset is stored in the config so the probe always lands well inside the bed area; I use safe-Z homing near the center to avoid ramming the frame. For repeatable probing I leave the pin deployed during multi-sample routines and enable touch-mode on my BLTouch revision. Because the heated bed is 230 V AC via SSR-25DA, the bed heater is declared with realistic limits and the hotend uses the appropriate sensor definition for my cardridge.

The key feature of this machine is the ability to actively square the gantry. I set up Quad Gantry Level (QGL) with four safe probe points inside the printable area, far enough from the edges to account for the BLTouch offset. QGL drives those points, computes per-motor corrections, and leaves the XY plane truly flat relative to the bed. After QGL, I run a dense bed mesh that captures the large-scale unevenness of the inherited AC bed. On this printer I keep mesh compensation enabled even for tall builds, because the deviation isn’t just a local bump—it’s a broad wave/saddle that benefits from continuous Z correction.

After setting up the firmware I started with testing and using the Quad Gantry Leveling and Bed Mesh Leveling.

I begin by heating the bed to the intended first-layer temperature and giving it a short heat-soak so the large plate reaches a steady state. I tested various temperature settings, which I will discuss in more detail in a later chapter.

With the machine warm, I home all axes and run QGL. The four probe points are placed safely inside the printable area and take the BLTouch offset into account, so the pin always lands on the bed and not over the edge. QGL measures those points, computes per-motor corrections, and leaves the XY gantry truly planar to the bed. If the routine ever needs more than a few millimeters of correction, I stop here and check mechanics; otherwise I accept the result and continue.

With the gantry squared, I switch to bed meshing. On this machine I use a relatively dense grid, because the bed isn’t just locally uneven—it shows a broad wave/saddle across the span. I keep mesh compensation enabled for tall prints instead of fading it out early; that way the nozzle tracks the real surface rather than an idealized plane. For day-to-day jobs I either load a known-good mesh or re-probe after any change that could affect flatness (moving the printer, servicing the bed, large temperature swings).

With wiring and firmware in place, I first tuned how much plastic the machine can actually push before touching any slicer settings. Only after that did I created my own SuperSlicer profile and run the first prints—which is where I discovered the first flaws of this printer.

Extruder calibration (rotation distance).

I heated the hotend to my intended print temperature, loaded filament, and marked it 120 mm above the extruder entry. From the console I commanded a 100 mm extrusion at a slow feed rate (to avoid slip). I then measured how much the mark actually moved and updated rotation_distance using:

new_rotation_distance = old_rotation_distance × (100 / measured)

I repeated once more to confirm the value, then saved the config. You can see my rotation distance in the attached printer.cfg, but keep in mind that this value is only correct for my printer and must be set individually for each printer.

Volumetric flow benchmark (how hard we can push).

Next I characterized the maximum sustainable flow using the CNC Kitchen benchmark (article + test model):

https://www.cnckitchen.com/blog/extrusion-system-benchmark-tool-for-fast-prints

I created my own test file with flow rates ranging from 25 to 70 mm³'/s. I tested it with PLA filament and a temperature of 240°C, then 230°C and 220°C. In the image above you can clearly see, that the SuperVulcano Hotend is capable of pushing 70mm³/s of material at 240°C.

Building a dedicated 1.4 mm profile

With calibrated flow, I created a fresh slicer profile for the 1.4 mm SuperVolcano setup:

1. Speed cap: 50 mm/s max everywhere (outer walls even slower).
2. Line width & layers: wide lines (≈ 1.2–1.6 mm) and tall layers (≈ 0.6–1.0 mm), within the flow limit from the benchmark.
3. Accelerations: moderate because of the heavy X/Y Gantry setup
4. Retraction: shorter than fine-nozzle profiles (the melt zone is long).
5. First layer: thicker and slower than usual, plus a wide brim for adhesion on the uneven bed.
6. Cooling: 100% everywhere except the first two layers

For more informationes see the slicer profile attached.

With my fresh created SuperSlicer profile I prepared my first print. Like every other 3D Nerd I started with an 3D-Benchy. As you can see in the images, it did not go as planned. The Z-offset was calibrated a little to high, so that my prints started getting loose mid print. Besides the bad bed adhesion I also noticed that the part cooling fan was way to weak to cool this amount of material in an acceptable time.

After the first round of tests it was clear where the weak links were: my Z-offset was set a touch too high, the part-cooling system couldn’t remove heat fast enough for a 1.4 mm nozzle, and the uneven bed still showed through on wide first layers. I tackled the three items in that order and then re-ran the same print.

I began with the Z-offset. With the bed heated to first-layer temperature, I homed, moved to the center, and inched the nozzle down on a plain sheet to the point where a strip of paper could just about drag. I saved the new offset and immediately ran QGL again to square the gantry. Because this machine’s bed is mechanically uneven, I also tightened the bed mesh: I increased the probe density and expanded the probed area to cover the regions where I’d seen early lift. To make the mesh more trustworthy on a large AC plate, I added a short heat-soak in my PRINT_START so the surface settles before probing or printing.

Next I addressed part cooling. The original fan and duct were fine for small nozzles but simply couldn’t keep up with the mass of a 1.4 mm bead. I switched to a higher-flow blower and reworked the duct so the airstream actually meets the strand right after it leaves the nozzle, with a little distance to avoid chilling the block itself.

Finally, I improved first-layer adhesion. On a bed that isn’t perfectly planar, a tiny safety margin helps: I slowed the first layer slightly, kept it thick and wide, and—old but gold—wiped a thin film of PVA glue (glue stick) on the print area. The glue evens out micro-texture and adds a predictable tack that survives long jobs. Together with the denser mesh, this prevented the mid-print de-bonding I’d seen before.

With those changes in place I started a new print and was finally successful!

Even with the successful Benchy and a stable day-to-day workflow, three technical realities still define this machine right now:

1) Uneven AC bed (geometry, not firmware).

The inherited 230 V plate has a broad wave/saddle. QGL makes the gantry planar and a dense mesh compensates locally, but truly large, flat parts remain sensitive. At the moment I don't realy have a solution for this problem, as the size of the printbead is way to large for an off the shelf solution.

2) Heavy XY gantry.

Large rails and hardware mean higher moving mass. I keep accelerations moderate to avoid ringing. Optional future work: input shaping (if I add an accelerometer), careful jerk/accel tuning, and attention to belt tension and pulley alignment. The goal isn’t speed records; it’s reliable, repeatable motion with high-flow extrusion.

3) Part-cooling headroom.

After my first successful print I started upgrading the part cooling fan once again. I designed my own fan duct, as shown in the images above and paired it with some server cooling fans, which are capable of pushing a lot more air than the fans before.

I’ll update this Instructable after the bed planarity upgrade; that change alone should lift large-format reliability dramatically.

This retrofit turns a shelved, unreliable large-format printer into a workable, modular platform using off-the-shelf parts and Klipper. The controls, wiring, and firmware are now predictable; small and medium prints are routine; and high-flow printing with a 1.4 mm nozzle is practical with a sensible 50 mm/s cap. The remaining limiter is bed planarity—a mechanical issue that I plan to solve with a tooling-plate upgrade.

Key takeaways:

1. Off-the-shelf electronics + Klipper = fast iteration and clear diagnostics.
2. Four-motor Z is fantastic if you let firmware square the gantry (QGL).
3. For big nozzles, calibrate flow first, then build a dedicated slicer profile.
4. On large machines, bed geometry decides whether big jobs are truly reliable.

If you adapt this guide to your own machine, I’d love to see your results—and your solutions for big-nozzle part cooling and bed planarity!