Phone Stand Aims To Fight Addiction

Sometimes, it’s hard to stop picking up your phone every few minutes to check on notifications and scroll endlessly through the slop of the day. [PushpendraC2] has been working on a solution to this problem that would ideally discourage such behavior —  a nifty little smartphone stand!

The concept is straightforward enough—the smartphone stand uses a simple tactile button to determine if your smartphone is sitting on the little 3D printed shelf, or not. However, the smarts inside do a bit more than that, too. An ESP32-S3 is charged with monitoring whether the smartphone is sitting in place, and starts counting “focus time” while it’s there. If the phone is picked up, the OLED display on the shelf starts ticking down a 5-second timer to encourage you to put it back. If you don’t, the focus time is reset and you lose your streak.

It’s also possible to tap a touch sensor on the device which sets a reminder timer, prompting you to put your phone back after a set period of time, between 2 to 30 minutes. A buzzer will then start going off to prompt you to put the phone down. If you want to track the devices impact, you merely need to log in to the web server hosted by the ESP32, which shows your current focus session time, along with a heatmap of your daily productivity.

It’s a simple idea, but one that uses a few neat psychological hooks to encourage compliance and behavioral change. We’ve featured similar projects in this vein before, No surprise, as phone addiction is a problem experienced by many.

Continue reading “Phone Stand Aims To Fight Addiction” →

RF Hacking A Ceiling Fan Via The Remote

[Sam Wilkinson] recently installed a Dreo CLF513S ceiling fan in his place — it’s cheap, well-sized, and blows air around as you’d expect it to. The only problem is that it only works with an ugly cloud-only smart home setup out of the box. Never mind, though, because [Sam] figured out how to hack up a custom solution.

Hacking efforts began with the included remote control. [Sam] identified that the remote had to be RF, since it didn’t need line of sight to work properly. The FCC ID on the back of the device further indicated this was the case. Armed with that knowledge, it was simply a case of figuring out the commands sent by the remote, building something to replay them, and then hooking that into [Sam]’s existing Home Assistant setup.

The remote ran on 433.92 MHz, a not-uncommon bit of spectrum for these sort of appliances. An RTL-SDR was thusly enlisted to capture the output, with a spectrogram indicating the remote used simple on-off keying to send commands. Once commands were captured, [Sam] grabbed an ESP32-C6 microcontroller, hooked it up to a RFM69HCW radio transceiver, and programmed it to replay the fan on/off command. From there, a little dabbling with MQTT got the ESP32 controlling the fan as desired from within the Home Assistant ecosystem.

Sometimes, it’s hard to find smart home gear that actually suits your tastes and budgets. Often, a bit of tinkering can shape existing appliances to bend to your will instead. If you’re tweaking your own gear to better fit your smart home, don’t hesitate to notify the tipsline.

Teaching An AI To Play A Racing Game Via Screen Input

If you’re a fleshy human, you probably learn to play video games by looking at the screen and pressing the buttons, and maybe copying the way you’ve seen others play the game before. [tryfonaskam] has recently been trying to teach an AI to play games in much the same way.

[tryfonaskam] built PILA—short for Polytrack Imitation Learning Agent. As you might have guest from the name, it’s an AI agent designed to play a simple racing game called PolyTrack. Rather than manually programming the agent’s behavior, PILA instead trains itself through supervised learning, where it observes the gameplay state via screen capture and monitoring the keyboard inputs made by human players as they drive the tracks. It then uses this to guide its own behavior, and learns to play the game by itself. The model receives live frames from the graphics engine while playing, and then predicts the appropriate actions and makes the right keyboard inputs in turn to steer the car through the track.

This project reminds us of similar efforts to teach a raw AI how to play Trackmania, or the Drivatar technology in the Forza series of racing games.

Hack Improves Cheap Speed Controllers

[Tony Goacher] has worked with a lot of cheap brushless DC motor controllers built in China. They can be very cost-effective, but sometimes limited in performance or capability, particularly when it comes to low-speed operation. Thus, he’s been working on a project to make cheap controllers more capable.

The prime problems [Tony] has faced are jerkiness, throttle deadspots, and inconsistent torque delivery at low speeds. This is especially the case when running brushless motors on heavier vehicles, where the greater inertia can compound any minor problems to the point things become undriveable. [Tony]’s solution has been to create a signal interceptor that lives in between a throttle and the cheap motor controller to change their overall behavior.

The demo vehicle for this build is TrakTrike, a sort of bicycle-half-track hybrid that [Tony] built for EMF Camp 2022. After blowing up some nicer controllers, [Tony] specced some cheaper parts from AliExpress. Only, the low-speed control was terrible, and the dual motor controllers didn’t respond identically to throttle and would cause the vehicle to steer or crab, making driving difficult. This was fixed by dropping in an Arduino Nano after the throttle, and before the two motor controllers. It allows calibrating the throttle output from the Arduino to eliminate dead spots, while also tuning the throttle output to left and right motors individually so they respond more similarly. There are also custom acceleration and deceleration curves that make the controllers respond more smoothly, and a precise crawling speed for consistent low-speed maneuvering.

Just by doing some fancy throttle smoothing and control, [Tony] was able to greatly improve the usability of these cheap controllers, for the price of an Arduino Nano and little more. Files are on GitHub for those eager to attempt the hack themselves. There are other ways to go about this of course, like diving into field-oriented control, if you’re so inclined. Alternatively, speculate on how you’d tackle this engineering challenge down in the comments.

Bringing Swift To The Apple II

Swift is a relatively modern program language, appearing in 2014 as a replacement for Objective-C. Since then, it’s become a popular solution for programming apps across Apple platforms. That led [Yeo Kheng Meng] to a simple yet fun idea—porting Swift to the oldest Apple platform of all.

Yes, [Yeo] managed to build a development environment for Swift that targets the Apple II platform. Not just one machine, either—everything from the original Apple II up to the IIe and a little beyond. Now, the Apple II is very different from modern Macs and iPhones and the like, having debuted in 1977 with a 1 MHz 6502 CPU and a minuscule 4 KB of RAM. But that doesn’t mean you can’t use a modern language to develop for it!

[Yeo] does a great job of explaining how it all works, and how Claude Code and GPT 5.5 Codex were used to help piece things together. The compiler is set up to spit out bytecode that’s executed by a virtual machine running on the 6502. The target was to allow the setup to work on a standard 1977 Apple II from the factory, which would allow it to then run on subsequent models without issue. However, there is a small note— [Yeo]’s implementation requires the RAM to have been upgraded to 48 KB.

We love seeing modern stuff ported to the Apple II. This Portal port was a particular highlight.

Continue reading “Bringing Swift To The Apple II” →

A Quantum Magic 8-Ball

If you ever cracked open one of those Magic 8-Ball toys, you found little more than a polyhedron floating in some dark-colored fluid. It was a quasi-random way of asking the universe to answer crucial questions like “will Mom and Dad get a divorce?” and “does Bethany like me?” even if the results were seldom accurate (sorry about your parents, kid). If you want a more reliably random 8-ball that is not even slightly more truthful, you might like this recent build from [David Noel Ng].

The concept is simple enough — leverage quantum effects that provide truly random results to seed run a random number generator that determines the outcome of a software magic 8-ball. [David] tried a few ways to build something along these lines, and eventually settled on a setup that he felt suited the task at hand.

In the final rig, a light source spits out photons, and is attenuated to the point where effectively only one photon is running through the light path at a time. Each photon passes through a beam splitter, and either passes through the mirror and hits photomultiplier A, or bounces off and hits photomultiplier B. This creates a truly random yes/no result for every photon that passes through. [David] does a great job of explaining the low-level physics at play, as well as the supporting electronics and code that turns this into a usable magic 8-ball that actually answers questions.

We’ve seen other magic 8-ball builds before, too. Few come with quite the same tactile wonder created by the original toy, but they nonetheless do the job of answering questions that are too frivolous to take to a tarot reader or local divining bog witch. If you’re whipping up your own way to deduce the wills of the fates, don’t hesitate to let us know on the tipsline.

A Custom Zigbee Touch Keypad

[Dominic Buchstaller] wanted a neat, tidy entryway keypad that actually looked good. Prime goals were something slim, wireless, and with no visible screws. Dependency on the cloud was also a no-go. With few ready-to-go options available on the market, he set about whipping up his own.

The heart of the build is an ESP32-C6 microcontroller devboard. This device has the benefit of including Zigbee communication functionality baked right into the chip. It’s hooked up to an MPR121 capacitive touch controller, which allows different segments of the touchpad PCB to act as capacitive buttons for numerical entry. The number labels are directly printed on the PCB solder mask, so there’s no overlay or other label required on top. Power is courtesy of a 1300 mAh lithium-polymer cell which gives a useful lifespan of six months between recharges. A simple 3D-printed case holds everything together and completes the clean and simple look. [Dominic] notes that it’s possible to also use the device via Matter or Thread without a lot of changes, as the ESP32-C6 can easily handle those protocols, too.

If you’re looking for a cheap, handsome keypad for your Home Assistant setup or similar, you might find this useful. We’ve explored DIY keypad entry systems before, too. If you’ve come up with some other creative way to get into your house, car, or bank vault, be sure to notify us via the tipsline.