Rolling Your Own Long-Range IoT Sensor Network

November 11, 2021 by 7 Comments

Homebrew wireless sensors are nothing new around these parts: grab an ESP8266, hang a BME280 from the I2C pins, and you’re just a few lines of code away from joining the Internet of Things on your own terms. Builds like this are so cheap and easy that they make an excellent first project for folks looking to get into the electronics game, but what if you’re looking for something a bit more bespoke?

In that case, you could follow in the footsteps of [Discreet Mayor] and put together a custom modular architecture for long-range wireless sensors. The core of the system is a breakout board for the Texas Instruments SimpleLink CC1312 wireless MCU which features a simple 2×11 header connector. This allows the module to either be plugged into a larger board or have a small sensor PCB attached directly to it.

Rather than using WiFi or requiring some existing radio infrastructure, the boards automatically create a private network using the IEEE 802.15.4 standard at a range of up to 600 meters. A dedicated receiver isn’t necessary, to pull data off the network, one of the CC1312 boards simply gets connected to a computer through a simple FT232 adapter.

[Discreet Mayor] has already created a number of projects that use these custom radios for communication, from a pool monitoring system to a temperature sensor for the BBQ. That portable battery operated devices are able to use this common communications backbone just as well as mains powered static devices is a testament to the work that went into the firmware to make it as robust and efficient as possible.

Like the idea of long-range private networks, but less enthusiastic about having to come up with your own hardware? Not to worry. Over the summer, Espressif announced that they’re working on an ESP32 variant that includes support for IEEE 802.15.4. Just as soon as this chip shortage is over, we might even get to see the thing.

Quantum computer

Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle

November 11, 2021 by 25 Comments

Quantum computers are really in their infancy. If you created a few logic gates with tubes back in the 1930s, it would be difficult to predict all the ways we would use computers today. However, you could probably guess where at least some of the problems would lie in the future. One of the things we are pretty sure will limit quantum computer development is error correction.

As far as we know, every quantum qubit we’ve come up with so far is very fragile and prone to random errors. That’s why every practical design today incorporates some sort of QEC — quantum error correction. Of course, error correction isn’t news. We use it all the time on unreliable storage media or communication channels and high-reliability memory. The problem is, you can’t directly clone a qubit (a quantum bit), so it is hard to use traditional error correction techniques with qubits.

After all, the whole point to a qubit is we don’t measure it until the end of the computation which, like Schrödinger’s cat, seals its fate. So if you were to “read” a bunch of qubits to form a checksum or a CRC, you’d destroy their quantum nature in the process making your computer not very useful. You can’t even copy a bit to use something like triple redundancy, either. There seems to be no way to practically duplicate a qubit.

Continue reading “Scientific Honesty And Quantum Computing’s Latest Theoretical Hurdle” →

Trying And (Mostly) Failing To 3D Print A Hydrofoil

November 11, 2021 by 5 Comments

[Sam Barker] had a boring dingy that he wanted to spice up a bit, so he resolved to 3D print a hydrofoil wing for it so that it could fly across the water. (Video, embedded below.)

With a large wing designed and sliced into several pieces, and a total print time of 200 hours, [Sam] was ready to glue the foil wing together when he realized his scale was way off and the wings were far too large for his boat. With some hacking, [Sam] was able to use a single wing across the bottom of the ship. [Tom Stanton] came over to help with fiberglassing, and they were ready for a test.

As you might have guessed from the title, the test wasn’t particularly successful. Swapping the engine on the boat for a more potent motor gave the lift he needed in the front, but without a back foil, it was a wheelie rather than what [Sam] hoped for. Back at home, they printed a second wing and went back for a second test. The boat would start to lift out the water, but the shaft of the engine lifted out of the water, sending him back down. Unfortunately, a downpour cut the test short.

Not to be defeated entirely, [Sam] connected it to a much larger boat once the weather cleared and pulled his dingy along behind. To [Sam’s] credit, they did get some solid foiling, and the ship did lift out of the water until the wings sheared off from the stress. All in all, an entertaining story of engineering while racing against the weather.

We admire [Sam’s] ambition, and if you’re thinking about building a whole hydrofoil, we suggest starting with a smaller RC model and scaling up from there.

The Game Of Life Moves Pretty Fast, If You Don’t Use Stop Motion You Might Miss It

November 11, 2021 by 12 Comments

Munged Ferris Bueller quotes aside, Conway’s Game of Life is the classic cellular automata that we all reach for. The usual approach is to just iterate over every cell in the grid, computing the next state into a new grid buffer. [K155LA3] set out to turn that on its head by implementing Game Of Life in the hardware of an FPGA.

[K155LA3]’s version uses Chisel, a new HDL from the Berkley and RISCV communities. Under the hood, Chisel is Scala with some custom libraries that know how to map Scala concepts onto hardware. In broad strokes, Verilog and VHDL are focused on expressing hardware and then added abstraction on top of that over the year. Chisel and other newer HDL languages focus on expressing high-level general-purpose elements that get mapped onto hardware. FPGAs already map complex circuits and hardware onto LUTs and other slices, so what’s another layer of abstraction?

The FPGA chosen for this project is a Digilent Arty A7 with a VGA Pmod to turn the RGB444 into analog signals to actually display. What’s impressive about [K155LA3]’s implementation is just how fast it is. Even running at 60 frames per second it’s almost as fast as the monitor can handle. Of course, most computers lying around you could simulate a 60 x4 8 grid at 60 fps. Next, instead of connecting the grid logic to the 60 Hz VGA clock, he connects it to the 100 MHz board external oscillator. Now each pixel in each frame displayed contains over a million generations.

Unfortunately, even this small grid of 60×48 takes up 90% of the LUTs on the Artix-7. In the future, we’d love to see an even larger FPGA hardware implementation capable of handling grids that could hold whole computers in them. And naturally, this isn’t the first FPGA version of the Game Of Life here at Hackaday.

8″ Floppy On Your PC?

November 10, 2021 by 52 Comments

We should probably have a new metric for measuring mass storage performance: bytes per pound. An old IBM tape drive from the S/360 days, for example, could hold almost 6 megabytes of data. It also weighed more than a typical refrigerator. Today, a tiny postage-stamp-sized card can hold gigabytes of data and weighs — at most — a few ounces. Somewhere in the middle is the old 8 inch floppy drive. At its peak, you could cram about 1.2 megabytes on it, but even with the drive you could lift it all in one hand. These disks and their descendants ruled the computing world for a while. [Adrian asks the question: can you use an 8″ floppy drive on a PC? The answer is in the video below.

He didn’t do it on a lark. [Adrian] is getting ready to restore a TRS-80 Model II so he wanted to create some 8″test floppies. But how do you marry a 40-something-year-old drive to a modern computer? He had a few drives of unknown condition so there was nothing to do but try to get them working.

Continue reading “8″ Floppy On Your PC?” →

Linux On The Windows 11 Desktop

November 10, 2021 by 38 Comments

A month ago Microsoft officially released Windows 11. One of its features is the ability to run Linux GUI applications side by side as peers to normal Windows desktop apps. [Jim Salter] of Ars Technica took a closer look and declared it works as advertised.

This is an evolution of the Windows Subsystem for Linux (WSL), which has existed for a few years but only in command-line form. Linux being Linux, it was certainly possible to put visuals onscreen, but doing so required jumping through some hoops and dealing with limitations. Now “WSLg” gives a smoother and more accessible experience.

While tremendously valuable for those who need it, WSLg is admittedly a niche feature. The circumstances will be different for different needs. Around these parts, one example is letting us work with pieces of proprietary Windows software (such as low level hardware drivers or hardware-specific dev tools) while still retaining Linux tools for the rest of our workflow.

It’s also interesting to take a peek behind the scenes for an instructive look at bridging two operating systems. A Microsoft blog post describes the general architecture, where we were happy to see open-source work leveraged. And by basing this work on Wayland, it is more forward-looking than working with just X11.

The bad news is that WSLg is limited to Windows 11, at least for now. WSL users on Windows 10 will have to continue jumping through hoops (We described one method using X11.) And opening this door unfortunately also opened the door to security issues, so there’s still work ahead for WSL.

Arduino Piano Tuner Is Pitch Perfect

November 10, 2021 by 16 Comments

[JanHerman] knows that tuning musical instruments is all about precision and that precision is measured in a logarithmic unit called a cent. A cheap tuner unit might be accurate to 1.5 cents which sounds good until you look at one for ten times the price and find it is accurate to 0.1 cents. So you can spend $800 for precision or $60 for something less. [Jan] decided to build something better and cheaper using a 32-bit Arduino and a DDS frequency generator chip on a breakout board.

Oddly enough, the device doesn’t have a display. Instead, it generates a precise frequency and couples it to the piano using a transducer. You tune the string to the corresponding note. The post has a lot of detail about how piano tuning works.

Continue reading “Arduino Piano Tuner Is Pitch Perfect” →