Building new, weird CPUs in FPGAs

CPU

The popularization of FPGAs for the hobbyist market means a lot more than custom LED controllers and clones of classic computer systems. FPGAs are also a great tool to experiment with computer architecture, creating new, weird, CPUs that don’t abide by the conventions the industry has used for 40 years. [Victor] is designing a new CPU that challenges the conventions of how to access different memory locations, and in the process even came up with a bit of example code that runs on an ARM microcontroller.

Most of the time, the machine code running on your desktop or laptop isn’t that interesting; it’s just long strings of instructions to be processed linearly. The magic of a computer comes through comparisons, an if statement or a jump in code, where the CPU can run one of two pieces of code, depending on a value in a register. There is the problem of reach, though: if a piece of code makes a direct call to another piece of code, the address of the new code must fit within an instruction. On an ARM processor, only 24 bits are available to encode the address, meaning a jump in code can only go 16 MB on either side of its call. Going any further requires more instructions, and the performance hit that comes along with that.

[Victor] decided a solution to this problem would be to create a bit of circuitry that would be a sliding window to store address locations. Instead of storing the literal address for jumps in code, every branch in the code is stored as a location relative to whatever is in the program counter. The result is an easy way to JMP to code very far away in memory, with less of a performance hit.

There’s an implementation for this sliding window token thing [Victor] whipped up for NXP’s ARM Cortex M3 microprocessor, and he’ll be working on an implementation of this concept in a new CPU over on his git.

Interfacing a GPU with a CPU

interfacing-a-gpu-with-a-cpu

[Quinn Dunki] pulled together many months worth of work by interfacing her GPU with the CPU. This is one of the major points in her Veronica project which aims to build a computer from the ground up.

We’ve seen quite a number of posts from her regarding the AVR-powered GPU. So far the development of that component has been happening separately from the 6502 centered CPU. But putting them together is anything but trivial. The timing issues that were so important to consider when developing the GPU get even hairier when it comes writing to the VRAM from an external component. Her first thought was to share a portion of the external RAM between the CPU and GPU as a way to push rendering commands from one to the other. This proved troublesome both in timing and in the number of pins available on the AVR chip. She ended up using something of a virtual register on the AVR chip that can receive commands from the CPU asynchronously. Timing dictates that these commands be written only during vertical blanking so this virtual register also acts as a status register to let the CPU know when it can send the next command.

Her post is packed with the theory behind the design, timing tests on the oscilloscope, and a rather intimidating schematic. But the most important part is the video showing her success in the end.

Emulators 101: how to write a program that functions like an NES CPU

We’d bet everyone reading this article has played a game on an emulator at some time or another. And you may have a base idea of how those emulators work. But we’d wager the vast majority of you are clueless about the actual implementation of game emulators (we know we are). But that has all changed after seeing this demonstration of how [Bisqwit] wrote his own NES emulator. The description doesn’t cover anything more than the basics of writing code that emulates the NES CPU hardware itself. But it’s presented in such a way that makes it quite easy to understand for anyone who has a basic knowledge of programming. He starts with a switch statement for handling the processor’s opcodes and then moves through piece by piece showing how he refined his code to make it work while keeping it readable. We think this is a great teaching method and appreciate the time he put into producing this tutorial.

The explanation starts about 4:22 into the video which is embedded after the break. You’ll also find the first two demo videos there. Those involve mostly fast-motion text editing of the emulator coding process with some gameplay tests at the end of the second video.

[Read more...]

LED case lights reflect CPU usage

A lot of Linux users include system monitor information in their status panel so that they can see when the CPU is grinding away. [Kevin] is taking the concept one step further by changing his case lights based on CPU usage. Above you can see green, orange, and magenta, but [Kevin's] implementation uses the full spectrum of color.

The project is based on an ATmega48. It’s running the V-USB stack and connects to one of the motherboard’s internal USB ports. This lets him easily push the CPU usage data over to the microcontroller where it is translated into color. One RGB LED has been installed behind each fan panel on the front of the case, with a white LED above and below as an accent. Pulse-width modulation via some MOSFETs lets him mix and match for just the right color. He’s powering the add-on off of the PSU rails rather than USB so that it turns off when the computer goes to standby.

Don’t miss [Kevin's] explanation of the system, and a demo of it in action after the break.

[Read more...]

8-bit logic chip computer build

[Kyle] has been hard at working building an 8-bit computer from the ground up. He’s using a set of logic IC’s for the various components, and some NVRAM chips to store the control words. What you see above is the roadmap for his instruction set. He’s just started writing them to the chips, making the job easier by building an Arduino-based programmer.

We’ve enjoyed watching [Quinn Dunki's] progress with her Z80  6502-based PC build which started on a breadboard in much the same way but has come a long way since those humble beginnings. Recently we also looked in on a 4-bit computer that is using discrete components. But [Kyle's] take on the challenge falls somewhere in between the two.

The gist of his design can be found in one of his earlier post. He’s got a ring counter which starts by clearing the address register. It then loads the NVRAM address of the next instruction which is then executed on the subsequent count. It seems the build still has some way to go so make sure to keep your eye out for updates.

[via Reddit]

Building a computer with discrete transistors

You’re going to want to do some stretching before undertaking a soldering project like this one. We’re betting that the physical toll of assembling this 4-bit discrete processor project is starting to drive [SV3ORA] just a bit crazy. This small piece of electronic real estate is playing host to 62 transistors so far, and he’s not done yet.

It’s one thing to build some logic gates in Minecraft (and then turn then into a huge 16-bit ALU). But it’s another thing to actually commit to a physical build. [SV3ORA] does a great job of showing the scope of the project by posting a tight shot of one inverter, then three in a row, then the entire 8-bit address and display system. These gates are built on the copper side of the board, with the power feed, LEDs for displays, and jumpers for control on the opposite side. We’re excited to see where he goes with this project!

But hey, if you don’t want to do that much soldering there’s a lot you can do on a few breadboards.

Mechanical CPU clock is just as confusing as its namesake

[Lior Elazary] designed and built this clock to simulate the function of a CPU. The problem is that if you don’t already have a good grasp of how a CPU works we think this clock will be hopelessly confusing. But lucky for us, we get it, and we love it!

Hour data is shown as a binary number on Register A. This is the center column of red parts and is organized with the MSB on the bottom, the LSB on the top, and left-pointing bits function as digital 1. The clock lacks the complexity necessary for displaying any other time data. But that’s okay, because the sound made by the ball-bearing dropping every minute might drive you a bit loony anyway. [Lior] doesn’t talk about the mechanism that transports that ball bearing, but you can see from the video after the break that a magnet on a circular path picks it up and transports it to the top of the clock where gravity is used to feed the registers. There are two tracks which allow the ball to bypass the A register and enter the B register to the right. This works in conjunction with register C (on the left) to reset the hours when the count is greater than 11.

If you need a kickstart on how these mechanical adders are put together, check out this wooden adder project.

[Read more...]

Follow

Get every new post delivered to your Inbox.

Join 92,407 other followers