A button that stopped working has probably led to more than a few smashed remotes over the years. Fortunately [pescado99] has shared a beautifully simple cure for dead or dying remote buttons: graphite dry lubricant.
Most remotes operate by pushing a conductive carbon coating on the back of the button onto a pair of contacts on the PCB. Unfortunately, that conductive coating can wear off, leaving you with a dead or dying button. The video after the break [pescado99] demonstrates how to use a cotton swab to apply powdered graphite to the rear of the buttons to make them conductive again. A soft pencil can also be used, but the graphite works better.
Imagine a flat surface that has no buttons on it, until they raise up like bubbles of goo for you to touch them. The Future Interface Group at Carnegie-Mellon has apparently developed just that. They’re calling the technology DynaButtons, and they look kinda weird…and very awesome.
The buttons use electro-osmotic pump technology. Basically, electricity is used to move a fluid under a flexible surface to create a dimple-shaped button. The team was able to increase the flow-rate of these pumps by 300% over traditional designs, while also integrating sensing for interactivity. This allowed the creation of a dynamic button that pops up as needed. The button design is fast and responsive. It’s able to readily change its position in an analog manner, both raising up and deflating below the base surface on command.
Every hacker is familiar with those teeny little tactile buttons that are so enjoyable to click over and over again. [ROBO HUB] has built a giant version as a tribute, and it works just like the real thing!
The giant button has been scaled up 20 times compared to the original. For simplicity’s sake, [ROBO HUB] designed this replica to use materials readily available around the home. Thanks to its cardboard construction, it’s easy to replicate with a minimum of tools. One need merely cut out the various sections before assembling them together with hot glue, with popsicle sticks serving as the legs. A juice bottle is used as the primary button itself, with aluminium foil serving as the contacts and rubber bands standing in for the spring.
It’s not the most useful button, given that it it’s quite fragile and has a weak spring return. However, it would be a great teaching tool to show students exactly what’s going on inside an actual button. As a bonus, it looks like it would be remarkably fun to pound on to activate some kind of massive air horn. Just an idea.
The war on Internet ads rages on, as the arms race between ad blockers and ad creators continues to escalate. To make a modern Internet experience even remotely palatable, plenty of people are turning to DNS-level filters to stop the ads from coming into the network at all. This solution isn’t without its collateral damage though, as the black lists available sometimes filter out something that should have made it to the user. For those emergencies, [Kristopher] created the Pie Stop, a physical button to enact a temporary passthrough on his Pi-Hole.
While [Kristopher] is capable of recognizing a problem and creating the appropriate white list for any of these incidents, others in his household do not find this task as straighforward. When he isn’t around to fix the problems, this emergency stop can be pressed by anyone to temporarily halt the DNS filtering and allow all traffic to pass through the network. It’s based on the ESP-01S, a smaller ESP8266 board with only two GPIO pins. When pressed, it sends a custom command to the Pi-Hole to disable the ad blocking. A battery inside the case allows it to be placed conveniently anywhere near anyone who might need it.
With this button deployed, network snafus can be effectively prevented even with the most aggressive of DNS-level ad blocking. If you haven’t thought about deploying one of these on your own network, they’re hard to live without once you see how powerful they are. Take a look at this one which also catches spam.
Competition sure brings out the brute in people, doesn’t it? So what do you do when you need a bunch of switches you can let people fist-pound or stomp on repeatedly without them taking damage? You could look to the guitar pedal industry and their tough latching switches, or you could simply build your own smash-resistant buttons as [wannabemadsci] has done.
The main thing about these switches is that they aren’t easily destroyed by shoes or angry fists. That’s because the shiny red push-me part of the button is made by cutting a foam ball in half.
Not easily crush-able Styrofoam, mind you — squishy, coated foam like an indoor football. This is mounted to the top of a sandwich made of hardboard and a couple pieces of easily-compressible foam from craft paintbrushes.
A brass washer is mounted to the middle of both pieces of hardboard, and these have wires soldered to them to read button presses. Then it’s just a matter of hooking it to a microcontroller like any other momentary.
There are all kinds of things you could cut in half for the top, like maybe tennis balls. Or, do what [Sprite_TM] did and use inverted plastic bowls.
Most projects that interface with the real world need some sort of input device. Obviously this article is being written from a standardized “human interface device” but when the computers become smaller the problem can get more complicated. We can’t hook up a USB keyboard to every microcontroller since we often only need a few buttons, but even buttons can be a little bit too cumbersome for some applications. For something even simpler, we would like to turn your attention to capacitive touch controllers.
Granted, these devices are really only simpler from a hardware perspective. Rather than a switch that can be prone to failure either when its moving parts break or its contacts become corroded, a capacitive touch button only needs a certain conductive area on something like a PCB, along with a few passive components, to work. The real difficulty is in the software, so this project aims to make it simpler to bring these sort of devices to any FPGA that needs some sort of interface like this. It can operate in stand-alone mode or in a custom user interface, and was written to be platform-independent in VHDL without the need for any dependencies or macros.
The project’s page goes into a great amount of detail on how capacitive touch sensors like these work in general, and describes the operation of this specific code as well. Everything is open source, so it’s ready to be put to work right away. If you need capacitive touch capabilities on something like a microcontroller, though, take a look at this tiny Atmel-powered musical instrument instead.
Press button, wait, press button again, repeat. There must be a better way! If that kind of interaction drives you nuts, you’ll probably appreciate [Tommy]’s buttonpusher, which has only one job: automate away some of the more boring parts of Nintendo’s Animal Crossing. On one hand the job the device does is very simple: press a button on the Nintendo joy-con in a preprogrammed pattern. There’s no feedback loop, it just dumbly presses and waits. But there are still quite a few interesting bits to this build.
Rigid mounting combined with interfacing the actuator to the servo horn (instead of to the servo shaft) were the keys to reliable button pushing.
For one thing, [Tommy] discovered that the little 9g RC servo can reliably exert enough force to press the button on the joy-con with the right adapter. He had assumed the servo would be too weak to do the job without a greater mechanical advantage, but a simple hammer-style actuator that attaches to the servo horn easily does the job. Well, it does as long as the servo and joy-con are held rigidly; his first version allowed a little too much wiggle in how well the parts were held, and button presses didn’t quite register. With a 3D-printed fixture to rigidly mount both the servo and the joy-con, things were fine.
In the process of making buttonpusher, which uses CircuitPython, [Tommy] created a tool to automate away another pesky task he was running into: circuitpython_tools was created to automatically watch for code changes, convert the .py files into (smaller) MicroPython bytecode .mpy files, then automatically deploy to the board. This saved [Tommy] a lot of time and hassle during development, but it was only necessary because he quickly ran out of memory on his M0 Metro Express board, and couldn’t fit his code in any other way.
Still, it’s a good example of how one project can sometimes spawn others, and lead to all kinds of lessons learned. You can see buttonpusher automate the crafting process in Animal Crossing in the video, embedded below.
