Ancient Cable Modem Reveals Its RF Secrets

April 22, 2024 by Dan Maloney 27 Comments

Most reverse engineering projects we see around here have some sort of practical endpoint in mind. Usually, but not always. Reverse-engineering a 40-year-old cable modem probably serves no practical end, except for the simple pleasure of understanding how 1980s tech worked.

You’ll be forgiven if the NABU Network, the source of the modem [Jared Boone] tears into, sounds unfamiliar; it only existed from 1982 to 1985 and primarily operated in Ottawa, Canada. It’s pretty interesting though, especially the Z80-based computer that was part of the package. The modem itself is a boxy affair bearing all the hallmarks of 1980s tech. [Jared]’s inspection revealed a power supply with a big transformer, a main logic board, and a mysterious shielded section with all the RF circuits, which is the focus of the video below.

Using a signal generator, a spectrum analyzer, and an oscilloscope, not to mention the PCB silkscreen and component markings, [Jared] built a block diagram of the circuit and determined the important frequencies for things like the local oscillator. He worked through the RF section, discovering what each compartment does, with the most interesting one probably being the quadrature demodulator. But things took a decidedly digital twist in the last compartment, where the modulated RF is turned into digital data with a couple of 7400-series chips, some comparators, and a crystal oscillator.

This tour of 80s tech and the methods [Jared] used to figure out what’s going on in this box were pretty impressive. There’s more to come on this project, including recreating the original signal with SDRs. In the mean time, if this put you in the mood for other videotext systems of the 80s, you might enjoy this Minitel terminal teardown.

Continue reading “Ancient Cable Modem Reveals Its RF Secrets” →

An Amiga Mouse, The Modern Way

February 22, 2023 by Jenny List 27 Comments

When we recently featured an Amiga upgrade project, [EmberHeavyIndustries ] was prompted to share one of their own, an adapter to allow a modern USB HID mouse to be used with the Commodore quadrature mouse port.

The first mice simply transferred the rotation of the ball through rollers to switches or optical sensors which passed pulse trains to the host computer. From the relative phase of these pulse trains the computer could work out what direction the mouse was going, as well as how far it had moved through counting the pulses. Since this was the simplest mouse interface, many of the 16-bit era machines used these signals. The PC meanwhile lacked such a port, so companies such as Microsoft had to place a microcontroller in the mouse to do the position sensing, and send the result over a serial interface. This evolved over time into the USB HID mouse interface you are probably using today.

Unfortunately for owners of quadrature mouse driven machines, real quadrature mice are a little thin on the ground these days, thus the adapter is a seriously useful device. At its heart is an STM32 microcontroller, and it’s been through a few updates and now supports mouse wheels. Your Amiga has been waiting for this!

There are quite a few other treats for Amiga enthusiasts in the EmberHeavyIndustries GitHub account, meanwhile here’s the video upgrade which caused us to receive the tip.

An SDR Transceiver The Old-School Way

June 29, 2019 by Jenny List 4 Comments

Software-defined radios or SDRs have provided a step-change in the way we use radio. From your FM broadcast receiver which very likely now has single-application SDR technology embedded in a chip through to the all-singing-all-dancing general purpose SDR you’d find on an experimenter’s bench, control over signal processing has moved from the analogue domain into the digital. The possibilities are limitless, and some of the old ways of building a radio now seem antiquated.

[Pete Juliano N6QW] is an expert radio home-brewer of very long standing, and he’s proved there’s plenty of scope for old-fashioned radio homebrewing in an SDR with his RADIG project. It’s an SDR transceiver for HF which does all the work of quadrature splitting and mixing with homebrewed modules rather than the more usual technique of hiding it in an SDR chip. It’s a very long read in a diary format from the bottom up, and what’s remarkable is that he’s gone from idea to working SDR over the space of about three weeks.

So what goes into a homebrew SDR? Both RF preamplifier, filters, and PA are conventional as you might expect, switched between transmit and receive with relays. A common transmit and receive signal path is split into two and fed to a pair of ADE-1 mixers where they are mixed with quadrature local oscillator signals to produce I and Q that is fed to (or from in the case of transmit) a StarTech sound card. The local oscillator is an Si5351 synthesiser chip in the form of an SDR-Kits USB-driven module, and the 90 degree phased quadrature signals are generated with a set of 74AC74 flip-flops as a divider.

Running the show is a Raspberry Pi running Quisk, and though he mentions using a Teensy to control the Si5351 at the start of his diary it seems from the pictures of the final radio that the Pi has taken on that work. It’s clear that this is very much an experimental radio as it stands with wired-together modules on a wooden board, so we look forward to whatever refinements will come. This has the feel of a design that could eventually be built by many other radio amateurs, so it’s fascinating to be in at the start.

If I and Q leave you gasping when it comes to SDR technology, maybe we can help.

Thanks [Bill Meara N2CQR] for the tip!

A Universal USB To Quadrature Encoder

June 12, 2017 by Brian Benchoff 9 Comments

Computer mice existed long before the Mac, and most of the old 8-bit computers had some software that could use a mouse. These mice had balls and quadrature encoders. While converters to turn these old mice into USB devices exist, going the other way isn’t so common. [Simon] has developed the answer to that problem in the form of SmallyMouse2. It turns a USB mouse into something that can be used with the BBC Micro, Acorn Master, Acorn Archimedes, Amiga, Atari ST and more.

The design of the SmallyMouse2 uses an AT90USB microcontroller that supports USB device and host mode, and allows for a few GPIOs. This microcontroller effectively converts a USB mouse into a BBC Micro user port AMX mouse, generic quadrature mouse, and a 10-pin expansion header. The firmware uses the LUFA USB stack, a common choice for these weird USB to retrocomputer projects.

The project is completely Open Source, and all the files to replicate this project from the KiCad project to the firmware are available on [Simon]’s GitHub. If you have one of these classic retrocomputers sitting in your attic, it might be a good time to check if you still have the mouse. If not, this is the perfect project to delve into to the classic GUIs of yesteryear.

If The I And Q Of Software Defined Radio Are Your Nemesis, Read On

May 16, 2017 by Jenny List 30 Comments

For those of us whose interests lie in radio, encountering our first software defined radio must have universally seemed like a miracle. Here is a surprisingly simple device, essentially a clever mixer and a set of analogue-to-digital or digital-to-analogue converters, that can import all the complex and tricky-to-set-up parts of a traditional radio to a computer, in which all signal procession can be done using software.

A quadrature mixer. Jugandi (Public domain).

When your curiosity gets the better of you and you start to peer into the workings of a software defined radio though, you encounter something you won’t have seen before in a traditional radio. There are two mixers fed by a two local oscillators on the same frequency but with a 90 degree phase shift, and in a receiver the resulting mixer products are fed into two separate ADCs. You encounter the letters I and Q in relation to these two signal paths, and wonder what on earth all that means.

Continue reading “If The I And Q Of Software Defined Radio Are Your Nemesis, Read On” →

Bring A Modern Mouse To An Atari ST

January 23, 2017 by Jenny List 35 Comments

Human input devices are a consumable on our computers today. They are so cheap and standardised, that when a mouse or a keyboard expires we don’t think twice, just throw it away and buy another one. It’ll work for sure with whatever computer we have, and we can keep on without pause.

On earlier machines though, we might not be so lucky. The first generation of computers with mice didn’t have USB or even PS/2 or serial, instead they had a wide variety of proprietary mouse interfaces that usually carried the quadrature signals direct from the peripheral’s rotary sensors. If you have a quadrature mouse that dies then you’re in trouble, because you won’t easily find a new one.

Fortunately there is a solution. In the intervening decades the price of computing power has fallen to the extent that you can buy a single board computer with far more than enough power to interface with a standard USB mouse and emulate a quadrature mouse all at the same time. This was exactly the solution [Andrew Armstrong] took to provide a replacement mouse for his Atari ST, he used a Raspberry Pi as both USB host and quadrature mouse emulator (YouTube link) through its GPIOs.

He’s put together a comprehensive description of his work in the video we’ve placed below the break, meanwhile if you’d like to have a go yourself you’ll find all you need to know in his GitHub repository.

Continue reading “Bring A Modern Mouse To An Atari ST” →

Encoders Spin Us Right Round

January 11, 2017 by Al Williams 44 Comments

Rotary encoders are great devices. Monitoring just a few pins you can easily and quickly read in rotation and direction of a user input (as well as many other applications). But as with anything, there are caveats. I recently had the chance to dive into some of the benefits and drawbacks of rotary encoders and how to work with them.

I often work with students on different levels of electronic projects. One student project needed a rotary encoder. These come in mechanical and optical variants. In a way, they are very simple devices. In another way, they have some complex nuances. The target board was an ST Nucleo. This particular board has a small ARM processor and can use mbed environment for development and programming. The board itself can take Arduino daughter boards and have additional pins for ST morpho boards (whatever those are).

The mbed system is the ARM’s answer to Arduino. A web-based IDE lets you write C++ code with tons of support libraries. The board looks like a USB drive, so you download the program to this ersatz drive, and the board is programmed. I posted an intro to mbed awhile back with a similar board, so if you want a refresher on that, you might like to read that first.

Reading the Encoder

The encoder we had was on a little PCB that you get when you buy one of those Chinese Arduino 37 sensor kits. (By the way, if you are looking for documentation on those kinds of boards, look here.; in particular, this was a KY-040 module.) The board has power and ground pins, along with three pins. One of the pins is a switch closure to ground when you depress the shaft of the encoder. The other two encode the direction and speed of the shaft rotation. There are three pull-up resistors, one for each output.

I expected to explain how the device worked, and then assist in writing some code with a good example of having to debounce, use pin change interrupts, and obviously throw in some other arcane lore. Turns out that was wholly unnecessary. Well… sort of.

Continue reading “Encoders Spin Us Right Round” →