I had plans to add register file and instruction decoder, and zero clue how to go from there to memory, clock, and I/O - but when I realized how painful soldering has been, and how much worse register file is going to be, I dropped the whole project.
It was still fairly cool way to learn electronics, and you can check the pictures and schematics.
So building entire computer still seems overwhelming, but here's a simpler idea.
- I could skip soldering completely by just getting a stack of breadboards. It's going to be less compact, and I'll need to setup some kind of frame for them, but anything beats soldering.
- I wondered about wirewrapping as another alternative to soldering, but nobody uses that.
- PCBs seem even harder than soldering.
- 74HC are apparently the new 74LS
- I've heard rumors that there are better languages than Verilog for modelling hardware. It would be nice to investigate one of them.
- In addition to Verilog-level simulation, I'd like to do some wiring estimations before I start building it
- Compiler for that architecture shouldn't be too hard to build.
What I actually want to build
- I want ALU, register file, and instruction decoder
- some RaspberryPi (or Arduino) will hold memory contents and interface with I/O - it will still need some kind of controller for it
- Interface between RPi and computer will itself be somewhat complex
- I'm not sure if I'll have separate clock, or if I'll use RPi as clock source
- At some point I'd like to get memory - but still every bootup RPi will send contents to that memory before my computer will start running
- Even if I get memory and clock off-RPi, it will still handle I/O, networking etc. It's nothing unusual, today every disk, every network card, every wifi dongle etc. have tiny computer on board.
- The fancy multiport register file needs to go as wiring hell, and I can have classic CISC style specialized registers. It doesn't seem like a big difference when you look at Verilog, but there's a reason all old architectures did it this way, and trying to build one taught me that lesson.
- Completely separate code and data will simplify a lot over shared memory architecture.
- With separate code vs data, I can make code words as wide as I'd like - it sort of offloads part of decoder duties to compiler.
- I don't think it will need any fancy microcode, then again any instruction will inevitably take multiple stages. I could start by having extremely wide words, and then moving parts of this logic gradually to instruction decoder.
- It feels really hard not having 32bits. Maybe going 32bit is reasonable - just making registers wider is simple, ALU won't get any harder (ALU won't do multiply or anything crazy like that, we'll do that in software) except for some zero checks etc., so it's just a matter of wiring all that to memory interface.
- 32bit architecture would definitely require RPi as controller, Arduino or small 74HC chip just won't have enough memory.
Where to start
- I think the first step would be to see if Raspberry Pi is a viable memory controller. The RGB LED experiment with software PWM was sort of sanity checking that, but actual memory interface would be much more complicated.
- If it can run at semi-reasonable speed, I can proceed to designing the rest of the system, and building it part by part. If it doesn't, the whole approach will need rethinking.