Walking around the alley at Hackaday Supercon 2024, we noticed an interesting project was getting quite a bit of attention, so we got nearer for a close-up. The ‘Circuit Graver’ by [Zach Fredin] is an unconventional PCB milling machine, utilizing many 3D printed parts, the familiar bed-slinger style Cartesian bot layout and a unique cutting head. The cutting tool, which started life as a tungsten carbide lathe tool, is held on a rotary (‘R’) axis but can also move vertically via a flexure-loaded carriage driven by a 13 kg servo motor.

The stocky flexure took a lot of iteration, as the build logs will show. Despite a wild goose chase attempting to measure the cutting force, a complete machine solution was found by simply making everything stiff enough to prevent the tool from chattering across the surface of the FR4 blank. Controlling and maintaining the rake angle was a critical parameter here. [Zach] actually took an additional step, which we likely wouldn’t have thought of, to have some copper blanks pre-fabricated to the required size and finished with an ENIG coating. It’s definitely a smart move!

To allow the production of PCB-class feature sizes compatible with a traditional PCB router, the cutting tool was sharpened to a much smaller point than would be used in a lathe using a stone. This reduced the point size sufficiently to allow feature sizes down to 4 mils, or at least that’s what initial characterization implied was viable.  As you can see from the build logs, [Zach] has achieved a repeatable enough process to allow building a simple circuit using an SMT 74HC595 and some 0402 LEDs to create an SAO for this year’s Supercon badge. Neat stuff!

We see a fair few PCB mills, some 3D printed, and some not. Here’s a nice one that fits in that former category. Milling PCBs is quite a good solution for the rapid prototyping of electronics. Here’s a guide about that.

[David Bryant] clearly has an awareness of the impact of an excess concentration of CO₂ in the local environment and has designed an SAO board to add a CO₂ traffic light indicator to one of the spare slots on the official Hackaday Supercon 2024 badge.

The part used is the Sensirion SCD40 ‘true’ CO2 sensor, sitting atop an Adafruit rider board. [David] got a leg up on development by creating a simple SAO breakout board, which could have either the male and female connectors fitted, as required. Next, he successfully guessed that the badge would be based around the RP2040 running MicroPython and hooked up an Adafruit Feather RP2040 board to get started on some software to drive the thing. This made hooking up to the official badge an easy job. Since the SAO has only two GPIOs, [David] needed to decode these to drive the three LEDs. There are a few ways to avoid this, but he wanted to relive his earlier EE college years and do it the direct way using a pair of 74HC00 quad NAND gate chips.

We’ve seen a few CO₂ monitors over the years. This sleek little unit is based around the Seeeduino XIAO module and uses an LED ring as an indicator. Proper CO₂ monitors can be a little pricey, and there are fakes out there. Finally, CO₂ is not the only household pollutant; check out this project.

As we all know, when developing software for any platform or simply hacking a bit of code to probe how something works, the ability to deploy code rapidly is a huge help. [Martin Donlon], aka [wickerwaka], is well known in retro gaming and arcade hardware reverse engineering circles and had the usual issues figuring out how an arcade CPU board worked while developing a MiSTer core. Some interesting ASICs needed quite a bit of poking, and changing the contents of socketed ERPOMs is a labour-intensive process. The solution was PicoROM, a nicely designed ROM emulator in a handy DIP-32 form factor.

As the title suggests, PicoROM is based on the Raspberry Pi RP2040. It emulates an 8-bit ROM up to 2MBits in size with speeds up to 100ns. Since it uses the RP2040, USB connectivity is simple, enabling rapid uploading of new images to one (or more) PicoROMs in mere seconds. A vertically orientated USB-C connector allows multiple PicoROMs to be cabled to the host without interfering with neighbouring hardware. The firmware running on core 1 passes data from the internal 264K SRAM, using the PIO block as a bus interface to the target. A neat firmware feature is the addition of a mechanism to use a ROM region as a bidirectional control channel, which the software running on the target can use to communicate back to the host computer. This allows remote triggering of actions and the reporting of responses. Responses which may not be physically observable externally. [Martin] is using this feature extensively to help probe the functionality of some special function chips on the target boards, which is still a slow process but helped massively by reducing that critical software iteration time. The PCB was designed with KiCAD. The project files for which can be found here.

This isn’t the first time we’ve seen the RP2040 used for ROM emulation; here’s a pile of wires that does the same job. It just isn’t as pretty. Of course, if you really must use EPROMs, then you could give this sweet programmer a look over.

[David Shadoff] has a clear soft spot for the NEC console systems and has been collecting many tools and data about them. When developing with these old systems, having a way to upload code quickly is a real bonus, hence the creation of the PC-FX Dev Cart. Based on the Raspberry Pi RP2040, the custom cartridge PCB has everything needed to run software uploadable via a USB-C connection.

While the PC-FX is a CDROM-based system, it does sport a so-called FX-BMP or backup memory port cartridge slot, which games can use to save state and perform other special functions. Under certain circumstances, the PC-FX can be instructed to boot from this memory space, and this cartridge project is intended to enable this. Having a quick way to upload and execute code is very useful when exploring how these old systems work, developing new applications, or improving the accuracy of system emulators. The original FX-BMP cartridge has little more inside than a supercapacitor-backed SRAM and a custom interfacing IC, and of course, it would be quite a hassle to use this to develop custom code.

The RP2040 isn’t really being too tasked in this application, with one core dedicated to emulating a 128K x 8 SRAM, handling the PC-FX bus interface, and the other doing duty on the USB side. At the top of the PCB are a pair of 74LVC16T245 16-bit level shifter ICs, which need to be translated from the 5 Volt console voltage domain into the 3.3 Volts at which the microcontroller operates. Power for the board is taken from the USB, not the console, enabling code to be uploaded before powering up the target. This way, the power budget of the console isn’t compromised, and the cartridge can be initialized before powering up and booting.

[David] Needed to overclock the RP2040 to 240 MHz, way beyond the specification limit of 133 MHz, because despite the PIO block being fast enough to emulate the required interface timing, the latency passing data between the PIO and the CPU core was too large, hence the need for GPIO-based solution. The project was created in KiCAD; the design files can be found here, and only one mistake has been found so far!

[David] is also heavily involved with documenting and collecting all the PC-FX resources available in the wild. These can be found in this GitHub repo. It doesn’t look like we’ve covered the PC-FX before, but we have seen a few hacks about its older sibling, the PC Engine and the closely related TurboGrafx-16. Here’s a simple PC engine-to-TurboGrafx converter board for starters. If you lack the genuine hardware, do not despair; here is an FPGA-based emulator.

A decade ago, [Jouke Waleson] bought a Dutch ‘model 1950’ PTT (The Dutch Postal Service) rotary-dial telephone of presumably 1950s vintage manufactured by a company called Standard Electric, and decided it would be neat to hack it to function as a Bluetooth hands-free device. Looking at the reverse, however, it is stamped “10.65” on the bottom, so maybe it was made as recently as 1965, but whatever, it’s still pretty old-tech now.

The plan was to utilise ESP32 hardware with the Espressif HFP stack to do all the Bluetooth heavy lifting. [Jouke] did find out the hard way that this is not a commonly-trodden path in hackerland, and working examples and documentation were sparse, but the fine folks from Espressif were on hand via GitHub to give him the help he needed. After ripping into the unit, it was surprisingly stuffed inside there. Obviously, all the switching, even the indication, was purely electromechanical, which should be no surprise. [Jouke] identified all the necessary major components, adding wires and interfacing components as required, but was a bit stumped at the function of one funky-looking component that we reckon must be a multi-tap audio transformer, oddly finished in baby pink! After renovating some interesting cross-shaped mechanical indicators and wiring up some driving transistors, it was time to get on to the audio interface.

Initially, [Joike] planned to use an INMP441 I²S digital microphone module, but this was incompatible with the standard ESP32 HFP client (used for Bluetooth hands-free support), so [Jouke] pivoted and used a WM8782-based ADC board for audio input. This also allowed the existing microphone to be used simply by biasing

it to 5 Volts and hooking it straight up to the ADC board via a coupling capacitor. This was a happy outcome, as the modern digital microphone would have sounded very different to the original equipment! On the speaker side, a PCM5102 I²S audio DAC module was pressed into service. The ringer/buzzer needed seven volts, so adding a boost converter board was also necessary. It’s a minor annoyance for powering a single device, but this is a one-off hack, so it’s no big deal. Finally, the backplate was modified to add a USB-C module and a power switch so it could be power-cycled, giving access to the ESP32 boot loader and enabling firmware updates without opening the case.

The outfit’s brains are courtesy of a LilyGo T-Koala board, a basic breakout board based around the older ESP32-WROVER module. This was necessary as the newer ESP32 chips drop Bluetooth classic support and, with it, support for handling the Bluetooth hands-free protocol. We were particularly ticked by the project tagline, “Bakelite to the future”, and that lifting the phone when not answering an incoming call connects you to Google Assistant or Siri! Nice work! For a look over the source code for the project, check out the GitHub page.

This is not the first modernisation of a classic telephone, and we hope it won’t be the last. Here’s an older GSM-based hack. If all this talk of rotary phones and tethered handsets confuses you, here’s our guide to this older telephone system. Telephones weren’t the only old-school home appliances constructed from Bakelite—far from it. It was also used to make many radios.