The 433 MHz spectrum is a little bit of an oddball. It’s one of the few areas of the radio spectrum which is nearly universally unlicensed, meaning as long as devices using it adhere to the power restrictions and other guidelines about best practices, it’s essentially an open playground. IoT devices operate here, as well as security systems and, of course, remote controls. And, using a few off-the-shelf parts [hesam.moshiri] shows us how to take advantage of this piece of spectrum by designing and building a programmable and versatile 4-channel 433 MHz remote control.

Built around an ATmega8 microcontroller, making it easy to work with Arduino sketches, and with a 2×8 character LCD for ease-of-use when not connected to a computer, the wireless switching device can store up to 80 remote control codes in its EEPROM memory. This was one of the harder parts for [hesam] to sort out, but using structures to store the data for the codes eventually solved the problems. A simple GUI makes using it with whatever remote happens to be on hand fairly straightforward, including the ability to record codes from existing remotes on the fly and also to associate those codes with specific actions.

Schematics and a bill of materials are available on the project’s page, making this fairly accessible to those looking to add some wireless connectivity to a project, home automation system, or IoT device. It’s mainly set up as a switching device, but with some modifications could be put to work doing more complex tasks. The 433 MHz spectrum is an exciting place to be, too, and things like setting up entire security systems using it are not too far removed from a switching device like this.

For as popular as the Arduino platform is, it’s not without its problems. Among those is the fact that most practical debugging is often done by placing various print statements throughout the code and watching for them in the serial monitor. There’s not really a great way of placing breakpoints or stepping through code, either. But this project, known as eye2see, hopes to change that by using the i2c bus found in most Arduinos to provide a more robust set of debugging tools.

The eye2see software is set up to run on an Arduino or other compatible microcontroller, called the “probe”, which is connected to the i2c bus on another Arduino whose code needs to be debugged. Code running on this Arduino, which is part of the eye2see library, allows it to send debugging information to the eye2see probe. With a screen, the probe can act as a much more powerful debugger than would otherwise typically be available, being able to keep track of variables in the main program, setting up breakpoints, and outputting various messages on its screen.

The tool is not without its downsides, though. The library that needs to run on the host Arduino slows down the original program significantly. But for more complex programs, the tradeoff with powerful debugging tools may be worth it until these pieces of code can be removed and the program allowed to run unencumbered. If you’d like to skip needing to use a second Arduino, we’ve seen some other tools available for debugging Arduino code that can run straight from a connected PC instead.

[Nick] does a lot of custom work with vacuum tubes. So much so that he builds his own vacuum tubes of various shapes, sizes, and functions right on his own workbench. While the theory of vacuum tubes is pretty straightforward, at least to those of us who haven’t only been exposed to semiconductors, producing them requires some specialized equipment. A simple vacuum won’t get you all the way there, and the complexity of the setup that’s needed certainly calls for some automation.

The vacuum system that [Nick] uses involves three sections separated by high-vacuum valves in order to achieve the pressures required for vacuum tube construction. There’s a rough vacuum section driven by one pump, a high vacuum section driven by a second pump, and a third section called the evac port where the tube is connected. Each second must be prepared properly before the next section can be engaged or disengaged. An Arduino Pro is tasked with all of this, chosen for its large amount of ADC inputs for the instrumentation monitoring the pressures in each section, as well as the digital I/O to control the valves and switches on the system.

The control system is built into a 19-inch equipment rack with custom faceplates which outline the operation of the vacuum system. A set of addressable LEDs provide the status of the various parts of the system, and mechanical keyboard switches are used to control everything, including one which functions as an emergency stop. The automation provided by the Arduino reduces the chances for any mistakes to be caused by human error, allows the human operator to focus on other tasks like forming the glass, and can also react much faster to any potentially damaging situations such as the high-pressure pump being exposed to atmospheric pressure.

[Nick] might look a little familiar to some of us as well. If you can’t quite place him, he did a talk at Hackaday Supercon 2022 detailing all of the intricacies of building one’s own vacuum tubes. Since getting into the somewhat niche field of constructing vacuum tubes, he’s gone on to produce all kinds of specialty devices and his YouTube channel is definitely worth a watch.

Thanks to [M] for the tip!

You’ve got to love the aesthetics of dystopian cyberpunk video games, where all the technology looks like it’s cobbled together from cast-off bits of the old world’s remains. Kudos go to those who attempt to recreate these virtual props and bring them into the real world, but our highest praise goes to those who not only make a game-realistic version of a prop, but make it actually work.

Take the Nokota Manufacturing radio from Cyberpunk 2077, for instance. [Taylor] took one look at that and knew it would be the perfect vessel for a Baofeng UV-5R, the dual-band transceiver that amateur radio operators love to hate. The idea is to strip the PCB out of a Baofeng — no worries, the things cost like $25 — and install it in a game-accurate 3D printed case. But this is far from just a case mod, since [Taylor]’s goal is to replace the radio’s original controls with something closer to what’s in the game.

To that end, [Taylor] is spinning up an interface to the stock radio’s keypad using some 7400-series bilateral analog switches. Hooked to the keypad contacts and controlled by a Mini MEGA 2560 microcontroller, the interface is able to send macros that imitate the keypresses necessary to change frequencies and control the radio’s settings, plus display the results on the yellow OLED screen that seems a dead-ringer for the in-game display. The video below shows some early testing of the interface.

While very much still a work in progress, we’ve been following [Taylor]’s project for a week or so and he’s really gaining some ground. We’ve encouraged him to enter this one in the Cyberdeck Challenge we’ve got going on now; it might not have much “deck” going for it, but it sure does have a lot of “cyber.”

The magnetic compass has been a crucial navigational tool for around a thousand years or so, perhaps longer. While classical versions still work perfectly well, you can now get digital magnetometers that work in much the same way. [mircemk] decided to whip up a digital compass to demonstrate the value of these parts.

The build uses a HMC5883L magnetometer. While this can detect magnetic fields in three axes, just one is necessary for building a device that operates akin to a traditional compass. The output of the device is read by an Arduino Nano, which is hooked up to a string of WS2812B LEDs and a small OLED display. The LEDs display the bearing of magnetic north, while the OLED screen shows the current angle between the compass’s arrow and magnetic north.

It’s a tidy build that would be a great educational resource for teaching both electronics and navigational skills. We’ve seen similar projects before, like the hilarious Pizza Compass. Video after the break.

It’s a pretty sure bet that anyone who survived high school biology has heard about the Miller-Urey experiment that supported the hypothesis that the chemistry of life could arise from Earth’s primordial atmosphere. It was literally “lightning in a bottle,” with a mix of gases like methane, ammonia, hydrogen, and water in a closed-loop glass apparatus and a pair of electrodes to provide a spark to simulate lightning lancing across the early prebiotic sky. [Miller] and [Urey] showed that amino acids, the building blocks of protein, could be cooked up under conditions that existed before life began.

Fast forward 70 years, and Miller-Urey is still relevant, perhaps more so as we’ve extended our reach into space and found places with conditions similar to those on early Earth. This modified version of Miller-Urey is a citizen science effort to update the classic experiment to keep up with those observations, plus perhaps just enjoy the fact that it’s possible to whip up the chemistry of life from practically nothing, right in your own garage.

[Markus Bindhammer]’s setup is similar to [Miller] and [Urey]’s in a lot of ways, but differs mainly by using plasma as the energy input, rather than a simple electrical discharge. [Markus] doesn’t expand on his reasoning for using plasma other than the practical consideration of it being hot enough to oxidize nitrogen inside the apparatus, providing the anoxic environment needed. The plasma discharge is controlled by a microcontroller and MOSFETs, to keep the electrodes from melting. Also, rather than methane and ammonia, the raw ingredient here is a formic acid solution, because the spectroscopic signature of formic acid has been detected in space, and because it has interesting chemistry that can potentially lead to the production of amino acids.

Unfortunately, while the apparatus and experimental procedure are fairly simple, quantifying the results requires some specialized equipment. [Markus] will be sending his samples off for analysis, so we don’t yet know what the experiment will show. But we love the setup here, which just goes to show that even the greatest experiments are worth repeating, because you never know what you’re going to find.

The “save” icon for plenty of modern computer programs, including Microsoft Office, still looks like a floppy disk, despite the fact that these have been effectively obsolete for well over a decade. As fewer and fewer people recognize what this icon represents, a challenge is growing for retrocomputing enthusiasts that rely on floppy disk technology to load any programs into their machines. For some older computers that often didn’t have hard disk drives at all, like the Commodore 64, it’s one of the few ways to load programs into computer memory. And, rather than maintaining an enormous collection of floppy discs, [RaspberryPioneer] built a way to load programs on a Commodore using Microsoft Excel instead.

The Excel sheet that manages this task uses Visual Basic for Applications (VBA), an event-driven programming language built into Office, to handle the library of applications for the Commodore (or Commodore-compatible clone) including D64, PRG, and T64 files. This also includes details about the software including original cover art and any notes the user needs to make about them. Using VBA, it also communicates to an attached Arduino, which is itself programmed to act as a disk drive for the Commodore. The neceessary configuration needed to interface with the Arduino is handled within the spreadsheet as well. Some additional hardware is needed to interface the Arduino to the Commodore’s communications port but as long as the Arduino is a 5V version and not a 3.3V one, this is fairly straightforward and the code for it can be found on its GitHub project page.

With all of that built right into Excel, and with an Arduino acting as the hard drive, this is one of the easiest ways we’ve seen to manage a large software library for a retrocomputer like the Commodore 64. Of course, emulating disk drives for older machines is not uncommon, but we like that this one can be much more dynamic and simplifies the transfer of files from a modern computer to a functionally obsolete one. One of the things we like about builds like this, or this custom Game Boy cartridge, is how easy it can be to get huge amounts of storage that the original users of these machines could have only dreamed of in their time.

There’s much truth in the advice that, to truly understand something, you need to build it yourself from the ground up. That’s the idea behind [Christian]’s entry for the Re-engineering Education category of the 2023 Hackaday Prize. Built as an educational demonstrator, this is a complete arithmetic-logic unit (ALU) using discrete relays — and not high-density types either — these are the big honking clear-cased kind.

The design is neatly, intentionally, partitioned along functional lines, with four custom PCB designs, each board operating on 4-bits. To handle a byte-length word, boards are simply cascaded, making a total of eight. The register, adder, logic function, and multiplex boards are the heart of the build with an additional two custom boards for visualization (using an Arduino for convenience) and IO forming the interface. After all, a basic CPU is just an ALU and some control around it, the magic is really in the ALU.

The fundamental logical operations operating upon two operands, {A, B} are A, ~A, B, ~B, A or B, A and B, A xor B, can be computed from just four relays per bit. The logic outputs do need to be fed into a 7-to-1 bit selector before being fed to the output register, but that’s the job of a separate board. The adder function is the most basic, simply a pair of half-adders and an OR-gate to handle the chaining of the carry inputs and generate the carry chain output.

3D printed cable runs are a nice touch and make for a slick wiring job to tie it all together.

For a more complete relay-based CPU, you could check out the MERCIA relay computer project, not to mention this wonderfully polished build.

The HackadayPrize 2023 is Sponsored by:

You might think that making your own electronic games would require some kind of LCD, but lately, [Mirko Pavleski] has been making his using inexpensive 8X8 WS2812B LED panels. This lets even a modest microcontroller easily control a 64-pixel “screen.” In this case, [Mirko] uses an Arduino Nano, 3 switches, and a buzzer along with some 3D printed components to make a good-looking game. You can see it in action in the video below.

The WS2812B panels are easy to use since the devices have a simple protocol where you only talk to the first LED. You send pulses to determine each LED’s color. The first LED changes color and then starts repeating what you send to the next LED, which, of course, does the same thing. When you pause a bit, the array decides you are done, and the next train of pulses will start back at the first LED.

It looks like the project is based on a German project from [Bernd Albrecht], but our German isn’t up to snuff, and machine translation always leaves something to be desired. Another developer added a play against the computer mode. This is a simple program and would be easy to port to the microcontroller of your choice. [Mirko]’s execution of it looks like it could be a commercial product. If you made one as a gift, we bet no one would guess you built it yourself.

Of course, you could play a real robot. You could probably repurpose this hardware for many different games, too.