A Very 2017 Take On A BBC Micro

In the early 1980s, there were a plethora of 8-bit microcomputers on the market, and the chances are that if you were interested in such things you belonged to one of the different tribes of enthusiasts for a particular manufacturer’s product. If you are British though there is likely to be one machine that will provide a common frame of reference for owners of all machines of that era: The Acorn BBC Microcomputer which was ubiquitous in the nation’s schools. This 6502-driven machine is remembered today as the progenitor and host of the first ARM processors, but at the time was notable for the huge array of built-in interfaces it contained. Its relatively high price though meant that convincing your parents to buy you one instead of a ZX Spectrum was always going to be an uphill struggle.

So, you never owned a BBC Micro, and this has scarred you for life. Never mind, all is not lost, for now you can have that Acorn experience without scouring eBay for a classic micro, by running one entirely in silicon on a myStorm FPGA board.

To be fair, running classic hardware on an FPGA is nothing new and there have been a few BBC Micros implemented in this way, not to mention an Acorn Atom. But this project builds on the previous FPGA BBC Micros by porting it entirely to Verilog and incorporating some of the bug fixes from their various forks. There are screenshots of the result running several classic games, as well as test screens and a benchmark revealing it to be a faithful reproduction of a 2MHz BBC Micro.

We covered the myStorm board when it arrived last year. We’ve also brought you another FPGA board running as a coprocessor for a real BBC micro.

Thanks [monsonite] for the tip. He also alerts us that the myStorm board’s ARM microcontroller can now be programmed from the Arduino IDE.

FPGA Clocks for Software Developers (or Anyone)

It used to be that designing hardware required schematics and designing software required code. Sure, a lot of people could jump back and forth, but it was clearly a different discipline. Today, a lot of substantial digital design occurs using a hardware description language (HDL) like Verilog or VHDL. These look like software, but as we’ve pointed out many times, it isn’t really the same. [Zipcpu] has a really clear blog post that explains how it is different and why.

[Zipcpu] notes something we’ve seen all too often on the web. Some neophytes will write sequential code using Verilog or VHDL as if it was a conventional programming language. Code like that may even simulate. However, the resulting hardware will — at best — be very inefficient and at worst will not even work.

Continue reading “FPGA Clocks for Software Developers (or Anyone)”

Retrocomputing With Open Source FPGAs

A few years ago, we saw the reverse engineering of the Lattice iCE40 bitstream, opening the door to a completely Open Source development tool chain for FPGAs. This was an astonishing amount of work from [Clifford Wolf], [Mathias Lasser], and [Cotton Seed], but since then we haven’t seen a whole lot from Project IceStorm. Now, that’s about to change, and in the coolest way possible. [hoglet] is retrocomputing on an ICE40 development board.

This is an implementation of the Acorn Atom on a myStorm BlackIce board. This board is basically just a Lattice iCE40 FPGA, a few support components, and a bunch of pin headers, some of which are in the not-so-handy Arduino pinout footprint. By porting some Acorn Atom implementations and a 6502 core to verilog, [hoglet] was able to stuff a cool old retrocomputer onto an Open Source FPGA development board. Video output is through a resistor DAC driving a VGA cable, and keyboard input is through PS/2.

Just about everything about this Open Source implementation of the Acorn works, and there’s still a lot left in the iCE40 FPGA. [hoglet] is able to run the 6502 core at 25MHz, which means just about every 6502-based system should be able to run on the BlackIce board.

 

TinyFPGA is a Tiny FPGA Board

We recently noticed an open source design for TinyFPGA A-Series boards from [Luke Valenty]. The tiny boards measure 18 mm by 30.5 mm and are breadboard friendly. You can choose a board that holds a Lattice Mach XO2-256 or an XO2-1200, if you need the additional capacity.

The boards have the JTAG interface on the side pins and also on a top header that would be handy to plug in a JTAG dongle for programming. The tiny chips are much easier to work with when they are entombed in a breakout board like this. Bigger boards with LEDs and other I/O devices are good for learning, but they aren’t always good for integrating into a larger project. The TinyFPGA boards would easily work in a device you were prototyping or doing a small production run.

Continue reading “TinyFPGA is a Tiny FPGA Board”

Game Gear HDMI with SNES Controller

With its backlit color screen and Master System compatibility, the Game Gear was years ahead of its main competition. The major downside was that it tore through alkaline batteries quickly, and for that reason the cheaper but less equipped Game Boy was still able to compete. Since we live in the future, however, the Game Gear has received new life with many modifications that address its shortcomings, including this latest one that adds an HDMI output.

The core of the build is an FPGA which is used to handle pixel decoding and also handles the HDMI output. The FPGA allows for a speed high enough to handle all the data that is required, although [Stephen] still has to iron out some screen-filling issues, add sound over HDMI, and take care of a few various pixel glitches. To turn this hack into a complete hodgepodge of adapters, though, [Stephen] has also added an SNES controller adapter to the Game Gear as well. Nintendo has featured Sonic in many of its games, so although we may have disagreed back in the early 90s we think that this Sega/Nintendo pairing is not crossing any boundaries anymore.

Game Gears have had their share of other modifications as well to make them more capable as a handheld system than they were when they were new. We’ve also seen them turned into a console system (they were Master System compatible, after all) and converted into other things entirely, too.

Continue reading “Game Gear HDMI with SNES Controller”

VexRiscv: A Modular RISC-V Implementation for FPGA

Since an FPGA is just a sea of digital logic components on a chip, it isn’t uncommon to build a CPU using at least part of the FPGA’s circuitry. VexRiscv is an implementation of the RISC-V CPU architecture using a language called SpinalHDL.

SpinalHDL is a high-level language conceptually similar to Verilog or VHDL and can compile to Verilog or VHDL, so it should be compatible with most tool chains. VexRiscv shows off well in this project since it is very modular. You can add instructions, an MMU, JTAG debugging, caches and more.

Continue reading “VexRiscv: A Modular RISC-V Implementation for FPGA”

You are Go for FPGA!

Reconfigure.io is accepting beta applications for its environment to configure FPGAs using Go. Yes, Go is a programming language, but the software converts code into FPGA constructs, so you don’t need Verilog or VHDL. Since Go supports concurrent routines and channels for synchronization and communications, the parallel nature of the FPGA should fit well.

According to the project’s website, the tool also allows you to reconfigure the FPGA on the fly using a cloud-based build and deploy system. There isn’t much detail yet, unless you get accepted for the alpha. They claim they’ll give priority to the most interesting use cases, so pitching your blinking LED project probably isn’t going to cut it. There is a bit more detail, however, on their GitHub site.

Continue reading “You are Go for FPGA!”