Building SIC-1 in VCB Part 2: DEMUX and Registers

 Last part we built the basic components needed, and a RAM prototype, the next step: a demuxer

A demuxer is a circuit that can convert an address into a selection, in this case, it's turning a binary address value into a selection from a "bank" of RAM


I then refined the RAM prototype to squash it as much as possible, since i was going to have to find a way to squash 256 cells into a workspace that's only about 2048 cells tall, i ended up with this circuit that's just 8 cells tall, though it meant i wouldn't be able to read the data non-destructively, since the circuit reads and writes simultaneously, destroying the old data, but then trying to separate reading and writing would effectively double the amount of wiring as well 

Quite some time wiring later, here's the initial design of the full demuxer plus the RAM bank:


Initially i made the "read" bus exit on the bottom, before deciding i'd prefer to have all the inputs in the same place for when the time came to build the actual CPU, so after a bit of wiring and cleanup, because all of this has to be as tiny as possible to stand a chance at fitting the board


The highlighted area in the top is my interface to the rest of the computer, nicely tidying away the nastiness that is this monstrosity, here's a short video showing a few write/read cycles


You'll note the read/write switch, which determines if the output gets sent into the data bus, this is something i initially built out of necessity.

I mentioned earlier on that the RAM blocks read destructively, this means they lose their stored data upon reading, so i made this system to write the data back into the RAM cells as part of the same RAM access, but then i realized it's an "accidental" system that lets the same data bus act as both input *and* output, 

Next up i figured i'd build some registers, i wanted to have 8 of them, just to stay in the "8-bit" pattern, but i had some different requirements:

first, i wanted to separate the read/write wires, so i could read the registers non-destructively

Second, i also wanted the address to be sent along the same bus, so i could perform a RAM lookup/write entirely using data stored within the registers

So i added a second "bridge" just as i had done to get the output onto the data bus in order to pull the address out of the data bus if appropriate.

Then it would just be a matter of switching things around with the correct timing in order to get read/write operations to work, i could even just do much of the switch timing based off of the existing clock signal


Next i need to figure out how to actually wire this up so it automatically uses the PC register to read the address, then switches the appropriate r/w channels with the correct timing to read a value from RAM into a register, and write from the register back to RAM with the Write line determining the direction

Comments

Post a Comment

Popular posts from this blog

Building SIC-1 in VCB Part 1: RAM

Image
 So i've started a (hopefully) short, and fun side-project again. I'm going to try to emulate the SIC-1 CPU within Virtual circuit board. The SIC-1 CPU is an 8 bit CPU with 256 bytes of addressable RAM i just realized i'm currently making it 256 bits but i'll fix that later (incorrect, turns out i was working on 8*8 bytes) And a single instruction: SUBLEQ A, B, [C] it's a S ingle I nstruction C omputer that should be relatively simple to emulate. As an added challenge, however, i'm also limited to using a Universal gate  to do so,  A universal gate, then, is able to "emulate" other gates, these are the NAND and NOR gates. I've chosen to use the NAND gate, Here's a comparison with their "standard" gates I then added some more designs that might come in handy, a pulse-former seemed useful, and i needed some way to delay signals, an R/S latch also seemed like it'd be needed for RAM, and i also added in a D-flip flop and a manual cloc...
Read more

On the intricacies of affordance-based interfaces in C++

Image
Well that's a rather obscure title, isn't it, and it'll require some explanation about some non-standard C++ structures i've been building at work. First, i've done a little bit of work in the GO programming language, and i really enjoyed the mechanics of it's non-inheriting interface polymorphism (i've called them affordance-based interfaces) Next, i found this talk explaining how to do type erasure in C++ in order to essentially emulate these affordance-based interfaces: I wrote a prototype of this system such that i could make a set of affordance classes that describe a specific member function, and might serve as a "delegate" for that function, and an interface class that could combine several of these affordance classes into a single type-erasing interface. This part actually uses a bit of "regular" polymorphism to attain it's goal, but since i've written macros that generate all the required code for you, you can effec...
Read more

Building SIC-1 in VCB Part 3: Fadder and auto-RAM

Image
 Last time i finished the RAM, an early design for registers and did some initial trial and error with reading data from RAM via registers Next i began some early ALU work, starting from the "traditional" full-adder i made a while back I translated it into a NAND-only version,  which, after some compression, ended up being the exact same size as the original so i could easily hook it into the same test rig Then i started working on automating the RAM read/write cycle, so i could write with registers G/H and read with F/H (H will become the program counter register) This process was somewhat painful since the RAM read signal is just barely long enough to fully store the data, so the write line has to be active before the data arrives, but stop on the same tick that the data line turns off so there's still some leftover wiring from when i tried to have it re-write its own data (which doesn't work since hysteresis can't easily set its own data when the circuit turns ...
Read more