Welcome back, tech enthusiasts! Today, we’re diving into the Voron 2.x Mod known as StealthChanger—an evolving toolchanger modification from the Tapchanger. Currently a work in progress, the StealthChanger sets itself apart by opting for bushings and pins instead of the conventional bearings. In this brief exploration, we’ll highlight their unique design and the potential it holds for reshaping the capabilities of Voron 2.x models.
The StealthChanger introduces a unique perspective on toolchanger capabilities for Voron 2.x models by replacing the bearings of the Tapchanger with bushings and pins. This departure is anticipated to yield advantages such as reduced friction and smoother movements while reducing weight. While still in the works, the mod’s innovative design is being closely monitored by the Voron community, eager to witness its promise of enhanced durability and robustness while simple in design.
StealthChanger Printed Parts (Dragonburner) by ZombieHedgehogTapChanger Mechanism
Crucially, it’s worth noting that the StealthChanger is a work in progress. As is customary with developing technology, refinements may be needed before it reaches its full potential. Currently, compatibility extends only to the standard Stealth Burner tool, with plans to incorporate Mini Stealth Burner, Dragon Burner, and XOL tools in the future. For now, StealthChanger docks and klipper config are sourced from the Tapchanger repository until StealthChanger establishes its own. The Voron community actively participates in the evolution of this mod, contributing valuable feedback to enhance its functionality.
Tapchanger on the other-hand is stable at revision 3.1. It can fit 6 Dragon Burner toolheads on a 350mm Voron frame. Though the normal stealthburner toolhead can still be used, limiting number of toolheads. Through multiple subtypes exist, each one provides different rigidness, but trades off assembly difficulty. The plate type is very rigid compared to rods version, while square rods are in-between. Plate type will require more work to assemble in comparison to the others.
Tapchanger versions: Plates, Rods, & Square Rods
In the ever-evolving world of 3D printing, Voron’s StealthChanger & Tapchanger mods introduces a fresh perspective on toolchanger capabilities. With its departure from bearing designs and ongoing development, it holds the potential to redefine how Toolchangers handle tool changes. For enthusiasts, staying tuned to the StealthChanger’s progress promises an exciting journey filled with anticipation. Welcome to the next phase of Voron innovation!
Update (March 9th, 2024): Apologies, additional resistors are not required.Updated for Katapult (formerly Canboot)
This is a continuation from Part 1. We’ll be setting up a basic CAN bus network with basic components.
BTT Octopus and EBB42 without U2C Basic Setup
Note: Assuming Klipper git was previously installed at ~/klipper. Please note there are other methods to use CAN bus without BTT U2C, but will involve additional hardware at this time.
Hardware being used
Octopus (STM32F446)
EBB42 V1.2 (STM32G0B1)
RJ11/RJ12 end (Proper connector is RJ12, but only difference is pin count [4 vs 6])
Power Cables
EBB42 V1.2 has maximum of 5A pull. The printer environment we’ll be using is a Voron 2.4r2 and it uses 24V. We estimate maximum 8 ft of cable from the power source. After using two online calculators provided by https://www.omnicalculator.com/physics/dc-wire-size and https://www.wirebarn.com/Wire-Calculator-_ep_41.html with using 6 Amps for higher tolerance, 18 AWG stranded copper cable would work. Unfortunately, we didn’t have 18 AWG stranded copper cable on hand, thus we’ll be using stranded 16 AWG Aluminum cable for power delivery that we had in our inventory.
CAN BUS Signal Cables
For CAN bus, it is recommended to use twisted data bus to enhance its’ high noise immunity and common-mode rejection. We’ll be using a twisted pair from a working CAT5e stranded cable. CAT5e cable contains 4 twisted pairs of cable.
Wiring
Above image is a typical CAN bus network, below its what logically it’ll look like.
We choose blue and blue/white stranded pair from the CAT5e cable and solid blue will be CAN high. On Octopus end of CAT5e cable, we added a RJ11/12 connector (used this external github reference). The RJ11/RJ12 end can be plugged into the BTT Octopus V1.1.After installing the twisted pair and power cable into the cable chains, we terminated the BTT EBB42 male Molex connector (#39-01-2040) with the diagram provided from Big Tree Tech at this external github reference. We also plugged in the 120R(Ω) jumper on the EBB42 as we weren’t planning on adding additional nodes/devices to the CAN bus network.
BTT Octopus Steps
We are using a STM32F446 Octopus V1.1 Board. Please check the MCU of your Octopus as your settings may be different.
Klipper Installation
Run the following commands:
cd ~/klipper
make menuconfig
Set the following settings:
[*] Enable extra low-level configuration options
Micro-controller Architecture (STMicroelectronics STM32)
Processor Model (STM32F446)
Bootloader offset (32KiB bootloader)
Clock Reference (12 MHz crystal)
Communication interface (USB to CAN bus bridge (USB on PA11/PA12)
Can Bus Interface (CAN bus (on PD0/PD1))
(1000000) CAN bus speed
Press q and then y.
Type make and confirm no errors occurs.
Our Octopus board was connected via USB, so we used:
sudo service klipper stop
make flash FLASH_DEVICE=/dev/serial/by-id/usb-Klipper_stm32f446xx_...
sudo service klipper start
Raspberry Pi/Klipper Service Host Setup
We will need to setup a CAN interface for Klipper service to interact with. To confirm that the firmware has been installed, run lsusb and one of the connections should show OpenMoko, Inc Geschwister Schneider CAN adapter.
Add /etc/network/interfaces.d/can0 file with the below contents
allow-hotplug can0
iface can0 can static
bitrate 1000000
up ifconfig $IFACE txqueuelen 2048
One liner:
echo 'allow-hotplug can0\niface can0 can static\nbitrate 1000000\nup ifconfig $IFACE txqueuelen 2048' | sudo tee /etc/network/interfaces.d/can0 > /dev/null
Then reboot the Raspberry Pi/Klipper service host.
EBB42 V1.2 Steps
We are using EBB42 V1.2, however a previous model version or versions have a flaw where the heater is turned on during flashing and caused fire damage. Double check your version with the manufacture and take necessary precaution steps if required.
If CAN bus connection is connected to EBB, remove this CAN bus connection.
Important: If you skip this step, you will damage your EBB42.
Place jumper on USB-C power.
Plug in USB-C cable between Klipper host and EBB.
Power LED should be on by this step.
Hold down boot button and reset button, then release reset button, then release boot button.
Type lsusb and hit enter.
Output text should have a STM and DFU for a single USB device. After ID there will be text formatted as ####:#### this will be referred to as <uuid> in the Katapult Install steps.
Katapult Install
Run following commands:
git clone https://github.com/arksine/Katapult
cd Katapult
make menuconfig
Match settings below:
Micro-controller Architecture (STMicroelectronics STM32)
Processor model (SMT32G0B1)
Build CanBoot deployment application (Do not Build)
Clock Reference (8 MHz crystal)
Communication interface (CAN bus (on PB0/PB1))
Application start offset (8KiB offset)
(1000000) CAN bus speed
() GPIO pins to set on bootloader entry
[*]Support bootloader entry on rapid double click of reset button
[] Enable bootloader entry on button (or gpio) state
[] Enable Status LED
press q and y.
Type the below commands and replace <uuid> from the previous EBB42 step 6.
make
sudo dfu-util -a 0 -D ~/Katapult/out/katapult.bin --dfuse-address 0x08000000:force:mass-erase -d <uuid>
Disconnect USB-C cable and remove USB-C power jumper.
Important: If you skip this step, you will damage your EBB42.
Reconnect CAN bus cable.
Klipper Install
These are steps involved to install Klipper on top of CanBoot for EBB42.
Type the following commands:
cd ~/klipper
make menuconfig
Set the following settings:
[*] Enable extra low-level configuration options
Micro-controller Architecture (STMicroelectronics STM32)
Processor Model (STM32G0B1)
Bootloader offset (8KiB bootloader)
Clock Reference (8 MHz crystal)
Communication interface (CAN bus (on PB0/PB1)
(1000000) CAN bus speed
Press q and y.
Run the following:
make
python3 ~/katapult/scripts/flash_can.py -q -i can0
From the previous output, there will be a line formatted like Detected UUID: ############, Application: CanBoot use the ############ portion for the <EBB UUID> going forward.
There will be another UUID listed with Application: Klipper, use this for <Octopus UUID> going forward.
Download the example *.cfg for your EBB. For our case we downloaded bigtreetech-ebb-canbus-v1.2.cfg from https://github.com/bigtreetech/EBB and uploaded it into the Klipper configurations folder.
We added [include bigtreetech-ebb-canbus-v1.2.cfg] to the top of printer.cfg.
The communication protocol, CAN bus, is used in various industries such as automotive, medical, and industrial systems. In the field of 3D printing, CAN bus has the potential to improve the printing process by connecting several components, including the main control board, extruders, and motors. CAN bususes high-speed serial communication to enable real-time communication, making it suitable for applications that require timing and synchronization.
The CAN protocol defines the way devices communicate over a CAN busnetwork, determining how data is transmitted and received, and how devices are addressed and identified. The protocol uses differential signaling to send data through two wires with equal and opposite voltage levels. The protocol can detect and correct transmission errors, ensuring reliable data transmission in noisy environments and over long distances.
Some Hardware Examples:
Main Controller Boards:
BigTreeTech(BTT) Octopus
Duet3D Main Board 6HC
Duet3D Main Board 6XD
Toolhead/extruders:
Duet 3 Tool Board 1LC
Duet 3 Tool Board 1HCL
BigTreeTech(BTT) EBB36 & EEB42 (Note: certain hardware versions may cause a fire, reach out to BTT support)
BigTreeTech(BTT) EBB U2C
Motors:
Duet 3 Expansion Board 3HC
Duet 3 Expansion Board 1XD
Once at least 2 CAN bus compatible components had been bought, the process of connecting them via the CAN bus network can begin. CAN bus cables are required to link all components together. Typically, these cables have four wires – two for power and two for communication. One can either purchase these cables or create them using CAT3 or higher-rated cables for the communication wires and appropriate AWG-gauge wires for the power wires if they choose to make them themselves.
After connecting the components, one needs to configure the firmware of the 3D printer to use CAN bus. This involves setting the correct baud rate, addressing scheme, and other parameters to ensure that the components can communicate effectively. Finally, one needs to test their setup to ensure that CAN bus communication is working correctly. This will involve sending commands to the printer and monitoring the responses to ensure that data is being transmitted accurately and reliably.
In case issues arise, some common issues that may occur include incorrect wiring, electrical noise, and software issues. Some resolutions to these issues, double-check all connections to ensure they are properly wired, reduce electrical noise by using shielded cables and ferrite beads, ensure the latest firmware is being used with all settings correctly configured, and ensuring correct resistance & voltage is used on CAN bus.
CAN bus enables fast and reliable communication between different components, allowing for greater control and precision in the printing process, resulting in higher-quality prints. Although implementing CAN bus in 3D printing may require additional hardware and configuration, the benefits are clear. By reducing the number of cables and simplifying the wiring of the printer, one can achieve faster printing speeds, possibly less toolhead weight, and improved reliability. Moreover, using CAN bus in 3D printing allows for scalability and expand-ability, which can accommodate future changes without requiring significant modifications to the network.
Want to setup Klipper’s input shaper, but don’t have a Raspberry Pi Pico on hand for a separate Klipper MCU? This article will step through using an Arduino Nano instead. A separate Klipper MCU in this context would allow you to run input shaper on multiple 3D printers by USB without requiring a dedicated ADXL345 sensor on each printer and reducing costs.
Wiring
Solder these pins together.
ADXL345
Arduino Nano
3V3/VCC
3.3V/VCC
GND
GND
CS
D10
SDO
D12
SDA
D11
SCL
D13
Flashing
Connect the Arduino Nano to the Klipper Host, in our case a Raspberry Pi 4. In order for us to flash the Arduino Nano from our Raspberry Pi 4. At this time of writing, there is a bug in avrdude used to flash and we will need to add a previous APT repo.
sudo nano /etc/apt/sources.list
Add deb http://raspbian.raspberrypi.org/raspbian/ buster main contrib non-free rpi
Save and quit (:wq)
sudo nano /etc/apt/preferences.d/avr-buster
Type below and save file Package: avr-libc avrdud binutils-avr gcc-avr Pin: release n=buster Pin-Priority: 1001
Change Micro-controller Architecture to Atmega AVR and Processor model to atmega328p
Press q and y
make clean make
avrdude -patmega328p -c arduino -b 57600 -P /dev/ttyUSB1 -v -D -Uflash:w:out/klipper.elf.hex:i Note: /dev/ttyUSB1 may be different on your system and per printer primary MCU. Change any reference to match further ahead.
Once this is completed, nano will be ready to be used as a Second Klipper MCU
Update 8/31/2023: For those whom wish to copy and paste into a terminal:
Steps 1-7 – Revert to older avrdude. Note: we didn’t test the newer version and may be fixed.
We had upgraded our Ender 3 to Marlin 2.0.5.3, this will provide the steps that we did. As noted, we are using the MKS Gen L board and not the board the Ender 3 comes with.
With the new Marlin firmware, it is better in our opinion to compile it via PlatformIO in Visual Studio Code than in the Arduino IDE. It is recommended to record any values stored such as current z-offset, extrusion settings, etc before flashing the updated firmware as these values will need to be placed back afterwards.
Environment Setup
Please follow these steps to setup the environment:
Install the following extensions: PlatformIO (by PlatformIO) & Auto Build Marlin (by Marlin Firmware)
Relaunch Visual Studio Code.
Download Marlin Firmware Version 2.0.5.3 from https://marlinfw.org/ and extract the zip folder.
Download the Ender-3 configuration from the Github repo as well: Link
Configuration
Let’s get started with configuring the project:
Place the Ender 3 example config files (configuration.h and configuration_adv.h, optional _Bootscreen.h and _Statusscreen.h) that was downloaded under step 4 under Marlin/src directory.
Click on the PlatformIO module in Visual Studio Code, click open project and select the directory where the platformio.ini file is located
Modify the configuration.h as follows:
Remove #define CONFIG_EXAMPLES_DIR "Creality/Ender-3/CrealityV1" line, it may have a different path
If the _Bootscreen.h and/or _Statusscreen.h has been copied; either to un-comment or comment (//) the lines beginning with associated lines beginning with #define SHOW_CUSTOM_BOOTSCREEN and/or #define CUSTOM_STATUS_SCREEN_IMAGE
Change line from #define MOTHERBOARD BOARD_MELZI_CREALITY to #define MOTHERBOARD BOARD_MKS_GEN_L
Change the stepper directions to opposite; end result values should be: #define INVERT_X_DIR false , #define INVERT_Y_DIR false ,& #define INVERT_Z_DIR true
Change the extruder direction to the opposite; end result value should be #define INVERT_E0_DIR false
Make any additional changes you may need for your setup.
Modify the Configuration_adv.h as below:
Set the line #define E0_AUTO_FAN_PIN to #define E0_AUTO_FAN_PIN 7
Building the firmware
To build the firmware, the Marlin Auto Build extension will be used in Visual Studio Code:
On the Marlin Firmware Auto Build extension, click Refresh button. The values will be updated to what is in the configuration files.
Click on the Build button next to mega2560 ; this should give a succeeded message in the terminal output. If it doesn’t give a success message, please review the configuration files for configuration issues.
On successful build, plug in the MKS Gen L board via USB and press the Upload button.
After the upload, don’t forget to place back any custom values prior.
A good practice is to archive this firmware somewhere (plus a simple date stamp) where it can be used as a future reference to newer Marlin firmware versions.
Here’s what I use to calibrate our 3D printers. There are many guides out there for most of the methods and didn’t see the need to go into heavy details.
Calibration Tools used:
Pro-Grade Electronic Digital Caliper 82806
Know your accuracy tolerances, ours was +- .02 mm for lengths below 100mm with a resolution of .01 mm
First thing we will need to calibrate on a new 3D printer is the filament extrude rate. It is very important to get this as accurate as possible, minor tweaking can be done with extrusion multipliers.
To figure this out by telling the printer to send 30 mm of filament through with the hot end disconnected and measuring with a caliper to see if the amount is accurate. Then update the stored value of Esteps/mm under Marlin Motion options by following this formula: Current Esteps/mm * 30mm / Actual amount of filament pushed
For example:
Current Esteps/mm: 93
Tell printer to extrude this amount of filament: 30mm
After measuring the amount of filament extruded: 29.33 mm
New Esteps/mm value = 93 * 30/29.33 = 95.124
2. Bed Leveling
Bed leveling is crucial for it will either allow your print complete properly or outright fail later on besides filament run-out or the disastrous thermal runaway. There are numerous ways of getting this done usually by sliding a piece of paper between the heated nozzle and heated bed, or something similar to a BLTouch or a conductive sensor.
The methods that are used often:
1st is done with piece of paper between heated nozzle and heated bed at normal printing temperatures for the printer. Since I print mainly in PLA, the temps would be at 200 C and bed at 70 C. Then manually level the middle, then the 4 corners where the paper is slightly catching between extruder and the bed
Next, print Bed Leveling squares that looks like the 5 dot side on dice, 1 mm height and slightly adjust our leveling while it prints and wait a few lines are printed after adjusting and see if its flat and clean looking and doesn’t come off of the bed easily. An example of these squares on Thingiverse: https://www.thingiverse.com/thing:2789086
For Auto Bed leveling, a great bed visual is from OctoPrint with the plugin Bed Visualizer. It will highlight which corners need to be readjusted much better and readjust the dark red and blue slightly. Just keep an eye on the visual scale as it will re-adjust.
3. Wall thickness
Next up to calibrate our Wall thickness, please note that this will affect your bed leveling, extrusion multiplier, and/or Esteps/mm. Essentially with .2 mm nozzle, print a hollow cube with .2 mm thick walls with a layer height of 0.16 mm (80% the size of the nozzle), then measuring with a caliber. A good resource to use are the Thin Wall calibration files created by MEH4d at https://www.thingiverse.com/thing:342198
Once the .2 mm thick walls have been printed, measure the wall thickness with the caliber but exclude the bottom of the walls. The bottom will usually be a tad off due to 1st layer height/bed leveling is a tad off. If the thickness is off try adjusting the multiplier between .9 and 1.1, but keep in mind of your calibers limits. For example, if the measured result was .19, you could be very will be accurate.
If you had to adjust your multiplier to get best results outside of this range, place the multiplier back to 1 and adjust your ESteps/mm. Lower if the walls were too thick and the opposite if the walls were thin. After readjusting, you may need to readjust the bed level and layer heights.
Usually, a good max layer height for each of the nozzle sizes are at 80% as shown below:
0.2 mm nozzle = 0.16 mm layer height
0.3 mm nozzle = 0.24 mm layer height
0.4 mm nozzle = 0.32 mm layer height
0.5 mm nozzle = 0.40 mm layer height
0.6 mm nozzle = 0.48 mm layer height
4. XYZ Calibration Cube
At this point, print a calibration cube and measure with the caliber. Usually, it’ll be within measured dimensions that are to be expected. Check how the cube looks by actually looking for infill, speed, and other issues and try to correct them in our slicer program. Slowing down the speed improves many issues at this point.
5. Stress Test
Now its time to stress test your printer. Good set of models to use are by ctrlV on Thingiverse especially https://www.thingiverse.com/thing:704409 and then part fitting a M4 nut in the slot. Also, look at how well the filament retraction works and increase or decrease the retraction length.
