Warning: include(counter/counter.php) [function.include]: failed to open stream: No such file or directory in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 1

Warning: include() [function.include]: Failed opening 'counter/counter.php' for inclusion (include_path='.:/usr/local/lib/php') in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 1
ERIC-1: an Electronic Reduced-Instruction-set Computer

  ERIC-1: an Electronic Reduced-Instruction-set Computer* 

Quick-jump to a particular section...
2005.08.29: Beginning: a 4-bit counter
2005.08.30: Counter becomes 8-bit
2005.08.31: Parts arrive -- and flip-flop problems
2005.09.01: The flip-flop saga continued (and some progress)
2005.09.02: Towards an architecture
2005.09.03: Ring counter / progress on the program counter
2005.09.04: Stupid RAM Tricks: Displaying digits of PI!
2005.09.05: Initial thoughts on programming; WRT opcode will be needed.
2005.09.06: More breadboards -- and the perfect case!
2005.09.07: Starting work on the adder/subtracter
2005.09.08: Starting to implement counter settability
2005.09.09: The (fully-settable) counter is completed!
2005.09.10: Wiring of adder mostly completed
2005.09.11: Possible use of microcode for Control Matrix
2005.09.12: EPROM burner arrives -- and progress on microcode
2005.09.13: First half of the RAM
2005.09.14: A register, B register, and Instruction Register
2005.09.23: Large-scale architecture
2005.09.24: Input / MAR circuitry
2005.09.25: Output LED panels -- and rotary switches!
2005.09.26: A+B registers combined with add/subtract unit
2005.09.29: Some progress -- and a to-do list
2005.10.02: Rotary switches arrive / designing the panel
2005.10.03: Input panel complete!
2005.10.04: The EPROM burner works!!!
2005.10.06: ...(mostly, anyway)...
2005.10.07: EPROM burner issues appear solved.
2005.10.09: Control circuitry mostly complete!


Comments? Suggestions? Questions? ...or just amazed that someone can be so bored they'd work on something like this? Email me!

Project Status:
SubsystemStatus
T-state ring counterCompleted; control line questions remain. Internal clock drives the ring counter, which drives the counter.
Program CounterCompleted
Input and MARCompleted
Input/address switchesCompleted and tested.
16x8 RAMBuilt 32K(x24bit) version; upper 32K can be added later.
Instruction registerCompleted
Controller/sequencerMostly complete; need to connect reset-to-zero (T1) circuitry.
Accumulator A>Completed
Adder/subtractor>Completed
B register>Completed
Output registerCompleted and tested.
Binary displayCompleted, except for mounting it in the case.

Project journal logs

2005.08.29

Well, you found it. Nothing much here yet; I haven't even settled on a basic architecture for the computer. Or a name for the project, for that matter. It will be based to some extent on the SAP-1 computer described in Malvino and Brown's "Digital Computer Electonics", which is the text we're using in the ETR272 Microcomputer Electronics class.

For now, some really crummy pictures of the first piece built; the 4-bit (for now) Program Counter subassembly...


(The counter, showing binary 1011)

It actually counts from 0 to 15 (0000 to 1111 in binary).
The two chips are 74LS107 dual J/K flip-flops; the one on the right handles the lowest two bits, and the one on the left handles the highest two. Most of the wiring can be seen even in this low-res, out-of-focus photo; the two white and single brown wires crossing over the chips are the three "carry" lines, which bring each bit's status to the next flip-flop circuit.

The green alligator clip at the top brings the clock signal in to the circuit, which drives the low-bit flip-flop. The circuit triggers on the falling edge of the clock signal.

This part of the computer is nearly complete (if I decide to stick with a 4-bit address bus); all that needs to be added is a 74LS126 3-state output chip.



(Part of my lab setup, showing the connections)

Next on the list: Add the 3-state output chip, to decouple this circuit from the address bus when needed.
Also, maybe go with a 6-bit or 8-bit address bus instead of the 4-bit one which limits it to 16 memory locations.

(Also, FIND MY REAL CAMERA and take some decent pictures. Sheesh.)
Back to the top
2005.08.30
The counter is now 8 bits!

Realizing that 4 bits only allows for 16 memory locations, I decided to go ahead and increase the address bus size to 8 bits, which allows for a whopping 256 memory locations. I'm planning on increasing this yet again to 16 bits, which should work well, since that will allow 64K of memory space (65,536 words.) I'm out of 74LS107 chips for now, but the parts from DigiKey should be here tomorrow.

Now that I have it wired up, the 8-bit counter seems quite reliable. I first clocked it at a few Hz and watched it count from 00000000 to 11111111 and cycle over. Then I sped it up to 256Hz and watched the high-order bit blink on and off once per second. Then, I clocked it up to some 2.5kHz, which made even the high-order bit blink furiously, while the lower bits just sort of glowed. With 16 bits, I should be able to get a bit closer to the max response time of these things. (Somewhere south of 100ns, according to the spec sheet.) 100ns cycle time represents 10MHz; at that clock rate, the counter should zip through all 65,536 addresses at roughly 152Hz. Wow. (I'll probably only run it at a small fraction of that speed, for reliability and to make the blinking lights look cool rather than just a blur.)

...and I found the Kodak! Now I can post real pictures!

The 8-bit counter in action.


A close-up of the circuit, showing the connections (see below for explanation). I hate the way the output lines are routed...

The circuit is fed from the 5Vcc and ground rails at the top and bottom.
The brown line at the upper right brings in the clock signal.
The four chips are 74LS107 "Dual J/K flip-flop with clear" chips. They're cascaded, with each chip handling two bits. The lowest bits are on the right.

(The control lines, !CLR and CP, have been isolated since the photo was taken, so that they can be easily controlled (as opposed to everywhere being just tied into the nearest 5Vcc feed); this will show in the next photo.)

Back to the top
2005.08.31
Good news and bad news today.

The good news is, the parts from DigiKey arrived!
The bad news is, the flip-flops I ordered (CD4027BE chips) have a different pinout from the 74LS107s -- and so far, something is keeping them from working like the 74LS107 chips. I copied the schematic over, determined the new pin numbers, and wired one chip up, but so far, no counter activity. Hmm. Perhaps the reset and enable pins work differently, or something. The documentation states that reset and set are active high, and I've tried grounding them. I'm probably overlooking something simple...
I'm really glad I left the original counter circuit intact. Better eight working bits than none!

I ordered ten (yes, ten; they were cheap) 830-position modular prototype boards from MPJA (found them through Froogle.) I'll need them. And it's hard to beat $3.95US each!

I figure I'll work a bit more on redesigning the counter for the new flip-flops, and if it still doesn't work, I might see if I can find 74LS107s like the original design called for in the first place. Now that the rest of the parts are here, too, I can work on other subassemblies, too.

Spent lots of time today organizing the parts drawers. Radio Shack has great quantities of assorted resistors, but it's time-consuming to decipher all the codes and put them in individual drawers so you can find them when you need them. It'll certainly help later on, though; I just hate housekeeping.

I ought to try connecting the 3-state register to the counter, but I figure I'll do that once I have a working 16-bit counter in one form or another. And that may have to wait until I get a few more 74LS107s, if the new chips still don't cooperate.

I think I'll go build the 6-state ring counter now. That looks easy, right?

Back to the top
2005.09.01

Okay, that's weird.
I left the SET pins floating (which in TTL amounts to high), and that was causing the problems. Or at least the original problems. Now I have an entirely new set of good news/bad news...

The good news now is, it counts.
The bad news now is, it's counting BACKWARDS! I wasn't aware they were even capable of that!
Well, at least I know it will work now. And I have plenty of the 4027s to work with, so the 16-bit counter should be a reality fairly soon. It alone will take up more than a whole prototype board, though! (I think I can get both it and the 555-based clock on a pair of boards. Maybe even the ring counter, too.)

...

Switching Q for !Q on the carry line works; it counts forwards now. I think the 74LS107 had a reversed input or something. Now to test it with more than a single chip -- but it should work OK.

...

Got an 8-bit counter working with the new chips!

...

The counter is up to 10-bit. (And still working!) The counter and a readout will just fit on two boards.
Also, a bunch of independently-ordered parts arrived today, including the RAM and a box full of switches. They'll do nicely for entering data; much nicer to use than the flaky DIP switches we have in class at RCC.
Back to the top
2005.09.02

It's looking like this will be a 24-bit machine. 8 bits for opcodes, and 16 for data. The final design will probably either ignore the opcode portion of memory for any data locations (simpler), or treat data and code identically, reading each memory as 8+16-bit when executing it or as 24-bit when accessing it as data (trickier, but far more powerful). I'm really leaning towards the latter; I like the idea of being able to write self-modifying code, as well as deal with numbers up to 224( = 4,194,304 unsigned) natively...


I created a new icon for this page. First one to figure out what it means and email me gets recognized on this page, if you want. (Sorry; I'd offer a real prize, but what little spare money I have is going into this project!)

I just realized I'm going to need a lot of jumper wires. For some reason, there doesn't seem to be a good bulk source for these. Digikey usually has good prices, but they want $27.50 for the 350-pc kit; the going rate is closer to $10. They do sell the individual lengths in bulk ($10 for 200 pc of the small ones), but this still seems high.

...

Picked up some jumper wires, and completed the basic program counter. 16 bits tested and working; it seems to count perfectly well up to the limit of my signal generator (2MHz or so) -- enough to make even the top bit a blur! Still quite a bit of work to be done to it, including setting it up with 3-state outputs, and implementing settability (which will be needed if it's going to implement any form of JMP instructions!!

...
Connected a 4027 upside-down by mistake. (Oops.) Thank goodness for current-limited power supplies; I reversed it and it still works fine, even up at 2MHz. (I substituted it in for the lowest-position 4027 to stress-test it.)

The working 16-bit counter.


I just discovered that the breadboards can be detached and reattached at will to the assembly (that is, they're not glued in place as I had feared.
(This is a Good ThingTM.)

Back to the top

2005.09.03

Added four 74AHC126 3-state register chips, to give the counter the required ability to unhook itself from the bus. AFAIK, all subsystems have to be able to disengage from the bus when the appropriate command line goes low. Tested it out -- EP low, lights go off. EP high, lights go on. EP floating, who knows what they'll do. All of them started flickering crazily at one point; I thought I had a short or a loose power line, until I realized EP was floating. Tied it to Vcc and all was well.

And the data lines look a bit neater now. They're more-or-less grouped into nibbles.

The working 16-bit counter with 3-state outputs (click for diagram)


...

Working on building the clock circuit now; since this is tied in with several of the other control circuits (the single-step and halt/run circuitry etc), I'm building that as well.

...

Very basic clock circuit working; the 555 timer circuit as described in the book, except 10 Megohm resistors substituted for the two timing resistors in the circuit, in order to clock it down to a few Hertz for diagnosability. The clock-halving flip-flop is implemented as well. Next step will be to connect the run/halt and single-step circuitry.

...

Single-step and run/halt circuitry completed. Running out of boards to construct on -- at least until the batch of ten gets here on Wednesday. I may have to move some circuits around to make room for the ring counter on the boards I'm using now. If that's even possible. Definitely starting to look more computerlike, now; it clocks itself and can be stopped and started.

New idea for the computer (very easily implemented, so I can't imagine I won't add it) -- a "slow motion" switch, to auto-clock the computer at a slow speed. Maybe a few settings; Diagnose (1Hz or so), Hollywood (a few Hertz; to make it look like a 70s-era Hollywood computer), and full speed (couple hundred kHz to 1-2 mHz?)

...

Got the ring counter working, and most of the control circuits separated (okay, "most" taken in its most literal sense of "over 50%"...) The entire board is now pretty much used. I might do some experiments with the RAM chips on the other boards between now and Wednesday, but I think the construction of the components is pretty much at a standstill until the rest of the breadboards arrive.

A full board, with clock, ring counter, program counter, control circuitry, and displays.



Back to the top
2005.09.04

I'm out of the modular breadboards for now, but wanted to work on something related to the project. I figured I'd try out using the RAM chips for something, so I wired up two of the 16x4s (to get 16x8), and set about programming them to store the first fifteen digits of Pi.

I had no idea RAM read-and-write procedures were so picky!

First of all, the bits seemed to come out backwards. I looked over Chapter 9 in the book and found out this was actually normal behavior for these SRAM chips. Oookay then; 1 is 0 and 0 is 1 when programming. No problem. Next, the chips didn't seem to want to acknowledge any change in address. They would accept a word, but would read back that word no matter what address bits I selected. All the SRAM chips behaved this way, so it probably wasn't a bug. A very frustrating half-hour later, I determined that !CE (Chip-Enable-Not) has to go high when addresses are changed. Once I did this, things started to work a bit better.

The next problem was that not all of the memory locations seemed to get programmed correctly. I would go back to previously-programmed locations, only to find that they were in states similar -- but not identical -- to the states that they were left in. Another few minutes of wondering why this was and trying different things, and I determined that I couldn't just let !WE (Write-Enable-Not) float when switching addresses; it had to be tied high.

That was the last of the problems. Fifteen manual address changes, fifteen manual 8-bit DIP switch entries, and several dozen control line state changes later, I had the digits 3.14159265358979 programmed into the RAM chips. Now for the FUN part!!

I connected the four RAM address lines to the lowest four bits of the Program Counter, and connected !CE to the State 1 line of the Ring Counter. This way, every time the program counter updates, the address lines are changed -- and when the Ring Counter switches to Position 1, !CE goes high, disabling the RAM. When the Ring Counter increments, Position 1 goes low, and the RAM chips become active again -- this time with the new address selected.

I wired an 8-position display to them, and it cycles through the first fifteen digits of PI!

A still image doesn't do it justice, but it's better than nothing. (I temporarily tied !CE high to take the picture, of course, since it flips through the digits at 2-3 per second...)

The PI counter, with the first of fifteen digits showing...


Back to the top

2005.09.05

The RAM chips apparently work OK; I left the PI display running all night, and it's still going well today.

Later today, I'm planning on building another RAM circuit, using the 64K chips, and seeing how easy it is to copy data on-the-fly from the existing RAM. I figure if I tie !WE low, copy the address, data (output-to-input), and !CE lines across, the data should be copied from the 16x4s into a 64kx8. It should be one step closer to building the whole 64kx24 memory (which I won't do until the new boards arrive; I don't want to build it twice.)

...So for now, I'm working on how I'll program it. My thinking is that, if I come across any programming snags now, I'll be able to modify the design to take them into consideration. A simple program to display triangular numbers would go something like this in (simplified-assembler-compatible) BASIC:

10 count=1
20 curadd=2
30 iter=5000
40 print count
50 a=count
60 a=a+curadd
70 count=a
80 a=curadd
90 a=a+1
100 curadd=a
110 iter=iter-1
120 if iter<>0 then goto 40
130 end

...

Hmm. I'm going to need a WRT opcode; looks like the original SAP-1 can't even write data back to its own memory(!!)

...

So, the program could be implemented in simplified assembler as:

This is kind of tacky, since the initial values in 0000h-0001h will be overwritten with values larger than 2^16-1, which will result in them no longer being NOP opcodes. Since the program will never execute them again, though, this shouldn't be an issue. If I were to run this, I would probably start out with the program at 0000h and start the data somewhere convenient like 0100h where it wouldn't ever be executed. That way, the program could be restarted with no possibility of invalid opcodes.

(It just occurred to me that I might someday want to have a greater-than opcode, too. Hmm...)

...

Congratulations to Kevin Wnuk (ALT1202 on Altair Virtual Airlines), who was the first to guess the meaning of the icon for this page. (It represents, top row to bottom row, the ASCII codes for "ERIC-ONE".)

Back to the top
2005.09.06

The breadboards arrived today (a day early)! Too busy to do much of anything on the project today, but I should have most of the day tomorrow to get some more subsystems built.

I realized that I don't yet have enough memory chips to make the entire 64k x 24bit RAM subsystem; I'll need to order a few more. That, and some extra jumper wires.

I'll probably work on the adder-subtracter tomorrow; it should be fairly straightforward.

I found the perfect case for the completed computer. Turns out I have an empty AT-class PC case -- complete with an AT-class power supply -- in the closet. Rock solid 5.0VDC line, rated at 20 amps. So far, the whole project draws 0.07A peak. I think 20A should do nicely. And it's free!

There's a story behind the case, actually. Last summer, when I was packing up to move back to Virginia from Boca Raton, I got rid of a lot of stuff. I've been a packrat for a long time, and hate to throw anything away that looks remotely useful. I had actually taken this case out to the curb to be thrown away, but something made me reconsider. I didn't know why at the time, but I grabbed it and put it in the truck. Now I know why!

Random thought of the day: Implementing multiply/divide would be possible by programming an EPROM with logarithm and anti-logarithm equivalents; use LOG and EXP operations, along with ADD and SUB operations, to emulate MUL and DIV. (I wonder if this is how the 8080 does it? I ought to see if there are any good books on CPU architecture...)

Back to the top

2005.09.07

Built the first 8 bits of the adder. I might have enough to build a 16-bit version, but the full 24-bit version will have to wait until I have more parts. (When I sent in the DigiKey order, I wasn't planning on building a 24-bit machine -- only the original 8-bit SAP-1.) I'll need to verify parts availability for the entire machine.

In the meantime, there's always the control logic to be designed. (That should actually be the most difficult part of the project -- that, and wiring the control matrix.)

Back to the top

2005.09.08

Started working on implementing settability on the Program Counter. Got all the Set and Reset bits broken out (and tied to a ground bar for now.) A control matrix to either ground these (to let the counter run) or set them appropriately (to set the counter) will be next. The circuit to do this will:


This way, when the Set Counter line is high, this will load the contents of the lowest 16 bits of the bus onto the counter.

The data lines are everywhere. Anyone know where to find solid-conductor ribbon cable??

Back to the top

2005.09.09

The counter is 100% completed! It not only counts from 0000h to FFFFh, but can be directly set to any value in between. It's ready to be plugged into the main data bus; I just need to document where all of the control lines are a bit better.

Back to the top

2005.09.10

Wired up the rest of the adder today. It needs two more chips to complete it, which I'll order in the next shipment from DigiKey. Also ordered 100 5mm blue LEDs for the output display. 15 cents each, and they'll be useful on other projects, too. Red LEDs are more historically accurate -- but blue will look so much cooler...

I'm also nearly done with the Excel version of the parts list. (Once the complete project is done, I plan to document exactly what parts are used, since the design tends to change a bit as new ideas are implemented.

Back to the top

2005.09.11

I just read the section on microcode. What a fascinating idea!!

I'm now planning on using microcode for the control matrix. I found an old Heathkit ID-4801 EPROM programmer on eBay, and hope to be able to use it to program up a small EPROM with microcode to run the controller subsystem. Instead of using discrete logic gates to set the control lines to the right settings for each opcode, this can be programmed into the EPROM. All the control matrix needs to do is to look up the starting address in the EPROM for that opcode, and read the control line settings out one T-state at a time. Fascinating idea; I got it from the Digital Computer Electonics textbook. The book doesn't seem to go into the details of how it's done, but it looks like it's nothing that can't be easily worked out based on the EPROM documentation.

Now all I need is a manual for the EPROM programmer -- and an appropriate EPROM chip to use!

...

Going to class down in Glenns tomorrow. MK is gonna be amazed, I think!

...

Was reading about EPROMS; turns out they're really analog devices, and the original digital voice playback systems used them this way, stepping through the analog bits to produce the audio playback. 8x more efficient!


Back to the top

2005.09.12

Showed the subsystems so far to MK in class; looks like it's on the right track. Worked some more on the microcode for the various operations -- for the original opcodes from the SAP-1, the microcode instructions are described in the book. I'm working out the others based on what needs to be done when. I believe I have the WRA, WRB and LDB opcodes correct (with the microcode option, WRT can just as easily become WRA and WRB, since all I need to do is add the instructions.) More opcodes may be in the picture, too -- since little or no extra circuitry will be needed.

...

Picked up some more jumper wire at Radio Shack, so I can continue building. Borrowed a few chips from class, too. Radio Shack had 4-wire solid conductor ribbon cable available. It isn't the wide style I'd like to see, but 4-conductor cable will certainly help clean up the project. 6 of these side by side will do for the entire bus. Got two rolls of the stuff.

...

The EPROM programmer is here. It's filthy, but nothing a bit of 409 won't fix. WHY do people insist on smoking around electronics?? At least it seems to work OK; even got it talking to the workstation using the serial port. It uploads and downloads data OK. 9600 baud seems so slow! I guess if you're only transferring 32k or so, it's not a big deal. And I should be able to write QBasic programs to talk to it very easily. EPROM chips are on the way.

Idea for the conditional and nonconditional JUMP opcodes: Instead of a "Load Counter" line, have JMP and JNA lines. JMP would load the counter by itself; JNA would, combined with an OR circuit looking at A.

Idea for Greater-Than: Use 2's-compliment math, subtracting from zero, and check for negativity. Implement a LTZ (Less-Than-Zero) opcode, and do comparisons in software.

Back to the top

2005.09.13

Built the first half of the memory today (32K). I'm two chips (and a whole lot of wires) short to be able to build the other half -- but I'm running out of breadboards, too! 32K should be more than enough for now, and it should be reasonably straightforward to add the other 32K later. (I can see how memory modules could be added one at a time, tying the high-order address lines into the enable lines to switch in banks of memory...)

I still need to build the MAR (Memory Address Register), and start to think about how I'm going to go about tying all of these subsystems into a 24-bit bus without having wires of length measured in meters. (I would eventually like to be able to clock this machine at more than a few kHz...

Back to the top

2005.09.14

Got quite a bit done today. Built the instruction register -- and that went so well that I tied it into the 24-bit RAM bus. Since I had the parts, I then built the A and B registers, and am currently building the output register. The data lines have turned out a lot cleaner than I thought possible; maybe this won't be such a horrible mess after all!

Still working on it, but here's the picture so far...

Left to right: RAM, instruction register, A register, B register, output register.

Back to the top

2005.09.23

Yes, I'm still working on the project. Last week was really busy, with my uncle's wedding in Seaside, FL, assignments due in several classes -- and the usual 18 hours of tutoring. I'm hoping to get some more accomplished on the project this weekend.

What I need to determine now is how all of this will fit together in the PC case. I'd really like to eventually have everything tied together by a passive backplane, like the MITS Altair seems to have done -- but the initial implementation will be with breadboards and a lot of wires all over the place. I want to try to keep the wire runs as short as possible, so as to be able to hopefully run the computer at 1MHz or so.

Right now, I'm working on tying the data lines of the adder/subtracter unit together, so it will be easier to tie into the main bus. I'm going to need to add separate 3-state outputs to the A and probably B registers, so the adder/subtracter unit can have access to them at all times, as was the plan in the original SAP-1 design.

This means, of course, that I'll need a boatload more 3-state registers. I think I picked some up from class last week -- but I'll definitely need to order more from DigiKey. Time to get another order together.

Got ten more breadboards and ten more wiring kits; spent about an hour or so Wednesday evening combining the wiring kits into my large kit for easy access.

I've also ordered an EPROM eraser and a manual for the 4801 programmer. If either the manual arrives or I figure out the checksum algorithm without it, I may start burning the control EPROMs this weekend.

Back to the top

2005.09.24

Built the Input/MAR circuit today, and connected it to the RAM. I had gone and built a 24-bit version before I realized that the address bus is only 16 bits. I also realized that I had the 173s the wrong way around, and had to redo that part of the circuit. It should be OK now, though. Running low on caffeine is a Bad Thing.

Took apart and cleaned the EPROM programmer, too. It looks much nicer now. (I only wish I knew how to make it actually *burn* an EPROM...)

Back to the top

2005.09.25

Found my ColdHeat soldering iron. It was in my toolkit -- no wonder I couldn't find it! That should teach me not to put things away properly where I can't find them. Anyway, I decided to wire up the output LEDs. Got 24 blue LEDs wired up and working -- and in the process, I realized that even with the new conical tip, using the ColdHeat for electronics work is probably not the best idea in the world. I finished the project with a 15-watt RadioShack iron. I still need to add 16 more LEDs for the address display.

I was working on the switch placement for the front panel, and came to the conclusion that it would be a lot easier to build and program if I could find some rotary switches. eBay to the rescue! I found some 16-position Alco switches that will do nicely. Binary-encoded, even! I'll need ten of them; four for the 16-bit addresses, and six for the 24-bit data. I should even have room on the front of the computer to place an opcode mnemonic.

It's going to be so much nicer programming in Hex rather than binary!

Built up a circuit board for the EPROMs, too. (It can be seen in the picture below.) The two EPROMs are unprogrammed for now, since the manual for the Heath 4801 hasn't shown up yet -- but the circuit should be mostly complete and ready to connect to the various subsystem boards.

...I'm gonna need a bigger desk!


Back to the top

2005.09.26

Went to class down at Glenns today. The class is still working on flip-flop counters and timing diagrams. At this rate, I'm glad I'm building the computer -- since it might be the closest thing the class will get to see this semester...

While in class, I took apart the A and B registers, added 74126 3-state buffers to each, and started connecting them to the add/subtract unit. I got the A register connected and realized I would need longer wires for the B register connections -- but by then, class was over anyway. I should have this done by later this week.

Next thing will be to verify the position and connection of the control lines. There will be a total of 15 or 16 control lines, controlled by microcode on the EPROMs. I think I'll see if the campus bookstore has some marking tape or something.

I also need to figure out just how all of this is going to fit in the PC case. I may need to hacksaw out the drive bays -- and may also need to mount the power supply on top of the unit -- although I'd rather not have to do that.

I'm thinking of creating hexidecimal display circuitry. (After all, the input will be in hexidecimal!) The blue blinking lights are just too cool to give up, though -- so if anything, it'll have both. This should make programming MUCH faster.

Possibilities for implementing a main ROM:


Not sure which approach I'll take. I'm leaning toward #4.

Split the website into separate files, one for each day's progress. I need to find out a slick way to make this into a collapsable format to save on bandwidth / loading time.

Back to the top

2005.09.29

It's been another busy week, unfortunately. So far, I haven't had a lot of time to work on the project. I did get some more done on the add/subtract unit (mostly isolating the control lines), and got the outputs of the A and B registers properly tied together with some of the 4-conductor ribbon wire.

The manual for the EPROM programmer should hopefully be here shortly -- otherwise, the project might be delayed. I tried wiring up a personality module for it, but that didn't seem to help. Since the rotary hex switches are also on the way, though, I suppose there will be plenty to work on.

A (mostly complete) to-do list:


Back to the top

2005.10.02

The rotary switches are here! Looks like they'll fit OK on the front panel; I made up some templates out of Legos, of all things. (Hey, it worked.) I'll have six rotary switches for the data on the bottom row, and 4 for the address on the top row. (All spaced at 2" intervals.)

A quick 4-LED experiment confirmed that they are indeed Binary (and not Gray) coded. This will make construction much more straightforward. Also, the two "common" leads are wired together; all pins are active if even one common is connected. This will help, too.

I put in a request for a quote for ten hexadecimal dials for it; I'll see how much they want. (Maybe I'm being wildly optimistic, but I hope it's no more than a few bucks each. I mean, they're small, right?)

I'm hoping to finish the panel today -- if so, I'll post pictures.

Back to the top

2005.10.03

The input panel is complete and tested!

Pictures should be available this evening -- but all ten hex switches are installed and wired, and all 40 bits are working correctly. (The output stage was partially disassembled to test them.)

The control knobs have arrived as well, and will be fitted to the panel this evening. No word yet on a quote for the labels; I might have to cobble something together with transparency film and metal plates from Lowe's...

Back to the top

2005.10.04

The EPROM programmer works!

Mr. Bill Wilkinson (who apparently used to work for Heathkit) was kind enough to provide schematics for the "personality modules" needed to get the 4801 working. I found a nearly-blank 2764 EPROM (apparently the "erased and cleaned" bit on eBay was only 99% accurate), and keyed in a few test patterns for the first few bytes. (The digits of Pi, a few repeating digits, then two rows of zeros.) It actually seemed to do something this time -- and this was confirmed when it was able to read the data back after powering down.

So much for my last good excuse as to why I haven't written the microcode! 8-)

These EPROMS aren't the cleanest in the world, contents-wise -- but that's what the UV eraser is for. Time to start cookin' a batch...

In other news -- I was able to test the output register with data from the newly-completed control panel. It works nicely, responding to the CLK and !LdOut lines.

Some pictures...

Laying out the switches to have enough circuit board for all:


The completed input panel, connected to the input register.
(Note the "3 1 4 1 5 9" on the display, corresponding to the switch positions.)


The switch wiring...


Close-up of the switch wiring.



Back to the top

2005.10.06

The EPROM burner is having issues. I erased one of the chips and tried to burn an all-zeroes pattern. Near as I can tell, bits 4 and 11 are stuck together, with 4 defaulting to (4 OR 11). This doesn't seem to affect the first part of the EPROMS, so I should be able to at least get basic functionality going. Using the whole 8K might be problematic, though.

I think I have the microcode written; I'm working on burning an set of EPROMs now (two, to provide the 16-bit control line width)...

Back to the top

2005.10.07

OK -- guess I spoke too soon. Seems I'd left one wire out of the Personality Module on the EPROM programmer, and that was causing all sorts of problems. With the wire in place (and another soldered where it had to make a double connection), the nine "uninteresting" EPROMs I'd erased all tested solidly blank, with multiple double passes through all coming up clean now. (Since these are 8Kx8 EPROMs with addresses 0000h through 1FFFh, and the tester can access 0000h through 3FFFh, two passes at once can be accomplished; each address 0000-1FFF is accessed twice since 8K EPROMs ignore the high (13th?) bit which distinguishes the low and high halves of the 16K EPROMs.

The first EPROM has also tested 100% when programmed with all zeros. I think the EPROM operation is in business! (I'll still need a proper interface program if I'm going to be writing anything longer than a few dozen bytes.)

I'm hoping to get some serious work done on the computer this weekend. Didn't make it to class last week, so I *have* to go on Monday -- and I'd really like to have this thing nearly done.

...

The second EPROM just passed the zero check. Seven minutes per chip to burn 'em to all-zeros.

Back to the top

2005.10.09

Got quite a bit done this weekend. Programmed the control EPROMs with the microcode for the LDA, ADD, SUB, OUT, JMP, JNA, WRA, WRB, NOP, and LDB opcodes. (I think the logic is correct.)

I also wired up the control circuitry (which mostly involved building a 12-bit resettable and presettable counter.) It's complete except for the reset-to-zero option, which will be implemented via a 3-state buffer tied to logic 1. When the buffer goes active, reset will go active (ground) on all of the flip-flops. That should be the easy part. The harder part (the preset circuitry, including two hex inverters and six quad-AND chips) is complete.

I'm not quite sure how I'll get all of this to Glenns tomorrow -- let alone get all of it to fit in the PC case. Mounting the power supply outside the case is looking increasingly likely, unfortunately. (Good thing I'm not going for a UL listing!)

I "smoke-tested" the whole circuitry (and in the process, found I was missing a few power and ground connections.) Everything seems OK -- no shorts anywhere, at least. Everything together draws about 1.3 amps; my bench supply is definitely starting to notice. It should be enough to test everything together, though; it's capable of 3A. The PC power supply is going to be positively bored, though; it's rated at 20A.

The whole kit and caboodle so far...


Back to the top

*Thanks to Co Alberts (ALT269 on Altair Virtual Airlines) for the suggestion of the project name!
So far,
Warning: include(counter/counter.txt) [function.include]: failed to open stream: No such file or directory in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 92

Warning: include() [function.include]: Failed opening 'counter/counter.txt' for inclusion (include_path='.:/usr/local/lib/php') in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 92
people (other than me) were so bored they stopped by to take a look. And there have been
Warning: include(counter/counter2.txt) [function.include]: failed to open stream: No such file or directory in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 92

Warning: include() [function.include]: Failed opening 'counter/counter2.txt' for inclusion (include_path='.:/usr/local/lib/php') in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 92
hits. Amazing.

Warning: date() [function.date]: It is not safe to rely on the system's timezone settings. You are *required* to use the date.timezone setting or the date_default_timezone_set() function. In case you used any of those methods and you are still getting this warning, you most likely misspelled the timezone identifier. We selected 'America/New_York' for 'EST/-5.0/no DST' instead in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 98

Warning: fopen(userlog.txt) [function.fopen]: failed to open stream: Permission denied in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 100

Warning: fputs() expects parameter 1 to be resource, boolean given in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 101

Warning: fclose() expects parameter 1 to be resource, boolean given in /var/www/intellectualism.org/html/computers/ERIC-1.php on line 102