FPGA

387 Articles

FPGA Calculator Uses Joystick

February 28, 2018 by 10 Comments

FPGAs are great fun, but sometimes you need a few starter projects under your belt. These projects might be something you could just as well do with a CPU, but you have to start somewhere. [LambdaPI] recently shared a 4-bit calculator created using an FPGA, and you can see it in the video below.

The calculator uses a Papilio FPGA board and a LogicStart accessory board for the display and switches. The Papilio normally uses schematic-based entry and Arduino code, but [LambdaPI] used VHDL. You enter the two 4-bit numbers on the 8 switches and then the joystick selects one of four operations (add, subtract, multiply, and divide).

Continue reading “FPGA Calculator Uses Joystick” →

Forth System-On-Chip Takes Us Back To The 80s

February 22, 2018 by 66 Comments

For anyone who has dealt with the programming language Forth, odds are good that you picked it up back in the 80s. Since the language is still in use for many applications, though, you might not have this sort of nostalgic feeling for the language that some might have. For that, though, you might want to try out [Richard]’s implementation which simulates the microcomputers of the 80s using this unique language.

The system has an FPGA-based CPU written in Verilog. It runs on a Nexys-3 board and features PS/2 Keyboard input, a VGA output with a VHDL VT100 terminal emulation module, access to the Flash and onboard SRAM, and a UART. With all of that put together it’s virtually a Forth-based time machine. It’s also extremely well documented even if you’re just curious how it works and aren’t planning on building your own.

The project also includes a CPU simulator written in C which can model the entire computer if you don’t have the hardware for building the actual computer. [Richard] also released everything that you’d need to roll out your own Forth computer on the GitHub page. There are other ways of heading way back to the 1980s, though, like using the quirky Parralax Propeller.

Catching The (PCIe) Bus

February 17, 2018 by 24 Comments

If you are trying to learn about FPGAs, there is only so far you can go with the usual blinking lights and VGA outputs. Eventually, you want to do something more. Although not terribly cheap, you can get FPGA boards in a PCIe form-factor and use them directly with PC software. Is it easy? Well, it isn’t flashing an LED, but there are tools to help. [Angelos Kyriakos] did a Master’s thesis on the very subject and used a project known as RIFFA to help with the task.

RIFFA (Reusable Integration Framework for FPGA Accelerators) is a simple framework for communicating data from a host CPU to an FPGA via a PCI Express bus. The framework requires a PCIe enabled workstation and an FPGA on a board with a PCIe connector. RIFFA supports Windows and Linux, Altera and Xilinx, with bindings for C/C++, Python, MATLAB, and Java. With proper design, RIFFA can transfer quite a bit of data in a short period of time between your computer and your FPGA.

Continue reading “Catching The (PCIe) Bus” →

A Perfect Rose, A Stepper, An X-Ray Machine, And Thee

February 14, 2018 by 18 Comments

The Day of Compulsory Romance is once more upon us, and in recognition of that fact we submit for your approval an alternative look at one of the symbols of romantic love: an X-ray of a rose.

Normally, diagnostic X-rays are somewhat bland representations of differential densities of the tissues that compose various organs and organ systems, generally rendered in shades of gray. But [Linas K], a physicist with time to kill and access to some cool tools, captured the images in the video below not only in vivid color, but as a movie. The imaging side of the project consists of a low-power X-ray tube normally used for non-clinical applications and a CMOS sensor panel. The second video shows that [Linas] did an impressive upgrade on the X-ray controller, rolling his own from an FPGA. This allowed him to tie in a stepper motor to rotate the rose incrementally while taking images which he stitched together in post.

Watching the interior structure of the flower as it spins is fascinating and romantic in its own right, for certain subsets of romance. And really, who wouldn’t appreciate the work that went into this? But if you don’t have access to X-ray gear, fear not — a lovely Valentine’s gift is only a bottle of ferric chloride away.

Continue reading “A Perfect Rose, A Stepper, An X-Ray Machine, And Thee” →

Arrow’s $30 FPGA Board Reviewed

January 27, 2018 by 57 Comments

We like cheap FPGA boards. It isn’t just that we’re cheap — although that’s probably true, too — but cheap boards are a good way to get people started on FPGAs and we think more people should be using FPGAs more often. One inexpensive board is the Max-1000 from Trenz and Arrow. At $29, it is practically an impulse buy. [ZipCPU] did a great write up on his experience using the board. He found that some of it was good, some was bad, and some was just plain ugly. Still, for $30, it seems like this might be a nice board for some applications or for getting started.

Billed an IoT Maker Board, the tiny board sports a Intel (formerly Altera) MAX10 device with 8,000 logic elements, a USB programming interface onboard, 8 MB of SDRAM, and both PMOD and Arduino MKR headers. The MAX10 has an analog to digital conversion block (with an analog mux for up to nine channels) and the ability to host a 32-bit soft controller onboard, too.

Continue reading “Arrow’s $30 FPGA Board Reviewed” →

34C3: Reverse Engineering FPGAs

January 17, 2018 by 11 Comments

We once knew a guy who used to tell us that the first ten times he flew in an airplane, he jumped out of it. It was his eleventh flight before he walked off the plane. [Mathias Lasser] has a similar story. Despite being one of the pair who decoded the iCE40 bitstream format a few years ago, he admits in his 34C3 talk that he never learned how to use FPGAs. His talk covers how he reverse engineered the iCE40 and the Xilinx 7 series devices.

If you are used to FPGAs in terms of Verilog and VHDL, [Mathias] will show you a whole new view of rows, columns, and tiles. Even if you don’t ever plan to work at that level, sometimes understanding hardware at the low level will inspire some insights that are harder to get at the abstraction level.

Continue reading “34C3: Reverse Engineering FPGAs” →

Tips On Building The BlackIce BBC Micro

January 3, 2018 by 4 Comments

You can look at pictures and video of the Grand Canyon, Paris, New York City or anywhere else, and yet when you finally see those places with your own eyes it is somehow different. Fielding an old computer like the BBC Micro on an FPGA has been done before. But there’s always something to learn when you do it yourself. [Machina] took a BlackIce board and made a BBC Micro replica, but he learned a few things along the way and decided to share them for our benefit.

He used the BlackIce board with [Dave’s] BBC Micro implementation that we’ve covered before. [Machina] was impressed that the board takes PMOD plug ins, so it was easy — almost — to add a VGA and keyboard port. Although both gave him some unexpected problems.

Continue reading “Tips On Building The BlackIce BBC Micro” →