Some people learning the noble art of electronics find the jump from simpler tools like Fritzing to more complex ones, such as KiCAD, a little daunting, especially since they need to learn at least two tools. Fritzing is great for visualising your breadboard layout, but what if you want to start from a proper schematic, make a prototype on a breadboard and then design a custom PCB? Well, with the Kicad-breadboard plugin for (you guessed it!) KiCAD, you can now do all of this in the same tool.

Originally designed to support EE students at the University of Antwerp, the tool presents you with a virtual breadboard with configurable size and style, along with a list of components and tools that can be placed. A few clicks and parts can be placed on the virtual breadboard with ease. Adding wires is the next logical step to make those connections that operate in the horizontal dimension. Finally, assigning power supplies and probe connections completes the process. It’s a simple enough tool to draw stuff, but drawing a layout is no use if you can’t verify it’s correctness. This is where this plugin shines: it can perform an ERC (check) between the schematic and the breadboard and flag up what you missed. Add to this that you can also perform an ERC at the schematic level, before even thinking about layout, and it’s pretty hard to make an error. Now, you can transfer this directly to a real breadboard, or even a veroboard, for more permanence once you have confidence in correctness. This will definitely save time correcting errors and help keep the magic smoke safely contained within those mysterious black rectangles.

As it stands, the tools are limited to a few select ICs, which, much to this scribe’s disappointment, did not include the venerable 555 timer; however, it would be possible to work around that with some imagination at the schematic level. The ability to drop in and document power supply, function generator, and oscilloscope probing points is nice, enabling one to close the loop on documenting a layout to make it truly transferable to physical reality.

We cover electronics prototyping with breadboards a lot because they’re accessible. Here’s a super simple computer on a breadboard. We also like seeing them integrated as tools, like here. Finally, why stick with the tired old common breadboard shapes when you could make your own?

Cooking food with fire is arguably the technology that propelled humans to become the dominant species on Earth. It’s pretty straightforward to achieve, just requiring a fuel source, a supply of oxygen from the air, and a way to initiate the reaction; then it self-sustains. You wouldn’t think there’s much to improve, but what about cooking with plasma? [Jay] from the plasma channel is no stranger here, and he thinks that there may be something in this idea, certainly enough to actually build something.

Now, let’s be straight with you, this isn’t a new concept, and you can buy a plasma-based cooking appliance right now. But they are all AC-powered devices. What if you want to go camping? [Jay] attempts (and succeeds) in building a portable, rechargeable 600W plasma cooking device that can actually cook food, but it was not all plain sailing.

The existing off-the-shelf ZVS driver modules available were a bit weak and unreliable, and the required flyback coils were hard to find with the right specs, so he needed to get down to work building custom parts. First off, the coils. Custom formers were resin-printed and machine-wound with 4000 turns of fine wire, and then resin-sealed into the former. [Jay] takes care to explain that it is crucial to get all the air out of the windings, or else local flashover breakdown will occur and wreck the coil in a short time. We reckon the resulting coils look amazing in their own right!

Next, the ZVS drivers on hand had low-quality capacitors (well, not enough capacitance anyway) and cheap driver transistors, so both were upgraded. The initial plan was to have four driver/coil pairs, each driving a single pair of electrodes, with a common ground ring connecting them all. It turns out this was a terrible idea: the drivers were not synchronised, so they were pulling on each other, causing catastrophic damage to the PCBs in a very short time. The solution was more complicated wiring, to give each coil secondary output a dedicated electrode pair, so there was no direct electrical connection between neighbouring coils and no coupling between them. A clever electrode arrangement meant that a pan would sit on top of a ring of electrodes, causing plasma discharges to jump directly to the pan, thereby concentrating localised heating there. We were wondering how this new direct connection (the pan is now a common connection!) didn’t also cause backfeeding and kill the ZVS drivers again, but it didn’t seem to happen.

Anyway, [Jay] demonstrates what is possibly the world’s first rechargeable, portable plasma cooker capable of making breakfast. Which we think is very important in its own right, however, we would like a plasma-based solution to making toast next, perhaps a plasma knife that cooks the bread as you slice it?

If this plasma cooking lark rings a bell, yes, we did touch upon this way back in 2017. And whilst not strictly plasma cooking, you can make an amazing microwave plasma in this ridiculously upgraded appliance. Definitely do not try that one at home.

The modern web is a major pain to use without a password manager app. However, using such a service requires you to entrust your precious secrets to a third party. They could also be compromised, then you really are in trouble. You could manage passwords with local software or even a notebook, but that adds cognitive load. You could use the same password across multiple sites to reduce the load, but that would be unwise. Now, however, with the HIPPO system, there is another way.

HIPPO is implemented as a browser extension paired with a central server. The idea is not to store any password anywhere, but to compute them on the fly from a set of secrets. One secret at the server end, and one the user supplies as a passphrase. This works via an oblivious pseudorandom function (OPRF) protocol. Details from the linked site are sparse, but we think we’ve figured it out from other sources.

First, the user-supplied master password is hashed with the site identifier (i.e., the domain), blinded with a random number, and then processed using an OPRF, likely built on an elliptic-curve cryptographic scheme. This ensures the server never receives the raw password. Next, the server applies its own secret key via a Pseudorandom Function (PRF) and sends it back to the client. Obviously, its private key is also never sent raw. Next, the client removes the blinding factor (using the same random number it used when sending) from the original key, producing a site-specific high-entropy secret value that the extension passes to a Key Derivation Function (KDF), which formats it into a suitable form for use as a password. Finally, the extension auto-fills the password into the website form, ready to send to the site you want to access. This password is still unique per site and deterministic, which is how this whole scheme can replace a password database. Neat stuff!

This advantage to this whole scheme means there’s no vault to compromise, no storage requirements, and it generates a strong password for each unique site, meaning no password reuse and a low chance of brute-force cracking. The obvious flaw is that it creates a single point of failure (the HIPPO service) and shifts the risk of compromise from vault cracking the master password, infiltrating the server, or compromising its secret key. It’s an interesting idea for sure, but it doesn’t directly manage 2FA, which is a layer you’d want adding on top to ensure adequate security overall, and of course, it’s not a real, live service yet, but when (or if) it becomes one, we’ll be sure to report back.

Confused by all this? Why not dig into this article first? Or maybe you fancy a DIYable hardware solution?

In a satisfying blend of classic console restoration and modern modding, [Elliot] from the Retro Future channel has transformed a broken, dirty PlayStation into what they call the “ultimate PS1.”

The first step was to deal with the really grungy case. The shell was soaked in dish soap and given a good brushing before being packed and sent to a collaborator. Upon inspection of the internals, several unknown modifications to the PCB were evident. These were likely to support playing home-burned copies of pirated games, as well as an NTSC region hack (for this PAL version of the console), courtesy of a dodgy-looking crystal oscillator hanging on the end of some wires.

Luckily, the PS1 product design is highly modular, giving excellent repairability, which made reversing this a doddle. The mod wiring was removed by simply desoldering it, but the cut traces needed to be cleaned up and reconnected to return it to stock condition.

After the first round of fixes, [Elliot] plugged into the TV for a test. It was still outputting black-and-white. Something was still amiss. He had simply connected one of the repair wires to the wrong spot on the PCB. After correcting that error (and getting lucky, no damage was done), the correct colour PAL output was seen.

Next, a PicoStation ZeroWire was soldered in place. This cleverly-shaped PCB hosts one of the Pico MCU chips and allows launching games from an SD card. Using a combination of large through holes on the PCB and a few castellated edge holes, installation looks very easy. ZeroWire is a bit of an unfortunate name, as it actually requires one jumper wire to be attached, but we’re just nitpicking here. Next, there was some really precarious-looking pin lifting on the CDROM controller chip. Cleanliness is in order here for a successful soldering mod. A special ESD toothbrush (not really) was pressed into service for cleaning with IPA. Proper ESD tools are not expensive, but you can get away without them.

An Amazon-sourced PAL-to-HDMI adapter was tried to perform some 720p “upscaling”. This reduced the obvious jaggies a bit, but it was not really good enough for [Elliot]. So instead, he installed an HDMI mod board sourced from an Aliexpress store (listing now defunct). The metal shielding can was removed to reveal the video ICs. The serial port connector was removed, as this is the location for the new HDMI port. The ‘fun’ part of this particular mod is attaching the custom flex PCB to the video chip. This is quite a daunting task for those not comfortable with SMT soldering techniques. It may look hard, but it’s actually dead easy to drag-solder this, so long as you use plenty of good-quality flux and keep the heat under control. Once that was out of the way and second smaller cable was routed to the audio chip.

Next up was to deal with the old-school wired controllers. The TechnoBit Videojuegos Re-Live BT controller board allows the use of a modern wireless controller. Its installation requires disassembling the original controller connector module. The PCB from the rear of the module is removed along with the ribbon cable connector and a through-hole Zener diode, both of which are reused and soldered to the new controller board. This seems like an unnecessary faff and could have easily been pre-installed or at least included with the PCB. Also, soldering the through-hole beeper to surface-mount pads made us cringe. That looks like someone forgot to make the correct footprint for a part that normal humans can solder.

Finally, a Robot Retro USB-C power supply was dropped in to replace the original AC power supply, bringing this build’s connectivity into the current decade. USB power, HDMI ‘1080p’ output, SD card game loading, and a BT controller. Nice! The last part of the build features a custom respray of the enclosure, a nod to the original ‘dev kit blue’ version when the PS1 was first announced all those years ago. Ah, we remember it well!

Retrogamers familiar with PS1 hacks might recall we covered the PicoStation hack some time ago. You might also remember this hack that squeezes a complete PS1 emulator into a DS cartridge. Finally, hacks can be pure software, with nary a soldering iron in sight, like this one.

Thanks to [Keith] for the tip!

EDM (Electrical Discharge Machining) is one of those specialised manufacturing processes that are traditionally expensive and therefore somewhat underrepresented in the DIY and hacker scenes. It’s with great delight that we present EnderSpark, a solution to not one but two problems. The first problem is how to perform CNC operations on hard-to-machine materials such as hardened metals (without breaking the bank). The second problem is what to do with all those broken and forgotten previous-generation Creality Ender 3D printers we know you have stashed away.

To be honest, there isn’t much to a cheap 3D printer, and once you ditch the bed and extruder assembly, you aren’t left with a lot. Anyway, the first job was to add a 51:1 reduction gearbox between the NEMA 17 motors and the drive pullies, giving the much-needed boost to positional accuracy. Next, the X and Y axes were beefed up with a pair of inexpensive MGN12H linear rails to help them cope with the weight of the water bath.

The majority of the work is in the wire feeder assembly, which was constructed around a custom-machined aluminium plate. It’s not lost on us how the original RepRap bootstrapping concept could be applied here: a basic frame made externally in a low-cost material, then using the machine to cut a much thicker, stronger copy for its own upgrade. The main guide nozzle is an off-the-shelf ruby part surrounded by a 3D printed water-cooling jacket. To maximise power transfer from the wire into the electrically conductive workpiece material, the top part of the wire feeder, including the wire itself, is one electrode, and the entire bottom part of the frame is electrically isolated from it. The bottom part pulls the ‘consumed’ stock wire through the nozzle above and keeps it under tension, sending it onward to the waste spool.

Electrically speaking, the project is based on stock Ender electronics, with an additional power driver stage to send capacitor-discharge-derived pulses down the wire from the 48V power supply, up to 10A, generating the needed tiny sparks as the wire is advanced into the electrically grounded workpiece. Industrial machines operate around twice this voltage, but safety is a big issue with a DIY machine. Not to mention 48V and water don’t make the best of friends. Speaking of water, it needs to be de-ionised to reduce dielectric loss, but ionic contamination will build up over time, so it needs to be regularly changed.

Software-wise, the machine is running on G-code, so all that is needed is a custom plugin for Fusion 360 to turn the extracted toolpath (they’re using the Wazer water cutter profile as a basis) into G-code, with knowledge of the material. There aren’t too many variables to play with there.

In the future, a few things are being considered. Adding closed-loop control of the pulse energy would be straightforward, but controlling the horizontal feed rate would be a little trickier to implement with a pure G-code approach. We’ll keep an eye on the project and report back any advances!

If you’re thinking you’ve seen this sort of thing before, you’re right. Here’s another DIY EDM machine, and another, and finally, a Kickstarter we covered a while back that converts any 3D printer into a wire EDM.

Thanks [irox] for the tip!

This project gives a whole new meaning to DIY PC. We don’t know how capable you were as a teenager, but could you have designed your own Ryzen-based mini PC?

Whilst making repairs to laptop internals, [Dominik Baroński] was busy taking notes. Modern super-integrated laptop PCs have reached the point where all the functions of a complete PC are embedded in a single chip. But it’s a big, complicated chip with very specific feeding and care needs. Once you’ve figured out what it needs, it ‘merely’ remains to supply it power, hook up some DDR4 RAM, PCIe storage, and some USB ports, and you’re away. It sounds easy when you say it like that, but do not underestimate how difficult it is to create such a board—or even to populate it by hand—yet that’s precisely what [Dominik] has achieved.

The first video is a time-lapse of the soldering process, which isn’t very interesting beyond the fact that they didn’t even waste time making a solder paste stencil and just ran with manual tinning and hot-air reflow. Well, we guess it works, but you wouldn’t want to build a whole batch this way! Anyway, the second video, produced by YouTuber [Coleslav], is originally in Polish, but auto-dubbed to English for the rest of us, and whilst a bit long-winded, does give a flavor of how [Dominik] approached this project. There are quite a few interesting little technical details that [Coleslav] has teased out of [Dominik] when interviewing them for the video, such as they noticed that certain laptop manufacturers were reusing older PMU circuits designed to power DDR2 RAMs by tricking the controller into operating at lower DDR4 voltages by tweaking resistor values, rather than specifying a ‘proper’ (i.e. more expensive) DDR4 compliant device and redesigning the circuit. [Dominik] relied heavily on the Saturn PCB toolkit for calculating differential pairs and other physical PCB aspects to make it possible to design the circuit in KiCAD with just six layers on a minuscule 100 mm x 100 mm outline. Quite a feat!

There were issues with using certain chips that were available to buy, but the documentation was leaked, so the seller was likely not authorized. But the biggest problem is the BIOS, which was duplicated from a similar laptop. [Dominik] hopes to find help to get coreboot running on this board, at which point the archaic keyboard and system controller (now called the EC) can be junked in favor of a more hacker-friendly STM32 setup.

No PCB footprint for the Ryzen chip was available either. [Dominik] created it using a Python script that read the SVG view of the ball-out downloaded from the WikiChip site. The pad positions were known, but the names still needed to be entered manually. All 1140 of them. Once the mappings were entered, schematic symbols could be generated to complete the schematic. Next, they created a 3D model using ChatGPT to write a Python script that read in the ball positions and spat out an STL file that could be molded into a complete footprint! [Dominik] has made a short write-up on Hackaday.io with a few images, and hopefully, more details will appear in the coming months. We’ll be keeping an eye on this young maker over the next few years; we have a feeling great things are coming.

Whilst we’re on the subject of building PCs, here’s a DIY gaming laptop with a twist. At the other end of the complexity scale, here’s a neat DIY computer built from scratch.

Thanks to [JM] for the tip!

[bogdanthegeek] has a lot of experience with the ARM platform, and their latest escapade into working with cheap ARM chips recovered from disposable vapes involved a realization that it was just plain wrong to debug such recovered silicon with something as expensive as a Pi Pico. No, they needed to build a debugger using the super cheap CH32V003.

What follows is an interesting tour around ARM Debug Access Port (DAP) programmers and creating a practical USB-connected device that actually works with modern toolchains. The first problem to be solved was that of host connectivity. These days, it’s USB or go home, which immediately limits the microcontrollers you can choose. Luckily for [Bogdan], they were aware of the excellent work by [cnlohr] on wedging low-speed USB support onto the RISC-V CH32v003 with the software-only bit-banging rv003usb, which provided a starting point. The next issue was to check for interrupt-driven endpoint support (needed for low-speed USB) in the Mac OS X kernel, which they knew was being dropped at an alarming rate (well, at least for full-speed). Luckily, the CMSIS-DAP standard required support for interrupt-driven USB endpoints, so kernel support was likely intact.

Next, [Bogdan] noticed that the DAPLink project had been ported to the bigger, native-USB WCH chips like the CH32V203, so it was a matter of porting this code to the diminutive CH32V003 using the rv003usb stack for the USB support using [cnlohr]’s ch32fun toolchain. There were a few bumps along the way with a lack of clarity in the DAPLink code, and some inconsistencies (across platforms) with the USB library dependencies of the upstream tool pyOCD, but they did get some tools working on at least Mac OS and some others on Linux. Which was nice.

We’ve covered the CH32V003 a fair bit, with people trying to give it all kinds of big-CPU tricks, such as speech recognition (of sorts) or even building a supercluster.