Hacking A Cat Litter Box

[Joseph DiGiovanni] is the owner of a Litter Robot 4. It’s a convenient mechanized litter box for cats that can clean itself to reduce unwelcome odors inside the home. He wanted to run automations based on the operation of the litter box, but was not eager to use the manufacturer’s cloud service to do it. Instead, he set about reverse engineering the device for his own ends.

Since the Litter Robot 4 relies on an ESP32 microcontroller for external connectivity, it was entirely possible for [Joseph] to whip up a custom firmware for the device instead. He started with ESPHome as a base, which is a popular firmware used for building smarthome devices based on Espressif hardware. The architecture of the Litter Robot 4 helped in this regard. It uses a PIC microcontroller to handle the low level hardware control, while the ESP32 is responsible for connecting to the cloud over WiFi. This allowed [Joseph] to mess with the connectivity features and get the device hooked up to Home Assistant without compromising the basic mechancial functionality of the device or any of the safety features.

All [Joseph] had to do was figure out how the original hardware’s ESP32 talked to the PIC and emulate that in his own firmware, which was achieved with some snooping and data capture and processing with an LLM. This was used as a basis to whip up an ESPHome firmware that could integrate the hardware neatly with Home Assistant.

Files are on Codeberg for those eager to tinker. It’s not the first time we’ve looked at cat litter management, and it won’t be the last. Video after the break.

Continue reading “Hacking A Cat Litter Box” →

PVC Pipe Turned DIY Digital Telescope

[Makestreme] had always wanted to own a nice telescope, but found that budget would not stretch to anything above a cheap model with a limited 50 mm aperture. Wanting a better view of the heavens, the way forward was obvious—it was time to build a better telescope, instead!

The build is based around a 114 mm diameter mirror sourced from Amazon. It’s assembled inside a length of 5-inch PVC pipe of just under a meter to suit the 900 mm focal length of the concave reflector. 3D printed components are used to mount the mirror and control its position for proper focus and collimation. Traditionally, a reflector based telescope would use a mirror and eyepiece to provide a view to the user. However, [Makestreme] built this as a smart telescope, instead integrating a Raspberry Pi Camera Module 3 at the focal point. It’s connected to a Raspberry Pi Zero 2W, running off an 18650 lithium-ion cell and a 5 V boost module for portability. The Pi runs a Python script that hosts a small web server allowing access to the live camera feed along with controls for brightness, exposure, and gain. [Makestreme] then uses apps like SkyMap and SkEye to help aim the telescope at astronomical elements of interest.

If you’ve ever wanted to explore the heavens from down on Earth, building your own telescope is a great way to start. A camera-based build like this one can be a bit simpler than traditional builds, too, without the fuss of having to install an eyepiece.

Continue reading “PVC Pipe Turned DIY Digital Telescope” →

Building A Discrete Component 75 Baud Modem

These days, modems are pretty fancy bits of kit, what with to keep up with the speeds of cable, VDSL, and fiber connections. At lower speeds, though, it’s entirely possible to build a modem out of simple discrete components. [sv3ora] did just that, building a simple modem for the CB2 Micro.

It’s a remarkably simple build.

The project takes advantage of the fact that the V1.54 firmware for the CB2 Micro enabled 75 baud serial communication. Thus, it made sense for [sv3ora] to build a 75 baud modem to suit. As was the way in the days of dial-up internet, the modem modulates data into audio, demodulates audio back into data, allowing the CB2 Micro to send and receive data over telephone lines, ham radio links, or to store and retrieve data via mediums like cassette tape.

The device is built out of good old BC547 transistors. along with a smattering of diodes, resistors, and capacitors as supporting hardware. That’s all you need to turn slow serial into audio and back again. [sv3ora] does a great job of demoing the hardware, using it to store a program on tape and retrieve it again later.

We love old school modems around these parts. We’ve even explored ways to build your own dial-up ISP in the past!

Continue reading “Building A Discrete Component 75 Baud Modem” →

Spoofed Serial Number Unlocks Cricut Machine

[xssfox] recently found a Cricut Maker in an e-waste disposal. A quick scan over the device indicated it was in moderately good condition, with merely some perished rollers to contend with. The device was salvaged, with the awareness that Cricut is plenty good at disabling and locking down machines when it wishes. However, those measures didn’t stop [xssfox] from bringing it back to life.

The suspicion was that the machine had been locked out after the original owner received a warranty replacement or similar. Whatever the reason, the rollers would have to be repaired and the machine unlocked if it were ever to cut (Cricut?) again. Hooking the machine up to Cricut software showed that it was “deactivated”, so there was work to do.

The rollers were not a difficult replacement, but the hacking would take a little work. Examining the motherboard didn’t reveal any obvious EEPROMs, and the microcontroller was not one [xssfox] had the debugger to work with. Thus, attention turned to intercepting communications between the machine and the host PC over USB. This revealed the machine sending its serial number to the Cricut PC software in plain text with no checksums or encryption at all. Unlocking the machine was as easy as installing an RP2040 in between the Cricut Maker and the host PC. It was programmed to relay packets between the two and spoof the serial number in the process.

[xssfox] suspects a software-only solution may be possible, too, though hasn’t implemented one yet. We’ve featured her work before, too, like her efforts to spoof emergency traffic light preemption signals.

Running Zork On The Steam Controller

The Steam Controller is a device capable of many interesting feats. It’s intended to act simply as an input device, and yet, it can run games all on its own. As [Owen Feldman] has demonstrated, by having the Steam Controller play Zork.

[Owen] took quite an interesting route to get the there: he wrote a Rust program to emulate the Intel 8080 CPU and CP/M, as one does. This was ported to the Steam Controller, which emulates the CPU and memory on its own internal processor. I/O is streamed over USB, since the Steam Controller lacks a keyboard or screen. The CP/M disk lives in the controller, but the Zork disk data is streamed over USB as well.

If you’re wondering how [Owen] got all this running on the controller, he explains on his personal website. He used what appears to be an undocumented tool included with Steam that allows flashing firmware on the device. Helpfully, Valve also include the original firmware in the same folder, unsigned and only relying on a simple CRC checksum. [Owen] bricked his controller a couple times experimenting with this tool and loading his own firmware, but all came good in the end.

The Steam Controller is probably the oddest device to run CP/M for a while, but hey—it’s a neat party trick. Not much is going to top the auto-docking hack from a few months ago, though.

Continue reading “Running Zork On The Steam Controller” →

Homebrew 68K Machine Has A PCI Bus

The Peripheral Component Interconnect (PCI) bus was first introduced all the way back in 1992. It quickly became the standard way to interface add-on cards on the PC platform, supplanting earlier buses like ISA and various other oddball standards. You wouldn’t expect to see a PCI bus on a Motorola-based machine, but [maniek86]’s homebrew rig offers just that. 

That’s a lot of soldering.

This computer is a beautiful piece of homebrew engineering, constructed out of protoboard and loose wires rather than any fancy PCB. At the heart of the build lies a Motorola 68000 running at 10 MHz. It’s got 1 MB of SRAM, 4 KB of ROM, and a MC68681P acting as a UART, timer source, and I/O controller. Where things get special, though, is in the inclusion of a Xilinx Spartan II FPGA (XC2S100), which acts as a PCI bridge. It provides the machine with two 32-bit 5-volt PCI slots which are interrupt capable, albeit with no bus mastering. A XC95144XL CPLD also sits present to act as glue logic to help lace everything together.

[maniek86] does a great job of explaining exactly why the PCI bus was hard to implement, and how it was pulled off in the end. The guide also covers how the system was able to interface various cards, from a PCI serial expansion to a Cirrus VGA adapter. It’s all good stuff.

We’ve featured other work from [maniek86] before, too, like this brilliant 486-based single-board computer. Video after the break.

Continue reading “Homebrew 68K Machine Has A PCI Bus” →

Quick Share Implemented On A Kindle

Quick Share is a useful tool for flipping files between Android smart phones in a fuss-free wireless manner. [unrealJune] has now implemented the feature on Kindle devices.

You’ll need a jailbroken Kindle to use this, which is running the Kindle Unified Application Launcher and KOReader as well. You’ll also want SSH access, and a machine that has Go and Docker for you to build the project. [unrealJune] steps through the steps to compile and install the Quick Share plugin to KOReader, as well as explaining how it works. Notably, it’s receive only—so you can spit files onto the Kindle, but you can’t send them from the Kindle to other devices. The Kindle will also automatically accept files, which is worth noting if you’re security conscious. If there’s no network, the Kindle is also able to appear as its own AP if needed.

Think of this as a nifty convenience if you find yourself regularly trying to truck files on to your jailbroken Kindle. It’s also a neat to see a Quick Share implementation from the open source world. Between-device sharing still sucks, as we’ve discussed before, but there are at least attempts being made to make it better. That’s something!