art-no-one-asked-for.com

Designing my first pen plotter from scratch

2026-07-31T00:00:00Z

Recently I really got into sewing and sewed some designs from https://freesewing.eu. While I enjoyed the overall process I really disliked printing the sewing patterns on A4 paper and assembling them into larger patterns by painstakingly cutting and gluing all the pages. I dreamed of owning a plotter that could simply take large rolls of paper and create the designs in one go. A second reason for owning/building a plotter was that I could create large artworks like big signs, maps and so on.

While large format plotters can be had from brands like Vevor for around 300€, I opted to build my own plotter. For the hacker credibility, for gaining mechanical design skills and also for seeing how far I could get without buying any new parts.

I had a large box of old 3D Printer parts, a functioning 3D printer and a lot of free time I could invest and so I set out to build my first plotter.

The goal of the whole design process was to get a working plotter, but the larger goal was to gain experience with mechanical design and plotter design to be able to build a larger better plotter down the line and all sorts of other machines and robots.

Base Design

I opted for a moving paper design in order to be able to plot huge sewing patterns and artworks. (For an exhaustive list of design variants and examples see Matt Widmanns site).

The design is able to move a pen carriage on the Y-Axis. The carriage mounts the pen and has some mechanism to lift it up and down. The paper is moved by feed rollers on the X-Axis giving me a canvas size that is theoretically only limited by the size of the paper roll. Practically of course there will be tracking issues with the rollers and the system will lose precision eventually.

The width of the design and thus the paper that could be used was set by the available linear rods I had for the Y-Axis. The design is able to work with paper up to a width of roughly 30 cm.

The overall design of the plotter which is now the two hours' traffic of our stage.

Components

Slider / Y-Axis

The Slider for the Pen Carriage was the easiest part to design. I used precision rods, linear bearings and linear bearing holders I still had from dismantling my first 3D-Printer. I used a GT2 Belt I also still had lying around.

To fix the belt to the carriage I used a solution that was a little bit janky. The belts get looped and lock themselves on their own teeth and then get inserted into the 3D printed part at the back of the carriage. Bolts are then put into the loops and the belt is tightened, so the bolts are immobilized by the friction. I tried to design the belt holder in a way, that there would be pieces of 3D printed plastic to stop the belts from moving, but I couldn't get the shape and dimensions right and they always snapped off. For the next design I would of course try to come up with a smarter solution.

The very janky mechanism to fix the belt to the carriage. Note that those bolts are just jammed in there and not screwed in at the back.

To tighten the belt I recreated a tightening mechanism I saw online. Tightening a nut pulls in the part of the mechanism that is connected to the bearing guiding the belt thus tightening it. I printed the static part of the mechanism in two parts, so the part would have optimal strength from the layer lines.

The tensioner mechanism. Turning the nut pulls the inner bracket and thus tensions the belt.

To mount the stepper motor I designed a simple bracket that screws both into the Frame and that the stepper can be bolted on.

A sideview of the whole design, showing the servos and their mounts and wiring.

Pen Lifter

The Pen Lifter is connected to the Slider and is used to lift the Pen up and down from the paper. I designed two iterations of the Pen Lifter because the first one didn't work out.

The Base Constraint for Both Iterations was that the Pen Lifter must be able to mount a Sharpie and that if the pen is down, it is actually pushed down by a spring. This way the pen doesn't get destroyed or jam the paper if there is some imprecision in the build, but simply moves a little.

First Iteration

For the First Iteration I opted to also use linear bearings to have the pen mount move up and down. Because I didn't have any precision rods that were small enough and also neither tools nor desire to cut the rods I had, I went to the hardware store and bought 8mm aluminium rods. Those I could cut easily.

I designed a system where the rods were mounted to the Slider Carriage for the sideway movement and a smaller carriage for moving the pen up and down was fixed to the aluminium rods. I also placed springs around the rods, to push the carriage down.

I designed a slider-crank mechanism and used a fairly large servo I had lying around to drive it. In the animation below you can see, how the whole thing worked.

The design had several problems. The first problem was many points of slack in the whole manufactured design. The aluminium rods allowed the pen carriage to wiggle in the X/Y-Plane. I also had no bearings for the slider crank mechanism, so there was a lot of play in that part. The other big problem was, that the servo was unreliable. It was not able to consistently overcome the pressure of the springs and lift the pen carriage up.

Second Iteration

Because the whole slider crank design was so unreliable and the servo seemed unusable I bought a new smaller servo and did a new design around that. Because I also realized I can't get away with the types of loose linkages I had used in the first design I utilized small bearings I found in my mechanical parts stash.

The second design is a lever based design. When the servo is not engaged a spring pushes the pen side of the lever down. When the servo engages and pushes on the other side of the lever the pen gets lifted up.

I have the gut feeling people who know basic lever physics might have come up with a better design, I will look into that for the next iteration. But maybe I will also try to come up with a third completly new design.

After all it works and I am happy that I was able to design my first small mechanical system.

Feed System

The Feed System is used to feed the paper through the machine. It is one of the design elements that differentiates this plotter from a classic CNC system like a router or a 3D Printer. Thus I wasn't able to find many reference designs or even off-the-shelf parts and instead had to design the whole thing myself.

The Feed System consists of a motorized Drive Roller that moves the paper and Pinch Rollers, that press the paper onto the Drive Roller.

Drive Roller

I manufactured the Drive Roller from 28mm stainless steel tube. I knew the roller had to be pretty straight in order to work well and the tube seemed suitable. I glued sandpaper to the tube to make it grippy and designed adaptors to mount the tube in my Frame and attach it to a servo.

The sandpaper was cut in a parallelogram shape, so there wouldn't be one straight seam where the paper could slip.

A picture of the glue up. The tube was roughed up, the sandpaper was coated in 2K Epoxy Glue and then fixed to the tube using rubber bands. The rubber bands could easily be removed after the glue had cured.

Pinch Roller

The Pinch Rollers need to exert pressure on the paper that is fed through the machine. I designed an arm with two roller bearings that would make contact with the paper and added a spring to exert constant pressure on to the bearings.

I tried to be smart and designed the thing in a sort of flat pack style to save printing time, however that made an already janky design even worse and thus the Pinch Roller is pretty wobbly, hard to orient right and one of the main pain points of the current design.

The very wonky pinch rollers. You can see that they are way too thin.

Frame

In order to keep the whole design cheap, I made the frame out of wood that I got cut at the hardware store. The frame cost me 12€ this way and I could easily add mounting holes using a cordless drill. While I am certain that aluminium extrusions would have been the nicer choice, this frame got the job done and was appropriate for a first design.

Electronics & Software

For motors I used unlabeled Nema 17 Servo Motors I had lying around from my first 3D-Printer. A friend gave me a GT2560 Board with reprap stepsticks for driving those. I also used an Arduino UNO to generate the appropriate signals for the servo motor, because I couldn't get the GT2560 board to do so.

As a firmware I used GRBL Mega and vibe coded an additional command into the firmware, so I could trigger the Arduino UNO to lower and raise the servo.

The plotter is connected to a PC via a USB Cable. I used Universal G-Code Sender for preliminary testing and GRBL-Plotter for plotting.

I ran into a small issue with my pen lifting command. Lifting the Pen takes some time, but GRBL doesn't know about that and simply keeps running through the motion commands after processing the pen lift command. Thus I had to add a little wait command in GRBL-Plotter, so the plotting would be fine.

The electronics I used.

Running the whole thing and Issues

Running the plotter is pretty straightforward. The paper is fed between the two rollers, the carriage is moved to the outer most point (no endstop yet) and the zero point for plotting is defined. Then GRBL-Plotter does its thing and a design is plotted onto paper. However there are some issues.

One of the main issues I already hinted at is the Paper Drive System. The pinch rollers are wonky, the sandpaper glued to the tube might introduce irregularities and the tube itself might not be mounted completely parallel to the Y-Axis, due to the wood frame construction. All of these issues compound and lead to the paper skewing after roughly 80 centimeters of feed. This may be mitigated in the future by using an aluminium extrusion frame and designing better pinch rollers. I have not found any alternative to my tube with sandpaper approach, but that is also an area that could be improved upon.

Another issue is, that putting the pen in the holder and adjusting it for the right height is fiddly. When it works it works well, but when not done right the paper jams or the pen simply doesn't reach the paper. This is an area that could be improved upon to increase the quality of life when using the plotter.

The last big design mistake I made is that the pinch roller is too far away from the pen. This way the paper can buckle between the pinch roller and the pen and thus make the final result worse. The fix is obvious.

See the plotter working in the video below.

Conclusion / Outlook

Overall I am happy with this first plotter. I proved to myself, that I am able to design and build a mechanical system and I was able to use the plotter to plot some larger designs.

The main thing for the next design would be to make it wider, to be able to plot larger formats. Preferably A0.

For a follow up design improving the feed roller is the main thing. Besides working on the obvious things I mentioned above I believe it would also be nice to have a paper roll holder parallel to the feed roller. In the current design the roll simply lays on the floor.

The Pen Mount was also a pain to use, but maybe simply using a Knurled Screw to fix the pen can fix it. Plotters from the 80s by HP used a voice coil actuator to move the pen up and down, and if one would want to get fancy, a system with a voice coil actuator and a position sensor could automatically home any pen, by simply checking when the pen collides with the paper. However voice coil actuators are not that easy to source and making them also requires new materials and skills.

I would also source a new driver board, that can run pwm directly, so I can forego the added Arduino UNO solution. GRBL seemed like the right choice, but I would somehow need to get my Pen Lift integrated into the motion pipeline to run more efficiently.

Software wise, I would imagine that for a moving paper design it would be wise to minimize large paper movements, in order to minimize drift issues. I could write a little G-Code Generator that takes this constraint into account.

To add new features one could add an optical flow sensor, to measure the drift of paper. However it is unclear how that information could be used and it is probably wise to invest as many resources as possible into building a perfect paper feed mechanism.

Another quality of life feature to add would be one button that simply turns the feed roller one rotation, to easily load paper into the machine.

Using different shades of fruit as pixels

2026-04-19T00:00:00Z

The USDA Pomological Watercolor Collection is a huge collection of watercolor images of fruits and nuts that was created between the 1880s and 1930s. The collection spans about 7.000 images with 2-4 individual fruit elements per image. My idea was to use all those approximately round elements as pixels to reproduce normal photographs using those fruit pixels. This is the write-up of how I did it.

Acquiring the USDA Pomological Watercolor Collection

The first step was to obtain all images in the collection. The collection is described at a designated page by the National Agricultural Library of the U.S. Department of Agriculture. The page links to the actual collection page, where each image can be viewed individually. Sadly, there is no way to download all images at once, and the page is also programmed in a way that makes crawling difficult.

Luckily, someone already mirrored the collection on Wikimedia, and so I opted to crawl all images from there.

I did the crawling 2 years ago for another project, so I am not sure if there might be an option to download the collection as a whole today.

One last thing to note is that the whole collection is in the public domain, so we can work with it freely.

Converting the Images to Individual Assets

The images of the collection often contain several fruits in one image. If we want to use the fruits as individual pixels, it would be ideal to separate these into their own files. There are also handwritten notes on a lot of images that we are not interested in.

As a first step, I batch processed all images with the tool rembgto remove the backgrounds. This worked great and gave me a folder full of PNGs of fruits with transparent backgrounds.

However, the fruits were still together in one image, so the next step was to separate them. Because they were now clearly separated on a transparent background, that was quite easy. I used Rust, the crate imageproc, and the function connected_components to identify the individual fruits and saved them to separate files. I also scaled them down and converted them to the Quite OK Image Format (QOI) so I could read them faster from file when using them later. In a previous iteration, I used PNG for saving the assets and didn't downscale the images, and that was painfully slow to use.

I wrote a little tool to automatically work through all 7.000 images and ended up with around 11.000 individual assets. rembg had sometimes failed to correctly separate out the background, and this gave me fruits that were mostly grey as assets. I reworked the tool and added some simple filters to discard those.

Colors

In order to use these images as pixels, we have to determine their dominant color. A few weeks ago I read this article on identifying the main color of an image and used some of the ideas presented. The core idea is that averaging all colors is a bad idea that will often leave you with muddy colors as a result. The author also argued that working in the sRGB color space further worsens the result. He proposed using the Oklab color space.

The core idea of the author is to not use an averaging approach but K-Means Clustering to identify N dominant colors of the image and then pick one. I tried that, but K-Means Clustering was really unperformant (at least when I used it with Python in a Jupyter Notebook). I opted to use a weighted average, where the intensity of the color was the weight, so more intense colors counted more towards the average. That worked for my use case. The image below shows how all the assets are placed in the Oklab color space using this method.

Reflecting now, while doing this write-up, I had the idea that by using K-means clustering, I would maybe be able to place these things differently and maybe use more of the color space. If that translates to better end results (whatever better means in this case), remains to be seen. Even though K-Means Clustering was unperformant with Python, I am now using Rust and downscaled images, so maybe it can work.

Intermission - Ideas that seemed Smart but weren't

Before I tell you about the final step to create images with the fruit pixels and show you results, I want to do a little intermission where I tell you about the ideas I thought were smart but didn't work out.

When first creating images with the fruit pixels, I placed them in a grid. I was unsure if I liked the grid look or maybe wanted a more chaotic look. I tried placing points randomly in a 2D canvas and placing my fruit pixels at those locations; however, I didn't like the look. In the end I preferred the natural shape of the fruits contrasted with the forced order of the grid.

I also tried to make Floyd-Steinberg dithering work. I had never used it before but knew it could be used to obtain nicer results when reducing the colors in an image, as opposed to simply using the most similar color of the reduced color set to the original color set at each pixel. However, I made each fruit 20-40 px large to get a nice balance between seeing the individual fruits and also being able to still see the whole image. At this scale, Floyd-Steinberg dithering had no effect, and so I didn't use it in the end.

Creating Images from the Assets

With all the things that didn't work out of the way, let's focus on what worked and how I got from a folder full of fruit assets and an input image to my final results.

The first step was to load all images into my program. Each image was analyzed for the dominant color using the method explained above and placed in a list. After that, a grid was placed on the original image, and for each pixel in the original image at a grid point, the best fruit asset by dominant color was identified. The fruit was placed on a new empty canvas, and thus the new image was built up. The results looked promising but also had two major flaws. Even though there were many assets with bright reds and greens, the algorithm favored the duller colors. Also, the algorithm often seemed to pick the same assets, making for a very repetitive image.

To combat the problem with the duller colors, I added a vibrancy bias. To check if an asset can represent an original color, the system checks the Euclidean distance in the Oklab color space between the original color and the dominant color of the asset. The vibrancy bias gets multiplied with the vibrancy of an asset and then subtracted from the overall distance. Thus, the system can be tuned to prefer more vibrant colors.

To combat the problem with the repetition, I added an overuse penalty. The system keeps track of how often a tile was already used and calculates an excess score quantifying if the tile is overused. The score then gets multiplied by the overuse penalty and added to the distance calculation between a candidate asset and the original color, meaning overused assets become more unattractive to pick. I also randomly rotate the picked asset when placing, so even the same assets give a different impression.

The last thing I fixed was adding some pictures of blue candies to the assets, because i felt this would make the images more interesting.

And so, without further ado:

Based on a photo by Femi Oyekoyaon Unsplash

Based on a photo by AussieActive on Unsplash

Based on a photo by Alexander Shatov on Unsplash

Based on a photo by enrico bet on Unsplash

Further work

The algorithm is still not perfect. There are still some grey transparent assets in my 11.000 assets that lead to black spots in the final images; for example, the floppy drive of the Macintosh. This needs to be fixed.

Loading and analyzing the images into one list takes the most time when running the tool. This can be done once and then cached for each new tool run.

I also plan to revisit the K-means approach for dominant color calculation in Rust to see if it will give me better results.

Painting on wood with foil stencils - The conclusion

2025-07-20T00:00:00Z

In a previous blog post, I experimented with creating stencils for painting on wooden surfaces. While the results were decent for a first attempt, there was significant paint bleed.

Following the time-honored computer scientist tradition of testing in production, I decided to skip further experimentation and jumped straight into stenciling the actual furniture I wanted to paint.

This time I invested much more effort in surface preparation. I sanded until the wood felt completely smooth, applied the stencil, then sprayed multiple clear coat layers to achieve crisp lines. I applied the paint with a foam roller in two passes and let it dry fully.

The result was an improvement over my previous experiment, but paint bleed remained an issue. For my next round of wood stenciling, I'll likely prime the surface before applying the stencil to hopefully further minimize bleed.

The stencil after spraying clear coat.

Close-up of the final result.

The complete result. I am still working on my overall interior design concept.

Painting on wood with foil stencils - A first experiment

2025-04-06T00:00:00Z

The front of the university library building in Münster, Germany, is decorated with a sculpture. In huge letters, it says “GEHORCHE KEINEM” (Obey no one). The artist explained that the sculpture is meant as a message to the users of the library: to use the information they obtain critically, ask questions and be ready to change their perspectives on topics.

The sculpture forces the visitor to literally change their perspective, because it is very large and installed on a corner of the building, so you must change your perspective to see the whole sentence.

I like both the message and the way the sculpture forces the viewer to change his perspective to fully see it. I am also a former student of the University of Münster and wanted something to remind me of my time there. I thought reproducing this sculpture in some way was a good idea. I have some boxy furniture I will paint the lettering on. This way I can make the furniture more interesting, and by painting the words on the edge of the furniture I also get the perspective effect.

But before I can do that, I want to experiment with how I can paint the lettering on my furniture. I own a Silhouette Cameo 4 Vinyl Cutting Machine, so I opted to cut a stencil out of foil and try that out. I started with some Oramask 810S, but that was a nightmare to cut and didn’t properly stick to the wood. After that, I went back to the foil I use for making vinyl stickers, Oracal 631. I cut the foil and transferred a first test piece onto some wood, and it adhered properly to it.

To test the whole workflow, I got a new piece of wood, similar to my furniture, and first sanded it up to 240 Grid Sandpaper. After that I transferred my stencil to the wood and masked off the surrounding area with masking tape. I sprayed on a first layer of clear coat, because I read that this prevents paint bleed around the edges of the stencil. After the first layer dried, I applied two more layers of red paint. After everything had dried, I pulled off the stencil.

For a first experiment I believe the results are good, but there is a lot of paint bleed in the direction of the wood grain. For the next experiment, I think I will first coat the wood with primer and maybe even a complete first layer of clear coat before using the stencil.