The Mill CPU Architecture

There are basically two ways to compute data. The first is with a DSP, a chip that performs very specialized functions on a limited set of data. These are very cheap, have amazing performance per watt, but can’t do general computation at all. If you’d like to build a general-purpose computer, you’ll have to go with a superscalar processor – an x86, PowerPC, or any one of the other really beefy CPU architectures out there. Superscalars are great for general purpose computing, but their performance per watt dollar is abysmal in comparison to a DSP.

A lot of people have looked into this problem and have come up with nothing. This may change, though, if [Ivan Godard] of Out-of-the-Box computing is able to produce The Mill – a ground-up rethink of current CPU architectures.

Unlike DSPs, superscalar processors you’d find in your desktop have an enormous amount of registers, and most of these are rename registers, or places where the CPU stores a value temporarily. Combine this with the fact that connecting hundreds of these temporary registers to places where they’ll eventually be used eats up about half the power budget in a CPU, and you’ll see why DSPs are so much more efficient than the x86 sitting in your laptop.

[Ivan]’s solution to this problem is replacing the registers in a CPU with something called a ‘belt’ – basically a weird combination of a stack and a shift register. The CPU can take data from any position on the belt, perform an operation, and places the result at the front of the belt. Any data that isn’t used simply falls off the belt; this isn’t a problem, as most data used in a CPU is used only once.

On paper, it’s a vastly more efficient means of general purpose computation. Unfortunately, [Ivan] doesn’t quite have all the patents in for The Mill, so his talks (two available below) are a little compartmentalized. Still, it’s one of the coolest advances in computer architecture in recent memory and something we’d love to see become a real product.

Continue reading “The Mill CPU Architecture”

Geometry Class Just Got Augmented

ruler

Just about every engineer needs to take a drawing class, but until now we surprisingly haven’t seen electronics thrown into rulers, t-squares, and lead holders. [Anirudh] decided to change that with Glassified. It’s a transparent display embedded in a ruler that is able to capture hand drawn lines. These physical lines can be interacted with or measured, turning a ruler into a bridge between a paper drawing and a digital environment.

For the display, [Anirudh] mounted a transparent TOLED display with a digitizer input into a ruler. The digitizer captures the pen strokes underneath the ruler, and is able to interact with the physical lines, either to calculate the length and angle of lines, or just to bounce a digital ball inside a hand-drawn polygon.

There’s no word on how this display is being driven, or what kind of code is running on it. [Anirudh] said he will have some schematics and code available up on his website soon (it’s a 404 right now).

A Variable Capacitor Made From Junk

cap

[Jezan] decided to introduce his son to electronics by building a small crystal radio. These crystal sets have been around for a long time, and make for a great beginner electronics project, but some of the required parts are a little hard to come by. The most difficult to source part for these radios is a variable capacitor, and not finding one in his parts bin, [Jezan] decided to make his own.

This variable capacitor comes directly from a piece of 1.5 mm thick aluminum sheet. Instead of fancy CNC machines, power tools, or even a pair of tin snips, [Jezan] cut the rotors and stators for his variable capacitors with a pair of scissors. The center hole was punched out with a piece of sharpened pipe, and all the pieces were filed down and sanded for a perfect finish.

Considering the variable caps you can get your hands on are either rare or very old, this looks like a great afternoon project for the budding electronics wizard or radio enthusiast. [Jezan]’s craftsmanship is incredible as well and the finished part looks like it came off an assembly line.

A Video Game With Custom LCD Characters

LCD

[Nakul] wanted to build a video game, and with a few projects worth of Arduino experience decided he could finally attain his goal. He used a character LCD display to make his game, and instead of a text-based adventure, he went with a graphical side scroller.

The display for this space-based side scroller isn’t a graphical display like a CRT or a graphic LCD. Instead, [Nakul] is using the ubiquitous Hitachi HD44780 character LCD display. Normally these are used to display text, but they all have the ability to display custom 5 by 8 pixel characters. The code puts these custom characters – a spaceship, missile, and barrier – into the display’s memory and uses them as the sprites for the video game.

You can grab [Nakul]’s code over on his git or check out the action videos below.

Continue reading “A Video Game With Custom LCD Characters”

Electro-permanent Magnets For Quadcopters

electromagnet

Imagine a quadcopter hovering above a payload – a can of beans, perhaps. The ‘copter descends onto the payload, activates an electromagnet, and flies away with a hobo’s dinner. Right now, this is a bit of an impossibility. A normal electromagnet that powerful would consume an amazing amount of power, something quads don’t usually have in abundance. With the OpenGrab project, the dream of a remote-controlled skycrane is within reach, thanks to some very clever applications of magnetics.

The tech behind the OpenGrab is an electro-permanent magnet, basically an electromagnet you can turn on and off, but doesn’t require any power to stay on. OpenGrab was heavily influenced by a PhD thesis aimed at using these devices for self-assembling buildings.

This project had a very successful Kickstarter campaign and has seen some great progress in the project. While beer doesn’t come in steel cans anymore, we can imagine a whole lot of really cool applications for this tech from infuriating electronic puzzles to some very cool remote sensing applications.

Animating A Lamp With The Leap Motion

leap

The Leap Motion is a very cool device, but so far we haven’t seen many applications of interacting with physical devices. [Xavier] wanted to control a cute servo animated desk lamp with his hands, and with the help of a Leap and an Arduino he was able to do just that.

The Leap Motion API has a handy feature that will output all its data over a websocket. It’s a very easy way to transfer hand positions with a minimum amount of overhead, and with just a little bit of Node.js, it’s only two lines of code to connect the Leap to a websocket server.

With the Leap data on a web server, the only thing left to do is pulling it down to an Arduino. Again, [Xavier] used Node.js, this time in the form of johnny five, a Javascript-based Arduino framework. After that, it was a simple matter of mapping the data from the Leap to servo movements in [Xavier]’s Pixar-inspired lamp.

Video of the build below.

Continue reading “Animating A Lamp With The Leap Motion”

Veronica 6502 Gets Keyboard Input Via USB

PS2

When building a homebrew computer, there are a few milestones that make all the work seem worth it. Of course, seeing the CPU step through address lines on the blinkenlights is near the top, but even more important is being able to type a character on a keyboard and have it show up on a display. [Quinn] didn’t want her Veronica computer to deal with serial terminals or PS/2 keyboards when she typed her first characters in; instead she wanted to read a USB keyboard using 80s-era hardware.

Back in the early days of USB, design specs and keyboard manufacturers included a legacy mode in nearly every USB keyboard ever manufactured. This allows a USB keyboard to work with the ancient PS/2 protocol. [Quinn] tapped into that functionality nearly every PS/2 keyboard has using a 6522 Versatile Interface Adapter. This VIA is in the same family of chips as the venerable 6502 CPU that provides GPIO pins and timers.

[Quinn] connected the keyboard connector tapped for PS/2 input to an ATtiny13. This microcontroller reads the scan codes from the keyboards and sends them to the VIA and the rest of Veronica. It’s quite a bit of work to get to this point, but [Quinn] finally has a computer she can type on, the first step to developing software for her homebrew computer.