Project Logs

Collapse

• resolution test

  Hexastorm • 9 hours ago • 0 comments

  After all that engineering, you might be wondering: does the damn thing actually print?

  It does—and the results are crisp. Below is an exposure test using a single facet on UV solar photo paper, easily hitting 60-micron resolution.

  The main hurdle right now is backlash. The stage has roughly 100 microns of play, which causes adjacent scan lanes to slightly overlap. Setting the seam width to -0.17 mm helps (though -0.16 mm might be the sweet spot), but dialing that in is left as an exercise for the reader—there is plenty of other stuff to optimize.

  In the slice preview below, you can see the individual lanes along with two alignment markers used to fine-tune the stitch registration.

• Scan Error Continued: Zero-Camera Feed-Forward Correction

  Hexastorm • 08/02/2026 at 15:22 • 0 comments

  If you've been following along with the Prism Laser Scanner project, you know that moving from a wobbly galvanometer to a high-speed rotating glass prism introduces a nightmare of optical aberrations. In my previous logs, we could clearly see massive orthogonal errors (pyramidal tilt between facets) and scan line jitter (timing differences). Each facet pair isn't perfectly planar or at 90 degrees, and mechanical mounting adds subtle angle defects.

  I am thrilled to report a major breakthrough. We can now correct for facet distortion along the scanline without the need for a camera. (For the orthogonal error, I will make a separate dedicated blog post).

  Although you know from my previous blog post that you can connect a camera, it is not easy. It requires ND filters, global shutter cameras, and much more development.

  1. Zero-Camera Feed-Forward: Predicting Scan Errors from Photodiode Timing

  We can actually predict along-scan errors on every single motor spin-up using our onboard photodiode sensor. Every time a facet sweeps, the laser bundle hits the photodiode, allowing the FPGA / ESP32 to measure the exact rotation period of each individual physical facet (facet period in ms).

  As the prism rotates, the laser beam undergoes lateral shift across the glass faces (acting as a rotating transparent parallel plate). The physical transversal displacement τ(I) on the substrate as a function of the angle of incidence I follows Snell's Law:

  
  

  Where T = 2 × inradius is the thickness of the glass prism (30.0 mm) and n = 1.49 is the refractive index. Taking the derivative near the center of the scanline (I ≈ 0°) gives the angular displacement sensitivity:

  Because of the square root and sine terms in τ(I), the effective scan speed is not strictly constant across the scanline. Counterintuitively, it is slowest at the center and increases symmetrically towards the edges! As the angle of incidence gets steeper, a small change in rotation causes a much more violent lateral shift inside the thick glass.

  At 3000 RPM (angular velocity ω = 314.159 rad/s), this linear optical scan speed across the substrate at line center is:

  However, we don't multiply v_scan(0) by the full timing error δt directly. The photodiode triggers at the start of the sweep (frac = 0.0), while our active laser exposure window is centered at center_frac = 0.525 (start_frac = 0.35 to end_frac = 0.70). The accumulated timing offset at the active scanline region scales with this fractional position. To put it otherwise: the full timing error only exists at the end of the sweep, but when you are halfway, you have only accumulated half the error.

  Because each facet has microscopic angular defects, the photodiode measures slight timing variations (δt = facet_period_ms - P_median) on the order of 10 to 20 microseconds per facet. Note, P_median = 4.99918 ms. By multiplying these timing offsets by our scale factor k_scale ≈ 1.6 μm/μs, the software computes an instant feed-forward correction:

  
  

  Math Note: Exact Derivation vs. Real-World Physics
  If we want to be mathematically rigorous, we shouldn't use the center speed approximation. We should calculate the exact mean speed by taking the integral of the velocity (which is simply the total physical displacement τ) from the photodiode trigger to our center fraction, and dividing by the elapsed time. Doing this exact derivation yields a mean speed of 3.87 μm/μs, which gives a theoretical k_scale = 2.03 μm/μs. The MAE worsens from 13.99 to 17.20 but is still better than original 22.87 (see end).
  
  However, when we applied this "perfect" k=2.03 to our actual measurements, the residual errors got worse. Running a least-squares optimization on the physical prism data reveals the true optimal scale factor for this specific unit is actually k = 1.37. Why? We didn't give the model the angle at which the diode is hit and the position...

  Read more »

• Extending DVP: Running an OV2640 on the ESP32-S3 Over an FFC Cable

  Hexastorm • 07/29/2026 at 08:31 • 0 comments

  Hardware Win: Extending DVP & Ditching the Pi Stack

  If you've ever worked with stock camera modules like the OV2640, you know the default ribbon cables are infuriatingly short. For my custom board setup, the stock cable was nowhere near long enough to reach under the laser head. I was banging my head against the wall, assuming I’d have to give up on DVP entirely and shell out for a significantly more expensive USB or SPI camera setup.

  Instead, I decided to test signal limits by extending the OV2640 using a 90 mm FFC cable coupled with a 24-pin Adafruit FFC extender. Because Digital Video Port (DVP) uses high-speed parallel lines, extending it isn't plug-and-play—trace impedance matching and signal integrity become make-or-break fast. It didn't work right out of the box, but once the impedance was dialed in, it delivered a crystal-clear image. This trick allowed us to retire our old, bulky camera stack (a Raspberry Pi tethered to an Arducam) in favor of a lean, direct ESP32-S3 connection directly on our custom PCB.

  Open Source Realities, AI Velocity, and Recent Wins

  Overall progress on the project has been flying recently. Going open source gave us fantastic marketing traction and project visibility, though outside code contributions have been sparse—the system is simply too technical and time-consuming for most casual builders to dive into. Plus, let's be real: most people just don't enjoy writing code from scratch.

  However, modern AI models have completely shifted the math on solo hardware/software development. Feeding deep technical specs, hardware constraints, and even half-baked architectural ideas into LLMs has turbocharged our feature velocity. Having detailed project documentation public online pays unexpected dividends here—AI models can ingest the full context instantly (and might even train on it for future iterations).

  Thanks to this accelerated workflow, we've been landing major wins almost daily:

  • Full support for both machine and workspace coordinate systems
  • Clean sensorless homing implementation
  • A completely overhauled, much more responsive GUI
  • Automated build and deployment workflows
  • Native support for G-code parsing and FPGA binary optimization

  There's certainly no shortage of things left to improve, but turning complex custom hardware into a streamlined, functional machine is getting faster every single day.

• Laserhead working and dutch deepstate doubles down

  Hexastorm • 07/05/2026 at 11:38 • 0 comments

  
  
  
  

  The new electronics have been successfully tested on the CNC3018Pro, and everything is working smoothly! The stages can now achieve sensorless homing using TMC2209 drivers. The DVP camera can also be positioned directly under the laser head using an extended FFC cable, with stable I2C communication. The laser head is currently on a fixed mount, but we will be transitioning to quick-release magnetic mounts in the final version.

  In other news, the Dutch "deep state" has decided to double down on laser prism technology. A state-backed consortium operating a closed-source commercial alternative, Amsystems, to Hexastorm — a spin-off with roots in TNO — recently raised €1 million to target 3D printing.
  But it is worth noting this isn't their first rodeo with this exact IP (US10114289B2).The original "killer app" for this complex optical architecture was always intended to be printed circuit board (PCB) lithography. Years ago, TNO spun this out as a highly funded company called LDI Systems. However, after struggling to make their multi-laser setup commercially viable, the company was quietly absorbed by the exact same tight-knit network of institutional deep-tech funds, like Innovation Industries (mostly known for Nearfield Instruments, an AFM chip inspection unicorn)

  Now, they are simply recycling the tech to try again in a new market (actually since 2017). I actually pitched this technology to ASML early on. They are keenly aware of the potential in this space and hold key stakeholder positions on the boards of these regional funds. I've always pitched Hexastorm as "ASML for the maker"—a label I'm sure they don't love, but it perfectly captures our mission. Despite their massive institutional funding, their system offers no real technical advantage over our open-hardware design. They still require multiple modules to span large substrates, and their prism relies on a restricted 45-degree angle. History shows that throwing state money at this specific multi-laser architecture doesn't guarantee a win. A similar system developed by Carl Zeiss, the Kleo LDI, was never a true commercial success. Even after heavy investment from the German government and a rebrand to Manz LDI, the technology struggled to gain traction before the division was ultimately sold off to Tesla.

• new board working

  Hexastorm • 05/30/2026 at 18:46 • 0 comments

  
  The newest revision of the Open Hardware Laser Scanner board is finally alive! Upgrading to a 4-layer design packed with extra safety features was 100% the right call.
  Of course, getting here wasn't without its hurdles. Here is a quick rundown of the crazy bugs I ran into getting this revision off the ground:
  
  The Rogue Power Supply: My Vevor DC power supply completely failed and suddenly started dumping 48V into my 24V rail (I'm pretty sure that violates a regulation or two). Luckily, my TVS diode did exactly what it was supposed to do and saved the board. In my confusion ("wait, why is this broken?"), I measured 24V, removed the diode to test, and accidentally hit the unprotected board with 48V. Incredibly, the board survived! Note to self: always trust the TVS diode.
  
  The Silent TMC2209s (An ESP-IDF Gotcha): My TMC2209 stepper drivers still weren't communicating, which was actually one of the main reasons I spun this new board in the first place. It turns out the culprit was a sneaky change in the ESP-IDF toolchain that altered the UART protocol. Previously, the protocol would let the transmission line float after a successful transfer; now, it actively ties it to 0V. Because of the high drive strength of the ESP32-S3, the standard 1K resistor used between TX and RX for single-wire UART isn't enough anymore. Bumping that resistor up to ~5.4K ohms fixed the issue completely.
  
  A Hot Camera Mistake: I learned the hard way that the camera FFC connector I used was a top-contact style, not bottom-contact. I plugged the ribbon cable in backwards. Fortunately, the camera survived the ordeal, though it got alarmingly hot before I caught the mistake
  
  Minor Schematic Gremlins: The schematic for a basic button was incorrect. A minor inconvenience compared to the rest, but fixed nonetheless.
  
  All in all, the V2 board is a massive step up. The 4-layer stackup makes routing so much cleaner, and having those extra safety features already paid off. Onward to the next step of the build!
  
  Board was purchased from PCBway. We thank PCBway for the sponsorship of the previous board and they will be featured in upcoming video. For now it was easier to simply purchase instead of relying on sponsorship.

• Drop-In Laserscanner Upgrade Board for CNC3018 Pro

  Hexastorm • 04/30/2026 at 21:42 • 0 comments

  
  Link: https://github.com/hstarmans/firestarter/

  Building a high-speed polygon laser scanner from scratch is a fantastic engineering flex, but reproducing one has always been a barrier for the average maker. Previously, if you wanted to build this specific ESP32/FPGA-driven polygon scanner, you had to source and modify a custom Felix 3D printer frame. It was a brilliant proof-of-concept, but hardly accessible.

  Now, the project has undergone a massive overhaul, and the entry barrier just hit the floor: the new hardware is designed as a direct, drop-in extension for the ubiquitous Vevor CNC3018 Pro. You replace the controller board but keep using everything else; power source, spindle, fan, encasing, frame.

  By targeting one of the cheapest and most widely available desktop CNC machines on the market, anyone can now turn a standard 3018 frame into a high-speed, closed-loop laser scanning platform. Here is a look under the hood at what makes this new iteration so impressive.

  Consolidation: 4 Layers and No More Ribbon Cables

  The previous architecture relied on a complex two-board setup for the control electronics: a compute module and an extension board. Those have now been beautifully merged into a single, unified 4-layer PCB. Moving to 4 layers allowed for proper, unbroken ground planes—an absolute necessity when you have an ESP32-S3 blasting Wi-Fi, a Lattice uP5k FPGA switching at high frequencies, and stepper motor drivers all crammed onto an 88x70mm footprint.

  Interestingly, the designer leaned heavily on AI to assist with the board’s power management and component selection. From sizing the correct PTC resettable fuses for motor inrush currents to calculating thermal via arrays for the FPGA’s exposed pad, AI was used as a sounding board to bulletproof the power tree.

  The FFC Lifeline: Keeping the Optics Pristine

  While the brains of the operation have been completely overhauled, the project made a very smart design choice: the laser head remains completely separate.

  The delicate optical assembly—housing the polygon mirror, the high-speed laser, and the photodiode—sits on its own dedicated board. It hasn't changed at all.
  Integration is not possible as the laserdriver has to be close to the laser and opamps close to the photo diode.Instead of trying to integrate everything, the new 3018 control board connects to this pristine optical head using a clean, 20-pin Flat Flexible Cable (FFC). This connector can only be used so many times (up to 20 times) but is backward compatible and cheaply available.
  
  

  Integrated Vision: Ditching the Pi

  In the older setup, if you wanted machine vision for alignment or scanning, you had to tether a Raspberry Pi to the rig. That’s now a thing of the past.

  The new board integrates a direct interface for an OV2640 camera module. By offloading the rigid, microsecond-level laser timing to the FPGA, the ESP32-S3 has the breathing room to handle the camera’s 24MHz data bus directly. It’s a leaner, cheaper, and significantly more elegant solution.

  24 Volts and Future-Proofing

  To get better performance out of the stepper motors and support beefier laser modules, the board's power architecture has been bumped up from 12V to 24V.
  Vehor also supplies 24V DC power packs and not 12V. 

  But the best part of this being a 3018 board drop-in replacement? It actually fits perfectly inside the stock Vevor CNC3018 Pro plastic enclosure and connectors. The hardware has even been provisioned to drive the stock 3018 spindle and cooling fans. While the software to run the spindle isn't quite finished yet, the silicon is there and waiting for a pull request.

  By taking an advanced optical project and mapping it onto commodity CNC hardware, this project just moved from "cool prototype" to a platform that makers can actually build and iterate on.

• Lessons Learned

  Hexastorm • 03/27/2026 at 13:55 • 0 comments

  Sometimes in hardware design, you have to take a step back to move forward! I was ready to finalize my effors with a video using facet correction to make a PCB, but I've hit a wall: my stepper drivers are dead. After doing some digging and testing multiple setups, I found the culprit. The drivers were only surviving on a wing, a prayer, and a few hacks.To do this right, I'm retiring the V1 board and starting fresh.

  Here is the roadmap for the new design:

  • Drop the Pi4 for the camera: Using the ESP32-S3 directly for a rock-solid camera connection.
  • Better Optics: Designing proper mounts for the cylinder lenses.
  • Better Wiring: Natively fixing the TMC2209 connection bugs.
  • Better Chassis: Ditching the Felix frame for a CNC 3018 as this is more widely available and fully integrating the camera into the machine.

  Realistically, this means physical video updates are on pause, though I’ll try to share some 3D renders of the new setup soon. But honestly? I'm thrilled. The facet correction concept is officially proven in the camera setup, so I know this redesign will be entirely worth the effort.

• Industrial Precision from DIY Hardware: Conquering 2D Prism Distortion

  Hexastorm • 03/21/2026 at 15:06 • 2 comments

  If you've been following along with the Prism Laser Scanner, you know that moving from a wobbly galvanometer to a high-speed rotating prism introduces a whole new nightmare of optical aberrations. In my previous logs, we could clearly see massive orthogonal errors (pyramidal tilt between facets) and scan line jitter (timing differences). This is due to that each facet pair is not perfectly planar and at 90 degrees, also the mounting is not exactly at 90 degrees.

  I am thrilled to report that the main technical challenge seems fixed. We can now  correct for facet distortion both along (scan) and orthogonal (orth) to the scanline and create perfect exposures. The hardware might be cheap and DIY, but the correction algorithm now guarantees industrial-grade results. It allows you to use all four facets and not use additional lenses and still have top results. More proof will follow, just look at the commit history https://github.com/hstarmans/hexastorm/commits/master/ and results below to gauge the effort required.

  Here is how we got there.

  1. The Median Average Reference

  Previously, the calibration relied on picking a single facet as the "master" reference. The problem? If that specific facet was an outlier, it skewed the entire baseline. Furthermore, the coefficients of one facet were fixed to zero, so we didn't use all coefficients.

  I achieved a major stability upgrade by ditching the single-facet reference. The system now calculates a virtual "median average" across all facets. This spatial median acts as a perfect, idealized virtual facet that we use to anchor the correction math, preventing any single highly-skewed facet from throwing off the calibration table.

  2. Proving Statistical Stability

  To prove this wasn't just a one-off lucky measurement, I automated a baseline calibration cycle to take 10 consecutive measurements. The results show that our underlying hardware timing is remarkably stable. A challenge with my previous log is that you just look at one result. How repeatable is this?

  Here is the raw statistical payload using 10 measurements per facet. Notice the standard deviations (std_um): our orthogonal jitter is hovering between 0.25 and 0.8 microns, and scan jitter is around 0.5 to 1.0 microns. We have a spot diameter of 40 microns and eccentricity of around 1.5. The spot is dependent on how many neutral density filters. I use if i use all, I measure around 25 microns. Also, vibration artifacts can be removed further with cylinder optics.

  Facet	Scan Shift (mm)	Orth Shift (mm)	Angle (°)	Scan Std (µm)	Orth Std (µm)	Scan Spread PtP (µm)	Spot Size (µm)
  0	0.0229	0.0109	-86.5079	1.063	0.257	3.118	40.366
  1	-0.0452	-0.0306	-86.3956	1.020	0.244	2.973	43.464
  2	0.0032	-0.0109	-86.5607	0.476	0.257	1.853	40.266
  3	-0.0032	0.0569	-86.3327	0.476	0.809	1.853	41.549

  3. Verification: The 2D Dot Grid Simulation

  To visually and mathematically prove the correction works, I wrote a routine that measures the 2D error by projecting a dot grid pattern.

  Because my global shutter camera is stationary, we can't physically move the stage to expose a 2D area. I create a SVG with a dot grid, send it to the slicer using calbiration and projects it onto the camera sensor line by line. It then simulates the physical movement of the stage by stacking these individual 1D exposures into a single 2D image using a custom LaserStackSimulator class.

  The routine evaluates the hardware twice: once without correction, and once with the active calibration profile fed into the slicer. It verifies if the optical correction forces the dots from all 4 facets to align perfectly.  There is an algorithm which detects the centroids of the final dot pattern an matches them. It then computes the average offset.

  The Results

  The log output speaks for itself:

  15:28:48 - INFO - Uncorrected 2D Errors (um) [Scan, Orth]: [[20.073,...

  Read more »

• Taming a prism Scanner with Computer Vision

  Hexastorm • 12/24/2025 at 15:35 • 1 comment

  We all love laser scanners, but moving from a wobbly galvanometer to a high-speed rotating prism introduces a whole new nightmare of aberrations. In my previous blog posts, you clearly see that there is an orthogonal error between the scan lines. In addition, there are small timing differences (jitter). So far, no one has been able to handle, let alone quantify this.

  My four-facet prism is spinning at 3000 RPM. While the motor controller is keeping the facet timing stable to within 0.2% (where the mean is 5ms per facet), each facet has a slightly different timing signature, which actually allows me to detect which facet is active.

  To get usable data, I needed to map the imperfections of every single facet. "Close enough" wasn't going to cut it.

  The Setup and The Hack

  My optical setup involves a spinning prism directing a laser onto an OV2311 global shutter camera (2MP, with nice square 3.0μm pixels). To see what was happening, I set the camera exposure long (~1000ms) and modulated the laser with a sparse repetitive pattern: a single pulse followed by a long gap [1] * 1 + [0] * 39. This turned the scan lines into distinct strings of dots, freezing the scanner's behavior in time and space. The images are multiple exposures of a facet imposed on top of each other. You can see that the projection is extremely stable. All the smearing or ghost pixels are gone.

  The Metrology

  Using OpenCV, I grabbed images from all four facets. I detected the dots and fitted ellipses to find their precise sub-pixel centroids. By defining Facet 0 as the "golden" reference, I calculated the relative horizontal and vertical shifts for the other three faces.

  The results gave me a perfect digital signature of the prism's physical defects:

  Facet	Timing Shift (Scan μm)	Mechanical Tilt (Orth μm)	Spot Diameter (μm)	Eccentricity
  0 (Ref)	0.0	0.0	23.023	1.307
  1	18.171	4.177	22.35	1.464
  2	13.45	77.707	24.801	1.577
  3	44.907	48.889	22.826	1.363

  The data is revealing. While the motor timing is stable, the timing synchronization (Scan) varies by over 44 microns between facets. More dramatically, we see massive pyramidal errors (orth-shift). Facets 1, 2, and 3 are all tilted significantly compared to Facet 0, shifting the scan line vertically by nearly 78μm. This is exactly what we were seeing before!

  We also see high eccentricity (~1.6). This is expected as I don't use cylinder optics yet but a simple aspherical lens. Still, I am surpised. If the laser spot is 30 microns, we should be able to get much better results; previously, we never really got beyond 75 microns.

  Verification

  To prove the calibration model works, I did a lot. I repeated the measurements. I switched facets to see if the algorithm is stable. I moved the camera around the laser line to see if the result is consistent. This all proved to be the case.
  Finally, I generated a composite verification image by stacking the raw captures from all four facets ( a single image is seen all the way on the end).

  • Hollow colored circles (cyan, green, red, yellow) are the detected centroids of the actual laser spots.
  • Small red 'x' marks are where my calibration model predicts those spots should be after applying the calculated X and Y shifts.

  As you can see, the red crosses land dead-center in the detected circles. With this calibration table, I can finally close the loop and feed these precise offsets into the slicer. As a final remark, LLMs are really accelerating the technology innovation here. I really think I am 3 to 4 times faster. Also some problems like, my pi's wifi is not working. Are fixed almost immediately, as the LLM states switch of your power management. This speeds up development 10-fold. As I would previously simply accept and not debug it.

  Read more »

• Jitter test

  Hexastorm • 10/04/2025 at 14:45 • 1 comment

  Five months have passed since my last cross-scan test results. 

  Jitter and Scanline Error Resolution

  The extended delay was primarily due to addressing extremely poor initial results from the jitter test, i.e. error along scanline. Resolving this critical issue required a deep dive and specific hardware/software adjustments. I will not outline all of the code optimizations but want to highlight two main changes:

  1.  Mirror Position Adjustment: The physical position of the mirror was moved, allowing the laser's position to be measured at the start of the scanline instead of the end.
  2.  Photodiode Trigger Algorithm Change: A key change was made to the algorithm governing the photodiode trigger timing. The algorithm was proposed by a LLM (https://github.com/hstarmans/hexastorm/blob/master/src/hexastorm/blocks/photodiode_debounce.py).
  These fixes now allow for successful photodiode detection and consistent measurement. The table below shows the resulting timing statistics for each facet (there are four). It's hard to stratify samples. I now set a minimum i.e. 32 which can result in more samples for other facets. Each row corresponds with a different facet. They are ordered sequentially.

  Samples	Mean (ms)	Standard Deviation (ms)
  32	5.00133	0.00076
  451	5.00226	0.00037
  34	4.99797	0.00036
  458	4.99818	0.00031

  Experimental Notes

  Operational Parameters:

  Laser Power:  130/255, both channels of laser driver
  Exposures: Four exposures are used per line.
  Facets: All facets were used, testing confirmed that using a single facet did not improve the overall results.

  Lines seem to wide in the image, spacing should equal line width,  I probably need to add an erosion operation.

  Focusing Procedure:

  Achieving accurate laser focus is critical. A white sheet of paper is placed on the exposure plane, and the laser is focused using a single channel of the laser diode driver at 133 a.u (digipot) to draw a test line. Successful focus is immediately confirmed by drawing a sharp, visible line (burning)
  

  Future work

  I need to pin facet data to certain facet, so I can use measurements to  correct for each facet.

View all 175 project logs