Loading

The FIBIAC - a simple electromechanical computer

by chris, published

The FIBIAC - a simple electromechanical computer by chris May 10, 2012

Featured Thing!

Description

This is a proof-of-concept for building a simple electromechanical computer. Using a series of punch-cards, it can compute the fibonacci sequence (or other simple algorithms). Additional registers could be added to support more complex operations.

See it in action here: chrisfenton.com/the-fibiac/

Recent Comments

view all
this is amazing
This looks amazing

More from DIY

view more

Liked By

view all

Tags

Give a Shout Out

If you print this Thing and display it in public proudly give attribution by printing and displaying this tag. Print Thing Tag

Instructions

1. Print and assemble three 3-digit counter registers (http://www.thingiverse.com/thing:16068), including magnets and reed switches. Arrange them artistically (I bolted them to a sheet of plywood).

2. Use a laser cutter to cut out 'card_frame_base.dxf' (units are in inches). Cut out 'card_frame.dxf' next. Use 1/4" acryllic or plywood. Use L-brackets from a hardware store to assemble the pieces into a box with card_frame on top (this is what the card reader will get mounted to).

3. Print 2 copies of the 'hol_plate_holder.stl' file - this is the base of the punch-card reader and will hold a copper-clad board. Bolt these to the middle of card_frame so that the copper plate is in the center of the sheet.

4. Take a bare copper-clad board (http://www.goldmine-elec-products.com/prodinfo.asp?number=G18389 or similar). Cut the board to be 3.4"x2.25" (I used a CNC mill for this step). Using a file, file away a line of copper 0.8" from one edge of the board. This should divide the plate into two copper pads, roughly .8"x2.25" and 2.6"x2.25".

5. Acquire 32 spring-loaded pogo pins (with rounded tip) like these: sparkfun.com/products/9173. Get a piece of proto-board with .1" spaced holes, and solder the pins in place in an 8x4 grid, with 0.4" spacing between pins. The pins should be mounted about halfway through the protoboard, and the entire grid needs to be aligned carefully so that some pins don't stick down further than others. The current version only actually uses 11 of these, in case you are feeling thrifty, but it leaves room for expansion. Use a utility knife to score the protoboard on the rows of holes just outside the pins, and snap off the excess protoboard.

6. Print 2 copies of the 'hol_pin_holder.stl' file. These will hold the board we built in step 5 in place. Place 4 skate bearings (http://store.makerbot.com/skate-bearing-pack-8.html) on the studs of the hol_pin_holder pieces (2 each).

7. Use a laser-cutter with 1/4" acryllic to print out two copies of pin_support_grid.dxf. These will 'sandwich' the protoboard with the pogo pin array and hold the pins straight. They should snap into the 'hol_pin_holder' pieces on either side. With the bearings in place, this should slide into the hol_plate_holder assembly fairly snugly, and be able to move in the vertical direction. The pogo pins should all compress a bit when the pin array assembly is as low as it can go, in order to ensure good contact. 8 of the pins on one side should hit the smaller section of the copper board, the other 24 should hit the big side. Insert a 3/8" threaded rod and fasten with bolts so that it extends between the two hol_pin_holder pieces and secures them together. It should stick out 2-3 inches on either side of the hol_pin_holder pieces (this is where the servo_cam will grab it).

8. Print off two copies of 'servo_cam.stl.' You will need to mount these onto two HS-311 type hobby servos (http://www3.towerhobbies.com/cgi-bin/WTI0001P?I=LXDEL5&P=8 or similar).

9. Print off two copies of 'servo_support.stl.' Mount the servos with cams to these, and slip the cams on to the threaded rods, such that the servos can raise and lower the pin array by rotating. Mount the servo_support blocks on either side of the plate_holder assembly with bolts. The cams should be able to rotate 90 degrees to raise and lower the pin array. When in the 'up' position, there should be plenty of clearance between the bottom of the pins and the copper plate. When in the 'down' position, the pogo pins should all be slightly depressed.

10. Print out the 'motor_mount' piece, and attach a NEMA17 stepper motor. This will eventually advance the instruction card chain forward.

11. Use a laser cutter to cut 2 copies of 'instr_card_box.dxf' out of 1/8" plywood or acryllic. Glue them together.

12. Print out 3 copies of axle_stopper.stl. These will hold axles to mount the 2 instr_card_box things we built in step 11.

13. Using a universal mounting hub (http://www.sparkfun.com/products/10006) and some 4-40 bolts, attach the instr_card_box to the stepper motor from step 10. Attach motor mount to the frame so that it sticks out a bit into the larger of the 2 rectangular cut-outs. If necessary, add a bit of glue between the hub and the instr_card_box so that there is no play and it rotates smoothly. The top of the box should be roughly co-planar with the top of the frame.

14. Attach 1 axle_stopper opposite the motor to support the other side of the instr_card_box. Glue a short length of 5/32" brass rod into the axle_stopper so that it protrudes an inch or so for support. The instr_card_box mechanism should now rotate smoothly.

15. Use the other 2 copies of axle_stopper on the opposite side of the frame (with the smaller cutout). Cut out a length of 5/32" brass rod to go between the two axle_stoppers, and mount the remaining instr_card_box on the rod. It should be able to rotate freely (and there should be 10" between far edges of the two instr_card_boxes, such that a chain of 5 2"x3.5" cards should hang across them).

16. Get 4 stepper motor drivers (http://store.makerbot.com/stepper-motor-driver-v3-3.html or similar), and attach them to be able to drive the four stepper motors (3 to control the counter registers, 1 to control the card-advance mechanism).

17. Solder two long wires to either side of our copper plate beneath the pin array. The wires can be routed out either side of the plate_holder thing. The wire connected to the larger copper section should be connected to your system ground - this is now the 'ground plate'. The other wire should be labeled 'zero_detect' and left hanging for now (this section of the copper plate is now the 'zero_detect plate'.

18. Now we're going to control the counter registers. Using wire-wrap wire and your circuit-building-technique-of-choice, connect pins above the ground plate to the 'enable' and 'direction' signals of each stepper driver for the counters (This uses 6 pins). Make sure those signals also have 5V pull-up resistors on them (1k ohm is usually fine) as well. [optional] Use one additional pin above the ground plate and connect it to a buzzer and/or small 6V lamp. This will be our 'alert' signal. Connect the other side of the buzzer/lamp to +5V. We can now control the enable and direction signals for our counters by means of selectively punching holes in instruction cards.

19. Each counter register should contain 3 reed switches that will complete a series circuit when the register reads '0-0-0.' For each of the counters, ground 1 side of the series-reed-switch circuit. Connect the other side to one of the pogo pins above the 'zero_detect plate.' We should now be able to selectively connect a zero-detect circuit from a subset of our counters to the zero_detect plate. The wire connected to that plate will be grounded whenever the selected register is reading 0-0-0. Hard-wire one of the remaining pogo pins above the zero-detect plate to ground, so that we have a means of forcing the zero_detect plate to ground (i.e. automatically advance to the next instruction). The zero_detect wire should have a pull-up resistor (1k ohm is fine) to +5V.

20. Get a microcontroller of your choice. Use it to drive the servo PWM signals. Use trial and error to figure out appropriate values for your servos (Remember - they will be rotating in opposite directions) to raise and lower the card reading pin-array. You can hardware the direction and enable signals of the stepper controller used to advance the card chain such that it always rotates forward, and is always enabled. Connect the 'step' signal of the card-advance motor controller to a digital output signal of the microcontroller.

Wire all three 'step' signals from the three counter registers to the same digital output on the microcontroller.

Wire the zero_detect signal (with pull-up resistor) to a digital input pin on the microcontroller.

Program the microcontroller with the following algorithm:
-------------------------------------------------------------
1. Lower pin-array.
2. Wait 1 sec.
3. Read 'zero_detect' signal. If zero_detect==0, skip to step 6. Otherwise, go to step 4.
4. Send appropriate # of step pulses to rotate enabled counter registers 36 degrees.
5. Go to step 3.
6. Raise pin-array.
7. Wait 1 sec.
8. Send appropriate # of step pulses to card-advance motor to rotate the motor 90 degrees.
9. Go to step 1.
------------------------------------------------------------------------

21. Print out two copies of card_tensioner.stl as well as two copies of big_roller.stl. Bolt the two tensioner pieces to the frame such that they project downward underneath the frame. Cut a 5/32" rod to fit between the two pieces and serve as an axle for the two large rollers. The rollers should push down on the chain of instruction cards to keep them under tension (their height can be adjusted by moving the rod up/down the tensioner pieces).

22. Acquire 12 or more 3.5"x2" instruction cards (US business-card sized) - you will need to design a different tensioner mechanism to use more than 12 cards. I used a nice, coated card-stock for mine (my wife's spare business cards). Print out the 'punch_Card_template.pdf' file, and use a 1/4" hole punch to punch out holes corresponding to the signal pins you chose to use in earlier steps. I overlayed the template on each card I was using, and used a sharpie to stencil the hole grid onto each card.

23. Program it! Write a program to control your wonderful machine. A program to compute the fibonacci sequence looks like the following:

1. Enable R0, R2. R0=Down, R2=Up. Stop when R0==0.
2. Enable R0,R1,R2. R0=Up, R1=Down, R2=Up. Stop when R1==0.
3. Enable Buzzer/lamp. Ground the zero_detect plate automatically to auto-advance.
4. Enable R1, R2. R1=Up, R2=Down. Stop when R2==0.

To get 12 cards, I just repeated this algorithm 3 times. Every time the machine beeps / lamp lights, the next number in the fibonacci sequence is located in R2.


With more registers, you could do more complicated operations. Punch out the corresponding holes on your cards in sequence, and then carefully align the card edges and tape them together with the tape on the bottom side of the card chain.

24. Feed the instruction chain into the machine and then carefully tape the two loose ends together, getting them as flush as possible (to make a circular chain of instruction cards).

25. Position the card chain such that the first card in your program is underneath the pin array. Manually lower the pin array to check for alignment. Power up your machine and let it go!

26. Bask in the glory of your fantastic, punch-card-based calculating engine!
Top