Bandwidth is one of those technical terms that has been overloaded in popular speech: as an example, an editor might ask if you have the bandwidth to write a Hackaday piece about bandwidth. Besides this colloquial usage, there are several very specific meanings in an engineering context. We might speak about the bandwidth of a signal like the human voice, or of a system like a filter or an oscilloscope — or, we might consider the bandwidth of our internet connection. But, while the latter example might seem fundamentally different from the others, there’s actually a very deep and interesting connection that we’ll uncover before we’re done.
Let’s have a look at what we mean by the term bandwidth in various contexts.
Continue reading “Say It With Me: Bandwidth”
We featured [Fabrizio Di Vittorio]’s FabGL library for the ESP32 back in April of this year. This library allows VGA output using a simple resistor based DAC (3 resistors for 8 colors; 6 resistors for 64 colors), and includes functions for PS/2 mouse and keyboard input, a graphics library, and many of the miscellaneous functions you might need to develop games on the ESP32. Now, a GUI interface library has been added to ease application development.
The GUI, of course, runs on the VGA output. The library includes what you’d expect from a minimal windowing GUI, like keyboard and mouse support, windows with the usual minimize/maximize/close controls, and modal and message dialog boxes. For input controls, there are labels, text boxes, buttons, radio buttons, checkboxes, normal and editable combo boxes, and listboxes — you know, pretty much everything you need to develop a modern GUI application. All the code is open-source (GPL 3.0) and in the GitHub repo.
While the original FabGL had a game-development orientation, the addition of this new GUI functionality opens up a new range of applications. If you want to find out more about using the FabGL library, you can check out our previous coverage of the mostly game-oriented functions.
You can get a look at the new GUI functions in action in the video, after the break.
Continue reading “ESP32 Gets Advance Windowed Apps Using This VGA GUI Library”
From time to time, we see electronics projects for model rocket instrumentation. Those who have been involved in the hobby for many years may remember when 8-bit microcontrollers like the PIC16F84 were the kind of hardware you might fly on a mission. These days, however, there’s little reason not to send a high-powered processor. This is exactly what [Mohamed Elhariry] has done with his PiX project, which turns a Raspberry Pi Zero W into a neat little flight data recorder.
The hardware has what you might expect from a flight recorder, including accelerometer, gyroscope, and pressure sensor. In addition, it carries temperature and humidity sensors, and of course, a camera. A 64 GB microSD card provides the storage, while a LiPo SHIM board allows the whole thing to run from a 150 mAh battery. All of the components are off-the-shelf breakouts, which makes assembly as easy as soldering a few connections and securing the modules with a little tape.
The project is in GitHub, including python code, schematics for the hardware, and detailed instructions. If you ever wanted to get started with instrumenting a model rocket, this looks like a great resource. Also in the repo is a captured video from an actual flight [34 MB GIF] if you just want to see the view from one launch.
Using commercial modules seems pretty convenient, but if custom hardware is more your thing, check out these 22 mm round PCBs designed to fit inside rockets.
Cyclic redundancy codes (CRC) are a type of checksum commonly used to detect errors in data transmission. For instance, every Ethernet packet that brought you the web page you’re reading now carried with it a frame check sequence that was calculated using a CRC algorithm. Any corrupted packets that failed the check were discarded, and the missing data was detected and re-sent by higher-level protocols. While Ethernet uses a particularly common CRC, there are many, many different possibilities. When you’re reverse-engineering a protocol that contains a CRC, although it’s not intended as a security mechanism, it can throw a wrench in your plans. Luckily, if you know the right tool, you can figure it out from just a few sample messages.
A case in point was discussed recently on the hackaday.io Hack Chat, where [Thomas Flayols] came for help reverse engineering the protocol for some RFID tags used for race timing. Let’s have a look at the CRC, how it is commonly used, and how you can reverse-engineer a protocol that includes one, using [Thomas’] application as an example.
Continue reading “Reverse Engineering Cyclic Redundancy Codes”
The problem is well-known: programming and debug headers consume valuable board space and the connectors cost money. Especially troublesome are the ubiquitous 100-mil pin headers, not because they’re expensive, but because they’re huge, especially along the z-axis. If you’re building miniature devices, these things can take up a ridiculous amount of space. With some clever thinking, [Simon Merrett] has found a way to re-use something many of us already have — an SOIC-8 test clip — to connect to a special footprint on the PCB without requiring another connector. He calls the system SOICbite.
The SOIC clip attaches to a footprint consisting of eight pads, four on each side of the PCB, plus five non-plated-through holes, which serve to anchor the clip in place. The idea of mating a PCB footprint directly with a removable connector isn’t entirely new — Tag Connect has been doing this for a while, but the connectors are expensive and single-sourced. On the other hand, SOIC test clips of varying quality are available from a number of vendors, including dirt-cheap deals on your favorite websites. The one disadvantage we can see is that the SOICbite footprint must be at the edge of the PCB to properly mate with the clip. The savings in space and cost may well make up for this, however.
[Simon] has made his KiCAD footprint available in a GitHub repo, and has offered to host footprints for any other CAD package there as well. So, fire up your preferred tool and draw one up for him to get these things widely adopted, because we think this is a great idea.
For the commercial alternative, check out our coverage of Tag Connect back in 2014.
For those of us who remember LED calculators, the HP 5082-7400 series red “bubble” displays hold a special charm. Available in 3, 4, or 5-digit varieties, these multiplexed 7-segment displays provided countless hours of entertainment to those who would spell upside-down words on their pocket calculators. In case you happen to be lucky enough to have access to a few of these beautiful vintage display sticks, [Gigawipf] has designed a small driver PCB that lets you easily interface them to a modern microcontroller.
At the heart of the board, aimed at either the 5082-7405 or 5082-7415 5-digit modules, are a pair of 74HC595 shift registers in tiny QFN packages. Five lines from one register drive one of the common cathodes for the selected digit, while the other register drives the eight anode lines through 330-Ohm resistors. The boards are slightly smaller than the width of the displays allowing you to stack them seamlessly for more digits, and eight header pins on each allow you to plug them into solderless breadboards for prototyping. The result is easy to drive with some simple code, and [Gigawipf] provides an example for Arduino as part of the project. The Eagle design files are supplied, as well as Gerbers for those who just want to have some boards made. This sounds like a great way to get some of these vintage displays going again.
If you can’t find any of these displays to play, with, you can try making some larger digits from individual surface-mount LEDs.
When your thermostat comes with Linux running on it, that’s not a hack. When it doesn’t, and you get Linux on there yourself, it most definitely is. This is exactly what [cz7asm] has done. In a recent video, he shows the Honeywell thermostat booting Linux and running a wide range of software.
While the hardware inside the thermostat doesn’t afford all the luxuries of a typical modern embedded Linux, it’s got enough room for the basics. The system runs from a 1 MB rootfs in RAM, and has a 2.5 MB kernel image, leaving a spare 12 MB for everything else. With just these meager resources, [cz7asm] shows how the system can use a USB network adapter, connecting to telehack.com for some command-line retro fun, and host a web server, although no browser runs yet. There’s also framebuffer support for displaying graphics and animations, and the usual Linux terminal goodness.
All we’ve seen so far is the video, so we hope [cz7asm] posts the code somewhere, because we’re tired of using our thermostat just to run the AC.
You might remember [cz7asm] from his previous thermostatic triumph: running Doom. Check out the video of the latest thermostat adventure after the break.
Thanks to [Piecutter] for the tip!
Continue reading “Running Linux On A Thermostat”