Mysterious Files PH

[Térence Grover] had a very special coin—a  €1,000 commemorative piece only available to Monégasque nationals. If you want to flip one, normally you’d have to go snatch one up from somebody in Monaco—or you could just do it online!

Yes, he built an automated online coin flipper to flip this very special piece of coinage. A 12-volt solenoid is fired to flip the coin into the air. It then lands on its 3D-printed tray, where a Raspberry Pi-based computer vision system built with OpenCV and a TFLite model classifies whether the result is heads or tails via a machine learning algorithm. An iris mechanism operated by servo motor then centers the coin on the tray, so it sits back over the solenoid, ready to flip once again. [Térence] was eventually able to refine this simple homemade build to the point that it ran autonomously for a full 50,000 flips on a livestream without issue.

The mechanism in this build is not dissimilar to a coin flipper we’ve seen before. We’ve also explored the statistics involved, too. Video after the break.

This week Jonathan chats with Johannes Millan about Super Productivity and Parallel Code! Those are two very different projects, but both aiming for helping us get our work done. Super Productivity is a scheduling and time tracking suite, while Parallel Code is an almost-IDE for managing and isolating AI coding agents. This episode has something for everybody, so check it out!

• https://github.com/johannesjo
• https://super-productivity.com
• https://parallelcode.app/

Did you know you can watch the live recording of the show right on our YouTube Channel? Have someone you’d like us to interview? Let us know, or have the guest contact us! Take a look at the schedule here.

Direct Download in DRM-free MP3.

If you’d rather read along, here’s the transcript for this week’s episode.

Theme music: “Newer Wave” Kevin MacLeod (incompetech.com)

Licensed under Creative Commons: By Attribution 4.0 License

It’s a phrase we use a lot in our community, “Drink the Kool-Aid”, meaning becoming unreasonably infatuated with a dubious idea, technology, or company. It has its origins in 1960s psychedelia, but given that it’s popularly associated with the mass suicide of the followers of Jim Jones in Guyana, perhaps we should find something else. In the sense we use it though, it has been flowing liberally of late with respect to AI, and the hype surrounding it. This series has attempted to peer behind that hype, first by examining the motives behind all that metaphorical Kool-Aid drinking, and then by demonstrating a simple example where the technology does something useful that’s hard to do another way. In that last piece we touched upon perhaps the thing that Hackaday readers should find most interesting, we saw the LLM’s possibility as a universal API for useful functions.

It’s Not What An LLM Can Make, It’s What It Can Do

When we program, we use functions all the time. In most programming languages they are built into the language or they can be user-defined. They encapsulate a piece of code that does something, so it can be repeatedly called. Life without them on an 8-bit microcomputer was painful, with many GOTO statements required to make something similar happen. It’s no accident then that when looking at an LLM as a sentiment analysis tool in the previous article I used a function GetSentimentAnalysis(subject,text) to describe what I wanted to do. The LLM’s processing capacity was a good fit to my task in hand, so I used it as the engine behind my function, taking a piece of text and a subject, and returning an integer representing sentiment. The word “do” encapsulates the point of this article, that maybe the hype has got it wrong in being all about what an LLM can make. Instead it should be all about what it can do. The people thinking they’ve struck gold because they can churn out content slop or make it send emails are missing this.

So we have an LLM, even a small one on our own computer, and looking at it in that light it’s immediately apparent that it can become a function to do almost any processing task, if you wrap the right prompt and API call in a function definition. Of course that’s dangerous, because if I may I would like to coin a new phrase: function slop.

As an example I can call an LLM to do simple numerical addition and it will perform the task, but doing so would be utterly pointless given the existence of the + operator. If you are going to use an LLM to perform a processing function it’s important that it be a function where doing so makes sense, otherwise your function is just function slop. A quick web search tells me that function slop is not yet a thing, so I would like to take this moment to apologise for what I may have unleashed upon the world.

Function slop aside though, using the LLM to do a processing task where it makes sense, shouldn’t be ignored as a useful tool. These things are very good at summarising and categorising information in the way a human might do it, a task that’s often hard in traditional programming, so if the job in hand fits those capabilities then it makes sense to use them.

This has been a three-part series, and unlike Star Wars or The Hitchhikers Guide To The Galaxy, it’s probably going to stay that way. I hope that in our explanation we’ve successfully looked beyond the hype and found something useful in all this. It’s odd though, as the one writing it you might think I would be bubbling over with new ideas, but aside from the previous article’s sentiment analysis I still find myself with not much I find the need to use an LLM for. Which is maybe the point, it’s one thing to know a bit about them, but just because they’re there doesn’t mean you have to use them.

When [OGS Mechanics] got a Mercedes EQC 300 battery-electric car in for repair, it was found to have a bit of a weird issue: after sitting in a garage for a while, its range on battery had suddenly reduced significantly without clear cause. Although the typical response here is to just mark the battery pack as ‘faulty’ and replace the whole unit, [OGS] decided to dig into the pack to see what was going on.

The short version is that this particular battery pack consists of two individual batteries, each with its own BMS, one of which had reported a condition to the master BMS that triggered the ‘replace battery module’ error observed with the scan tool. From this it could also be seen that the first battery was at a 10% state-of-charge (SoC), and the second at 95%, making them incredibly unbalanced. Unfortunately the dealer procedure to rebalance did not work here, with only the second battery wanting to charge even after draining both to the same initial level.

To diagnose the underlying issue in earnest required gently prying open the battery pack like a massive glued-shut smartphone. Going by the theory that it is a software glitch, since the first battery was still at a healthy voltage level, it was decided to manually charge it. With both batteries now fully charged, the BMS for the first battery was then removed to have its memory overwritten with that of a known good BMS module, clearing the ‘replace battery module’ error.

Although in the preview for the next video it’s hinted that there’s also an internal balancing issue in the first battery pack, this could be another symptom of its BMS glitching out. Either way, it would seem that BEVs battery modules are both heavily dependent on software, as well as afflicted by the same throw-away culture that has people just buying a new smartphone when the battery fails.

Distraction free writing tools are a reaction to the bells and whistles of the modern desktop computer, allowing the user to simply pick up the device and write. The etyper from [Quackieduckie] is one such example, packing an e-paper screen into a minimalist case.

These devices are most often made using a microcontroller such as an ESP32, so it’s interesting to note that this one uses a full-fat computer — if an Orange Pi Zero 2W can be described as “Full-fat”, anyway. There’s an Armbian image for it with the software pre-configured, and also mention of a Raspberry Pi port. It works with wired USB-C keyboards, and files can be retrieved via Bluetooth. It doesn’t look as though there’s a framebuffer or other more general driver for the display so it’s likely you won’t be using this as a general purpose machine, but maybe that’s not the point. We like it, though maybe it’s not a daily driver.

This hack is part of our 2026 Green Powered Challenge. You’ve just got time to get your own entry in, so get a move on!

There are plenty of electronic components out there, but the one we tend to forget is the most basic: wire. Sure, PC boards have largely replaced wire with copper traces, but most projects still need some kind of wire somewhere. Once you need any wire, there’s a good bet you will need longer wire, and that means splicing one wire to another. Simple, right? Not really. There are a variety of ways to splice wires, and which one you use depends on what you want to do and the type of wire you are using.

If the wires touch, good enough, right? Not necessarily. You need enough contact area for the current you are drawing through the wire to flow. It is also nice if the splice can survive some amount of mechanical strain, vibration, and survive getting hot and cold repeatedly.

Usually, after splicing, you’d like to solder the connection, although depending on the application, you don’t always see that. At the very least, you’d want to wrap it in electrical tape, use heat-shrink tubing, or otherwise insulate the bare wires and maybe provide a little mechanical support or strain relief.

Keep in mind that there are connector options, either mechanical, crimped, or soldered, that allow you to avoid splices. Soldering to a terminal strip, for example, or scewing wires into a barrier strip will get the job done. So will a butt connector, a wire nut, or a WAGO connector. But sometimes, for whatever reason, you just need to attach two wires to each other. It’s been done before.

The Gold Standard

Arguably, the best way to join two similar-sized solid wires is the Western Union splice, or the lineman’s splice, which goes back to at least 1915 when the book Practical Electric Wiring (PDF) described it. It will work with stranded wire, too, if you twist it tightly and, even better, tin the wires first.

You essentially bend each wire around the other and then tightly wrap each wire around the other wire. There are a few options about how to handle the middle part, as you can see in the adjacent figure.

These aren’t hard to make, but it does depend a bit on the skill and patience of the person making the splice. On the other hand, they are mechanically very robust.

NASA’s workmanship document (NASA-STD-8739.3, PDF) urges you to avoid splices and prefer controlled processes like crimps, where a tool produces repeatable connections. However, in testing, soldered Western Union splices were found to be quite strong, usually stronger than the wire around them.

Other Common Splices

Perhaps the most common splice is the rat or pig tail splice. That’s where you just twist two wires together. If you don’t have to survive mechanical tension and you have solid wire, this works ok and is what you often see inside electrical boxes in North America, either made by or topped with a wire nut.

These are fast and simple, but without something like a wire nut, a bit suspect. They tend to loosen over time, especially under vibration.

Another problem is when you have very large solid wires that are not practical to twist. That calls for a Britannia splice. Here, you put two presumably thick wires end-to-end and bind them with a smaller wire. You don’t see these very often, although you may see them in some utility contexts. More often, you’d crimp a butt connector to join two large wires. Note the binding wire wraps around both wires and the common part where the wires touch.

A similar splice is the so-called fixture splice, in which a smaller wire wraps around a larger one. This is another case where you would almost always finish this off with some kind of mechanical connector, like a wire nut.

Sometimes you need a splice that isn’t much larger than the original wire. You can do that with a scarfed splice. This is usually only practical for large, solid wires. You essentially taper each wire to a point (using, for example, a file) and then bond them together much like a scarf joint in carpentry. Of course, you must solder or somehow fix the wires together, as there is no mechanical connection. This takes a lot of work and also takes skill to get right.

Specialty Splices

Sometimes, you want a splice into an existing wire to form like a “T” or a tap. It is possible to create a tap joint by removing insulation from the main conductor and then wrapping wire around the bare metal. Often, you’ll tie a knot it the tap wire before wrapping to try to improve the mechanical hold a bit.

However, these are not especially strong, and you have to be careful removing the insulation so as not to nick the main conductor and weaken it or reduce its current capacity.

If the main wire is stranded, another variation is to carefully split the main conductor into two segments and then pass the tap wire through the center before wrapping it as before. While this might be slightly more mechanically advantageous, it is still not a good replacement for a crimp-on tap or a connector to hold three wires.

Splicing multiconductor wire can also pose a challenge. Sure, for a lamp cord, it is just as simple as making two splices. But in cables where the pair is balanced, it is often impractical to maintain the spacing and twisting of the wire. Better to get a cable of the proper length.

Probably Others

There are probably as many ways to make a splice as there are people making splices. Some are clever, others are terrible, and a few — like the Western Union splice — have stood the test of time.

Most of the time, you want to avoid splices where you can. Try a terminal block, a solder sleeve, or a crimp connector. Even a wire nut, while technically a splice, will give you some mechanical advantage over just twisting wire together.

We favor the Western Union splice with a good coat of solder. In the end, the “right” splice is the one that matches the electrical load, mechanical demands, and environment you expect it to live in. A quick twist might work today, but a properly executed splice will still be working years down the line.

What’s your go-to method? Let us know in the comments.

Once the microcomputer era got going in earnest, the floppy disk quickly supplanted the tape as the portable storage method of choice. They were never particularly large, but they were fine for the average user to get by.

At the same time, it wasn’t long before heavier-duty removable storage solutions hit the market for power users who needed to move many megabytes at a time. In the 1980s, these were primarily the preserve of big print shops, corporate users, and governments. By the 1990s, even the mildly savvy computerist was starting to chafe against the tyrannical 1.44 MB limit of the regular 3.5″ diskette. Against this backdrop launched the SuperDisk—the product which hoped to take the floppy format to the next level, yet faltered all the same.

More Is Better

The SuperDisk was yet another innovation spawned by 3M, or more specifically, by the company’s storage group, Imation.  Landing on the market in 1996, it was intended to be a higher-capacity successor to the regular floppy disk. In this era, the default removable storage was was the 3.5″ floppy, capable of storing 1.44 MB on a high-density double-sided disk in the dominant IBM format. The SuperDisk would easily eclipse that with its 120 MB capacity, nearly ten times what users were used to getting from a compact floppy disk. Back in the mid-1990s, when hard drives were just starting to flirt with gigabyte capacities in the single digits, this was a huge chunk of storage to be carrying around in your pocket.

The format relied on so-called “floptical” technology. The idea was to use optical guidance to more precisely position the magnetic heads that read and write the floppy magnetic platter. This would allow a disk to pack more tracks in per given area of disk, massively increasing the storage density. Where a regular 3.5″ floppy disk had 135 tracks per inch, an LS-120 disk would expand that to 2,490 tracks per inch. The LS-120 disks were physically unique, due to the need to have optical alignment tracks on the magnetic surface that could be read via a laser and sensor. Hence the LS designation, for “laser servo.”

A variety of drives were made available in the marketplace, both in internal and external versions. The latter typically used parallel, USB, or SCSI interfaces, while internal drives were accessed via SCSI or ATAPI. Despite the special technology inside SuperDisks, they were otherwise very close in size to regular floppies, albeit with a rather unique shutter design. This allowed the SuperDisk drive to also read regular 1.44 MB and 720 KB diskettes. Notably, though, this was really only a thing in the PC world—the drives could not read 800 KB or 400 KB Macintosh format disks.

Unfortunately for Imation, the SuperDisk had a major hurdle to overcome from the outset. Iomega had already launched the Zip drive in 1995 to rapturous applause, racking up huge orders from the drop. The drives were not compatible with regular floppies in any way, and initial versions stored just 100 MB per disk. However, the first mover advantage had launched Iomega’s market share and stock into the stratosphere. There was little market interest in the upstart competitor when purple drives were already sitting on desks in business and universities around the world. Nevertheless, the SuperDisk drive still found some traction with big OEMs, showing up as an option in Dell, Compaq, and Gateway computers way back when. Panasonic even launched a line of digital cameras that used the supersized disks, not unlike Sony’s floppy disk cameras but with far more storage that made them more practical. Sadly, though, uptake was never high enough to make the SuperDisk a normalized replacement for a regular floppy drive, nor even a viable or well-known competitor to the all-domineering Zip.

Nevertheless, Matsushita persevered with the SuperDisk concept for some time. In 2001, the company launched LS-240 drives, which doubled capacity to 240 MB per disk. They also came with a fun party trick that allowed regular 3.5″ floppies to be formatted to hold 32MB. This feat was achieved in part due to the use of shingled magnetic recording (SMR), a technique wherein magnetic tracks on the platter are allowed to overlap to increase storage density. “FD32MB” formatted disks could only be read in LS-240 drives.

By this point, however, the CD burner had already taken over the world. With a CD-R or CD-RW retailing for less than a dollar in quantity, and capable of storing 700MB-plus, the value proposition of the SuperDisk faltered, along with most other magnetic storage solutions of the era. The drives would eventually go out of production in 2003, by which point the venerable USB drive was rising to prominence as the go-to standard for removable media.

Other than being a little late to market, there wasn’t a lot the SuperDisk got wrong. There were no major scandals with the reliability of the drives or media, and they had the nice feature that they were backwards compatible with existing floppy disks to boot. Sometimes, though, it’s impossible to overcome showing up late to the party. Between Iomega’s dominance in the 90s, and the widespread abandonment of magnetic removable media in the early 2000s, there was never really a good time for the SuperDisk to shine. Like so many other technologies out there, it was perfectly capable at what it was supposed to do, it just didn’t find the right audience. A solution without a problem, perhaps, given that others had already solved the issue before the SuperDisk saw the light of day.

Featured image: “SuperDisk” by [Miguel Durán]