Back in 1978, the world was a bit different. There was no Raspberry Pi, no Internet, and not even an ESP32 to build projects with. And rather than order electronics kits from Tindie or Adafruit, [Dr. Francitosh] selected this binary clock with his mother from a catalog, and made the order via mail. Simpler times. The good Doctor, AKA [Greg Smith], was a young electronics tinkerer, and his mother wanted a good project-in-a-box to show off his skills. Thus, a Greymark Binary Clock was ordered and assembled. Then, sadly, the beloved clock crashed from its proud mantle position, doomed to never to blink or blip again. Or was it? Continue reading “Binary Clock Kit Blips Again”→
Before video games, there were pinball machines. Not that they don’t exist today, but a modern pinball machine will likely have microprocessors and other fancy things that traditional pinball machine designers could never dream of. [Eli] had one of these mechanical machines from 1974 as a kid and, later, encountered a more modern machine with a rudimentary microprocessor and other integrated circuits onboard. One thing this enabled is the ability to remember high scores. But you have to physically look at the machine, and you can only see the top four scores. [Eli] decided to adapt the machine to upload high score data to the Internet, and it is a fun project.
[Eli]’s design goals were to make it automatic and robust. That is, if the network is down or the machine loses power, you shouldn’t lose high score data. In addition, he didn’t want to change the appearance or damage the 40-year-old machine. You can see a video of how it all turned out below.
The Laser Cue machine is one of many built around the “Williams System 7” platform. A 6808 CPU, along with some I/O chips to manage all the lights, sensors, and bells. The game has only 1K of RAM, 12K or ROM, and 128 bytes (no prefix, just bytes) of RAM with battery backup. There was even a common “operating system” called Flipper ROM, and that’s actually documented over on GitHub.
Since the memory for the machine is all in external chips, it was a reasonable idea to replace the CPU with a board that monitored signals on the board. The CPU would plug into this new board, and then a newer microcontroller with an Internet connection could eavesdrop on bus traffic. However, removing the old CPU and jamming pins into the ancient socket was worrisome, so instead, [Eli] elected to tap into a test connector that was already on the board but not plugged into anything.
An ESP32 is more than capable of the speeds, although connecting to 5 V logic was a bit of a problem. The CPU has 5 V tolerant pins, but some of the 25 available pins on the development board either set items on boot or may briefly be outputs and were thus unusable. To reduce the necessary pins, [Eli] decided to do some of the decoding in separate logic. Instead of using TTL chips, he elected to use a programmable logic array.
After that, it seemed it would be straightforward, but there was something preventing the ESP32 from reading each bus cycle. [Eli] never got to the bottom of it but instead switched to the Raspberry Pi Pico W. Using the chip’s special I/O processors made the job easy, and it worked perfectly. The rest of the project was just fit and finish. Be sure to read to the end to find out the lessons learned which might help you on your next similar project.
The Raspberry Pi Pico is a handy little microcontroller that has become a widespread addition to many hackers’ workbench. The Pico W has a CYW4342W module (just like the Pi Zero W) to add WiFi capabilities and [Jeremy Bentham] ported his bare-metal WiFi driver to the Pico W.
The CYW43438 is an SDIO interface, so most of the code ported over from his Zerowi project, but there were a few notable tweaks along the way. Given that the Pi Pico SDK has the complete source code to drive the CYW43439 with an open source TCP/IP stack (lwIP) and the datasheets from Infineon are pretty detailed, why create your own driver?
The short answer is…because why not. But a second answer is to tweak it just how you like it. With his own implementation, [Jeremy] can focus on maximizing throughput and making WiFi a little easier to debug. He deeply delves into the hardware, scope traces, and code samples. It’s a tremendous five-part read over lunch. Some highlights include writing some code for the PIO (Programmable I/O) to interface with the SPI interface, bank switching in the WiFi RAM, handling the 140 different events, connecting to a network, and sending pings.
NASA’s Mars Rovers are robots that have inspired many budding engineers around the world. [Nikodem Bartnik] had a particular fondness for them himself, and set out to build a miniature version of his very own.
The Raspberry Pi Pico W is the brains of the operation, serving as both microcontroller and remote wireless link for control. The robot uses four mecanum wheels for locomotion, with each getting its own motor. This allows the robot to move in all directions simply by rotating the wheels in different configurations. On top, the rover sports a articulated robot arm controlled by servos, which allows it to pick things up and put them down. Plus, there’s an FPV camera on top that delivers a video feed so the robot can be driven remotely. This is achieved over WiFi, thanks to a bit of custom control code written in Python.
It’s a surprisingly capable bot on smooth surfaces, as the mecanum wheels allow strafing and other movements that regular wheels simply can’t do. It’s also fun having a bot that can interact with its environment, thanks to its motorized appendages.
Bringing modern connectivity to retro computers is an endearing field- with the simplicity of last-century hardware and software being a double-edged sword, often, you bring a powerful and tiny computer of modern age to help its great-grandparent interface with networks of today. [yyzkevin] shows us a PCMCIA WiFi card built using a Pi Pico W, talking PCI ISA. This card brings modern-day WiFi connectivity to his IBM PC110, without requiring a separate router set up for outdated standards that the typical PCMCIA WiFi cards are limited by.
The RP2040 is made to talk PCI ISA using, of course, the PIO engine. A CPLD helps with PCI ISA address decoding, some multiplexing, and level shifting between RP2040’s 3.3V and the PCI 5 V levels. The RP2040 software emulates a NE2000 network card, which means driver support is guaranteed on most OSes of old times, and the software integration seems seamless. The card already works for getting the PC110 online, and [yyzkevin] says he’d like to improve on it – shrink the design so that it resembles a typical PCMCIA WiFi card, tie some useful function into the Pico’s USB port, and perhaps integrate his PCMCIA SoundBlaster project into the whole package while at it.
This is a delightful project in how it achieves its goal, and a pleasant surprise for everyone who’s been observing RP2040’s PIO engine conquer interfaces typically unreachable for run-of-the-mill microcontrollers. We’ve seen Ethernet, CAN and DVI, along many others, and there’s undoubtedly more to come.
We thank [Misel] and [Arti] for sharing this with us!
Many of us hacker types with some hardware knowledge and a smattering of embedded experience would like to get into home automation, but there can be quite a learning curve. If you’re looking for a hackable starting point; something to deploy, learn about and then later expand upon, then look no further than the PicoW Home Assistant Starter project from [Danilo Campos].
The project is based upon the arduino-pico core, which supports a whole pile of RP2040-based boards, so you don’t need to restrict yourself to the “official” Pico-W, so long as you have working networking, Wi-Fi or otherwise. Integration is provided by the arduino-home-assistant library, which acts as the bridge between your sensors and other widgets, MQTT, and thence the network beyond. Events and sensor data on the end-point are packaged up with MQTT and published out to the broker via the network provided, all for minimal initial effort. Once you’ve got the basic connectivity to your Home Assistant instance working, there are many code examples in the arduino-home-assistant GitHub page to give you a helping start to connect whatever tickles your fancy.
RGB LEDs are great for adding a bit of color to your life, and it’s even more satisfying to use a matrix of them as a graphic display. [bitluni] built an RGB LED display with Pi Pico to which you can share a pixelated version of your PC’s screen.
[bitluni] wanted to gain some experience with MicroPython on the Raspbery Pi Pico W, and had previously used WebSockets to transmit display data over WiFi. Unfortunately, the available MicroPython WebSockets implementation didn’t leave enough RAM for the rest of the code. Instead, he set up a simple HTTP server on the Pico that receives the pixel data as a POST request. This makes for a slow refresh rate but still looks great, especially with the 3D printed rear-projection frame.
This looks like a fun weekend project to add to your lab or home and only costs about $20 in parts. It’s basically a scaled-down version of his giant ping pong ball wall display.