TechyMagThings

The Bernoulli disk was a wild piece of 1980s hardware. Take a big floppy. Spin the platter at 1500 RPM just a micron or so from a read head. The airflow around that rapidly-spinning disk actually stabilizes the disk that close to the read-head via the Bernoulli effect, hence the name. Once upon a time, everybody wanted a Bernoulli Box to put under their Macintosh 512, but [Will It Work?] wanted to see how well these old drives held up to the 21st century… by using it to load games onto a WiiU. 

It’s not as crazy at is it seems. The WiiU is happy to read and write anything that looks like a USB mass storage device. The Bernoulli Box is of course pre-USB– even the later model 5 1/4″ drive [Will] is using from 1987. That means it uses SCSI, the USB of the 1980s. He’s got a 90 MB disk, though IOmega did make disks of higher capacity in that format, all the way up to 230 MB. Yes, the same iOmega of Zip-drive fame and infamy— but don’t worry, the peculiar pneumatic nature of the Bernoulli disks makes them immune to the click of death.

You might think it’s going to take a great deal of hacking and homebrew to get the WiiU talking to a SCSI drive from the 80s, but as we said in the introduction, Nintendo made this thing respect USB conventions, so all that’s needed is an SCSI-to-USB cable. Well, plus a passive SCSI 1 to SCSI 2 adapter to get the USB adapter to fit. Daisy-chaining adapters isn’t the most advanced hack, but the point isn’t how hard it was to pull off– it’s that we’re amazed it worked at all.

It doesn’t seem like the drive slows down the WiiU nearly as much as we’d expect, but then it’s not a console known for fast load times. The other suprizing detail is how much space the WiiU’s formatting sucked up, knocking the 90 MB disk down to only 68 MB– combine that with the WiiU’s firmware wanting to pad space for save files, and not much fits. Thus we don’t expect this odd tower of power to take off like the original did– still, if you had one of these back in the day, it might be a nice nostalgia hit to hear the drive whirring away.

If you think a disk drive is something Nintendo would never imagine for their consoles, think again! The Japanese version of the NES had the Famicon disk drive, which turns out to be essential if you want to run UNIX on that system.

With the advent of affordable 2.5 Gbit, 5 Gbit, and 10 Gbit consumer networking gear, more and more people are taking advantage of these higher networking speeds, with [This Does Not Compute] having used 10 Gbit SFP+ modules over regular Cat-5e copper to connect to a NAS in the next room. Only problem was that after a while these SFP+ modules began to start dropping frames. On taking a closer look at these modules, he found that they were running pretty hot: 40°C while idle. A teardown of one of these modules showed severe discoloration due to heat.

Inside these 10Gbit modules is the Marvell-branded Alaska X 88X3310/40P PHY, which despite the ‘low-power’ claims have a metal heatsink glued onto the actual IC and thermally coupled to the module’s metal enclosure. The other side of the PCB was quite discolored, further indicating how hot these modules run in operation. Some digging revealed that this can go up to around 2.5 watts.

Perhaps the most fascinating part of this teardown is the discovery of an 8051-based MCU that’s responsible for telling the switch the module is put into that it is a 30-meter multi-mode fiber module, presumably for compatibility purposes. It’s definitely an interesting feature of these FS-branded SFP+ modules.

These old modules were replaced with Wiitek-branded modules that are supposed to use only up to around 1.5 watts in operation courtesy of a newer chipset, in the hope that these wouldn’t fry themselves. At idle these do however still run at 30 °C. As noted in the comments, it might be a good idea to have active airflow over high-speed networking gear like this, as they generally can get pretty hot and sometimes crispy.

The final solution for the video’s networking problem was to just run single-mode fiber to the room and use appropriate SFP+ modules for that, also because these run noticeably cooler. If you still have room in your cable ducts, that would seem to be the optimal solution.

Few things are more satisfying during a Summer night than hearing the crackle and pop of another mosquito hurling itself against a bug zapper and knowing that it won’t be trying to suck your blood any more. The only problem with those bug zappers, whether the mounted or hand-held type is that you cannot get every single attacking mosquito. Unless you were to put the bug zapper on yourself, of course. This is basically what [Dani Cruster] of the aptly named ‘DiWHY’ channel decided would be the right course of action.

The video is apparently dubbed over from the original Russian – with the team claimed to be based in Moldova – which probably explains a lot of the reasoning behind this engineering. At the core of the whole-body bug zapper is galvanized mesh, with a big question being how close you can get it to the body before said body gets zapped too. With about a millimeter of clearance between both layers of mesh required at 1 kV, this was another design consideration.

Ultimately the guts of stun guns were used, which output around 10 kV and thus require a 1 cm gap between the mesh layers. PVC plates were used to create the structural elements of the walking bug zapper suit, using a heatgun to form it into a body-appropriate shape. That’s when human testing started, to try and not make it zap the wearer.

The final suit of bug zapping armor uses six stun gun modules, each powered by a 3 V power source created from two 1.5 V alkaline cells that are good for an hour of zapping. One issue found during a human trial run was that the zip ties used turned out to actually cause arcing, which had to be addressed first before heading to the mosquito-infested woods. In the video these are said to be near Tarkov in what appears to be the national park in Russia’s Tver Oblast and clearly a prime mosquito breeding ground.

During the real-life test run many mosquitoes and apparently even some ticks find their electrifying demise, before for some reason they seem to clear out after an hour or so. Overall it seems to work well, even if it’s not that ergonomic and things get spicy when it starts to rain.

Although the basic principle of radio direction finding is easy to understand (measure the phase difference between different antennas, then calculate the angle of arrival from this difference), the radio hardware to actually implement this has historically been hard for hackers to access. The QuadRF project aims to change this by building a phase-coherent four-channel SDR which makes direction mapping easy (GitHub repository).

The QuadRF uses two boards: one to receive and pre-process radio waves, and a Raspberry Pi 5 for additional processing. The RF board has four patch antennas, each capable of either transmitting or receiving in the 4.9 GHz to 6.0 GHz range, with switchable right- or left-hand polarization. For on-device processing, it uses a Lattice ECP5 FPGA, which uses two MIPI cables to connect to the camera and display interfaces on the Raspberry Pi. These form a very high-speed data exchange, and after further processing, the Pi can pass data on over Ethernet or Wi-Fi. Individual QuadRF boards can connect together in a lattice grid to form larger phased arrays.

The QuadRF’s software shows off its real strength: it’s compatible with standard programs like GNU Radio, but it also hosts a few of its own programs. The most striking of these is an “RF camera” which scans its entire frequency range at 30 fps, tracking the direction of detected signals and visualizing them on a spatial plot. When overlaid on a camera feed, this plot lets one easily see the radio signals emitted from electronics; as an example, the creators tracked a drone in flight, even distinguishing the two radio transmitters on the drone.

This isn’t the first multi-antenna SDR we’ve seen, though this is the first that could transmit. It’s important to be careful, though: some applications of this kind of hardware run afoul of arms regulations.

Thanks to [Swake] for the tip!

How fast can you count to a million? It would probably take you a while. A computer could certainly do it faster. Indeed, the The National Museum of Computing figured it could actually prove to be a simple but useful benchmark for comparing computers over many eras and architectures. Thus was born the Million Measure.

The intention was to develop a benchmark that could run on just about anything considered a “computer.” As explained in a recent talk, the Million Measure can be run quite simply on anything from an ancient World War II computer like Colossus, to a modern Raspberry Pi. There are no complicated algorithms that need optimization, nor architecture-specific code required to do the job. The museum also found it to be a useful way to figure out which computers in their collection were actually working at any given time. Early computers from the mid-20th century reported benchmark times in minutes, while a 1995 BeBox is the fastest machine tested so far at 0.004 seconds.

It’s not a particularly useful measure for modern machines, which are so fast as to make the test difficult to parse in an intuitive way. But if you’re working with today’s hardware, there are other techniques you can use. Video after the break.

[Thanks to Dave Wild for the tip!]

One of the most hilarious things you can do with an LLM-based chatbot is to ask it to do calculations. If it’s a well-written chatbot frontend, it can detect requests for arithmetic – like summing 1 and 1 – and pass it on to a dedicated calculator application, even if still cannot correctly count the ‘r’s in ‘strawberry’. This is where [Alvaro Videla] asks the question whether it is at all possible to perform arithmetic with a language model.

Since an LLM at its core is nothing but a vector space of probabilities that a matrix-based inference process uses to create a probabilistic output of tokens you’d not expect a lot of deterministic behavior. How can you do arithmetic without grounding it in some kind of deterministic process?

This is where [Alvaro]’s Rune project comes into play, which is ‘a mechanism-aware JIT compilation project for language-model arithmetic’. Although it is statistically impossible for an LLM to ever correctly perform any random series of arithmetic calculations, you can monitor the internal state of the model and interfere once the parameters of an arithmetic calculation have been identified. By putting the correct result back into the inference process and letting it continue you did not need to rely on external tools.

Ultimately this attempt sort-of worked, but was deemed a failure. It would seem that a language model is the wrong tool after all for replacing the humble calculator.

The Epson HX-20 is sometimes referred to as an early laptop computer. It’s a little odd in its form factor, and in its storage, relying on a microcassette drive to store data. It can be problematic to keep these tapes and drives going after so many decades, so [Andrew Menadue] has been tinkering with a more modern solution.

The replacement drive uses a Raspberry Pi Pico to emulate the original tape drive. The Pico uses a microSD card to store data instead of the magnetic media of old. The device has a small screen for showing status information and four buttons for navigation, allowing the faux drive to be controlled as to what “tape” it’s pretending to be. It’s also possible to use the device to emulate ROM cartridges that could be used with the HX-20 in place of its original tape deck storage solution.

We’ve seen some other old hardware get similar drive upgrades before, too. No surprise, because mechanical drives and media simply don’t last forever. Sometimes you need to build a replacement that’s viable today. Video after the break.