Simple Pen Plotter Rolls On The Table

Pen plotters are popular builds amongst DIY CNC enthusiasts. They’re a great way to learn the fundamentals of motion control and make something useful along the way. In that vein, [Maker101] has created a neat barebones plotter for tabletop use. 

The basic design relies on familiar components. It uses a pair of MGN15 linear rails as the basis of the motion platform, along with NEMA 17 stepper motors to run the X and Y axes. These are assembled with the aid of 3D-printed parts that bring the whole frame together, along with a pen lifter operated with a hobby servo.

The neat thing about the design is that the barebones machine is designed to sit upon an existing tabletop. This eliminates the need to integrate a large flat work surface into the plotter itself. Instead, the X axis just runs along whatever surface you place it on, rolling on a small wheel. It’s likely not ideal for accuracy or performance; we could see the machine itself skating around if run too fast. For a lightweight barebones plotter, though, it works well enough.

If you dig building plotters, you might like to step up to something more laser-y in future. Video after the break.

Continue reading “Simple Pen Plotter Rolls On The Table”

New Pens For Old Plotters

Finding consumables is an ever-present problem facing anyone working with old computer hardware. Many of these devices ceased manufacture decades ago and what old stock remains is invariably degraded by time. [Retrohax] has encountered it with the pens for an Atari plotter, a machine that uses an ALPS mechanism that appears in more than one 1980s machine. The original pens had dried out beyond the ability to refill, so he takes us through the process of finding replacements.

Sadly there are no equivalent modern pens ripe for modification, so whatever replacement he used would have to involve a little lateral thinking. He thought salvation was at hand in the form of multicolor ballpoint refills of the type where the ink is in an easily cuttable plastic tube. [Retrohax] and was able to make a 3D-printed holder for a cut-down ballpoint refill. Sadly the pressure required for a good line from a ballpoint was much higher than the original pens, so he was back to square one. Then he happened upon gel pens and tried the same trick with a gel pen refill. This gave instant success and should provide a valid technique for more than just this ALPS mechanism.

If you haven’t got a classic plotter to hand, never fear. You can have a go at making your own.

A Compact SCARA Arm Plotter

If you’re unfamiliar with SCARA robots, the acronym stands for Selective Compliance Assembly Robot Arm. This refers to the fact that the arms are rigid in the Z axis but somewhat compliant in the X and Y axes, and that they’re often used for assembly tasks. In any case, you can spend a great deal of money equipping your factory with these robots, or you can build your own for the fun of it. If you’re not endowed with a seven-figure investment for opening a production plant, consider exploring [tuenhidiy’s] project instead.

The build enlists an Arduino Mega as the brains of the operation. It’s paired with a RAMPS controller for running a pair of NEMA 17 stepper motors that actually move the arm in the X-Y plane. Additionally, a tray eject mechanism from a CD/DVD drive is enlisted to act as the Z axis. The frame is assembled from PVC plumbing components and a small amount of aluminium T-slot profile.

The resulting arm isn’t fast in the video we see of the build, but it works as a basic plotter without too much complaint. The benefit of the Z-axis in this case is obvious, as it allows the pen to be lifted off the page where necessary.

We’ve seen plenty of good plotter designs around these parts before, too. Video after the break.

Continue reading “A Compact SCARA Arm Plotter”

2D Plotter attachment for 3D printer.

Ender 3 Plotter Attachment For Printing Onto Cassettes

One way to look at FDM 3D printers is as machines that turn filament into three-dimensional objects, but at their core they are much more versatile than that. Since they can move just about any tool around in 3D space, you can also use them for plotter tasks, a fact that [Geoffrey Gao] made use of when he had to write labels for a stack of music tapes. The resulting FS-Plotter project is based around a Creality Ender 3 FDM printer. Standard g-code from PrusaSlicer is used to move a pen around, after the latter has been fitted into a (3D-printed) spring-loaded fixture.

The cassette tape is fitted into its own fixture that is attached to the printer bed to hold it in place, while the writing utensil can move in its spring-loaded fixture to account for some unevenness on the surface it’s writing on. In the linked GitHub project a PrusaSlicer profile is provided that can generate 2D plotter Gcode. Where [Geoffrey] says that this project is very useful to him as a musician is that it enables him to make small runs of tapes with professional printing, without running into extra expenses.

Beyond putting a writing utensil into the holder, it could also be used for light engraving and similar tasks, while still making it possible to switch between the FDM hotend and this plotter attachment as needed. For about $30 in parts, it doesn’t seem like a bad deal to get a small-ish plotter and maybe give that old Ender 3 a second life.

Need A Serial Data Plotter? Better Write Your Own

When you’re working with a development team, especially in a supporting capacity, you can often find yourself having to invent tools and support systems that are fairly involved, but don’t add to the system’s functionality. Still, without them, it’d be a dead duck. [Aidan Chandra] was clearly in a similar situation, working with a bunch of postgrads at Stanford, on an exoskeleton project, and needed an accurate data plotter to watch measurements in real-time.

This particular problem has been solved many times over, but [Aidan] laments that many solutions available seem to be too complex, hard to extend, or just have broken dependencies. This happens a lot, and it simply leads to yet another project to get going, before you can do the real work it supports. Based on Python and PyQT5, serial-plotter is a new beginning, with an emphasis on correct data acquisition and real-time data visualization with a little processing thrown in. Think, acquire data, show the raw values as well as the mean value, and RMS noise all on the same windows side-by-side, all of which is easily tweakable with a bit of programming using Numpy and Matplotlib.

One particularly important point to highlight is that of the handling of time-stamping. [Aidan] needed to ensure samples were logged together with a local MCU timestamp so that when displayed and possibly later post-processed, it was possible to accurately determine when a particular value or event occurred. With the amount of buffering, data loss and multiple-thread shenanigans, it is easy to forget that the data might get to the application in a non-deterministic way, and just relying on local CPU time is not so useful.

If you need to visualize data transported over the serial port, we have seen many projects to help. Like the highly configurable Serial Studio, for one. If your needs are a bit more complex, especially with multiple data transport methods, then a Supercon 2022 talk by [Alex Whittemore] might be a jolly good place to start.

CoreXY On The Pi Pico

There are enough off-the-shelf CoreXY mechanisms out there that for the cost of an AliExpress order it’s possible to quickly and cheaply make yourself a plotter. But [Koushani Das], [Mahathi Andavolu] and [Dengyu Tu] are completing their project for Cornell University’s ECE 5730 course, so of course they have designed one from the ground up. Happily for us it seems to be fairly easy to replicate, so you can build one too if it takes your fancy.

The write-up makes for an interesting dive into the nitty-gritty of design, for which we hope they managed to secure a decent grade. The hardware itself seems pretty straightforward as does the pair of stepper controllers and RP2040 they use to run the thing, and their explanation of the math behind the CoreXY coordinate system is genuinely interesting for those of us who’ve never taken the time to consider it.

All the good stuff can be found in a GitHub repository if you’d like to take this further, and meanwhile they’ve also put up a demo video which you can see below the break. We like this little plotter, and we hope others will take its design and run with it.

Want more CoreXY explanation? We’re happy to oblige.

Continue reading “CoreXY On The Pi Pico”

Lessons Learned While Building A DIY Pen Plotter

There was a time when plotters were the pinnacle of computer graphics output. While they aren’t as common as they used to be, there are some advantages to having a plotter. [Symon] wanted a plotter and decided to make one from scratch. Truthfully, he wants to build a CNC machine, so the plotter is just a stepping stone. In fact, some of it may be a little much for just a plotter. Other design choices have worked for the plotter, but don’t look like they will work well for the eventual CNC design.

As an example, the plotter uses 2020 extrusions and lead screws. An Arduino with a CNC shield provides the brains. GRBL, of course, runs on the Arduino, so the whole machine runs fine with normal G-code. This post will be especially interesting if you want to build a plotter or something similar. We especially like that it covers the design rationale for each choice made It is great to learn from others successes and, of course, their mistakes.

If you really want just a plotter, you don’t have to spend much. You can even go super minimal if you want.