Category Archives: Technology

3D Design: Parametric Mixing FDM Hotend with Metal Printing

by Rene K. Mueller · published November 19, 2022 Technology AlSi10Mg, Hotend, Inhouse Development, Metal 3D Printing, Multi-In Mixing, Prototypying, SLM

Status: early prototype, metal printed model, temperature testing, no extruding yet

Updates:

2023/01/09: iteration 2 testing results
2022/11/22: early heating tests, no extruding yet
2022/11/21: iteration 1: SLM AlSi10Mg metal printed photos added
2022/11/19: published finally
2022/09/10: adding photos of PLA+ prototype
2022/09/02: starting writeup

This blog-post will be updated as I progress.

Introduction

I experimented with the Diamond Hotend in the past, but I was limited with the setup given – and adding another color or otherwise change the design seemed impossible, but it has changed now.

Metal 3D printing has been a niche and high priced application the past years, but in 2022 many 3D printing services support:

stainless steel: low heat conductivity 15W/mK
aluminium: good heat conductivity 210W/mK, yet low melting point 660C°
inconel: low heat conductivity 15W/mK
titanium: low heat conductivity 17W/mK

at relatively low price and all of the sudden designing a FDM mixing hotend, where multiple filaments are mixed together before exiting the nozzle – like with the Diamond Hotend – can be printed in metal, like with aluminium – so, I started to design a Parametric Mixing Hotend.

Concept

parametric design with 2 up to 6 filaments inputs
combine heatblock, heatbreak and heatsink, make it compact
permit ordinary nozzles (MK8/E3D V6), using M7 thread
orient heat cartridge vertically (like a E3D Volcano) to support up to 0.8mm nozzles
single 30mm fan for heatsink
using PC4 M10 or M4 pneumatic couplers as intakes

Pros:

mixing colors: 2 to 6 colors, CMY(KW), actual true color printing
fast switching of materials, given they have similar extrusion temperature

Cons:

filaments must be present in order to withstand backpressure even if not printed
filaments must be printed eventually, otherwise ‘bake’ in the hotend

Challenges:

controlling actual mixing in the chamber, e.g. creating turbulence to mix properly
- creating turbulences may limit retraction, which is anyway not easy with mixing hotends

Gallery

The filament channels:

Mounting options, plain mounting holes 3x 20mm, or plate with 3x 40mm holes:

and adding my Parametric Part Cooler:

Gallery

Early prototype printed in cold white eSun PLA+ 0.25mm layer height (~1h 20m print time):

iterations of prototype, model printed in PLA+ (frontside)

Adding nozzle, heat cartridge, heat thermistor, heatsink fan and pneumatic couplers PC4 M6:

Multi-in Mixing Hotend PLA prototype (sideview)

and just testing my Parametric Part Cooler using 50×15 blower fan:

2-in Mixing Hotend prototype with 30mm fan mounted Part Cooler

which very likely leads to have a some sort of thermal insulator aka silicon sock for lower part of the heat chamber and nozzle.

Metal Printing

The first attempt to order with WeNext using SLM failed, they were not able to find a way to print it without support, which was surprising as powder-based metal printing¹⁾– the removal of support was not guaranteed, so I canceled the order.

SLM powder-based printing requires support structure to counter act geometric distortion when sintering, when the piece shrinks.

The 2nd attempt with PCBWay – disclosure: they approached me a couple of weeks later to sponsor metal printing process, which I agreed on – also using SLM AlSi10Mg at first looked good at first, but then they also needed to add supports once the production step came close, and then I followed up and approved the production. The order was submitted November 5, and 14 days later the piece was at my door.

Parametric Mixing Hotend, 2-in SLM in AlSi10Mg (printed by PCBWay)

the print quality is excellent, the supports have been removed pretty much with little remains (between the cooling plates a few spikes remained but they have no functional influence)
a bit rough surface overall, more than I expected; which means, the inner holes are also rough and likely add friction to the motion of the filament

Preassembled with MK8 0.4mm nozzle, 30mm fan, heat cartridge and thermistor:

and 2x PC4-M6 threaded, with PTFE tubes:

Mixing Hotend: SLM AlSi10Mg 3D Printed Hotend fully assembled

Heating

My test rig:

Mellow Fly Super8 V1.2 running RepRapFirmware with two stepper motors attached driving two extruders in Bowden style

Test rig: Mellow Fly Super8 running RepRapFirmware 3.4.1, two steppers/extruders with custom mixing hotend printed in SLM AlSi10Mg (Aluminium)

Pass 1: First results

I heated to 50C°, 80C° and 100C°:

thermistor does poor job to measure actual temperature at the heatblock ~20C° off
heat conductivity to nozzle is very poor, barely heat up at all (when thermister reports 100C°) – very surprising
heat piles up from the heart cartridge cables
the fan cools barely, could be better

Pass 2: Adding thermal paste

adding thermal paste for the thermistor and nozzle thread
running M303 for 100C° and keeping it at 100C° for 10mins

lowest heatsink fin reaches 50C° – also connects to heatsink fan
nozzle looks cold (but when touching it it is hot), filament will definitely melt above
heat block has consistent heat distribution

Pass 3: Setting 150C°

nozzle looks cold on the thermal camera, but definitely is hot

heatblock is at ~120C° while thermistor reports 150C°
the filament pipe above the heatblock is at 100C°
the nozzle looks cold, but is hot at 105C° when touching with 2nd thermistor, an issue with reflective brass not properly showing proper thermal reading

Pass 4: Lowering Fan

As the lowest fin heats up significantly, as a first remedy I lowered the heatsink fan a bit:

lowest fin is cooler, also overall better air flow; the fins seems a bit too thick, thinner would be better
lower end of heat block has near set temperature, delta of just ~5C°

Conclusion Pass 1-4

make heatbreak section of pipes thinner
optionally have PTFE tubes until lower end of heatsink for smooth motion of filament
make fins thinner
lower heatsink fan by one fin

Putting Kapton tape on brass nozzle in order to get accurate temperature reading

Iteration 2

After the tests, I changed the design slightly:

thinner pipes to lessen heat transfer to the heatsink
a few wings on the fins to increase heat dissepation
thinner fins so the air flows better

Submitted to PCBWay 2022/11/29 for manufacturing review, a day later I was informed of thin walls of the pipes near the heatbreak (<1mm) and I gave OK to manufacture.

The thin heatbreak walls seemed to help:

ability to heat up to 210°C nominal, some parts reach 220°C, but nozzle is around 210°C
30mm fan performs well
40mm fan removes too much heat, no possible to reach 210°C anymore
heatbreak pipes are still too thick, too much heat flows away (hence 30mm vs 40mm fan)
first extrusion worked, but after 1-2min both channels are blocked, near lowest fin of the heatbreak, to clear the blockage, I removed the fan and heated to 180°C and allow entire hotend to reach ~90°C, then with 0.4mm needle and 1.8mm copper wire was able to clear the blocked section

Conclusion

Heatbreak is most critical, and has to be short and has to be a hard cut temperature gradient-wise – and 0.5mm wall thickness is still too much. So, regardless of cooling fan on the heatsink, if the heatbreak is too thick, too much heat creeps up or away – it’s not a matter of cooling capacity, but conductivity.

Todo

~~metal printed version (aluminium)~~, done 2022/11/21
heating tests (on-going)
test prints with multiple filaments
- 2 inputs, e.g. complementary colors (Black/White: Grey Shades, Yellow/Violet: Red Shades)
- 3 inputs, e.g. CYM: saturated colors only
- 5 inputs, e.g. CYMKW: full spectrum colors
silicon socks for all variants, as part cooler will introduce otherwise heating instabilities

References

Diamond Hotend: 3 color mixing hotend experiments
PCBWay 3D Printing: metal printing service used
WeNext: another metal printing service considered

Misc: XCR3D 3in1-S1 aka Bigtree ZSYong 3in1 (Switching/Non-Mixing) Hotend

by Rene K. Mueller · published November 12, 2022 Technology 3in1 Switching Hotend, Hotend, Multi-In Switching, XCR3D

Updates:

2022/09/10: designing part cooler for its
2022/08/29: starting

Introduction

The XCR3D 3in1 S1 aka Bigtree ZSYong 3in1 is a neat 3 in 1 out switching hotend (non-mixing):

XCR3D 3in1-S1 – 3in / 1out (switching, non-mixing)

Pros:

cost effective with EUR 20-24 (2022/09) complete with heat cartridge, thermistor, 3xPTFE tubes, 30mm fan

Cons:

nozzle / heatblock asymmetry: the heatblock extends right-side ~2mm
clumsy fan fastening between heatsink ribs
slightly overengineered otherwise, too much mass for the basic functionality

XCR3D 3in1-S1

BigTreeTech ZSYong 3in1

NF THC-01 3in1

Very similar, but with symmertric E3D V6 heatsink:

Clones of Clones

It seems to me, the this 3-in-1 hotend with hexagon heatsink, was cloned from NF THC-01 3in1, and likely engineered by a small company, and now brands like BigTreeTech, XCR3D and others purchase in bulk the hotend black/red anodized and their white brand stamp on the hotend.

What makes things truly confusing is that the hotends from China have terrible naming, e.g. “3in1” and “2in1” are used for switching and mixing hotends, which are quite different functionalities, and otherwise the name does not distinct designs.

Part Cooler

I adapted the Parametric Part Cooler using 50×10 blower fan for the XCR3D 3in1 S1 as well:

XCR3D 3in1-S1 / BigTreeTech ZSYong 3in1 mounted on Ashtar C #1

Download Part Cooler

Printables: XCR3D 3in1 / Bigtree ZSYong 3in1 Part Cooler (STL model)
Thingiverse: XCR3D 3in1 / Bigtree ZSYong 3in1 Part Cooler (STL model)

As you can see on the illustration and photos, put the part cooler on the heatsink, and then 30mm heatsink fan on top. The part cooler itself requires 50x15mm blower fan.

It is a bit fiddly as there are no clear threads for the screws on the heatsink, so the first mounting is crucial to thread properly.

Marlin 2.0.x Configuration

In Configuration.h one has to update the thermistor type:

#define TEMP_SENSOR_0 5    // changed from 1 to 5

...

#define PID_FUNCTIONAL_RANGE 25   // changed from 10 to 25

recompile, upload/update firmware and then run via G-code console the autotune PID procedure:

M303

and after 3-5 mins or so, when the autotune is done, save settings in EEPROM:

M500

and one is done.

Conclusion

I really struggled to get decent quality prints first, as somehow the temperature reports were off by 40C°, and various Google searches gave the same wrong answers, the seller did not give proper detailed information about the thermistor either. Eventually at Amazon one customer gave the relevant information ATC Semitec 104GT-2/104NT-4-R025H42G and defining TEMP_SENSOR_0 5 in Marlin gave sane results.

Retraction settings are in my case 3mm at 70mm/s with apprx. 500mm long Bowden tube on my Ashtar C (CoreXY 400x400x380) and also Ashtar K #3 (300x300x360).

Ashtar K #3 with XCR3D 3in1-S1 hotend with 3 rolls of filament

I really like the switching filament solution close to the hotend, compared to other multi-material solutions where materials are switched far away from the hotend; e.g. switching material is faster, but one has to still purge one material/color by 30-50mm filament – so I tend to use the multi-material/color feature for fast switching colors for single material/color prints.

Following procedure I use when switching material:

heat up nozzle
purge 30-40mm regardless
retract 55mm at 70mm/s
switch to new material/color (e.g. “T1“)
push 55mm at 70mm/s forward
extrude/purge 30-40mm filament
start actual print
[ … ]
end print
retract 55mm at 70mm/s
switch to “T0“
push 55mm at 70mm/s forward [note: not purging material/color transition]

so by default “T0” is ready to be printed. In order the print with the other materials, I have two macros with Print3r e3-t1 and e3-t2.

print3r --printer=ashtar-c-1 print cube.stl @e3-t1
print3r --printer=ashtar-c-1 print cube.stl @e3-t2

~/.config/print3r/macro/e3-t1:

prepend_gcode="G91\nT0\nG1 E20 F100\nG1 E-55 F3000\nT1\nG1 E55 F3000\nG1 E30 F100\nG90\nG92 E0\n"
end_gcode="G1 Y{$machine_depth-10} F6000\nG92 E0\nG91\nG1 E-2 F2000\nM140 S0\nM104 S0\nG1 E-55 F3000\nT0\nG1 E55 F3000\nM84\nG90\n"

and ~/.config/print3r/macro/e3-t2:

prepend_gcode="G91\nT0\nG1 E20 F100\nG1 E-55 F3000\nT2\nG1 E55 F3000\nG1 E30 F100\nG90\nG92 E0\n"
end_gcode="G1 Y{$machine_depth-10} F6000\nG92 E0\nG91\nG1 E-2 F2000\nM140 S0\nM104 S0\nG1 E-55 F3000\nT0\nG1 E55 F3000\nM84\nG90\n"

The way it is composed: start_gcode + prepend_gcode + slicing G-code + end_gcode.

Sourcing / Purchase

Declogging

As it happened to me several times, the hotend clogs up and the reason is often the filament is not hot enough, and when pulling back/retracting it forms a long pointy drag, and might break and the next cold filament jams in further down, but not enough to melt – it clogs up eventually.

First solution is to heat hotend at 240C° at least, not more than 250C° because of the PTFE – and try to push with filament on top, eventually some of the clogging might melt and free the nozzle.

Second solution is removing the lower part with heatbreak, heatblock, by opening the worm screws at the heatsink, and review the PTFE intake:

References

XCR3D 3in1 / Zsyong 3in1 mockup (STL model)

Virtual G-code Controller vgcodectl

by Rene K. Mueller · published October 31, 2022 Technology Gcode, Inverse Kinematics, Virtual Serial

Status: experimental, not yet released

Updates:

2022/11/29: covers 0.1.6 API
2022/10/31: published
2022/10/28: starting write up

Introduction

As I was developing the 5-axis PAX printhead, and implement Inverse Kinematic (IK) for it in RepRapFirmware (RRF) for Duet3 board, the development speed was slow due the overhead to get to know the RRF written in C++, hence very verbose code, and the “recompiling, uploading, and reboot of the board” cycle to iterate the development – which turned out to be very slow and tedious.

My first remedy was to do a pre- or post-processor which takes tool coordinates and converts into motor positions applying IK, and Print3r supports it via declaring a post-processor like --post_something=something %i %o and then use with --post=something, but would only be a Print3r-centric solution.

So I thought, why not do a virtual serial device, and have a framework where the controller behaves like a physical one, but is pure software and thereby shorten development cycle to convert G-code coming out of a slicer or some software and then being processed and then sent to the 3D printer or robot – so the Virtual G-code Controller (vgcodectl) was born.

It’s main feature is that it operates bidirectional:

it takes input and optionally changes it, and outputs it to a file or a device
it takes output from a device, and forwards it back to the virtual serial to so it can read back transparently

in essence it operates as in bidirectional intermediary looking like a serial port and thereby can be integrated into existing G-code-based machine park.

slicer/console/controller ⇆ physical device

↓

slicer/console/controller ⇆ vgcodectl ⇆ physical device

as a result the setup looks like a capability extended device:

Features

simple to write G-code extensions with Python:
- execute macros and calculate additional values
- code execution from G-code
- synchronize G-code with external devices, e.g. webcam
extend drivers/controller, like Inverse Kinematics (IK) which otherwise would run on the controller
live reloading of controller code: change printer/robot behavior while it’s processing G-code
- fast iteration of code due scripting (no compiling, uploading or reboot)
supported platforms: Linux

Limitations

line-based processing: one line comes in, one line or multiple lines comes out (future version might lift this constraint)

Usage

% vgcodectl -h
VirtualGcodeController 0.1.4 USAGE: [<opts>]
   options:
      --help or -h               this help
      --version                  display version & exit

      --verbose=<n>              increase verbosity
         -v or -vvv
      --quiet or -q              don't output to device or console anything unless an error

      --output=<device/file>     set output, e.g. /dev/ttyUSB0 or file or another device (default: /dev/stdout)
         -o <device/file>
      --controller=<ctl>         set controller (default: conf['output'])
         -c <ctl>
         
      --keep-orig or -O          enable to keep original g-code line as comment (default: off)
      --keep-comment or -C       enable to keep original comment (default: off)
                                    hint: --keep-orig/-O includes comment as well
      --serial-speed=<s>         set serial speed [baudrate] (default: 115200)
      --serial-timeout=<s>       set serial timeout [s] (default: 0.1)
      --check-code-timeout=<s>   set code checking timeout [s] (default: 1)
      --output-value-format=<fmt>  set output value format (default: .4f)
      
   examples:
      vgcodectl --output=/dev/ttyUSB0 &
      cat test01.gcode > pass0.pty
      print3r --device=pass0.pty print tests/test01.gcode
      print3r --device=pass0.pty print --scad 'cube(20)'
      
      vgcodectl -o /dev/ttyACM0 -c gcode+ -Ov

Let’s try pass2 controller, which doubles X, Y and Z coordinates.

As first we start the controller:

% vgcodectl -c pass2 -O
== VirtualGcodeController 0.0.3 == https://github.com/Spiritdude/VirtualGcodeController
; VirtualGcodeController 0.0.3, created 2022-10-28T13:23:23.513285
;   verbose = 0
;   output = "/dev/stdout
;   serial_speed = 115200
;   controller = "pass2"

In another terminal we take a sample G-code and send it into pass20.pty serial port (“pass2” plus the “0” indicates the first instance of pass2 controller):

% cat tests/test01.gcode > pass20.pty

and the vgcodectl outputs to stdout as it is the default:

G28 X0 Y0 ; G28 X Y
G92 ; G92   ; reset
G90 ; G90   ; abs coords
G0 X200 Y200 ; G0 X100 Y100
G1 X200 Y220 E1.2000 ; G1 X100 Y110 E1
M84 ; M84

As you notice, the new G-code is altered, e.g. X, Y and Z is doubled, the E is multiplied by 1.2 in this case, and the original G-code is appended as comment due the -O switch used (--keep_orig or -O).

If we did call vgcodectl with --output=/dev/ttyACM0 the end point would be a real 3D printer for example at /dev/ttyACM0.

Print3r

% print3r --printer=ashtar-k-3 --device=pass20.pty print tests/test01.gcode
== Print3r 0.3.18 == https://github.com/Spiritdude/Print3r
print3r: conf: device pass20.pty, Ashtar K #3 E3 38x30x33, build/v 300x300x330mm, nozzle/d 0.4mm, layer/h 0.25mm, filament/d 1.75mm
print3r: authenticated "Ashtar K #3 E3 38x30x33" (8a09209a-1b93-11ed-861d-0242ac120002) at pass20.pty
print3r: print: 0h 00m elapsed, eta 0h 00m, 100.0% complete, z=0.00mm, layer #0, filament 0.00m

as indicated, the pass20.pty operates bidirectional, reports back the proper UUID as requested by print3r and then sends G-code forward and does proper synchronous messaging back and forth.

print3r ⇆ pass2*.pty:vgcodectl ⇆ /dev/ttyACM0

Controllers

Following controllers are available:

pass: it’s a simple pass-through changing no code, for debugging purposes
pass2: double X, Y and Z, and multiply E by 1.2
- don’t use with actual 3D printer, only for debugging purposes
scale: scaling X, Y, Z and E, rather experimental / for debugging purposes
- CLI argument: use --scale=<s> to set scale in , e.g. 0.8 (default: 1.0)
- actually produces some working G-code
gcode+: writing low-level G-code and replace E automatically based on distance
- use G0 X100 Y100 and then G1 Y110 E and the G1‘s extrusion will be calculated
- actually produces some working G-code
- CLI arguments:
  - --layer-height=<lh> [mm] (default: 0.2)
  - --line-width=<lw> [mm] (default: 0.4)
  - --filament-diameter=<d> [mm] (default: 1.75)
delta: implementing cartesian XYZ -> T1,T2,T2 motor angles, using Delta printer inverse kinematics
pax: implementing 5-axis inverse kinematics for PAX printhead
5axis: generalized 5-axis driver, define forward kinematics, automatic inverse kinematics calculated:
- open5x: Open5x
- pax: PAX Printhead, same as pax controller, but defined within 5axis controller
macros: implementing RepRapFirmware’s M98 functionality

Download

[coming soon] Github: VirtualGcodeController (vgcodectl)

Writing A Controller

Note: vgcodectl is currently under heavy development, API subject to change a lot – check back this page frequently.

This covers vgtcodectl 0.1.6 API:

controllers/<controller> /:
- main.py
  - must contain def _map(self,c=None) function, in there you can recalculate any existing G-code, the c contains a dictionary with all the G-code values, the function returns
    - a dict of the remapped variables, e.g. { "G": 0, "X": 100.0 } – note: order matters, make sure ‘G’ or ‘M’ key comes first for G or M commands
    - a string, e.g. "G0 X100.0" or G0 X100.0\nG1 X110 E1.2"
    - a tuple or list of
      - strings, e.g. [ "G0 X100.0", "G0 X110.0" ], each element is a line
      - dictionaries, e.g. [ { "G": 0, "X": 100 }, { "G": 0, "X": 110 } ], each element is a line
    - if None is returned, no change of G-code is made and the original data is passed on
    - if "" (empty string) is returned, nothing is passed on (mute)
  - optionally def __init__(self,conf=None) function be composed, where persistent state can be stored, and referenced in _map() then; the conf is the configuration of vgcodectl:
    - command line arguments vgcodectl --test="ABC" ... becomes conf['test'] available within __init__(), the controller profile profile.json is loaded and available as conf['profile']
    and if you store conf as self.conf then _map() has access to it as well with self.conf['test'] or self.conf['profile']['name']
- profile.json (optional):
  - basic JSON file with follow keys:
    - name (string): full name of the controller
    - version (string): version of the controller, e.g. “0.1.0”
    - and any other key value default relevant for the controller

e.g. controllers/mine/main.py:

def __init__(self,conf=None):
   pass

def _map(self,c=None):
   if 'X' in c:
       c['X'] *= 2
   return c

then the controller can be referenced as such:

% vgcodectl -c mine -v
== VirtualGcodeController 0.0.7 == https://github.com/Spiritdude/VirtualGcodeController
vgcodectl: 2022-10-31T06:48:14.026650: loading <mine> profile
vgcodectl: 2022-10-31T06:48:14.026705: loading <mine> code
vgcodectl: 2022-10-31T06:48:14.027444: created mine0.pty (/dev/ptmx,/dev/pts/7)
vgcodectl: 2022-10-31T06:48:14.027473: opening /dev/ptmx
; VirtualGcodeController 0.0.7,  2022-10-31T06:48:14.027622
;   verbose = 1
;   quiet = 0
;   output = "/dev/stdout"
;   keep_orig = 0
;   keep_comment = 0
;   serial_speed = 115200
;   serial_timeout = 0.1
;   check_code_timeout = 1
;   output_value_format = ".4f"
;   ignore_codes = ["M117"]
;   controller = "mine"

Scale Controller

The scale controller is just an experiment, to scale G-code with a factor:

% vgcodectl -c scale --scale=0.8 -o /dev/ttyACM0 &
% print3r --printer=ashtar-k-3 print --scad 'cube(20)' --fill-density=0 --device=scale0.pty

cube(20) in –`-scale=.8`, `--scale=1`, `--scale=1.2` processed with `scale` controller

References

G-code Reference (reprap.org)

Misc: More Materials – Testing JLCPCB 3D Printing Services 2022

by Rene K. Mueller · published October 26, 2022 Technology JLCPCB, MJF, SLA, SLM, SLS

Updates:

2022/10/26: published finally
2022/09/27: adding measurements and verdict
2022/09/15: starting write up

Introduction

Beside Fused Deposition Material (FDM) / Fused Filament Fabrication (FFF) aka extruding hot filament, there are more methods to 3D print:

SLA (stereolithography): resin based printing
SLS (selective laser sintering): laser sintering, like polyamid powder
MJF (material jetting): deposite material and binder in one go
SLM (selective laser melting): metal laser sintering, aka metal printing

and I choose JLCPCB which provides all four of them, whereas SLM only stainless steel is available as of 2022 – other 3D printing services provide wide-range of metals as well.

Review

I ordered Pulley 20T 6ID (GT2 20 teeth 6mm inner diameter) as created via OpenSCAD Customizer, a piece which requires high accuracy and is mechanical stressed when in use, in following materials:

8x PA12 aka Nylon aka Polyamid, black reflective (MJF), 1.04 EUR / pc
8x 9000R resin, natural white (SLA), 1.04 EUR / pc
8x 3201PA-F aka Nylon, dark gray matte (SLS), 1.04 EUR / pc
1x 316L stainless steel (SLM), 8.30 EUR / pc

after 3 weeks the pieces arrived:

The overall quality of all pieces are excellent, regardless of automatic warnings I received while requesting the 3D printing task.

MJF: PA12 / Polyamid / Nylon

MJF has a nice finish, slightly reflective, deep dark, slightly grainy surface, and the top of the pulley is uneven, otherwise very precise.

diameter 16.1mm (+0.62%)
height 15.5mm (+0%)
cost EUR 1.04

SLS: 3201PA-F / Polyamid / Nylon

3201PA with SLS is a very good piece, dark gray matte, grainy surface, very precise.

diameter 16.05mm (+0.31%)
height 15.6mm (+0.65%)
cost EUR 1.04

SLA: 9000R Resin

9000R resin with SLA produced a very nice piece, best finish at the top (near perfection), milky white color (vs cold white or warm white), but as it turns out not very precise:

diameter 17.75mm (+4.68%)
height 16.1mm (+3.87%)
cost EUR 1.04

It is very surprising to see the SLA having the biggest imprecision of all the samples.

SLM: 310L Stainless Steel

316L stainless steel with SLM produced a nice piece as well, the top of the pulley is good, some unevenness where the top goes over the gear:

overall it’s grainy surface – indicating powder-based additive procedure. Holding the piece in the hand feels heavy compared the other materials.

diameter 16.0mm (+0%)
height 15.5mm (+0%)
cost EUR 8.30

Verdict

The SLA / resin piece looked most smooth but it had the biggest imprecisions with over 3% in height and diameter – very surprising to me, it should comparatively be as precise as SLS and MJF. I cannot determine if it’s from the JLCPCB resin printer, or inherent of SLA.

SLS and MJF with Nylon performed expectedly very good, very sturdy and precise.

SLM stainless steel surprisingly very precise, yet unsuitable in real life application due the heavy weight.

Long Term Usage

I will update this part as soon long term (1-2 years) usage experience is available:

SLA: Resin 9000R: (not yet)
MJF: Polyamid/Nylon PA12: (not yet)
SLS: Polyamid 3201PA-F: (not yet)
SLM: Stainsteel 310L: (not yet)

Materials & 3D Printing Methods

Comparing MJF Nylon vs SLS Nylon

Comparing Resins

References

JLCPCB

Misc: MKS Monster8 Board Configuration with Marlin for Ashtar K & C

by Rene K. Mueller · published September 21, 2022 Technology Ashtar K, Makerbase, Marlin, MKS Monster8

Update:

2022/11/20: Linux DFU upload details added
2022/09/19: adding Ashtar C M503 dump beside Ashtar K
2022/08/24: extending with part cooler fan and extruder fan connection
2022/08/14: starting with the notes

Introduction

These are just my notes for configuring Makerbase (MKS) Monster8 V1.0 for Ashtar K and Ashtar C:

STM32M407VET6 (ARM Cortex M4), 168MHz, 512KB Flash, 192KB RAM
8 stepper drivers TMC2209, configured in UART mode
MKS MINI 12864 V3 display (the “V3” is relevant)
12V power in/out
3 hotends & bed heating
Price ~EUR 55 (2022/08) incl. 8 stepper drivers TMC 2209 and 12864 display

Pros:

cost effective, EUR 55 (2022/08) incl. 8x TMC 2209 stepper drivers and 12864 display
8 stepper drivers: e.g. X, Y, Z1/Z2 (on-board splitter) and 5 extruders (e.g. E0, E1, E2, E3, E4 – but only 3 hotends possible)
TMC 2208 or TMC 2209 silent drivers
good connectors on board, clean setup
github with Marlin source (partially preconfigured) for Arduino^*) & PlatformIO

Cons:

no RepRapFirmware
no Wifi (the V2.0 version has optional Wifi board to attach)
no Ethernet
requires Marlin with PlatformIO (tedious to configure, recompiling required, reupload)
limited documentation: actual details are scattered around

Stepper Motor UART Mode

As first putting in the jumpers on all the driver sockets, in my case I choose UART mode for each one of the 8 drivers:

Marlin with Arduino vs PlatformIO

As of 2022/08, it seems Arduino is no longer able to compile Marlin-2.x (various compile errors within Arduino), at least with this board and everybody moved on the PlatformIO, which really surprised me.

PlatformIO CLI

As of 2022/08 there is no Linux GUI for PlatformIO but only PlatformIO CLI, but it’s simple enough:

pip3 install platformio

Download

As next download the firmware, Marlin 2.0.x source from github:

git clone https://github.com/makerbase-mks/MKS-Monster8/

Building

By default the board is configured for Voron 2.4 CoreXY, with 3x Z motors and Z probing in the midst of the bed and other things, so I had to edit Marlin/Configuration.h:

#define MACHINE_UUID "..." (use online generator to generate one)
#define CUSTOM_MACHINE_NAME "Ashtar K #x L8", given Lead 8×8 are used
#define LINEAR_AXES 3
#define EXTRUDERS 1 (or 2, 3 max)
comment out //#define PREVENT_COLD_EXTRUSION needed for calibration
comment out //define COREXY
define [XYZ]_DRIVER_TYPE and E[012]_DRIVER_TYPE
#define DEFAULT_AXIS_STEPS_PER_UNIT aren’t that important, as one can define it with M92 and M500 saving to EEPROM
comment out //#define Z_MIN_PROBE_USES_Z_MIN_ENDSTOP_PIN
test motors regarding #define INVERT_[XYZ]_DIR true or false
test motors regarding #define INVERT_E[012]_DIR true or false
#define [XYZ]_HOME_DIR -1
#define X_BED_SIZE 380
#define Y_BED_SIZE 300
#define Z_MAX_POS 330

and Configuration_adv.h:

#define NUM_Z_STEPPER_DRIVERS 1 even when two Z-stepper motors are attached
if you want an automatic E0 fan which turns on only when nozzle is heated: #define E0_AUTO_FAN_PIN PA1 and attach extruder fan (watch polarity) on FAN1/J12 connector

once those changes are made, build the firmware:

cd marlin\ firmware/MKS_MONSTER_Marlin-2.0.x/Marlin-2.0.x/
platformio run

After a short while (~1min) it should finish successfully (if not, edit files).

Firmware Installation

SD Card Firmware Update

Use a SD card, e.g. 8GB with simple FAT filesytem, and copy .pio/build/mks_monster8_usb_flash_drive/firmware.bin and mks_monster8.bin on the SDcard.

Insert the SD card into the Monster8 board next to the USB connector, and turn off and on the board (power cycle) – wait 5-10 seconds so the new firmware is installed, then the display should show the Marlin splashscreen eventually, and the board becomes available as USB device, in my case as /dev/ttyACM0 on Linux Ubuntu 20.04 LTS.

DFU Util Firmware Update

connect board with USB cable and optionally select POWER USB (via jumper)
power cycle board (e.g. via USB cable) while you push BOOT 0 button in the center of the board briefly (~2 secs)
the device will appear as a new USB device

Linux: install apt install dfu-util and then

% sudo dfu-util -a 0 -s 0x0800C000:leave -D .pio/build/mks_monster8_usb_flash_drive/mks_monster8.bin -d 0483:df11
dfu-util 0.9

Copyright 2005-2009 Weston Schmidt, Harald Welte and OpenMoko Inc.
Copyright 2010-2016 Tormod Volden and Stefan Schmidt
This program is Free Software and has ABSOLUTELY NO WARRANTY
Please report bugs to http://sourceforge.net/p/dfu-util/tickets/

dfu-util: Invalid DFU suffix signature
dfu-util: A valid DFU suffix will be required in a future dfu-util release!!!
Opening DFU capable USB device...
ID 0483:df11
Run-time device DFU version 011a
Claiming USB DFU Interface...
Setting Alternate Setting #0 ...
Determining device status: state = dfuERROR, status = 10
dfuERROR, clearing status
Determining device status: state = dfuIDLE, status = 0
dfuIDLE, continuing
DFU mode device DFU version 011a
Device returned transfer size 2048
DfuSe interface name: "Internal Flash  "
Downloading to address = 0x0800c000, size = 178820
Download        [=========================] 100%       178820 bytes
Download done.
File downloaded successfully
Transitioning to dfuMANIFEST state
%

M503 Dump for Ashtar K

Ashtar K with 300×300 bed, single extruder:

> M503
-----
echo:  G21    ; Units in mm (mm)
echo:  M149 C ; Units in Celsius

echo:; Filament settings: Disabled
echo:  M200 S0 D1.75
echo:; Steps per unit:
echo: M92 X100.00 Y100.00 Z400.00 E95.00
echo:; Maximum feedrates (units/s):
echo:  M203 X300.00 Y300.00 Z5.00 E25.00
echo:; Maximum Acceleration (units/s2):
echo:  M201 X2500.00 Y2500.00 Z100.00 E5000.00
echo:; Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>
echo:  M204 P3000.00 R3000.00 T3000.00
echo:; Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate> X<max_x_jerk> Y<max_y_jerk> Z<max_z_jerk> E<max_e_jerk>
echo:  M205 B20000.00 S0.00 T0.00 X10.00 Y10.00 Z0.30 E5.00
echo:; Home offset:
echo:  M206 X-35.00 Y-3.00 Z0.15
echo:; Material heatup parameters:
echo:  M145 S0 H180.00 B70.00 F0
echo:  M145 S1 H240.00 B110.00 F0
echo:; PID settings:
echo:  M301 P22.20 I1.08 D114.00
echo:; LCD Contrast:
echo:  M250 C255  
echo:; Power-Loss Recovery:
echo:  M413 S1
echo:; Stepper driver current:
echo:  M906 X500 Y500 Z700
echo:  M906 T0 E500

echo:; Driver stepping mode:
echo:  M569 S1 X Y Z
echo:  M569 S1 T0 E
ok
>

M503 Dump for Ashtar C

Ashtar C with 400×400 bed, 3 extruders with single nozzle:

> M503
-----
echo:  G21    ; Units in mm (mm)
echo:  M149 C ; Units in Celsius

echo:; Filament settings: Disabled
echo:  M200 T0 D1.75
echo:  M200 T1 D1.75
echo:  M200 T2 D1.75
echo:  M200 S0
echo:; Steps per unit:
echo: M92 X100.00 Y100.00 Z3200.00 E102.00
echo:; Maximum feedrates (units/s):
echo:  M203 X500.00 Y500.00 Z2.00 E120.00
echo:; Maximum Acceleration (units/s2):
echo:  M201 X9000.00 Y9000.00 Z50.00 E10000.00
echo:; Acceleration (units/s2): P<print_accel> R<retract_accel> T<travel_accel>
echo:  M204 P1500.00 R1500.00 T1500.00
echo:; Advanced: B<min_segment_time_us> S<min_feedrate> T<min_travel_feedrate> X<max_x_jerk> Y<max_y_jerk> Z<max_z_jerk> E<max_e_jerk>
echo:  M205 B20000.00 S0.00 T0.00 X10.00 Y10.00 Z0.20 E2.50
echo:; Home offset:
echo:  M206 X0.00 Y-5.00 Z0.15
echo:; Material heatup parameters:
echo:  M145 S0 H180.00 B70.00 F0
echo:  M145 S1 H240.00 B110.00 F0
echo:; PID settings:
echo:  M301 P22.20 I1.08 D114.00
echo:; LCD Contrast:
echo:  M250 C255
echo:; Power-Loss Recovery:
echo:  M413 S1
echo:; Stepper driver current:
echo:  M906 X700 Y700 Z1000
echo:  M906 T0 E700
echo:  M906 T1 E700
echo:  M906 T2 E700

echo:; Driver stepping mode:
echo:  M569 S1 X Y Z
echo:  M569 S1 T0 E
echo:  M569 S1 T1 E
echo:  M569 S1 T2 E
echo:; Tool-changing:
echo: Z2.00
ok
>

Fans

Part cooler fan is plugged into FAN0/J11, and if you enabled extruder fan (temperature dependent), plug it in FAN1/J12.

**Part Cooler Fan** (FAN0/J11) and **Extruder Fan** (temperature sensitive) FAN1/J12

Part Cooler Fan (FAN0): cools the extruded filament, the filament which becomes the part you print
Extruder Fan (FAN1): cools the heatsink near the heatbreak, when attached to FAN1/J12 it only runs when the hotend is hotter than 50C° as defined in Marlin.

The jumpers are needed next to the fan connectors to define the voltage, either Vin (left) which is 12V-24V depending on the power input of the board, or 12V (middle) or 5V (right).

Multiple Materials/Colors

With 8 stepper drivers one is able to run:

3+1x motors for X, Y, Z(2)
5x extruders (colors or materials), the board supports 3 hotends (3 different temperatures)

Monster8 V1.0 vs V2.0

The boards differ in physical layout such as connectors, but the firmware is the same, incl. the pin for the hotend cooler fan (which switches on conditionally when hotend heats up).

Update V2.0

Board Comparison 2022

As of 2022 (I intend to update this) following boards are suitable for my cases:

	MKS Monster8 V1.0/V2.0 & 12864 display	Mellow Fly Super8 V1.2 & 12864 display	Duet 3 Mini 5+ & Duet 3 Mini 2+	Duet 3 MB 6HC & Duet 3 Expansion 3HC
Price	55 EUR	80 EUR	155 EUR (120+35)	385 EUR (255+130)
Stepper Drivers	8	8	7 (5+2)	9 (6+3)
Stepper Connectors	9 (dual Z)	8	7	9
Hotends	3	4	5 (2+3)	6 (3+3)
USB	YES (USB-C)	YES (USB-C)	YES (MicroUSB)	YES (MicroUSB)
WIFI	– / YES³⁾	YES	YES¹⁾	YES¹⁾
Ethernet	–	–	YES¹⁾	YES¹⁾
Firmware	Marlin 2.x	Marlin 2.x RepRapFirmware 3.4.x	RepRapFirmware	RepRapFirmware

Alternatively, there are Duet 2 & 3 clones available on the market:

	Duet 2 WIFI Clone	Duet 2 WIFI Original	Duet 3 6HC FYSETC Clone with Duet 3 3HC	Duet 3 6HC Original with Duet 3 3HC
Price	30-50 EUR²⁾	175-185 EUR¹⁾	225 EUR (150+75)	385 EUR (255+130)
Stepper Drivers	5	5	9 (6+3)	9 (6+3)
Stepper Connectors	6	6	9	9
Hotends	2	2	7 (4+3)	6 (3+3)
USB	YES (MicroUSB)	YES (MicroUSB)	YES (MicroUSB)	YES (MicroUSB)
WIFI	YES	YES¹⁾	–	YES¹⁾
Ethernet	–	YES¹⁾	YES	YES¹⁾
Firmware	RepRapFirmware	RepRapFirmware	RepRapFirmware	RepRapFirmware

either WIFI or Ethernet
without or with display
MKS Monster8 V2.0 has Wifi module option

As of 2022, RepRapFirmware has become quasi standard in professional level 3D printing; while a lot of people run Klipper & Marlin together I can’t see the point doing this^*) but rather have a more capable microcontroller like the Duet boards have to run the printer and manage WIFI / Ethernet at the same time. The only reason to run Klipper on a Single Board Computer (SBC) setup like Raspberry Pi is cost and enhance simple microcontrollers functionality this way.

	Marlin	Klipper & Marlin	RepRapFirmware with Duet
CPUs	1x Simple Microntroller	1x SBC + 1x Simple Microcontroller	1x Capable Microcontroller
Connectivity	USB only	USB, Ethernet and/or WIFI	USB and Ethernet or WIFI
Configuration	3x .h files, recompiling required	single .cfg file	single .g file^**)
Boot Time	3s	Klipper 30s, Marlin 3s	3s

*) running different kinematics on the SBC converting G-code on the fly might be a reason
**) multiple .g file can be used optionally

If you are cheap, buy the Duet clones, if you want to support Open Source and Open Hardware community, buy from Duet3d.com direct, pricing is +45% of the clone prices, whereas the Duet resellers add another +15% (Clone: EUR 150, Duet3d.com: 220 EUR, Reseller 255 EUR)

RepRapFirmware: Mind the SD Card

Whether to run an original Duet board or a clone, one thing though one might pay attention to is the SD card, it is the weakest link as far I can tell:

SD card needs to be present at all time to provide configuration
SD card is not written regularly to unless the logging is enabled

After power-cycling the board, as it was in a strange state no longer responding to G-code properly, the display remained blank, no response to G0/G1 – after investigation it turned out, a single file vanished from the SD card: config.g – the main configuration file, and that is bizarre. The board appeared to be broken, when in truth, the SD card came to its end of life of operating reliably already after only ~1.5 years. The SD card was the one originally shipped with. In this light, a Marlin-based board requiring no SD card being present operates more reliable, unless one uses an industrial grade SD card.

References

github: MKS Monster8 V1/V2: minimalistic information, PDFs and Marlin firmware for V1.0 and V2.0 of the board
github: MKS MINI 12864 V3 cases (STL), unfortunately the MKS MINI 12864 V3 display has a slightly different form factor, and existing cases don’t fit

Misc: Mellow Fly Super8 V1.2 with RepRapFirmware for Ashtar C & D

by Rene K. Mueller · published September 15, 2022 Technology Duet Clone, Mellow, Mellow Fly Super8, RepRapFirmware

Updates:

2022/08/25: extending for more details of config.g limit switches
2022/08/16: starting notes

Introduction

I have become a big fan of Duet3 boards running RepRapFirmware, and as I was looking for a suitable board, and I came across Mellow Fly Super8 V1.2 board, 8 steppers TMC 2209, and 4 possible hotends.

STM42F407ZGT6 (ARM Cortex-M4), 168MHz, 1MB Flash, 192KB RAM
8 stepper drivers TMC2209, configured in UART mode
- 3x X, Y, Z(2 using splitter)
- 5x extruders
Fly MINI 12864 display
12V power in/out
4 hotends & bed heating
Price ~EUR 80 (2022/08) incl. 8 stepper drivers TMC 2209 and 12864 display

Pros:

cost effective, EUR 80 (2022/08) with 8x stepper drivers TMC 2209 and 12864 display
runs RepRapFirmware
- most configuration is done with .g files using G-code notion
- only new non-supported kinematics require recompiling
USB & Wifi connectivity (both simultaneously possible)
relative simple configuration (compared to Marlin firmware)

Cons:

no Ethernet (Wifi is less reliable)

Software Configuration

Majority of configuration is done via a file-system on a SD card which contains a bunch of .g files which define basic settings of the board and machine it operates:

I operate the board direct with USB and Wifi, not in SBC (Single Board Computer) setup.

download firmware, single .bin file from (e.g. firmware-stm32f4-wifi-3.4.1_102.bin) and put it into / (root) folder and rename to firmware.bin – it will vanish once installed on the board
download web GUI (e.g. DuetWebControl-SD.zip) and then unzip on the SD card, rename folder name as www/
run online configurator to get basic configuration config.g, board.txt and multiple other files (all zipped together)
- enable Wifi: enter your Wifi Name and Wifi Password
- you get a single zip file, unzip in the / (root) folder
insert SD card into the board, restart board
- eventually the board will join your Wifi network, scan the network to find out which IP it has, then access the board via web-browser, e.g. http://192.168.1.174/

I operate my 3D printers (3x Ashtar K, 1x Ashtar C, 1x CTC DIY I3 Pro) which use different controller boards all accessed via USB cables and Print3r as main interface (CLI) – having an additional Web-GUI aside allows to operate in parallel beside the USB connectivity.

12864 display with knob to configure on the printer
USB connectivity to deliver print job
Wifi connectivity to access printer via Web-GUI (simultaneously to USB connectivity)

Hardware Configuration

Important is to put the fuses first, otherwise the board won’t operate, further the stepper driver settings, pluggeable fan MOS, limit switches:

I configured the board first using simple USB power delivery, later when the 12V power supply is attached I remove the small jumper to avoid the USB powers the board.

Limit Switches / Endstops

In config.g following lines define the limit switches / endstops:

; Endstops
M574 X1 S1 P"io0"                            ; configure switch-type (e.g. microswitch) endstop for low end on X via pin io0
M574 Y1 S1 P"io1"                            ; configure switch-type (e.g. microswitch) endstop for low end on Y via pin io1
M574 Z1 S1 P"io2"                            ; configure switch-type (e.g. microswitch) endstop for low end on Z via pin io2

therefore the endstops are laid out as such:

Attention: the limit switch with three wires must be inserted correctly, otherwise you short GND with 5V when pushing the switch. The proper layout of io[012] pins (left-to-right):

Signal
GND
5V

Makerbot Endstop V1.2: Pin 1: Signal, Pin 2&3: GND, Pin 4: 5V

Bed Heating & Hotends

Given the config.g defines the heaters as such:

; Heaters
M308 S0 P"ADC_0" Y"thermistor" T100000 B4092 ; configure sensor 0 as thermistor on pin ADC_0
M950 H0 C"bed" T0                            ; create bed heater output on bed and map it to sensor 0
M307 H0 B0 S1.00                             ; disable bang-bang mode for the bed heater and set PWM limit
M140 H0                                      ; map heated bed to heater 0
M143 H0 S120                                 ; set temperature limit for heater 0 to 120C
M143 H0 S120                                 ; set temperature limit for heater 0 to 120C
M308 S1 P"ADC_1" Y"thermistor" T100000 B4092 ; configure sensor 1 as thermistor on pin ADC_1
M950 H1 C"heat0" T1                          ; create nozzle heater output on heat0 and map it to sensor 1
M307 H1 B0 S1.00                             ; disable bang-bang mode for heater  and set PWM limit
M143 H1 S280                                 ; set temperature limit for heater 1 to 280C

; Fans
M950 F0 C"fan0" Q500                         ; create fan 0 on pin fan0 and set its frequency
M106 P0 S0 H-1                               ; set fan 0 value. Thermostatic control is turned off

therefore the connections are:

Bed Temperature Sensor ADC0
Bed Heater BED_OUT
Hotend 1 Temperature Sensor ADC1
Hotend 1 Heater HEAT0
Part Cooler FAN0

M503 Dump for Ashtar D

M503 dump for Ashtar D (Classic XY) with 400×400 bed, single extruder:

> M503
; Configuration file for Fly Super8 (firmware version 3)
; executed by the firmware on start-up
;
; generated by RepRapFirmware Configuration Tool v3.4.0-LPC-STM32+4 on Tue Aug 16 2022 20:32:44 GMT+0200 (Central European Summer Time)

; General preferences
G90                                          ; send absolute coordinates...
M83                                          ; ...but relative extruder moves
M550 P"Ashtar D1"                            ; set printer name
;M669 K1                                      ; select CoreXY mode

; Network
M552 S1                                      ; enable network
M586 P0 S1                                   ; enable HTTP
M586 P1 S0                                   ; disable FTP
M586 P2 S0                                   ; disable Telnet

; Drives
M569 P0 S1                                   ; physical drive 0 goes forwards using default driver timings
M569 P1 S1                                   ; physical drive 1 goes forwards using default driver timings
M569 P2 S1                                   ; physical drive 2 goes forwards using default driver timings
M569 P3 S1                                   ; physical drive 3 goes forwards using default driver timings
M569 P4 S1                                   ; physical drive 4 goes forwards using default driver timings
M584 X0 Y1 Z2:3 E4:5                         ; set drive mapping: Z drivers port 3&4, E drives 4&5
M350 X16 Y16 Z16 E16 I1                      ; configure microstepping with interpolation
M92 X80.00 Y80.00 Z3200.00 E420.00            ; set steps per mm
M566 X900.00 Y900.00 Z30.00 E120.00          ; set maximum instantaneous speed changes (mm/min)
M203 X6000.00 Y6000.00 Z150.00 E1200.00      ; set maximum speeds (mm/min)
M201 X500.00 Y500.00 Z20.00 E250.00          ; set accelerations (mm/s^2)
M906 X800 Y800 Z800 E800 I30                 ; set motor currents (mA) and motor idle factor in per cent
M84 S30                                      ; Set idle timeout

; Axis Limits
M208 X0 Y0 Z0 S1                             ; set axis minima
M208 X380 Y380 Z380 S0                       ; set axis maxima

; Endstops
M574 X1 S1 P"!io0"                            ; configure switch-type (e.g. microswitch) endstop for low end on X via pin io0
M574 Y1 S1 P"!io1"                            ; configure switch-type (e.g. microswitch) endstop for low end on Y via pin io1
M574 Z1 S1 P"!io2"                            ; configure switch-type (e.g. microswitch) endstop for low end on Z via pin io2

; Z-Probe
;M558 P0 H5 F120 T6000                        ; disable Z probe but set dive height, probe speed and travel speed
;M557 X15:215 Y15:195 S20                     ; define mesh grid

; Heaters
M308 S0 P"ADC_0" Y"thermistor" T100000 B4092 ; configure sensor 0 as thermistor on pin ADC_0
M950 H0 C"bed" T0                            ; create bed heater output on bed and map it to sensor 0
M307 H0 B0 S1.00                             ; disable bang-bang mode for the bed heater and set PWM limit
M140 H0                                      ; map heated bed to heater 0
M143 H0 S120                                 ; set temperature limit for heater 0 to 120C
M143 H0 S120                                 ; set temperature limit for heater 0 to 120C
M308 S1 P"ADC_1" Y"thermistor" T100000 B4092 ; configure sensor 1 as thermistor on pin ADC_1
M950 H1 C"heat0" T1                          ; create nozzle heater output on heat0 and map it to sensor 1
M307 H1 B0 S1.00                             ; disable bang-bang mode for heater  and set PWM limit
M143 H1 S280                                 ; set temperature limit for heater 1 to 280C

; Fans
M950 F0 C"fan0" Q500                         ; create fan 0 on pin fan0 and set its frequency
M106 P0 S0 H-1                               ; set fan 0 value. Thermostatic control is turned off

; Tools
M563 P0 D0 H1 F0                             ; define tool 0
G10 P0 X0 Y0 Z0                              ; set tool 0 axis offsets
G10 P0 R0 S0                                 ; set initial tool 0 active and standby temperatures to 0C

; Custom settings are not defined

; Miscellaneous
M501                                         ; load saved parameters from non-volatile memory

; 12864 Display                              ; https://teamgloomy.github.io/fly_super8_screen_12864.html
;M950 P1 C"LCD_D4"
;M42 P1 S0
;G4 P500
;M42 P1 S1
;M918 P2 C30 F100000 E4

; M918 P1 E-4 F2000000                        ; https://github.com/jadonmmiller/UltimateDuetMenuSystem

M950 P1 C"LCD_D4"
M42 P1 S0
G4 P500
M42 P1 S1
M918 P2 C30 F100000 E4

Multiple Materials/Colors

With 8 stepper drivers one is able to run:

3x motors for X, Y, Z(2) – attach two Z stepper motors to one driver via splitter
5x extruders (colors or materials), the board supports 4 hotends (4 different temperatures)

Gallery

Board Comparison 2022

As of 2022 (I intend to update this) following boards are suitable for my cases:

	MKS Monster8 V1.0/V2.0 & 12864 display	Mellow Fly Super8 V1.2 & 12864 display	Duet 3 Mini 5+ & Duet 3 Mini 2+	Duet 3 MB 6HC & Duet 3 Expansion 3HC
Price	55 EUR	80 EUR	155 EUR (120+35)	385 EUR (255+130)
Stepper Drivers	8	8	7 (5+2)	9 (6+3)
Stepper Connectors	9 (dual Z)	8	7	9
Hotends	3	4	5 (2+3)	6 (3+3)
USB	YES (USB-C)	YES (USB-C)	YES (MicroUSB)	YES (MicroUSB)
WIFI	– / YES³⁾	YES	YES¹⁾	YES¹⁾
Ethernet	–	–	YES¹⁾	YES¹⁾
Firmware	Marlin 2.x	Marlin 2.x RepRapFirmware 3.4.x	RepRapFirmware	RepRapFirmware

Alternatively, there are Duet 2 & 3 clones available on the market:

	Duet 2 WIFI Clone	Duet 2 WIFI Original	Duet 3 6HC FYSETC Clone with Duet 3 3HC	Duet 3 6HC Original with Duet 3 3HC
Price	30-50 EUR²⁾	175-185 EUR¹⁾	225 EUR (150+75)	385 EUR (255+130)
Stepper Drivers	5	5	9 (6+3)	9 (6+3)
Stepper Connectors	6	6	9	9
Hotends	2	2	7 (4+3)	6 (3+3)
USB	YES (MicroUSB)	YES (MicroUSB)	YES (MicroUSB)	YES (MicroUSB)
WIFI	YES	YES¹⁾	–	YES¹⁾
Ethernet	–	YES¹⁾	YES	YES¹⁾
Firmware	RepRapFirmware	RepRapFirmware	RepRapFirmware	RepRapFirmware

either WIFI or Ethernet
without or with display
MKS Monster8 V2.0 has Wifi module option

	Marlin	Klipper & Marlin	RepRapFirmware with Duet
CPUs	1x Simple Microntroller	1x SBC + 1x Simple Microcontroller	1x Capable Microcontroller
Connectivity	USB only	USB, Ethernet and/or WIFI	USB and Ethernet or WIFI
Configuration	3x .h files, recompiling required	single .cfg file	single .g file^**)
Boot Time	3s	Klipper 30s, Marlin 3s	3s

*) running different kinematics on the SBC converting G-code on the fly might be a reason
**) multiple .g file can be used optionally

RepRapFirmware: Mind the SD Card

Whether to run an original Duet board or a clone, one thing though one might pay attention to is the SD card, it is the weakest link as far I can tell:

SD card needs to be present at all time to provide configuration
SD card is not written regularly to unless the logging is enabled

References

Github Teamgloomy: Super8 V1.2 information

3D Printing: Slicing with Non-Planar Geometries

by Rene K. Mueller · published March 26, 2022 Technology EnochSlicer, MetatronSlicer, Non-Planar Printing, Non-Planar Slicing, Research Paper, Universal Slicing

Updates:

2022/04/25: added single photo with various 20mm cube prints
2022/04/01: rewording to avoid confusion of “planar slicing” with non-planar geometries
2022/03/26: finally published
2022/03/25: adding “Benefits of Non-Planar Printing” and “Blind Spots of CAD Systems” and “Scale and Functional Quality”
2022/02/18: getting ready to publish
2022/02/15: adding different slicing geometries and the resulting G-code
2022/02/12: starting write-up

Introduction

After researching non-planar slicing using planar slicers it was obvious to find a way to slice with any kind of geometry, and it meant to step back and formalize slicing procedure in a general manner like “Universal Slicing” – and look at the procedure of slicing itself.

Two classes were defined:

Class 1: using a geometry, either planar or non-planar, and slicing with a static slicing path
Class 2: slicing with variable slicing path and/or variable slicing geometry while slicing

This document/blog-post features a solution for Class 1 Universal Slicing.

My video Non-Planar 3D Printing: Slicing with Non-Planar Geometries goes through this information in an animated form, this is the textual form.

Slicing with Non-Planar Geometry (Class 1 Universal Slicing)

When using a static planar slicing vector one usually uses a plane, hence the term “planar slicing”, yet, there is also the possibility to use a non-planar geometry and slice in a planar direction (introducing ambiguity what planar and non-planar slicing actually mean). Regardless which slicing geometry is used in this procedure, the thickness of the sliced layer stays the same.

Slicing 20mm cube with wave-like geometry

In order to explore non-planar slices, using a wave-like geometry composed by Bezier curves and slice a 20mm cube:

20mm cube wave-like sliced: wave-like geometry itself, partial complete, complete and even slices only

Note: OpenSCAD is used solely used as 3D viewer, the slicing itself is performed by an experimental slicer.

Routing a single non-planar slice

A single slice is routed to wall/perimeter and infill extrusion:

There are several approaches to achieve this:

slice non-planar, map single slice 3d to 2d, route with 2d offsetting, and map back to 3d space (MetatronSlicer)
map entire mesh and slice planar, and map routes or resulting G-code back again (EnochSlicer)

and likely other more complex means.

Non-planar Printed Wave-like Sliced 20mm Cube

Preview of the complete G-code:

Preview the non-planar G-code of 20mm cube sliced with wave-like geometry

and a brief and fast printing simulation showing the entire print:

The computed G-code printed with a 3D printer, e.g. an ordinary 3-axis FDM:

Non-Planar 3D Printing: 20mm cube sliced with wave-like geometry (1x speed with a few skips)

and produces output like this:

left-to-right: wave-like geometry itself, progressive state of 20mm cube sliced with wave-like geometry at 0.25mm layer height

Implementing Non-Planar Slicing Geometries Slicer

The illustrations and actual G-code above were produced by two new in-house slicers which are in early development (2022/03):

20mm cube sliced with wave-like geometry
left-to-right: MetatronSlicer (0.0.7), EnochSlicer (0.0.2)

MetatronSlicer: boundary-based (BREP / OpenCASCADE) and voxel-based (OpenVDB) geometry engine, performing true non-planar slicing, and LabSlicer performing routing and G-code creation; slower slicing yet precise G-code
EnochSlicer: mesh and G-code transformation approach, fast slicing yet less accurate G-code

The extrusion precision is still rough, but overall concept and algorithms have been proven to work.

Results & Achievement

This work as presented here resolves a long pending issue of slicing meshs “non-planar”, or general “non-planar slicing” with all its inherent ambiguity – consider it as given that

one can use any 3D geometry with sufficient upper “surface” to slice a mesh with

and create printable G-code for 3- and 5-axis FDM:

using a block as planar blueprint
hemisphere, convex
hemisphere reverse, concave
cone, slicing conical like for Rotating Tilted Nozzle
wave-like defined via Bezier curves
wave-like defined via NURBS (Non-Uniform Rational B-Splines) curves
tilted plane, slicing for belt printer with 45° tilted XY frame toward Z belt
pimple-like

Along with volume segmentation as presented previously and conical, cylindrical and spherical slicing now any kind of slicing geometry can be used.

**20mm cube** sliced with various non-planar geometries:
1. conic (EnochSlicer), 2. wave (MetatronSlicer), 3. wave (EnochSlicer), 4. pimple (EnochSlicer), 5. pimple 2x tiled (EnochSlicer), 6. hemisphere (EnochSlicer), 7. tetrahedron 2x tiled (EnochSlicer)
limited to 3mm Z amplitude, printed on 3-axis FDM (Ashtar K #2)

As pointed out in Universal Slicing, this “Planar Slicing with Non-Planar Geometries” is Class 1 of Universal Slicing whereas Class 2 covers changing slicing geometry and/or flexible slicing path along the slicing.

Limiting Non-Planar Height for 3-axis FDM

When using non-planar geometries to slice a model also non-planar G-code is produced and possibly significant Z motion occurs, and when printing with an ordinary 3-axis FDM 3D printer it may be suitable to limit the Z motion aka Z amplitude to 2-3mm in order to avoid part-cooler or other parts of the print head to collide with the already printed part:

left column: wave-like slicing, right column: hemisphere slicing
top row: full range, bottom row: limited to ~3mm Z amplitude

Future blog-posts will go into further details implementing Universal Slicing using those two slicers MetatronSlicer and EnochSlicer.

Regarding naming the slicers: Metatron is an archangel in jewish mythology – consider an “angel” as a fundamental intelligence, and in esoteric context Metatron is the being responsible for Form or Geometry itself – separating one into many in a spatial manner; whereas Enoch as a human, who ascended to become the archangel Metatron. I use those names in deep reverence for these two projects.

Blind Spot of CAD Systems

Current CAD systems (2022) neglect or actually are unaware of the inner vs outer structure – because only one kind of the “structure” is known, e.g. a piece is designed because of a certain function, which defines its outer form, e.g. a wrench to use a simple example – but how about the inner structure? This isn’t defined in the CAD, it is defined at the manufacturing stage, yet with 3D printing this can be described and designed even in a parametric way as well, the slicing or general 3D printing stage with different materials.

We require 2 or 3 abstraction layers to design a functional piece:

the functional description (doesn’t exist yet)
the inner structure (description how material is deposited in Additive Manufacturing, e.g. the infill geometry as of with FDM, incl. non-planar printing, or lattice structures as with SLA or SLS)
the outer structure (e.g. mesh, boundaries)

So far CAD systems only covers the 3rd point, the outer structure.

The functional description is almost non-existent in the CAD world, and only becomes some attention when Finite Element Analysis is made and the form is changed, it is kind of hidden in plain sight.

In future blog-posts I will address and elaborate on these issues further.

Scale and Functional Qualities

To put the flexible slicing geometry in the grander context of 3D printing engineering:

3D printing engineering starts at nanometer scale (10^-6mm) with material science level, over to filament composition at 1 to 10 micrometer scale (10^-2mm) such as fibers, inner geometry where slicing geometry & procedure and infill geometry define strength properties at millimeter scale (10⁰mm), and outer geometry with the shape of the object itself provide the final stage of mechanical properties.

This entire “scale chain” as a whole defines the mechanical property of the final 3D printed object.

That’s it.

References

Universal Slicing
Video: Mastering Non-Planar Printing: Slicing with Non-Planar Geometries
MetatronSlicer (Class 1, partial Class 2 Universal Slicer)
EnochSlicer (Class 1, partial Class 2 Universal Slicer)
3D Printing: Sub-Volume Segmenting & (Non-)Planar Slicing
Involved tools: YAGV, G-code Previewer, Gcode2png, LabSlicer
HackaDay: 3D Printering: Non-Planar Layer FDM (2016), brief overview
Inner Structure Approaches
- Hyperganic: software designing parts based on actual function and strength properties, voxel-based, output for SLS, SLA, FDM – very little information available on the net (2022/02), secretively operating company
- nTopology: generative design using implicit modeling, more open company, they even have a Github presence

EnochSlicer

by Rene K. Mueller · published March 26, 2022 Technology EnochSlicer, Non-Planar Slicing, Universal Slicing

Status: early development, not available yet

Updates:

2022/03/26: published with little information
2022/02/28: starting write-up

Introduction

EnochSlicer is aiming to be a fast Universal Slicer by taking research results from development of MetatronSlicer.

MetatronSlicer vs EnochSlicer

MetatronSlicer implements true non-planar slicing and routes each slice exact, whereas EnochSlicer using pre- and post transformation of mesh and routes (pre g-code).

As development of an Universal Slicer is in early stage (2022/03), both projects are pushed forward to see which one is more fit and suitable and cross-fertilize each other.

	MetatronSlicer	EnochSlicer
mesh	plain	transformation
slicing	non-planar	planar
route	dedicated ¹⁾	–
gcode	dedicated ¹⁾	native²⁾
post processing	plain	transformation

Footnotes:

utilizing LabSlicerCore library
native via planar slicer (direct mesh to gcode) like CuraEngine

In-House Slicers

LabSlicer	Vox3lSlicer	VoxGLSlicer	MetatronSlicer	EnochSlicer
– full planar slicer – 4 stages: mesh, slice, route, gcode – experimental – API defined – LabSlicerCore library – import/export data of each stage	– voxel-based planar slicer – fast slicing – uses LabSlicerCore library for route and gcode stage	– OpenGL based planar slicer – fast slicing – uses LabSlicerCore library for route and g-code stage	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses OpenZCAD²⁾ engine to slice non-planar	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses mesh & gcode transformation

Footnotes:

Class 2 Universal Slicing only partially implemented (status 2022/03)
OpenZCAD is alike OpenSCAD but with Python as base-language with multiple backends (OpenCASCADE, LibFive, Fogleman’s SDF)

Availability

See MetatronSlicer

References

MetatronSlicer

by Rene K. Mueller · published March 26, 2022 Technology MetatronSlicer, Non-Planar Printing, Non-Planar Slicing, Universal Slicing

Status: early development, not yet available

Updates:

2022/04/01: bringing terms/wording in-sync with Universal Slicing
2022/02/26: published finally with basic information
2022/02/18: copying content from “Universal Slicing” page start to focus on the slicer itself

Introduction

MetatronSlicer aims to become full functional Universal Slicer:

Universal slicing means free slicing geometry along a free path.

“free (definable) slicing geometry”: any kind of geometry, may it may a solid or just a surface defining the slicing geometry.

“free (definable) path”: the slicing procedure can go in any direction, curvature and steps.

See Universal Slicing for more thorough description and theoretical examples.

Implementing Universal Slicing

As I was proposing the concept of “Universal Slicing”, I had the impulse to start an implementation right away in order to produce illustrations for the concept.

MetatronSlicer aims to become full Universal Slicer, it’s not optimized for speed but to be capable as of completeness.
EnochSlicer is a sister project which takes research results from development of MetatronSlicer and tries to find a more efficient way to achieve the same or a subset.

Universal Slicer: MetatronSlicer

MetatronSlicer is the first attempt of an Universal Slicer (2022/02), which implements for a start planar-slicing of non-planar slicing geometries, for example a wave-like geometry:

The wave-like geometry was defined via Bezier curves.

Via some transformations back and forth the in-house LabSlicer and g-code produced non-planar slice:

the green represents the ideal 3D slice,
the yellow/golden are the extrusions,
the red dots indicate the start of a G1 extrusion segment.

As of MetatronSlicer 0.0.8 (still very experimental as of 2022/02) it was possible to produce printable G-code:

and then printed on a 3-axis FDM (Ashtar K #2 Prusa-Mendel style) machine with apprx. 3mm vertical nozzle spacing ²⁾, the wave-like reference geometry was slighted scaled in Z to comply to this physical contraint:

full print at 1x speed with a few skips

MetatronSlicer: toward implementing Universal Slicing capabilities

A few samples of non-planar geometries slicing 20mm cube:

Class 1 Universal Slicing: Planar Slicing with Non-Planar Geometries: cube (planar), hemisphere (convex), hemisphere inverse (concave), conic, wave-like, nurbs, tilted, pimple-like

Convex hemispherical slice geometry slicing 20mm cube:

Concave hemispherical slice geometry slicing 20mm cube:

Conic slice geometry slicing 20mm cube:

which essentially replaces Slicer4RTN.

As of 2022/02 MetatronSlicer is still in very early development, but eventually aims to implement also variable slicing geometries and variable slicing vector such as:

Class 2 Universal Slicing: Variable Slice Geometry / Variable Slicing Path

MetatronSlicer vs EnochSlicer

MetatronSlicer implements true non-planar slicing and routes each slice exact, whereas EnochSlicer using pre- and post transformation of mesh and routes (pre g-code).

As development of an Universal Slicer is in early stage (2022/03), both projects are pushed forward to see which one is more fit and suitable and cross-fertilize each other.

	MetatronSlicer	EnochSlicer
mesh	plain	transformation
slicing	non-planar	planar
route	dedicated ¹⁾	–
gcode	dedicated ¹⁾	native²⁾
post processing	plain	transformation

Footnotes:

utilizing LabSlicerCore library
native via planar slicer (direct mesh to gcode) like CuraEngine

Availability

MetatronSlicer and alike EnochSlicer are in early development, and will be tuned for industrial 3D printing applications for 3- and 5-axis FDM.

Sometime during 2022 one or both might become available as commercial products in order to fund future development, unless I find another way to fund the research and development – in that case an open source “community edition” is possible.

References

Universal Slicing
3D Printing: Slicing with Non-Planar Geometries
Video: Mastering Non-Planar Printing: Slicing with Non-Planar Geometries
LabSlicer: in-house slicer & slicing library
Slicer4RTN: conic slicer or Rotating Tilted Nozzle

In-House Slicers

LabSlicer	Vox3lSlicer	VoxGLSlicer	MetatronSlicer	EnochSlicer
– full planar slicer – 4 stages: mesh, slice, route, gcode – experimental – API defined – LabSlicerCore library – import/export data of each stage	– voxel-based planar slicer – fast slicing – uses LabSlicerCore library for route and gcode stage	– OpenGL based planar slicer – fast slicing – uses LabSlicerCore library for route and g-code stage	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses OpenZCAD²⁾ engine to slice non-planar	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses mesh & gcode transformation

Footnotes:

Class 2 Universal Slicing only partially implemented (status 2022/03)
OpenZCAD is alike OpenSCAD but with Python as base-language with multiple backends (OpenCASCADE, LibFive, Fogleman’s SDF)

LabSlicer, Vox3lSlicer, VoxGLSlicer

by Rene K. Mueller · published March 26, 2022 Technology In-House, LabSlicer, Vox3lSlicer, VoxGLSlicer

Updates:

2022/03/26: published
2022/03/03: starting write-up, based on internal documentation

Introduction

As part of getting to know the inner working of a slicer and have a toolkit for advanced non-planar slicer I had in mind, I started to code my own “laboratory slicer” or simply “LabSlicer” as an in-house project.

Its main features are:

Python-based, it’s slow for production but good enough to test new algorithms
PyClipper as offsetting & clipping engine
four stages clearly defined with API and file-format export/import:
- mesh: import & export meshs
- slice: slices 3d objects into 2d slices/polygons
- route: routes polygons with wall/perimeter and infills, bottom/top layers, skirts/brims
- gcode: takes routes and converts into G-code
LabSlicerCore: slicer available as library, with clear defined & simple API
easy to extend to non-planar slicing/routing/g-code, incl. 5-axis FDM

Motivation

It may look like redundant to code another slicer and define those rather simple steps as such, but the benefits came days after I finished the basic layout and was able to exchange the mesh and slicing stage with voxel-based engine, or use OpenGL screenbuffer to slice and then hand over polygons to route and gcode stage – within 2-3 weeks I had 3 working slicers with different slicing engines.

By having a clear API the integration into various in-house projects was truly swift and the cross-fertilization paid off quickly and immensely. I might have taken me more time to learn to memorize Slic3r or CuraEngine API than writing a basic slicer myself. Granted that coding a slicer in Python limits its overall performance, compared to an optimized slicer like Cura; but to research and develop new slicing and routing algorithm coding with Python is fast, a couple of hundred lines in Python can represent ten thousands of lines of C++ code, not to mention wait time for compiling.

Four Stages of Slicing

It may appear to be simplistic at first sight, but it’s worth to clearly layout the main stages of slicing:

Mesh

One has to import the geometry such as a mesh which circumscribes a volume.

Slice

The slicing stage takes the geometry and slices it into slices, which are a set of polygons which also describe holes – essentially an array of arrays of polygons.

Route

The real work of the slicer is actually the routing, which means to plan extrusion paths:

walls or perimeters: offsetting or rather insetting 2D polygons
infill pattern: offsetting and clipping of 2D polylines
skirts and brims: offsetting at bottom via 2D polygons
bottom and top layers, also intermediary: difference & intersecting previous and next layers to determine delta areas (polygons) were, are or becoming bottom/top layers
support structures (not yet implemented)

Routes are held in an array of arrays of routes (polylines).

Off- and Insetting Polygons

At first sight it looks trivial, but in the details this isn’t trivial at all as offsetting or insetting can clash with itself or other polygons and fork into two or more polygons. Clipper as developed Angus Johnson has laid the ground for many slicers and does the heavy lifting and therefore unloads some of the burden and one can focus on higher level algorithms.

Gcode

At this stage now all the slicing settings like travel and extrusion speeds, retraction and so on are factored in and further optimizations are done, given we know now all routes at a given (planar-)layer.

It’s easier to separate routing and actual creation of G-code as transforming routing, like for non-planar slicing, is more efficient than parsing G-code with more overhead.

From a development point of view the routing results is the most precious and worthwhile data; the other stages are rather simple, but routing is where the magick happens.

History

To give you a bit insight to how I coded it, I started with the API in mind, defined the 4 stages roughly, then the parameters and the data-structures and import/export file-formats, essentially all is encoded in JSON to keep things simple.

Within 2 days I had basic wall routing coded using PyClipper – I had some experience with coding with it at Mandoline (fork) but felt to start from scratch anyway – and I did not even try to slice yet but had a simple function returning the same square (polygon) no matter which slicing height – yes, starting with the simple 20mm cube.

Once I had the routing done, I coded the gcode stage, to create basic extrusion and preview the gcode with a G-code viewer – and added support start- and end-gcode with some sane defaults and sent it to my 3D printer – and the first print outs were bad, no retraction, no infill, single wall, no path/routing optimization.

LabSlicer early tests 2021/12 (left to right, bottom to top): 20mm cube, wall, top/bottom layers, cylinder;
20mm cube with square hole, openscad logo, 3D benchy (retraction not yet coded)

After I matured routing and gcode stage, I focused on the slicing from mesh to polygons, which took most of the time, as I had to decide on the notion how holes are defined in a set of polygons, using clock-wise (CW) and counter-clock-wise (CCW) notion – the code grew quickly complex as I coded those polygon processing from scratch instead to use shapely library right away; but it was good to look so closely at the details, as when one wants to carry metadata of facets of the mesh to the polygon slice and routing stage to the final gcode, e.g. changing color, material or other special G-code, this chain or pipe to hand over metadata had to be possible.

I also kept the file format of routing somewhat open to support easily also non-planar routes, means, the coordinate could be more than x, y, z but also u, v, w (nozzle vector for 4-, 5- or 6-axis FDM) and layer thickness for non-planar slicing.

Cross-Fertilization

Vox3lSlicer: as I experimented with voxel-based geometries, such as reliable CSG operations when slicing with voxels, I replaced the mesh– and slice-stage with voxel-based functions, and then use the next two stages of route and gcode to create G-code; it was truly a matter of a couple of hours
VoxGLSlicer: utilizing OpenGL screenbuffer to “render” volume and easily slice within the GL engine, vectorize and feed the polygons into LabSlicerCore; the same, after a few hours I had another slicer

Examples

Vox3lSlicer, printing tilted Voronoi Bear to avoid supports

In-House Slicers

LabSlicer	Vox3lSlicer	VoxGLSlicer	MetatronSlicer	EnochSlicer
– full planar slicer – 4 stages: mesh, slice, route, gcode – experimental – API defined – LabSlicerCore library – import/export data of each stage	– voxel-based planar slicer – fast slicing – uses LabSlicerCore library for route and gcode stage	– OpenGL based planar slicer – fast slicing – uses LabSlicerCore library for route and g-code stage	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses OpenZCAD²⁾ engine to slice non-planar	– non-planar slicer – implements Class 1 + 2¹⁾ Universal Slicing – uses mesh & gcode transformation

Footnotes:

Class 2 Universal Slicing only partially implemented (status 2022/03)
OpenZCAD is alike OpenSCAD but with Python as base-language with multiple backends (OpenCASCADE, LibFive, Fogleman’s SDF)

Availability

All three slicers are in-house slicers where I do a lot of experimenting, changing rapidly and testing new algorithms, such as mapping coordinate systems and new routing procedures – for now there are no plans to publish them.

I recommend to look at my fork of Mandoline to learn about slicing, which is available at github but I have stopped to work on, it actually produces printable G-code unlike the original code of it.

References

MetatronSlicer & EnochSlicer (universal slicers)
Slicer4RTN (conic slicer)
Cura CLI Wrapper
Mandoline (fork)