A light bulb might seem like an unlikely platform for gaming, but we’re living in the future now, so anything is possible. And with enough know-how, it turns out that an RGB light bulb can indeed be modified to run Doom.
[Ed note: The project pages and video got pulled right when this went to press. Nicola received a takedown notice. We’ll let you know more when we do. The main link has been updated to the Wayback Machine.]
That’s not to say that the Ikea TRÅDFRI light bulb is the only thing [Nicola Wrachien] needed to accomplish the hack. But the bulb, specifically this addressable GU10 RGB LEB bulb, donated the most critical component, a Silicon Labs MGM210L wireless microcontroller, with enough processing power to run vanilla Doom. Added to the microcontroller was a TFT display, a controller made from a handful of buttons and a shift register, and a few odds and ends to stitch it all together. Some more memory was needed, though, so [Nicola] used an 8 MB QSPI flash memory and a couple of neat tricks to reduce latency and improve bandwidth. There are a lot of neat tricks with this one, but the coolest thing might just be that the whole footprint of the build isn’t that much bigger than the original bulb. Check out the surprisingly smooth gameplay in the video below.
This is a nice addition to the seemingly neverending “Will it Doom?” series. We’ve seen the classic game ported to everything from a GPS to a kitchen “bump bar” computer and even to an oscilloscope.
Continue reading “A Smart Light Bulb Running Doom Is A Pretty Bright Idea”
By now it’s a hardware hack that’s become common enough to be unremarkable, taking a smart light bulb or other mains switchable appliance and replacing its firmware with an open-source equivalent such as Tasmota. But what can be done when a new device is found to have a microcontroller unsupported by any open-source equivalents? If you are [Luca Dentella], you don’t throw in the towel and buy another one with a known processor, instead you reverse engineer it enough to give it a brain transplant of an ESP8266 module.
The Fcmila branded smart bulb in question was found to have a relatively unknown Chinese SoC, the Opulinks OPL1000. Since this couldn’t even raise a serial port it was more trouble than it was worth to write software for it, so instead he spent a while reverse engineering its schematic and electrical protocols, before grafting in a Wemos D1 ESP8266 board. He’s made a video about the project which you can see below the break.
Thankfully the majority of smart bulbs on the market seem to use more familiar hardware that can be flashed with relative ease.
Continue reading “A Brain Transplant For An Uncommon Smart Bulb”
There are some incredibly cheap WiFi smart bulbs on the market these days, but as is often the case, you tend to get what you pay for. When [Viktor] took delivery of his latest bargain basement bulb, the thing didn’t even work. So much for Quality Assurance. On the plus side, it was a great excuse to pop it open and replace the firmware.
For anyone wondering, [Viktor] never actually figured out why the bulb didn’t work. Its ESP8266-based control board was getting power, and data was getting spit out of the serial port when he connected it to the computer (although he never got the communications settings right to actually see what it was saying). But he also didn’t care much; once he confirmed that the hardware was good, he just uploaded the custom firmware he’d previously developed for another ESP8266 bulb.
Of course, it wasn’t quite that easy. The chances that both bulbs would have used the same GPIO pins to control the red, green, blue, and white LEDs were pretty slim. But after some testing and modifications to the code, he was able to fire them up. The other issue was a bit trickier, as it turned out the bulb’s flash chip was too small to hold his firmware’s web configuration pages. So he had to break out the hot air gun and replace the SPI flash chip with something a bit roomier. We suppose he could have just made smaller web pages… but where’s the fun in that?
Even with the chip swap, this looks a lot easier than building your own smart bulbs from scratch. With so many cheap ESP8266 bulbs on the market, it seems there’s never been a better time to code your own home lighting solution.
It’s the end of another decade, and while we don’t have real hoverboards, flying cars, or affordable dental care, we do have multicolored lightbulbs you can control over WiFi. [Don Howdeshell] picked up a couple of cheap Merkury branded units in a Black Friday sale, and quickly set about hacking them.
By and large, many of these bulbs are manufactured by various companies and rebranded for whoever happens to place an order. The bulbs tend to use the Tuya IOT ecosystem. Based on the ESP8266, reflashing the bulbs with custom firmware is simple, thanks to the Tuya Convert project. Using a Linux computer with a WiFi card running in Access Point mode, it spoofs a server that tricks the Tuya product into downloading a firmware update. From there, the bulb is an open book, ready to do your bidding.
One of [Don]’s attempts didn’t go so swimmingly, however. Flashing the firmware failed and the bulb was non-functional. [Don] elected to to a teardown, photographing it for our perusal, before hooking up to the ESP8266 directly over its serial interface. From there, it was simple to reprogram the bulb with Tasmota firmware, getting it back up and running.
Security alone is a great reason for running your own firmware on IoT devices. It never hurts to know what you’re connecting to your network!
Who would have thought that some day we’d need programming jigs for our light bulbs? But progress marches on, and as there’s currently a number of affordable Internet-controlled bulbs powered by the ESP8266 on the market, we’re at the point where a tool to help update the firmware on the light over your kitchen sink might be something nice to have. Which is why [cperiod] created this programming jig for AiLight smart bulbs.
Flashing the AiLight bulbs is easy enough, there’s a series of test points right on the face of the PCB that you can hook up to. But if you’re updating more than one of them, you don’t want to have to solder your programmer up to each bulb individually. That’s where the jig comes in. [cperiod] says there are already some 3D printed designs out there, but they proved to be a bit finicky.
The design that [cperiod] came up with and eventually milled out on a 1610 CNC router is quite simple. It’s effectively just a holder to keep the five pogo pins where they need to be, and a jumper that lets you toggle the chip’s programming mode (useful for debugging).
The neat trick here are the “alignment pins”, which are actually two pieces of 14 gauge copper wire that have had their ends rounded off. It turns out these will slip perfectly into holes on the AliLight PCB, ensuring that the pogo pins end up on target. It works well enough that you can hold the bulb and jig in one hand while programming, it just needs a little downwards pressure to make good contact.
We’ve previously seen how easily you can replace the firmware on some of these ESP8266 bulbs. While there’s certainly a downside to these bulbs being so simple to modify, it’s hard to deny their hackability makes them very appealing for anyone looking to roll their own network-controlled lighting system.
The regular Hackaday reader no longer needs to be reminded about how popular the ESP8266 is; they see the evidence of that several times a day. But what might not be quite so obvious is that it isn’t just us hacker types that are in love with the inexpensive IoT microcontroller, it’s also popping up more and more frequently in commercial products.
As [Majenko] demonstrates, one of those ESP-powered devices is the LOHAS Smart LED Bulb. Upon cracking one open, he found that these relatively low-cost bulbs are little more than a standard ESP8266 chip and a couple of LED drivers. He wanted to see how hard it would be to get his own code running on the bulb, and by the looks of it, it took longer to get the thing open then it did to load it up with a custom firmware.
The bulb’s PCB features the aforementioned ESP8266, a 1MB 25Q80 flash chip, and MY9231 LED drivers. Whoever put the board together was nice enough to label the RX, TX, and GPIO test points, though [Majenko] notes that what’s labeled as 3.3 V appears dead. With a ESP-01 programmer wired up to the board and the appropriate board settings (which he provides), you can use the Arduino IDE to upload whatever you like to it.
Running “Hello World” on a smart bulb is fun and all, but what about kicking on those LEDs? [Majenko] found a library that works with the MY9231 drivers, and it didn’t take long to figure out which of the ESP’s pins were used to communicate with them. All in all, he said it was far easier than he expected.
You’ll probably want to put this bulb back into service after reprogramming, so [Majenko] advises caution when cracking open the shell. There are clips holding on the diffuser which he assures us are going to break no matter what you do, plus some silicone adhesive. He suggests super glue to hold it together when you’re done programming it, and using an OTA firmware so you don’t need to get back in there.
In the past we’ve shown how some hackers are rolling their own smart bulb hardware, but with cheap commercial offerings that are so easily hackable, it frankly doesn’t seem worth the effort. On the other hand, an influx of cheap ESP-powered bulbs isn’t all good news.
The idea of the so-called “smart bulb” sounds good; who wouldn’t want to be able to verify the porch light is on if you’re out of town for the night, or check to see if you left the bathroom lights on in your rush out the door in the morning? But in practice, it can be a nightmare. Each brand wants to push their own protocol. Even worse, it seems you can’t get anything done without signing up for three different services, each with its own application that needs to be installed on your phone. It’s a frustrating and often expensive mire to find yourself in.
[Dom Gregori] liked the Hue bulbs offered by Philips, but didn’t want to buy into the whole ecosystem of phone apps and hardware hubs they require. So he decided to create his own open source version that would do everything he wanted, without any of the seemingly unavoidable baggage of the commercial offerings. The final result is a professional looking ESP8266 controlled RGB bulb that hooks into Home Assistant via MQTT.
Looking at his Bill of Materials, it’s actually pretty amazing to see how little it really takes to pull a project like this off. Outside of the Wemos D1 Mini board, [Dom] just needed a few concentric WS2812 rings, and a USB charger small enough to fit into the base of his 3D printed enclosure.
We especially like how he handled the socket-side of the bulb, as that’s the part that would have left us scratching our heads. Rather than trying to salvage the base from an existing bulb, or come up with his own printed piece to stick in the socket, he just used a cheap and readily available light socket adapter. The solution might be a little bulky, but we like how he’s deftly avoided having to handle any AC voltages in this project.
Over the last couple years, we’ve seen more and more smart bulb related content come our way. From the ever popular teardown of a new entry into the market to the sobering realization that your light bulbs might provide the key attackers need to access your network, it’s been fascinating to see the transformation of these once simple pieces of hardware into something far more complex.