Measuring An Unknown Velocity Factor

April 19, 2024 by 14 Comments

When is the speed of light not the speed of light? Of course, that’s a trick question. The speed of light may be constant, but just as sound travels at different speeds in different media, electronic signals move through transmission lines at a reduced speed. When you have a known cable, you can look up the velocity factor and use it to approximate the length of cable to have a given effective length. But what if you don’t know what kind of cable you have? [More Than Electronics] used a scope to measure it. You can see what he did in the video below.

For example, RG-8/U has a factor of 0.77. Even air isn’t exactly a factor of 1, although it is close enough that, in practice, we pretend that it is. If you wonder why it matters, consider stubs. Suppose you have a 300 MHz signal (handy because that’s 1 meter in wavelength; well, OK, pick 299.792 MHz if you prefer). If you have a quarter wavelength piece of coax shorted at one end, it will attenuate signals at 300 MHz. To understand why, picture the wave on the stub. If the close end of the stub is at 0 volts, then the other end — because it is a quarter wavelength away — must be at the maximum positive voltage or the minimum negative voltage. If either of the extremes is at the close end, then the far end must be at zero volts. That means the maximum current flows only when the signal is at 300 MHz.

Continue reading “Measuring An Unknown Velocity Factor” →

End-Of-Life For Z80 CPU And Peripherals Announced

April 19, 2024 by 54 Comments

In a Product Change Notification (PCN) published on April 15, Zilog (now owned by Littelfuse) announced the End of Life for a range of Z80 products, specifically virtually all of the Z84C00 range. This also includes the peripherals, such as the Z84C10 range of MPUs. These are currently already marked as EoL on stores like Mouser, with Littelfuse noting that the last orders with them can be placed until June 14th of 2024. After that you’ll have to try your luck with shady EBay sellers and a lucky box of old-new-stock found in the back of a warehouse.

What this effectively means is that after just under 48 years since its launch in 1976, the Zilog Z80 will no longer be available for sale as discrete components, which is likely to primarily impact hobbyists and people who are trying to keep retro systems going. This does not mean that it’s the end of the road for Z80, however, as the eZ80 will be produced for the foreseeable future.

These new chips will of course not come in easy to drop in DIPs, making the challenge of breadboarding your own Z80-based microcomputer that much tougher. Yet one thing that definitely won’t happen is any of us witnessing the end of the era of the Z80, 6502 and 8051 architectures.

Thanks to [Techokami] for the tip.

Roboticizing An Etch-a-Sketch

April 19, 2024 by 7 Comments

The Etch-a-Sketch was a popular toy, but a polarizing one. You were either one of those kids that had the knack, or one of the kids that didn’t. [Micah] was pretty firmly in the latter group, so decided to roboticize the Etch-a-Sketch so a computer could draw for him instead.

The build uses a pair of stepper motors attached to the Etch-a-Sketch’s knobs via 3D-printed adapters. It took [Micah] a few revisions to get the right design and the right motors for the job, but it all came together. A Raspberry Pi is charged with driving the motors to draw the desired picture.

Beyond the mechanics, [Micah] also does a great job of explaining the challenges around drawing and the drive software. Namely, the Etch-a-Sketch has a major limitation in that there’s no way to move the stylus without drawing a line. He accounts for this in his code for converting and drawing images.

The robot draws slowly but surely. The final result is incredibly impressive, and far exceeds what most of us could achieve on by hand. We’ve seen some similar builds in the past, too. Video after the break.

Continue reading “Roboticizing An Etch-a-Sketch” →

Crystal Radio Kit From The 1970s

April 19, 2024 by 19 Comments

If you read the December 1970 issue of Mechanix Illustrated, you’d be treated to [Len Buckwalter]’s crystal radio build. He called out Modern Radio Labs as the supplier for parts. That company, run by [Elmer Osterhoudt], got so many inquiries that he produced a kit, the #74 crystal set. [Michael Simpson] found an unopened kit on eBay and — after a bidding war, took possession of the kit. The kit looked totally untouched. The crystal detector was still in the box, and there were period-appropriate newspaper wrappings.

The kit itself isn’t that remarkable, but it is a classic. An oatmeal box serves as a coil form. There’s a capacitor, a crystal detector, and headphones. The original cost of the parts was $7, but we imagine the eBay auction exceeded that by a large amount.

If the name [Len Buckwalter] sounds familiar, he was quite prolific in magazines like Electronics Illustrated and also wrote several books about transistors. [Michael] also shows off his innovative coil winder made from plastic cups and a coat hanger.

We’d love to find some old kits like this, although, from one way of thinking, it is almost a shame to build them after all these years. With an added audio amplifier and fiddling with the cat whisker, it sounded just fine.

If you don’t like oatmeal, you could fire up the 3D printer. While the basic circuit is simple, you can make it more complex if you like.

Continue reading “Crystal Radio Kit From The 1970s” →

Hackaday Podcast Episode 267: Metal Casting, Plasma Cutting, And A Spicy 555

April 19, 2024 by 3 Comments

What were some of the best posts on Hackaday last week? Elliot Williams and Al Williams decided there were too many to choose from, but they did take a sampling of the ones that caught their attention. This week’s picks were an eclectic mix of everything from metal casting and plasma cutters to radio astronomy and space telescope budgets. In between? Some basic circuit design, 3D printing, games, dogs, and software tools. Sound confusing? It won’t be, after you listen to this week’s podcast.

Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments!

Download an audiophile-quality oxygen-free MP3 file here.

Where to Follow Hackaday Podcast

Places to follow Hackaday podcasts:

Continue reading “Hackaday Podcast Episode 267: Metal Casting, Plasma Cutting, And A Spicy 555” →

Ultra-Tiny Wii Uses Custom Parts And Looks Amazing

April 19, 2024 by 17 Comments

The Nintendo Wii was never a large console. Indeed, it was smaller than both the Xbox 360, PlayStation 3, and most consoles of previous generations, too. That’s not to say it couldn’t be smaller, though. [loopj] has built what is perhaps the smallest Wii yet, which measures roughly the same size as a deck of cards. The best bit? The housing is even to scale!

There’s no emulation jiggery-pokery here. This build uses an original Wii motherboard that’s been cut down to the bare basics. Measuring just 62 mm by 62 mm, it features the CPU, GPU, RAM, and flash memory, while most of the extraneous hardware has been eliminated. Power and data is provided to the board from a special Wii Power Strip PCB, while the Periphlex flex PCB handles breaking out controller interfaces. Indeed, the build is nicknamed Short Stack as it’s built from a number of specialist PCBs for builds like this one. It also uses two boards designed by [YveltalGriffin] — the fujiflex for HDMI video output and the nandFlex to handle the Wii’s NAND memory chip.

[loopj] also had to design two further PCBs specifically for this build. One handles power, the micro SD card, HDMI connector, and controller ports. Meanwhile, the second handles the power, reset, and sync buttons along with status LEDs. Another neat hack of [loopj]’s own devising is using TRRS connectors in place of the original bulky GameCube controller ports.

Ultimately, it’s volume is just 7.4% that of an original Nintendo Wii. It’s probably possible to go smaller, too, says [loopj], so don’t expect things to end here. We’ve seen some other great Wii mods before, too, like this excellent handheld design.

This Week In Security: Putty Keys, Libarchive, And Palo Alto

April 19, 2024 by 3 Comments

It may be time to rotate some keys. The venerable PuTTY was updated to 0.81 this week, and the major fix was a change to how ecdsa-sha2-nistp521 signatures are generated. The problem was reported on the oss-security mailing list, and it’s quite serious, though thankfully with a somewhat narrow coverage.

The PuTTY page on the vulnerability has the full details. To understand what’s going on, we need to briefly cover ECDSA, nonces, and elliptic curve crypto. All cryptography depends on one-way functions. In the case of RSA, it’s multiplying large primes together. The multiplication is easy, but given just the final result, it’s extremely difficult to find the two factors. DSA uses a similar problem, the discrete logarithm problem: raising a number to a given exponent, then doing modulo division.

Yet another cryptography primitive is the elliptic curve, which uses point multiplication as the one-way function. I’ve described it as a mathematical pinball, bouncing around inside the curve. It’s reasonably easy to compute the final point, but essentially impossible to trace the path back to the origin. Formally this is the Elliptic Curve Discrete Logarithm Problem, and it’s not considered to be quantum-resistant, either.

One of the complete schemes is ECDSA, which combines the DSA scheme with Elliptic Curves. Part of this calculation uses a nonce, denoted “k”, a number that is only used once. In ECDSA, k must be kept secret, and any repetition of different messages with the same nonce can lead to rapid exposure of the secret key.

And now we get to PuTTY, which was written for Windows back before that OS had any good cryptographic randomness routines. As we’ve already mentioned, re-use of k, the nonce, is disastrous for DSA. So, PuTTY did something clever, and took the private key and the contents of the message to be signed, hashed those values together using SHA-512, then used modulo division to reduce the bit-length to what was needed for the given k value. The problem is the 521-bit ECDSA, which takes a 521-bit k. That’s even shorter than the output of a SHA-512, so the resulting k value always started with nine 0 bits. Continue reading “This Week In Security: Putty Keys, Libarchive, And Palo Alto” →