Homebrew GPU Tackles Quake

March 28, 2024 by Julian Scheffers 21 Comments

Have you ever wondered how a GPU works? Even better, have you ever wanted to make one? [Dylan] certainly did, because he made FuryGPU — a fully custom graphics card capable of playing Quake at over 30 frames per second.

As you might have guessed, FuryGPU isn’t in the same league as modern graphics card — those are made of thousands of cores specialized in math, which are then programmed with whatever shaders you want. FuryGPU is a more “traditional” GPU, it has dedicated hardware for all the functions the GPU needs to perform and doesn’t support “shader code” in the same way an AMD or NVIDIA GPU does. According to [Dylan], the hardest part of the whole thing was writing Windows drivers for it.

On his blog, [Dylan] tells us all about how he went from the obligatory [Ben Eater] breadboard CPU to playing with FPGAs to even larger FPGAs to bear the weight of this mighty GPU. While this project isn’t exactly revolutionary in the GPU world, it certainly is impressive and we impatiently wait to see what comes next.

Continue reading “Homebrew GPU Tackles Quake“ →

Weird Things To Do With FPGAs

March 21, 2024 by Al Williams 5 Comments

There’s an old joke about how can you find the height of a building using a barometer. One of the punchlines is to drop the barometer from the roof and time how long it takes to hit the ground. We wonder if [Alexlao512] had that in mind when he wrote a post about unconventional uses of FPGAs. Granted, he isn’t dropping any of them off a roof, but still. The list takes advantage of things we usually try to avoid such as temperature variation, metastability, and the effects of propagation delays.

For example, you probably know that hooking up an odd number of inverters into a loop forms an oscillator—the so-called ring oscillator. The post discusses how you can use an oscillator like that to measure propagation delay or even as a strain gauge. If you put pressure on the FPGA chip, the frequency of the ring oscillator will subtly vary.

Continue reading “Weird Things To Do With FPGAs” →

Reverse Engineering The Behringer Ultranet Protocol

March 5, 2024 by Richard Baguley 21 Comments

Ultranet is a protocol created by audio manufacturer Behringer to transmit up to 16 channels of 24-bit sound over a Cat-5 cable. It’s not an open standard, though: Behringer doesn’t offer an API or protocol description to build your own Ultranet devices. But that didn’t stop [Christian Nödig], thanks to a defective mixer, he poked into the signals and built his own Ultranet receiver.

Ultranet runs over Cat-5 ethernet cables but isn’t an ethernet-based protocol. The electrical protocols of Ultranet are identical to Ethernet, but the signaling is different, making it a Level 1 protocol. So, you can use any Cat-5 cable for Ultranet, but you can’t just plug an Ultranet device into an Ethernet one. Or rather, you can (and neither device should explode), but you won’t get anything out of it.

Instead, [Christian]’s exploration revealed that Ultranet is based on another standard: AES/EBU, the bigger professional brother of the SPD/IF socket on HiFi systems. This was designed to carry digital audio over an XLR cable, and Behringer has taken AES/EBU and tweaked it to run over a single twisted pair. With two twisted pairs in the cable carrying a 192 kbps signal, you get sixteen channels of 24-bit audio in total over two twisted pairs inside the Cat-5 cable.

That’s a bit fast for a microcontroller to decode reliably, so [Christian] uses the FPGA in an Arduino Vidor 4000 MKR in his receiver with an open-source AES decoder core to receive and decode the Ultranet signal into individual channels, which are passed to an ADC and analog output.

In effect, [Christian] has built a 16-channel mixer, although the mixing aspect is too primitive for actual use. It would be great for monitoring, though, and it’s a beautiful description of how to dig into protocols like Ultranet that look locked up but are based on other, more open standards.

Continue reading “Reverse Engineering The Behringer Ultranet Protocol” →

Compute The Mandelbrot Set With A Custom RISC-V CPU

January 17, 2024 by Julian Scheffers 9 Comments

When faced with an FPGA, some people might use it to visualize the Mandelbrot set. Others might use it to make CPUs. But what happens if you combine the two? [Michael Kohn] shows us what happens with his RISC-V CPU with an instruction specially made for computing the Mandelbrot set.

[Michael] takes us through the unusual process of turning his 8008 into a RISC-V CPU. Re-using bits of logic here and replacing other logic there leaves him with a functional RISC-V core. Not finished, [Michael] takes it upon himself to also create a custom instruction just for computing a point for the Mandelbrot set, accelerating the demo from twenty-three seconds to merely one!

Still not finished, [Michael] also creates an implementation of the long gone F100-L CPU, once again with added Mandelbrot set flair, simultaneously with the RISC-V project. Finally, he ports his “Java Grinder” Java bytecode compiler to both RISC-V and the F100-L, because Java runs on 1 Billion devices^TM.

Continue reading “Compute The Mandelbrot Set With A Custom RISC-V CPU” →

Building A GPS Receiver From The Ground Up

January 2, 2024 by Bryan Cockfield 11 Comments

One of the more interesting facets of GPS is that, at least from the receiver’s point-of-view, it’s a fairly passive system. All of the information beamed down from the satellites is out in the ether, all the time, free for anyone on the planet to receive and use as they see fit. Of course you need to go out and buy a receiver or, alternatively, possess a certain amount of knowledge to build a circuit that can take those signals and convert them into something usable. Luckily, [leaning_tower] has the required knowledge and demonstrates it with this DIY GPS receiver.

This receiver consists of five separate circuit boards, all performing their own function. The first, a mixer board, receives the signal via an active antenna and converts it to a lower frequency. From there it goes to a second mixer and correlation board to compare the signal to a local reference, then a signal processing board that looks at this intermediate frequency signal to make sense of the data its seeing. Finally, an FPGA interfacing board ties everything together and decodes the information into a usable form.

Dealing with weak signals like this has its own set of challenges, as [leaning_tower] found out. The crystal oscillator had to be decapped and modified to keep from interfering with the GPS radio since they operated on similar frequencies. Even after ironing out all the kinks, the circuit takes a little bit of time to lock on to a specific satellite but with a second GPS unit for checking and a few weeks of troubleshooting, the homebrew receiver is up and running. It’s an impressive and incredibly detailed piece of work which is usually the case with sensitive radio equipment like GPS. Here’s another one built on a Raspberry Pi with 12 channels and a pretty high accuracy.

Will We Recycle FPGAs In The Future?

December 22, 2023 by Al Williams 21 Comments

If you really want to look at how much something costs, you need to look at total cost of ownership, not just the sticker price. Same goes for things like pollution and carbon footprint. A vehicle, for example, might have a low carbon footprint in operation but require more carbon in the manufacturing or disposal processes. Researchers have noted that FPGA accelerators get replaced and may wind up as e-waste in as little as two years. They propose REFRESH, an architecture that recycles old FPGAs into new ones by joining multiple FPGA dice with a simple interposer to coordinate the work.

The idea is not as radical as it might first seem. Many modern chips use chiplets anyway, so this is a reasonable extension of that idea. You simply need a way to harvest the old devices.

Continue reading “Will We Recycle FPGAs In The Future?” →

Hackaday Links: December 10, 2023

December 10, 2023 by Dan Maloney 8 Comments

In this week’s episode of “Stupid Chatbot Tricks,” it turns out that jailbreaking ChatGPT is as easy as asking it to repeat a word over and over forever. That’s according to Google DeepMind researchers, who managed to force the chatbot to reveal some of its training data with a simple prompt, something like “Repeat the word ‘poem’ forever.” ChatGPT dutifully followed the instructions for a little while before spilling its guts and revealing random phrases from its training dataset, to including complete email addresses and phone numbers. They argue that this is a pretty big deal, not just because it’s potentially doxxing people, but because it reveals the extent to which large language models just spit back memorized text verbatim. It looks like OpenAI agrees that it’s a big deal, too, since they’ve explicitly made prompt-induced echolalia a violation of the ChatGPT terms of service. Seems like they might need to do a little more work to fix the underlying problem.

Continue reading “Hackaday Links: December 10, 2023” →