[ Important: Please visit the 'Credit' section of this page ]
The general Idea:
The principle on which LUX is based is rather simple - by using a polygon mirror, a component commonly found in (paper) laser printers aswell as some custom circuitry and programming, it is possible to project images onto resin, one line at a time.
The Good and the Bad:
Advantages are mainly cost as the used polygon mirrors are common and available on aliexpress and ebay aswell as a ( theoretically ) unlimited buildvolume. Additionally, resolution will be considerable higher than all DLP solutions available on the market nowadays, although artifacts will most likely still be present, but less noticeable. Because of the way galvo-driven setups work, they don't suffer from the artifacts mentioned.
Disadvantages are most likely speed, because exposing a layer line by line takes a longer time as exposing it completely in one go . Speed should, nonetheless, be in the same magnitude as DLP exposure. Another downside that needs to be mentioned is the need of a big resin reservoir due to the nature of the build, which requires the printing surface to dip down into the resin. Actual resin usage will be the same as other systems, obviously.
- Write Firmware for the printer
- Write slicer
- Write host software
- Build a proof-of-concept
- Build a fully working machine
In the meantime, check out the WIP CAD plan of the printer here: http://a360.co/2rpLZ1T
While I am aware that there exist plenty of firmware choices for 3d printers already, no implementation of what I have in mind exists yet. As this project is supposed to be a learning experience for me aswell, I have decided to write a firmware from scratch. So far, receiving, checking for errors and parsing of gcode has been implemented, although no other functions exist yet.
The slicer takes in .svg vector files and converts them to gcode with a custom flavor, adding a way to save and read timing information for the laser. The base for this calculation exists already aswell, though additional compensation for angular projection is needed.
Additionally, code has to be further optimised and changed in order to support multithreading so slicing times are kept low.
Currently, slicing the famous 'benchy' benchmark model at a layerheight of 0.05mm takes around 180 seconds or 3 minutes. Hopefully, this time should be reduced by 400-800% by having one thread run on each available cpu core.
For now, the host software used is pronterface, although I would prefer a 'all in one package' that processes .stl files (instead of .svg files) and is able to directly send code to the printer. No efforts on that have been made yet.
Right now, all that works is powering and (roughly) controlling the polygon mirror's speed. How this is achieved will be explained in a project log however.
This concept was NOT developed by me, but by the user 'Mario Lukas' and his OpenExposer project, which you can find here: https://hackaday.io/project/1129-openexposer
Unfortunately, it seems like the project was abandoned, as the last update was published on 01/25/2016, over a year ago. I only intend to build upon the core ideas, not to steal any of his intellectual property.
The project, including this page is heavily WIP and will change.
Code explanations, concept drawings, models and additional source code will be added in later updates -
Comments and suggestions are greatly appreciated!