An FPGA And A Few Components Can Make A Radio

April 18, 2020 by 18 Comments

There was a time when making a radio receiver involved significant work, much winding of coils, and tricky alignment of circuitry. The advent of Software Defined Radio (SDR) has moved a lot of this into the domain of software, but there is of course another field in which a radio can be created via code. [Alberto Garlassi] has created a radio receiver for the AM and HF bands with a Lattice MachXO2 FPGA and minimal external components.

He describes it as an SDR, which given that it’s created from Verilog, is a term that could be applied to it. But instead of using an SDR topology of ADC and digital signal processing, it implements a surprisingly traditional direct conversion receiver.

It has a quadrature AM demodulator which has a passing similarity to an SDR with I and Q phased signals, but that’s where the similarity ends. Frequency selection is via an oscillator controlled from a serial port, and there is even a PWM amplifier on board that can drive a speaker. The result can be seen in the video below, and as you can hear the direct conversion with quadrature demodulator approach makes for a very effective AM receiver.

If this is a little much but you still fancy a radio with minimal components, you should have a look at the Silicon Labs range of receiver chips.

Continue reading “An FPGA And A Few Components Can Make A Radio” →

Stinger: The Hacked Machine Gun Of Iwo Jima

February 3, 2020 by 55 Comments

During the Second World War, the United States was pumping out weapons, aircraft, and tanks at an absolutely astonishing rate. The production of military vehicles and equipment was industrialized like never before, and with luck, never will be again. But even still, soldiers overseas would occasionally find themselves in unique situations that required hardware that the factories back at home couldn’t provide them with.

A Stinger machine gun in WWII

Which is precisely how a few United States Marines designed and built the “Stinger” light machine gun (LMG) during the lead-up to the invasion of Iwo Jima in 1945. The Stinger was a Browning .30 caliber AN/M2, salvaged from a crashed or otherwise inoperable aircraft, that was modified for use by infantry. It was somewhat ungainly, and as it was designed to be cooled by the air flowing past it while in flight, had a tendency to overheat quickly. But even with those shortcomings it was an absolutely devastating weapon; with a rate of fire at least twice that of the standard Browning machine guns the Marines had access to at the time.

Six Stingers were produced, and at least on a Battalion level, were officially approved for use in combat. After seeing how successful the weapon was during the invasion of Iwo Jima, there was even some talk of putting the Stinger into larger scale production and distributing them. But the war ended before such a plan could be put into place.

As such, the Stinger is an exceedingly rare example of a field modified weapon that was not only produced in significant numbers, but officially recognized and even considered for adoption by the military. But the story of this hacked machine gun actually started years earlier and thousands of kilometers away, as Allied forces battled for control of the Solomon Islands.

Continue reading “Stinger: The Hacked Machine Gun Of Iwo Jima” →

New Part Day: LED Driver Is FPGA Dev Board In Disguise

January 24, 2020 by 51 Comments

Our new part of the day is the ColorLight 5A-75B, a board that’s meant to drive eight of those ubiquitous high-density color LED panels over gigabit Ethernet. If you were building a commercial LED wall, you’d screw a bunch of the LED panels together, daisy-chain a bunch of these boards to drive them, supply power, and you’d be done. Because of that high-volume application, these boards are inexpensive, around $15 each, and available as quickly as you can get stuff shipped from China.

But we’re not here to talk commercial applications. Managing fast Ethernet and pushing so many pixels in real time is a task best handled by an FPGA, and [Tom Verbeure] noticed that these things were essentially amazing FPGA development boards and started hacking on them. [q3k] put it up on GitHub, and you can follow along with the chubby75 reverse engineering project to dig into their secrets.

While the first generations of these boards used the old-standby Spartan 6, things got interesting for fans of open FPGA tools when newer versions were found using the Lattice ECP5-25 chips, the little brother of the stonking big chip [Sprite_TM] used on the 2019 Hackaday Supercon badge. If you want to grab one you’re looking for ColorLight boards marked with revision 6 or 7 as of this writing.

What does this mean? For the price of a gourmet hamburger, you get an FPGA that’s big enough to run a RISC-V softcore, two 166 MHz, 2 MB SDRAMS, flash for the FPGA bitstream, a bazillion digital outputs on 5 V level shifters, and two gigabit Ethernet ports. The JTAG port is broken out in 0.1″ headers, and it works with OpenOCD, which is ridiculously convenient. How’s that for a well-stocked budget FPGA dev board that’s served by a completely open toolchain? Continue reading “New Part Day: LED Driver Is FPGA Dev Board In Disguise” →

Vintage Slide Viewers Make Beautiful Retro Emulators

April 21, 2019 by 6 Comments

35mm still photography is still hanging on out in the wild, with its hardcore fans ensuring it never quite dies out despite the onward march of digital imaging. Slides are an even more obsolete technology, forgotten long ago when the quality of color negative films improved. The related paraphernalia from the era of the photographic slide continues to clutter up attics and garages the world over. [Martin Burlus] was in possession of some retro slide viewers, and found they made an excellent basis for a RetroPie build.

The build relies on stock standard fundamentals – a Pi Zero runs the show, combined with a USB hub and a power supply. [Martin] then chose to build this all inside the case of the slide viewer, combined with a 2.8″ PiTFT display. This neatly slots directly on to the Pi Zero’s 40-pin header, and comes complete with a touch screen. It’s the perfect size to slide into most slide viewers, though some models required removal of the tact buttons.

The slide viewers make for a charming enclosure, and the classic 1970s optics make for pleasant viewing. Throwing a modern display behind a vintage lens is a great way to give a project a more classic look and feel. One thing’s for sure – we’ll be keeping an eye out for a slide viewer of our own next time we’re passing through the local junk shops.

3D Print Springs With Hacked GCode

November 14, 2018 by 36 Comments

If you’ve used a desktop 3D printer in the past, you’re almost certainly done battle with “strings”. These are the wispy bits of filament that harden in the air, usually as the printer’s nozzle moves quickly between points in open air. Depending on the severity and the material you’re printing with, these stringy interlopers can range from being an unsightly annoyance to triggering a heartbreaking failed print. But where most see an annoying reality of pushing melted plastic around, [Adam Kumpf] of Makefast Workshop sees inspiration.

Noticing that the nozzle of their printer left strings behind, [Adam] wondered if it would be possible to induce these mid-air printing artifacts on demand. Even better, would it be possible to tame them into producing a useful object? As it turns out it is, and now we’ve got the web-based tool to prove it.

As [Adam] explains, you can’t just load up a 3D model of a spring in your normal slicer and expect your printer to churn out a useful object. The software will, as it’s designed to do, recognize the object can’t be printed without extensive support material. Now you could in theory go ahead and print such a spring, but good luck getting the support material out.

The trick is to throw away the traditional slicer entirely, as the layer-by-layer approach simply won’t work here. By manually creating GCode using carefully tuned parameters, [Adam] found it was possible to get the printer to extrude plastic at the precise rate at which the part cooling fan would instantly solidify it. Then it was just a matter of taking that concept and applying it to a slow spiral motion. The end result are functional, albeit not very strong, helical compression springs.

But you don’t have to take their word for it. This research has lead to the creation of an online tool that allows you to plug in the variables for your desired spring (pitch, radius, revolutions, etc), as well as details about your printer such as nozzle diameter and temperature. The result is a custom GCode that (hopefully) will produce the desired spring when loaded up on your printer. We’d love to hear if any readers manage to replicate the effect on their own printers, but we should mention fiddling with your printer’s GCode directly isn’t without its risks: from skipping steps to stripped filament to head crashes.

The results remind us somewhat of the 3D lattice printer we featured a couple of years back, but even that machine didn’t use standard FDM technology. It will be interesting to see what other applications could be found for this particular technique.

Continue reading “3D Print Springs With Hacked GCode” →

Living Hinges At The Next Level

November 4, 2018 by 13 Comments

First of all, a living hinge is not a biological entity nor does it move on its own. Think of the top of a Tic Tac container where the lid and the cover are a single piece, and the thin plastic holding them together flexes to allow you to reach the candies disguised as mints. [Xiaoyu “Rayne” Zheng] at Virginia Tech designed a method of multimaterial programmable additive manufacturing which is fancy-ese for printing with more than one type of material.

The process works under the premise of printing a 3D latticework, similar to the “FILL” function of a consumer printer. Each segment of material is determined by the software and mixed on the spot by the printer and cured before moving onto the next segment. Like building a bridge one beam at a time, if that bridge were meant for tardigrades and many beams were fabricated each minute. Mixing up each segment as needed means that a different recipe results in a different rigidity, so it is possible to make a robotic leg with stiff “bones” and flexible “joints.”

We love printing in different materials, even if it is only one medium at a time. Printing in metal is useful and could be consumer level soon, but you can print in chocolate right now.

Via Phys.org. Thank you again for the tip, [Qes].

Icestorm Tools Roundup: Open Source FPGA Dev Guide

October 3, 2018 by 7 Comments

We like the ICE40 FPGA from Lattice for two reasons: there are cheap development boards like the Icestick available for it and there are open source tools. We’ve based several tutorials on the Icestorm toolchain and it works quite well. However, the open source tools don’t always expose everything that you see from commercial tools. You sometimes have to dig a little to find the right tool or option.

Sometimes that’s a good thing. I don’t need to learn yet another fancy IDE and we have plenty of good simulation tools, so why reinvent the wheel? However, if you are only using the basic workflow of Yosys, Arachne-pnr, icepack, and iceprog, you could be missing out on some of the most interesting features. Let’s take a deeper look.

Continue reading “Icestorm Tools Roundup: Open Source FPGA Dev Guide” →