Connecting to the Commodore 64 or 128 expansion port like a “normal” cartridge, TeensyROM from Sensorium adds ROM emulation, Internet, and even USB MIDI to some of the 1980’s most popular 8-bit machines.
We love seeing Teensy boards being used to give old hardware new superpowers, and the TeensyROM is a fantastic example of this!
TeensyROM emulates ROMs loaded from a USB thumb drive (via USB Host port), the Teensy’s mSD slot, or internal flash. USB Host is also used for MIDI in/out, allowing you to for example play the C64’s legendary SID chip with a MIDI keyboard using Cynthcart software.
An RJ-45 jack means you can connect to your favorite Telnet BBS via 38.4k modem emulation, as well as update system time using an Internet Time Server, like modern OSes. You can even load games via NFC tags, as shown in the video below! Source, schematics, and more can be found on the project’s GitHub repo.
We’ve seen Teensy boards in rockets, satellites, and more, but the first step of getting space-bound is developing a reliable engine.
Georgia Tech’s student-run Yellow Jacket Space Program enlisted three proud Teensy 3.6s in their mission to develop a liquid oxygen/kerosene rocket engine, the YJ-1S.
The first Teensy is used as a switchboard to control individual valves within the engine, as well as initiate engine startup and firing sequences. The engine controller uses another two Teensy boards to communicate with the switchboard and take control of the engine valves once initiated.
The results in the video below speak for themselves, and demonstrate the engine meeting its 790 pounds of force thrust target.
The elegant stacked-PCB system features eight assignable footswitches, bank selection, two expression pedal connectors with TRS/RTS switch, USB MIDI in/out, and MIDI DIN out.
Plan is to later build a full enclosure that will strengthen the structure.
The Sketchy Maker wanted to do something big for Star Wars day, but with only two weeks to put it together, this was a rather tall order.
The idea of a giant LEGO Luke Skywalker with working lightsaber came to mind, and thankfully a Teensy 3.2 and Prop Shield was at hand, greatly facilitating the electronic aspects of the project.
The minifig itself is 3d-printed, with a servo to move the lightsaber-toting arm up and down. Ninety WS2812B LEDs light said saber, and a small speaker adds sound effects. The Sketchy Maker finished the project in time for its May the Fourth debut, and put it on display for the local community to enjoy.
Swedish sound designer Christian wanted to jam with other musicians using Ableton Live, but it wasn’t working. Instead of playing cooperatively, it seemed like everyone would end up in their own little bubbles, locked in a volume arms race that typically results in one big sonic mess.
The solution? Custom controllers to gather loops from everyone, all orchestrated by a Teensy 3.5.
The resulting setup gives each musician their own channels, with someone controlling the overall mix, as well as their own sync button, headphone monitoring, and ability to contribute clips on the fly. The controllers connect to the Teensy via ethernet, which in turn talks to the host computer via a Max patch over USB serial using Open Sound Control (OSC) to talk to Ableton.
Clips start playing as soon as they are recorded, and looping status is indicated by eight RGB LEDs (red when recording, green while playing). Like a DJ cuing up the next track, the central knob acts as a crossfader, allowing the performer to experiment using headphones while only the loop is heard by the audience. Find out more about this unique system on Hackaday, or see it in action in the video below.
When Jim Harvey aka WB8NBS finally got his hands on an 64×64 RGB LED matrix, the question quickly became what to do with it. Experimentation with libraries and examples eventually led to the notion of a digital clock, and ultimately to Jim’s Sand Clock or “Clock with Benefits.”
Based on a Teensy 3.6, this unique timepiece adds some interesting features to the traditional timekeeping appliance.
I recently obtained a new code signing certificate used to sign the Windows version of Teensy’s software. Because key storage rules have changed, and very little information currently exists for use in a cross compile workflow, I decided to write this article.
The basic concept is you wish to compile software for Windows, from the comfort of your Linux machine. The Windows EXE file needs to be properly signed, so users see “Verified Publisher” and Microsoft Defender SmartScreen will (eventually) learn your application is safe.
These steps were performed on Ubuntu 22.04. Other Linux distributions can very likely also work.
Buying a Code Signing Certificate
Before June 2023, obtaining a code signing cert was simpler and less expensive. You would create a private key and use it to send a certificate signing request (CSR). After verifying your identity, the certificate authority would send you the certificate file.
Signing a Windows EXE file requires these 2 items, a secret key and a certificate issued by one of the certificate authority companies Microsoft trusts. Previously it was just 2 files on your computer, or a single “P12” format file which can hold both.
Since June 2023, your secret key must either be stored inside a hardware token and/or stored on the certificate authority’s cloud service. Supposedly this is more secure.
It is also much more expensive! As with buying anything, shop around. Prices vary and change. As of March 2024, the best price I found was at SSL.com. This article isn’t sponsored or affiliated with SSL.com in any way. They simply had the best (least bad) price in March 2024. Pricing for “OV” was $110 per year for 3 years, and $250 for the hardware key. The actual hardware has $80 retail price when blank from Yubico.
If you choose another certificate authority, you might contact them to confirm the hardware key is Yubikey FIPS. Theoretically other hardware keys might exist, if not today then at some point in the future, and you would want to confirm whether the hardware they send works with Linux and libengine-pkcs11-openssl.
SSL.com also offers a cloud service which eliminates the need for a hardware key, but its least expensive tier is $20/month. That’s almost as much as the Yubikey FIPS hardware, repeated every year! Worse year, that low tier offers only 20 signatures per month. Teensy’s software has several signed EXE files. Merely building a few beta tests could mean needing the next tier.
After you’ve paid, the certificate authority will verify your identity. For “OV” level, the verification is so simple that the price and complexity of needing a hardware token feels rather wasteful. Nonetheless, to get Windows “Verified Publisher” this is the process.
Then all you can do is wait for your Yubikey token to arrive.
Collect Critically Important Data
Your Yubikey FIPS token will arrive initialized with 2 passwords, called PIN and PUK. Your first step is to obtain these 2 passwords.
From SSL.com, my Yubikey came with an 8 digit serial number, printed on a label and also on the key. On the SSL.com website order summary, under “CERTIFICATE DETAILS” -> “physical tokens” was an “activate” link. Clicking it brings up a dialog box to enter the 8 digit serial number. After entering the serial number, the PIN and PUK passwords appeared.
Other certificate authorities will likely work differently, but all Yubikey FIPS use these PIN and PUK passwords for access to the key. You must get the PIN and PUK passwords the certificate authority used. If the PIN is entered incorrectly 3 times, the key becomes locked. The PUK password lets you assign a new PIN password. If PUK is incorrect 3 times, the hardware becomes unusable! Make sure you have the correct PIN and PUK before using your key.
You will also need the certificate data. On the SSL.com I found this on the order summary page under “END ENTITY CERTIFICATES”. It begins “—–BEGIN CERTIFICATE—–“, has a couple dozen lines of base64 encoded data, and ends with “—–END CERTIFICATE—–“. Save this to a file. Any name is ok, I named it “mycert.pem”.
Install Software
Fortunately Ubuntu 22.04 has all the required software as packages. Use these commands install everything demonstrated in this article.
You only need the (large) wine package if you want to run your freshly compiled EXE on Linux.
Check Yubikey Hardware
Now you’re ready to plug in your Yubikey and check it. First run this command:
ykman list
You should see it detect your Yubikey and print basic info. The 8 digit serial number should appear.
YubiKey 5 NFC FIPS (5.4.3) [OTP+FIDO+CCID] Serial: 00000000
Type this command to check the keys stored:
ykman piv info
You should see results like this, but with actual serial numbers instead of zeros.
PIV version: 5.4.3
PIN tries remaining: 3/3
Management key algorithm: TDES
Management key is stored on the YubiKey, protected by PIN.
CHUID: 0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
CCC: No data available.
Slot 84:
Algorithm: ECCP384
Subject DN: CN=SSL.com Code Signing Intermediate CA ECC R2,O=SSL Corp,L=Houston,ST=Texas,C=US
Issuer DN: CN=SSL.com Root Certification Authority ECC,O=SSL Corporation,L=Houston,ST=Texas,C=US
Serial: 00000000000000000000000000000000000000
Fingerprint: 0000000000000000000000000000000000000000000000000000000000000000
Not before: 2019-03-07 19:35:47
Not after: 2034-03-03 19:35:47
Slot 9a:
Algorithm: ECCP384
Subject DN: CN=PJRC.COM\, LLC,O=PJRC.COM\, LLC,L=Sherwood,ST=Oregon,C=US
Issuer DN: CN=SSL.com Code Signing Intermediate CA ECC R2,O=SSL Corp,L=Houston,ST=Texas,C=US
Serial: 00000000000000000000000000000000000000
Fingerprint: 0000000000000000000000000000000000000000000000000000000000000000
Not before: 2024-03-04 15:51:07
Not after: 2027-03-04 15:51:07
The “PIN tries remaining” is particularly important. If you enter the PIN password incorrectly 3 times, the hardware becomes locked. Best to download the graphical YubiKey Managers software from Yubico’s website, and use it to set a new PIN with the PUK password. However, 3 wrong tries with PUK locks the hardware completely. Unlocking requires deleting the keys you paid $250 to get.
Compile a Windows EXE program
Create a file “hello.c” with any simple C program.
#include <stdio.h>
int main() {
printf("Hello World\n");
return 0;
}
The default PKCS11 module pathname is /usr/lib/x86_64-linux-gnu/libykcs11.so
If you run Linux on hardware other than x86-64, such as Raspberry Pi, or if you use a different Linux distribution, the pathname may differ. On Ubuntu, you can use dpkg to see all the files the ykcs11 package installed.
dpkg -L ykcs11
ls -l /usr/lib/x86_64-linux-gnu/libykcs11.so
ls -l /usr/lib/x86_64-linux-gnu/libykcs11.so.2
ls -l /usr/lib/x86_64-linux-gnu/libykcs11.so.2.2.0
Sign your hello.exe file
To sign your freshly compiled EXE file, run osslsigncode with these parameters. If your PKCS11 module pathname is different, replace it as needed.
Replace XXXXXXXX with your PIN password. Remember, your Yubikey becomes locked after 3 wrong PIN password attempts!
If hello2.exe already exists, osslsigncode isn’t very smart and will show confusing errors. Best to make sure it’s deleted before running osslsigncode.
Your new hello2.exe file is a signed copy. When copied to a Windows computer, right click and view Properties. It should have a Digital Signatures tab. Clicking Details should show the signature info.
Microsoft Defender SmartScreen
Unfortunately, unless you purchased the most expensive “EV” type certificate, your signature using a brand new key will not yet have a reputation with SmartScreen. Windows users will see “isn’t commonly downloaded”.
Eventually as more people download and use your software, SmartScreen will begin to trust it.
For starters, as fun as it is to output the display to a tiny 320×240 TFT screen, some tasks are more practical on a “real” monitor — which is now possible thanks to the addition of VGA output.
In addition to its groundbreaking GEM-based GUI, the ST excelled in audio, with Cubase and Logic Pro both originating on the platform. Two standard 5-pin DIN MIDI ports allowed the computer to talk to other instruments as well, and thanks to Teensy’s USB MIDI support, sequencers running in the emulator can also output to real MIDI devices (with the appropriate dongles).
Complete project details and updates can be found on GitHub. Note that a Teensy 4.1 with PSRAM added is required for full 640×400 display resolution.
Teensy boards power all manner of commercial products, being an ideal solution for high-speed data acquisition, and we were particularly excited by this system from Bolder Flight Systems.
BFS CEO Brian Taylor shared this Teensy 3.6-based unit, which was developed in conjunction with the International Test Pilots School (ITPS) to facilitate test pilot and flight test engineer training on fixed or rotary-wing aircraft.The system logs inertial navigation data, airspeed, altitude, temperature, and 12 additional analog channels at a rate of 200Hz, with GNSS satellite integration to aid the accuracy of inertial data. The analog channels can be used for measuring pilot stick force or control surface positions. The unit is USB-powered and easily installed, with a web-based interface for real-time data viewing and configuration. More information can be found on the BFS web site.
We love alternative musical interfaces. XenonJohn’s Aetherharp uses inexpensive Sharp GP2Y0A41SK0F analog distance sensors to determine hand proximity.
Like a theremin it is played without physical contact by the performer, but using light rather than antennas to determine proximity. XenonJohn demonstrates the project on Instructables with his Teensy 3.5-powered Aetherharp.
Eight Sharp IR sensors are each configured to determine three discrete height levels, resulting in 24 possible notes.
Teensy’s USB MIDI capabilities are then leveraged to convert the hand gestures to sound via a connected laptop, which also provides power to the device.
Code and complete instructions can be found on Instructables, and a demonstration of the instrument can be seen below.
