FPGA Retrocomputer: Return To Moncky

September 26, 2021 by 5 Comments

Part of the reason that retrocomputers are still so popular despite their obsolescence is that it’s possible to understand the entire inner workings of a computer like this, from the transistors all the way up to the software. Comparatively, it will likely be a long time (if ever) before anyone is building a modern computer from discrete components. To illustrate this point, plenty of 8-bit computers are available to either restore from original 80s hardware or to build from kits. And if you’d like to get even deeper into the weeds you can design your own computer including the instruction set completely from the ground up using an FPGA.

This project, called the Moncky project, is a step above the usual 8-bit computer builds as it is actually a 16-bit computer. It is built around an Arty Spartan-7 FPGA dev board running around 20 MHz and has access to 2 x 128 kB dual-port RAM for memory. To access the outside world there is a VGA output, PS/2 capability, SPI, and uses an SD card as a hard drive. This project really shines in the software, though, as the project creator [Kris Demuynck] builds everything from scratch in order to illustrate how everything works for educational purposes, and is currently working on implementing a C compiler to make programming the computer easier.

All of the project files, as well as all of the code, are available on the project’s GitHub page if you’d like to follow along or build on this homebrew 16-bit computer. It’s actually the third iteration of this computer, with the Moncky-1 and Moncky-2 being used to develop the more basic building blocks for this computer. While it’s not the first 16-bit computer we’ve seen implemented on an FPGA, it is one of the few that builds its own RISC instruction set and associated software rather than cloning a known existing processor. We’ve also seen some interesting x86 implementations on an FPGA as well.

Thanks to [koen-ieee] for the tip!

Elderly Remote Keeps Things Simple

September 26, 2021 by 25 Comments

If you are lucky, you’ve never experienced the heartbreak of watching a loved one lose their ability to do simple tasks. However, as hackers, we have the ability to customize solutions to make everyday tasks more accessible. That’s what [omerrv] did by creating a very specific function remote control. The idea is to provide an easy-to-use interface for the most common remote functions.

This is one of those projects where the technology puzzle is now pretty easy to solve: IR remotes are well-understood and there are plenty of libraries for recording and playing back signals. The real work is to understand the user’s challenges and come up with a workable compromise between something useful and something too complex for the user to deal with.

Continue reading “Elderly Remote Keeps Things Simple” →

Reinforced Concrete: Versatile At Any Size?

September 26, 2021 by 19 Comments

In our community we’re no strangers to making things, and there are plenty among us who devote their efforts to modelmaking. It’s uncommon, though, for a scale model of something to be made using the exact same techniques as whatever it’s copying. Instead a model might be made from card, foam, glassfibre, or resin. [tiny WORLD] takes an opposite tack, building scale model civil engineering projects just as they would have been for real. (Video, embedded below.)

Here, a scale model of the Hoover Dam bypass bridge is made as the original, from reinforced concrete. In place of rebar is a wire grid in place of wooden shuttering is what looks like foam board, the concrete is a much smoother mortar, but otherwise it’s the real thing. We see the various bridge parts being cast in situ, with the result being as strong as you’d expect from the original.

We can see that this is a great technique for modelling concrete buildings and structures, but it’s also a material that we think might have other applications at this scale. How would the rigidity, strength, and mass of small-scale reinforced cement compare to 20-20 extrusion, 3D-printed plastic, or wood, for example? Regardless, it’s interesting to watch, as you can see from the video below the break.

Continue reading “Reinforced Concrete: Versatile At Any Size?” →

A Raspberry Pi-based COVID Green Pass validator verifies a QR code on a phone.

COVID Green Pass Validator With Raspberry Pi

September 25, 2021 by No comments

It seems like every nation is dealing with the plague a little differently. In June, the EU instated a COVID Green Pass which comes in the form of a paper or digital QR code. It was designed to grease the wheels of travel throughout Europe and allow access to nursing homes. As of early August, the Green Pass is now required of those 12 and older in Italy to gain access to bars and restaurants, museums, theaters, etc. — anywhere people gather in sizeable groups. The Green Pass shows that you’ve either been vaccinated, have had COVID and recovered, or you have tested negative, and there are different half-lives for each condition: nine months for vaccinated, six for recovered, and just forty-eight hours for a negative test.

[Luca Dentella] has built a Green Pass validator using a Raspberry Pi and a Raspi camera. Actual validation must be done through the official app, so this project is merely for educational purposes. Here’s how it works: the user data including their status and the date/time of pass issuance are encoded into a JSON file, then into CBOR, then it is digitally signed for authenticity. After that, the information is zipped up into a base-45 string, which gets represented as a QR code on your phone. Fortunately, [Luca] found the Minister of Health’s GitHub, which does the hard work of re-inflating the JSON object.

[Luca]’s Pi camera reads in the QR and does complete validation using two apps — a camera client written in Python that finds QRs and sends them to the validation server, written in Node.js. The validation server does formal verification including verifying the signature and the business rules (e.g. has it been more than 48 hours since Karen tested negative?) Fail any of these and the red LED lights up; pass them all and you get the green light. Demo video is after the break.

Are you Canadian? Then check this out, eh?

Continue reading “COVID Green Pass Validator With Raspberry Pi” →

The Simplest FT8 Transceiver You’ll Ever Build

September 25, 2021 by 48 Comments

Probably the most interesting facets of amateur radio in 2021 lie in the realm of digital modes. Using the limitless possibilities of software defined radios has freed digital radio communication from the limits of what could be done with analogue electronics alone, and as a result this is a rare field in which radio amateurs can still be ahead of the technological curve. On of these newer digital modes is FT8 created by the prolific [Joe Taylor K1JT].

And it’s for this  mode that [Charles Hill] has created an easy-to-build transceiver. Its brains are aTeensy 3.6, while the receive side is a Si4735 receiver chip and the transmitter is a Si5351 programmable clock chip driving a Mini-Circuits GVA84 power amplifier with an appropriate filter. The interface is via a touchscreen display. It relies on existing work that applies a patch on-the-fly to the Si4735 receiver chip for SSB reception, and another project for the FT8 software.

The charm of this transceiver is that it can be assembled almost in its entirety from modules. Some radio amateurs might complain that homebrew radios should only use the most basic of components assembled from first principles, but the obvious answer to that should be that anything which makes radio construction easier is to be welcomed. If the 100 mW output power seems a bit low it’s worth remembering that FT8 is a weak signal mode, and given the right propagation conditions the world should be able to hear it despite the meagre output.

We’ve featured quite a few radios using the Si47XX series, which can be made into very tidy receivers indeed.

Making Linux Offline Voice Recognition Easier

September 25, 2021 by 10 Comments

For just about any task you care to name, a Linux-based desktop computer can get the job done using applications that rival or exceed those found on other platforms. However, that doesn’t mean it’s always easy to get it working, and speech recognition is just one of those difficult setups.

A project called Voice2JSON is trying to simplify the use of voice workflows. While it doesn’t provide the actual voice recognition, it does make it easier to get things going and then use speech in a natural way.

The software can integrate with several backends to do offline speech recognition including CMU’s pocketsphinx, Dan Povey’s Kaldi, Mozilla’s DeepSpeech 0.9, and Kyoto University’s Julius. However, the code is more than just a thin wrapper around these tools. The fast training process produces both a speech recognizer and an intent recognizer. So not only do you know there is a garage door, but you gain an understanding of the opening and closing of the garage door.

Continue reading “Making Linux Offline Voice Recognition Easier” →

front view of a purple acrylic slide rule with white ink scale markings.

Design And Build Your Own Circular Slide Rule

September 25, 2021 by 11 Comments

You have to really like slide rules to build your own, including the necessary artwork. Apparently [Dylan Thinnes] is a big fan, based on this project he began working on a few months back. The result is a set of algorithms that automatically generates most of the scales that were common on slide rules back in the day. For example:

K       Cubic scale, x^3
A,B     Squared scale, x^2
C,D     Basic scale, x
CI,DI   Inverted scale, 1/x
CF,DF   Folded scale, x*pi
LLn     Log-log scales, e^a*x
LL0n    Log-log scales, e^-a*x
L       Log scale, log10(x), linear
S       Sine and cosines scale, sin(x)
T       Tangent scale, tan(x)

If you’ve ever tried to manually draw an axis using a computer program — attempting to automatically set reasonable tick marks, grids, and labels — you can appreciate that this is a non-trivial problem. [Dylan] tackled things from the bottom up, developing several utility functions that work in concert to iteratively build up each scale. One advantage of this approach, he says, is that you can quite easily build almost any scale you want. We’re going to take his word on that, because the project is not easily accessible to the average programmer. As [Dylan] notes:

At the moment it’s still a library w/ no documentation, and written in a relatively obscure language called Haskell, so it’s really only for the particularly determined.

The project is published on his GitHub repository, and sample scales and demo program are available. Without knowledge of obscure languages and being only mildly determined, one can at least generate some sample scales — just downloading the Haskell environment, a few dependencies, and clone [Dylan]’s repository. The output is an SVG file which can be scaled to any desired size. In this follow-up Reddit post he discusses the fabrication techniques used for the acrylic circular slide rule shown in the lead photo.

It’s always been possible to make your own slide rules using pre-generated artwork — for example, the Slide Rule Museum website has a slew of various scales available in graphic format. But if you want to make a custom scale, or make one of that’s meters long, check out [Dylan]’s project and give it a whirl. For another take on making slide rules, check out this project that we covered last year.