Home Built Numeric Printer

Around 1966 +/- I needed an output device for one of my first 4 bit state machines. I had developed it to the point of doing some basic math functions and wanted a way to output the data to a printed paper. It was a counting device for the number of times the phone rang in a sequence. The output of the state machine calculated the position in memory then output the numeral to the printer. It would also count the "Dial Clicks" on the phone line and save the number dialed (think... before Touch Tone Dialing).

This printer evolved from the desire to be able to log and store permanently a large amount of data. I had built several "state machines" which were always a drum with bumps and micro switches, dc relays, lights, optocouplers, flip flops, neon lamp trigger bulbs and usually a few triode vacuum tubes. Occasionally some transistors and SCR's were thrown in as funds allowed. They were just a collection of various logic elements that performed a fixed task. When I finished a project I almost always scrapped it to create the next project. Back then I called them computers, now I call them "state machines" because of their extreme simplicity .

Early "state machines" I built did things like control a robot, dial a phone number, add and subtract, invert numbers, record events like power failures, create Morse code from a dial up wheel, extract teletype signals and translate numbers to hex/binary equivalents. This was the first and only printer I ever tried to build. It was to print out the number of times a phone rang and went unanswered. I used to have people call and let the phone ring a specific number of times then call back and let the phone ring a different number of times, and by recording this sequence a code would be generated... I looked that up on a chart and voila I had a message and it didn't cost me a penny since there were no phone charges incurred unless you answered the incoming call. For example 2-3-2 (2 rings followed by 3 rings followed by 2 rings) might mean "...call back Jim....". The list of codes was quite long.  I always knew if it was a message or a phone call since the first code was always 2... so if the phone rang more than 2 times then I would answer it otherwise I just counted and wrote down the number of rings in each sequence. This printer was to record those rings when I wasn't at home. The state machine that did the counting was half analog and half digital and extensively used neon trigger tubes as well as vacuum tubes. I have clear recollections of the design of the printer but the state machine design seems to have faded from memory... i.e. I forgot how it worked.

How It Worked

The design used standard adding machine paper, 2 reversible motors - each with a cam switch, a felt tip pen, and a platen to write on. The Felt Tip Pen was in contact with the paper at all times so every line had an underline in it. The numbers were block style and hard to read. This is the same style as 7segment LED displays, except the 7 segment displays are angled to be easier to read. This is like printing numerals with the two knobs of an Etch-A-Sketch machine... which is exactly where I got the idea.

click to enlarge

Tilted 9º Right

The four instructions were left, right, forward, and back. One Motor moved the adding machine paper Forward and Back. The other motor moved a carriage holding the pen Right and Left across the width of the roll paper. The motors were friction drive via rubber O-rings to the paper and the block frame of the pen carriage. 

The 4 bit data bus was duplexed to write one 8 bit word a nibble at a time. Each "Command" to the printer consisted of two nibbles strobed one at a time to the printer. The first nibble selected 4 states and had options as per this table:

The second nibble was the number of spaces to move from 1 to 15 expressed as a binary nibble. This count was loaded into a count down flip flop array made with transistors. As the cam on the motor cycled one revolution the count would count down to zero and signal the "Host" (state machine) it was finished. The only instruction I remember clearly was the number 16 (Binary 1111) and that meant run the pen to the right until you hit the home position. It was always followed by a Motor A forward 14 spaces command to move down to the next line (line feed).

This was a parallel type interface where each nibble was strobed into the printer. It could only do 1 digit at a time starting in the lower right corner. Digits printed from right to left.... least significant to most significant. Each digit had a blank space to its right, As best I can recollect the width was 5 or 6 columns wide and there was 2 spaces between numerals.

Starting at position 1. To print a numeral zero.... you would first send a  left 4 spaces instruction. This is the underline that appears under the entire printed line.  the first 2 spaces are the separation between characters. The "Tail" is at the center so the printed numeral doesn't look like a '9'. L4

Then you would move Backward 3 spaces to the bottom of the zero. (motor A reversed) B3

Then right 2 spaces to the right hand bottom corner of the numeral. (motor B Reversed) R2

Then Backward 6 places to the top right corner of the numeral.  B6

Then Left 4 spaces to print the top. L4

Then Forward 6 spaces to print the left side. F6

Then Right 2 spaces to finish the bottom of he numeral. R2

Then Forward 3 spaces which overwrites the tail on the numeral....  F3

And finally Left 3 places to go to the start of the next most significant numeral. This places you in the bottom right square (7W X 10H grid) of the next numeral to the left. Which is the next most significant numeral.  L3

In printing the other numerals you will notice it is necessary to overwrite a line you have already drawn several times . When a row of numerals is finished the pen goes all the way back to the right and a separate "home" sensor stops the pen at the right hand edge of the paper. This was a count of 16....  a special command to send the pen home. It was sensed by overflow in the cycle counter.

So each printed numeral filled an imaginary grid on the paper 7 squares wide and 10 squares high. To print the numeral zero it took 9 instructions. The most complicated character takes 15 instructions to print... Isn't that convenient, binary 15 can be expressed with 4 bits... the exact amount I had available on the data bus that is a nibble wide (count could not be set to zero)... 

The tails on the numerals 0, 2, 3, 5, 6, and 8 are coming from the center of the character in order to make the printout easier to read. In the first design I made the tails all come from the right-hand side to simplify the instructions... it was too difficult to read so I moved the tails to the center of the numerals. On the numerals 1, 4, 7, and 9 the tails come from the right.

Parallel interface

The connector used was an 8 pin octal type tube socket and base of an old octal vacuum tube with the glass broken off and wires soldered to each of the pins. I had used this same connector setup on a robot I had build a year before as the connector for the "wired remote control". 

Design Evolution

My initial thought was to print dot matrix style with a solenoid raising and lowering the felt tip pen to make dots on the paper. But after I had  the motors working I hit upon the Etch-A-Sketch idea and this seemed to be a quick and dirty way to print without adding a solenoid.  I also had a plug board made up that was 200columns X 10rows  and used sockets for little fuse like cylinders  that were actually diodes. This was left over from a project I started but never finished to decode Morse code into encrypted code. The plug board stored the data to print the instructions for each numeral to be printed on the paper tape.

If I had gone with the Dot Matrix approach I would only have needed 35 dots (memory cells) per numeral printed.... using the Etch-A-Sketch approach I needed 8 bits (2 nibbles) times 16 instructions... or 128 memory cells per numeral printed. Even though this was an astronomically high amount of ROM memory at the time I had the plug board already made up that held 2,000 bits of diode memory.  So 128 bits per numeral printed.... times 10 numerals to print equaled 1,280 bits used... I had memory to spare. That ROM board only had one major flaw... the contacts were silver plated which oxidized quickly and required frequent cleaning. 

I considered several options when starting this project. One was to use a solenoid to advance the paper and the two motors like an X-Y Plotter to move the pen around. Another was to write "Cursive" by running both motors at the same time a curved line could be created. Both of these ideas quickly died when I figured out how much memory it was going to take to store the characters for printing. 

The 2 small DC motors and gearboxes were from industrial salvage and I bought them used from a junk dealer. They turned really slow (40-50 rpm) and already had the cams and micro-switches attached to turn one revolution and stop.  They had drive pulleys that accepted a rubber o-ring which I used as the friction drive. They were 12vdc motors but ran well from a 6 volt filament transformer rectified to dc. 

The tails from the printed numerals all came down the right side in the original design like this:

Later I reprogrammed it to have the tails in the center like this:

Now the zero doesn't look like a nine, the two and five look like numerals not wavy lines, and three, six, and eight are just easier to read. The 1, 4, 7, and 9 were the same.

Later I also made the home position off the paper on the right side and then the solid line disappeared from the printout. It frequently made a mess on the platen because if it set for long periods of time it would leak a lot ink due to gravity. Never found a work around for this but did make it so the pen could be removed and capped if the printer wasn't in use.

If I had run both motors at the same time then diagonal lines could have been made. The logic for the DC drive to the 2 motors  used Quantity 4 SPDT relays. Each relay switched the polarity of the power to one motor lead of either Motor A (paper) or Motor B (pen). These latching relays toggled from one position to the other when the "Strobe Instruction" ,pin 5, was grounded momentarily. Most standard relays at that time were momentary. Apply power and the relay engaged... disconnect power and the relay released. The 4 relays were telephone type Reed Relays. These relays toggled and remembered their position "Latching" memory for the "Strobed" instructions. For the Strobed Count I had to latch into transistor memory using flip-flop circuits which required a lot more components. 

I have the exact circuit diagram used to strobe "instructions" to the printer because I drew it on the back of a printed card that had the numbers and types of common transistors. It was a promotional giveaway from Meyers Radio Supply, an Electronics supply house in my home town. I have saved it all these years because of the pinouts for the transistors. It also has the pin #'s for the wires to the connector used to connect the printer to the state machine. My finding this old circuit is what inspired me to do this page on the WWW. I had used it as a bookmark in my 1963 RCA receiving tube manual.

Some of the glitches I encountered were... The cams on the motors would skip and then the printing would be off for the whole line....  The flip-flop count memory would lock up and have to be manually reset by powering on and off.... The felt tip pen would leak and ink would be everywhere.

I remember the first attempt was to print the characters in an endless run with the length of the paper roll. This was my second attempt with a smaller felt tip pen and the numerals running at a right angle to the paper.

Doing The Math Check

Each printed numeral can be checked for accuracy by adding its components. The difference between Forward and Reverse commands should equal zero. The difference between Right and Left commands should be 7 spaces greater to the left. This sets the position at the bottom left square of he next grid. The layout grid is 7 spaces wide ( Character = 5 spaces + 2 spaces between characters)

To print a Zero from the above example the commands are:
L4 B3 R2 B6 L4 F6 R2 F3 L3      Where L = Left  R = Right  B= Backwards  F = Forward

So:   L4 + L4 +L3 = 11 Left    &    R2 + R2  = 4 Right   The difference =  11 - 4 = 7 spaces left.

And:   Back instructions B3 + B6 = 9    &  
           Forward instructions F6 + F3 = 9    
           The difference =  9 - 9 = 0

The Demise

This printer got modified to operate from a fluidic sequencer circuit that was tripped by the second hand of a clock running from the power mains. I had it in college at Purdue University in 1969, my sophomore year. It printed the time once a minute in number of elapsed minutes. It had a placard that read "Every Minute Counts"*. My mantra back then between college lectures, working, studying, doing Fluidic research, protesting the Vietnam War, and playing with stupid projects.... minutes were hard to come by. My roommate at the time would unplug it because of the noise it made. Mostly it just sat there and flashed lights. Then once a minute it would print the # of minutes + 1. Then when memory overflowed it would restart at zero a couple of times a day. It wasted a lot of pens and paper :-)       (*The Placard "EVERY MINUTE COUNTS"  was hand lettered on the back of an orange 80 column IBM header/batch  punch card.)

The next year I moved to a different campus and had a rented room and no storage so the printer and all its circuitry were left on the back porch of the house where I was living. Between the rain and snow it rusted and rotted away and I abandoned it when I moved to Tennessee a few years later. 

ROM, RAM, Memory Cells, Arrays

Every digital design I worked on back in the 60's started with some kind of an array. My favorite arrays were built with small brass nails driven into a pine board in rows and columns. Probably every engineer has used an array to create a bank of switches for a keyboard or other computer input device. I used arrays for ROM, RAM, Switches, Pilot Lamps, adding numbers, subtracting numbers, and even multiplication. 

     For an explanation of how Arrays work [ Click Here ]

ROM for this printer was used to store the instructions to "draw" each character. As in the example above to print a "zero" character the instructions are: L4 B3 R2 B6 L4 F6 R2 F3 L3. That's 9 instructions. Other characters take more or less instructions from 4 to 15 instructions for printing the numerals 0-9. So the memory to print each character is set at 16 maximum instructions times 10 characters to print = 160 instructions in the set. I viewed this as ten sets of instructions each 16 pages long. Remember each instruction is 2 nibbles of 4 bits = 8 bits per instruction so the required ROM is 160 instructions times 8 bits = 1,280 bits of memory. In the 1960's this was a monumental amount of memory. Today it would be called a 1K EPROM.

The best anyone could do for non volatile memory at the time was an array. IC devices with fusible links were available but only the Military and very High Tech lab equipment used such devices. The rest of us were stuck with diode arrays. Physical layout quickly became huge.... sometimes these arrays were plug boards that could be 3 or 4 feet square. I was fortunate to have already built a 2,000 bit (10 by 200) array that was stacked in 20 (10 X 10) layers. It was about a 6" cube. I built it in a High School electronics lab as a class project from commercially available pieces ordered from Newark Electronics. It was actually a fuse panel but instead of fuses I made diodes with a ring on each end that could be plugged into the sockets. The reason it was originally laid out as a 10 wide bus was to accommodate decimal numbers. I never built the device it was intended for so it was a perfect fit for the printer.

To put this concept in perspective.... this page on the WWW is currently 22KB (kilobytes) so 1 KB = 1,028 bytes times 8 bits per byte = 8,224   times 22 = 180,928 bits. So that would take 90 of my diode arrays to store it. That's about 11 cubic feet of space... the size of a small refrigerator! Or if you flattened out the arrays and laid them on the floor... 90 arrays times 9 sq ft per array = 180 square feet of floor space..... An average size living room. All that to store 1 page on the WWW.

Now back to the ROM for the printer..... I needed access to my memory as Qty. 2 - 4 bits (nibble) at a time. The first 4 bits were the Instruction... Forward, Backward, Left or Right... the second nibble was the number of spaces to move. That was expressed as a Binary number from 1 to 9. Nine was the greatest number of spaces required to print any of the numerals. The special nibble count of 15 (1111 Binary) was reserved for the move pen all the way to the right till you hit the home position. Multiplexing the two nibbles from my 10 wide bus was easy. I just used diodes to isolate the two nibbles from each other and selected either the High nibble (instruction) or the low nibble (count).

The signal diodes used to create data arrays back then were often very early silicon power diodes. They were really a bargain from mail order houses and were rejects from the manufacturing process of making power rectifier diodes. They were rejected because they didn't meet the power ratings needed to be used in DC rectifier circuits. As I recall they were about $7 a hundred. They were slightly larger than a 1N4001 diode common today. Ratings were about 50ma at 150V. They worked great at very low signal level voltages. Some times they were glass encapsulated but usually they were phenolic dipped and looked like resistors of that day.

Row and column selection of the memory array was done by the "state machine". The memory for the printer instructions/count was in a separate box with a separate power supply. The printer itself only had motor control and count functions. The motor control was relays. The count functions were performed by 4 Flip Flops built from transistors. The actual printer assembly circuit was really small. The ROM memory box was huge since it did all the timing, data retrieval, byte to nibble conversion and strobing of the instructions and count.

From the partial schematic I have the two strobe pins were actually tri state... low's from the Diode array ROM to the printer... High to signal the "state machine" it needed the next instruction. For some reason it pulled both of the Strobe Pins High (instruction & count) when it completed one instruction and was ready for the next??  Can't remember why??

Revised:   October 22, 2006 11:33 PM