Home built 1-pin dot matrix printer hack

One of the peripherals I didn't have for the longest time was a printer. Having already hacked up a crude drum scanner, this seemed like the logical next thing.

home built dot matrix printer
The crude 'dot matrix printer' in action

The 'print head'

The actual print head mechanism of a real dot matrix printer is quite a piece of engineering, so this was not something I was about to attempt doing. And ink jet printers had not become widespread yet - not that I would have attempted that either. Instead, I used a ball-point pen and a solenoid as my one 'pin' of my 1-pin dot-matrix printer. I searched the whole house for the easiest rolling ball-point pen. This ironcially turned out to be a cheap BIC pen - though we didn't have much in the way of fancy ballpoint pens around the house. I cut off the plastic ink tube at about 4 cm in length and screwed this into the screw thread of a metal spacer that just happened to be the right diameter to fit neatly inside the solenoid from a slide projector. This was my 'print head' mechanism. I always had to keep the pen very close to the paper. Otherwise the mass of the solenoid core would have too much momentum when it hit the paper, and would actually bounce a bit, producing something that looked much like video ringing. Even so, you can see all the horizontal lines starting with a darker spot from the impact.
A downside of keeping the pen close to the paper at all times is that it would often barely touch the page even when disengaged, and leave a very light trail of ink for every line scanned.


    Printer output
    Printer output - scanned at 300 DPI  

Horizontal carriage movement

The other challenge was to drag the pen across the paper in some way that the computer knew at any time where it was. Stepper motors are of course a very logical thing to use for this purpose, but I didn't have any stepper motors, nor the materials for the drive electronics. Instead, I used a very large induction motor (for mechano set standards). I used a stiff rubber O-ring as the pulley, and gearing to ensure that the carriage moved always at the same speed, regardless of whether the pen was dragging on the page or not. Two gears were forced together and meshed as a clutch, actuated by an 8-track player solenoid.

To get the computer in sync with the mechanism, the computer would engage the gears, and then wait (in a tight assembly language loop) for the sync contact to get engaged, and then it just spit out a row of pixels, without in any way sensing the position of the 'print head'. Pixel columns on the right side somehow stayed pixel columns, regardless of whether a solid line or very little was drawn on a line. The white disc on the machine is the sync contact. A copper wire would drag against the exposed aluminium foil for the contact.

Spring loaded carriage return

The carriage return proved to be another challenge. Once the line of pixels was drawn, the computer disengaged the solenoid. To get the carriage to automatically return, I had it pulled back by a very soft spring from one of those glow in the dark 'yo-balls' that were popular in the early 1980's. Even with the very weak spring, the carriage was going pretty fast by the time it hit the left margin, and would often 'derail' as a result. So I coupled this old record player motor to the shaft that turned to pull the carriage, and put a few volts of DC across it. This acted as a dynamic brake (the faster the carriage, the more braking), and kept the carriage from hitting the left stop too hard, so it wouldn't derail.

Paper feed

The paper feed was an even bigger kludge. For starters, I just hooked up a cassette deck motor to a relay on the computer, and pulsed it for a very short time. Strangely enough, this produced a fairly consistent amount of advance of the paper, so I just left it on there. For the output on this page though, it wasn't working quite optimally.


At its peak, this printer could do about distinct 64 pixels per second (or about 30 Hz bandwidth with the pen solenoid). With an 8x8 character grid it came out to 1 character per second. But the commodore 64 8x8 font always used lines two pixels wide, so I could run it faster than the solenoid could go, and still have legible text, at 80 columns, two characters per second.

    80 column output
    Printer 80 column output

To do a 320x200 image took about 20 minutes. Unlike my plotter, I never did use the printer for any practical purposes. It was a pretty horrendous hack.

More details

Here's another view of the printer, with some of the components labeled.

APower supply for electronics - later turned into this one
BPower supply for shaded pole motor as brake (E)
CPower transistors for print head solenoid and carriage solenoid
DReed relays, used to strobe paper advance motor
EShaded pole motor - acts as brake for carriage return
FWheel is sync contact, behind is gearbox for carriage
HOil for lubricating mechanisms.
JSplit phase AC main drive motor.

I built this printer back in 1986. Within a year of building this printer, I built a plotter for my commodore 64. The plotter could write much faster than the printer could print, and I ended up using it as a printer for over half a year until I got a real printer. I did reuse the pen actuation mechanism idea for my printer for the plotter though.

Other related pages on my website:

To my Home page