In 1984 there weren’t many ways to listen to high-quality music, so an FM tuner was an essential part of any home hi-fi system. The Pioneer TX-950 picked up by [The Curious Lorenz] would have been someone’s pride and joy, with its then-cutting-edge microprocessor control, digital PLL tuning, and seven-segment displays. Astoundingly it doesn’t have an auto-tuning function though, so some work to implement the feature using an ATtiny85 was called for.
A modern FM tuner would be quite likely to use an all-in-one tuner chip using SDR technology under the hood, but this device from another era appears to be a very conventional analog tuner to which the PLL and microprocessor have been grafted. There are simple “Up” and “Down” buttons and a “Station tuned” light. One might imagine that given these the original processor could have done autotune. At least the original designers were kind enough to provide the ATtiny with the interfaces it needs. Pressing either button causes it to keep strobing its line until the “Station tuned” line goes high, at which point it stops. It’s an extremely simple yet effective upgrade, and since the ATtiny is so small it’s easily placed on top of the original PCB. The result is an ultra-modern tuner from 1984, that’s just that little bit more modern than it used to be.
To be clear, of course there’s a blade. They aren’t magic, obviously. The fan is just small, and hidden inside the base. Air is pulled from the sides and bottom, and into the ring mounted to the top of the unit. When the air eventually exits the thin slit in the ring, it “sticks” to the sides due to the Coandă effect and produces a low pressure zone in the center. That’s all a fancy way of saying that the air flow you get from one of these gadgets is several times greater than what the little dinky fan would be capable of under normal circumstances. That’s the theory, anyway.
We can’t promise that all the physics are working as they should in this 3D printed version, but in the video after the break it certainly appears to be moving a considerable amount of air. It’s also quite loud, but that’s to be expected given it’s using a brushless hobby motor. To get it spinning, [Elite Worm] is using a Digispark ATtiny85 connected to a standard RC electronic speed control (ESC). The MCU reads a potentiometer mounted to the side of the fan and converts that to a PWM signal required by the ESC.
Beyond the electronics, essentially every piece of this project has been printed on a standard desktop 3D printer. An impressive accomplishment, though we probably would have gone with a commercially available propeller for safety’s sake. On the other hand, the base of the fan should nicely contain the shrapnel created should it explode at several thousand RPM. Probably.
[Greg] loves hacking his bow ties. Back in high school, he added some bright RGB LEDs to the bow tie he wore to prom and even won the male best-dressed award. Recently he decided to try another bow tie hack, this time giving his tie some retro arcade game feels.
He decided to use an ATtiny85 and to experiment doing some more lower-level programming to refresh his skills. He wrote all his libraries from scratch which really helped him learn a lot about the ATtiny in the process. This also helped him make sure his code was as efficient as possible since he had quite a bit of memory constraints using the ATtiny85 (only 512 bytes of RAM).
He designed the body of the bow tie with wood. He fit all the electronics inside the body while allowing the ATtiny to protrude out of the body giving his bow tie some wanted hacker aesthetic. Of course, he needed to access the toggle switch to play the game, so he made a slot for that as well.
[Mitxela]’s repair of a Roland JV-1080 (a rack-mounted 90s-era synthesizer) sounds simple: replace a broken rotary encoder on the front panel. It turned out to be anything but simple, since the part in question is not today’s idea of a standard rotary encoder at all. The JV-1080 uses some kind of rotary pulse switch, which has three outputs (one for each direction, and one for pushing the knob in like a button.) Turn the knob in one direction, and one of the output wires is briefly shorted to ground with every detent. Turn it the other way, and the same happens on the other output wire. This is the part that needed a replacement.
Rather than track down a source for the broken part, [Mitxela] opted to replace it with a modern rotary encoder combined with an ATtiny85 microcontroller to make it act like something the JV-1080 understands and expects. There was an additional wrinkle, however. The original rotary pulse switch is an entirely passive device, and lives at the end of a four-conductor cable with no power provided on it. How could the ATtiny85 be powered without resorting to running a wire to a DC voltage supply somewhere? Success was had, but it did take some finessing.
For the power, it turns out that the signal wires are weakly pulled up to +5 V and [Mitxela] used that for a power supply to the microcontroller. Still, by itself that wasn’t enough, because the ATtiny85 can easily consume more current than the weak pullups can source. We really recommend reading all the details in [Mitxela]’s writeup, but the short version is that the ATtiny85 does two things.
First, it minimizes its power usage by spending most of its time in sleep mode (consuming barely any power at all) and uses an interrupt to wake up just long enough to handle knob activity. Second, the trickle of power from the weak pullups doesn’t feed the ATtiny directly. It charges a 100 uF capacitor through a diode, and that is what keeps the microcontroller from browning out during its brief spurts of activity. Even better, after browsing the datasheet for the ATtiny, [Mitxela] saw it was possible to use the built-in ESD protection diodes for this purpose instead of adding a separate component.
It’s a neat trick and makes for a very compact package. Visit the project’s GitHub repository to dive into the nitty gritty. In the end, a single assembly at the end of a 4-wire connector acts just like the original passive component, no extra wires or hardware modifications needed.
When opening older hardware it’s never quite certain what will be found on the inside. But at least [Mitxela]’s repair duties on this synth didn’t end up with him tripping out on LSD.
Adding an additional fan to your PC is usually pretty straightforward, but as [Randy Elwin] found, this isn’t always the case with the newer Small Form Factor (SFF) machines. Not only was the standard 80 mm fan too large to fit inside of the case, but there wasn’t even a spot to plug it in. So he had to come up with his own way to power it up and control its speed.
Now if he only needed power, that wouldn’t have been a problem. You could certainly tap into one of the wires coming from the PSU and get 12 V to spin the fan. But that would mean it was running at max speed the whole time; fine in a pinch, but not exactly ideal for a daily driver.
To get speed control, [Randy] put together a little circuit using an ATtiny85, an IR LED, and a LTR-306 phototransistor. The optical components are used to detect the GPU fan’s current speed, which itself is controlled based on system temperature. Using the GPU fan RPM as an input, a lookup table on the microcontroller sets an appropriate speed for the 80 mm case fan.
One could argue that it would have been easier to connect a temperature sensor to the ATtiny85, but by synchronizing the case fan to the computer-controlled GPU fan, [Randy] is able to manually control them both from software if necessary. Rather than waiting on the case temperature to rise, he can peg the GPU fan and have the external fan speed up to match when the system is under heavy load.
We’re not sure exactly why [Justin Garrison] decided to make these awesome name badges for himself and his coworkers at Disney+ streaming, but it’s fun to imagine them all lighting up a team-building ride down Space Mountain, isn’t it? Whatever the reason, they sure do look good.
Each badge has an ATtiny85 that drives the ten individually-addressable RGB LEDs, and both the wire and the LEDs are powered by the EL power inverter. [Justin] bought the thinnest EL wire he could find, which is conveniently also the brightest and probably the easiest to manipulate.
Nevertheless, we can’t get over how good the names look, and wonder if [Justin] missed his calling as a neon artist. He cleverly stuck wires through the protoboard to help form the letters, and then used superglue to hold them in place. [Justin] has the code up on GitHub and an album full of build pictures if you want to give this a go.
The most important rule of password use, especially when used for online logins, is to avoid reusing passwords. From there, one’s method of keeping track of multiple passwords can vary considerably. While memorization is an option in theory, in practice a lot of people make use of a password manager like Lastpass or KeePass. For those with increased security concerns, though, you may want to implement a USB password keeper like this one based on an ATtiny.
This password keeper, called “snopf”, is a USB device with an ATtiny85 which adds a layer of separation to password keeping that increases security substantially. Passwords are created by the USB device itself using a 128-bit key to generate the passwords, which are physically detached from the computer. Password requests are made by the computer to the USB device, but the user must push a button on the snopf in order to send the password to the computer. It does this by emulating a keyboard, keeping the password information off of the computer’s clipboard.
Of course, snopf isn’t perfectly secure, and the project’s creator [Hajo] goes into detail on the project’s page about some of the potential vulnerabilities. For most use cases, though, none of these are of serious concern. Upgrading your password keeper to a physical device is likely to be a huge security improvement regardless, and one was actually developed on Hackaday a few years ago.