in which I finally learn about Fritzing’s wire alignment facility …
I’ve had a couple of Teensy boards for a while, but a misunderstanding that they needed a load of of extra software installed (they need one thing, and it’s easy) had kept me away. They’ve got really impressive specs, and they’re especially easy to turn into USB devices like keyboards.
Super-heavy CEECO keypad
Here’s a little demo that turns a phone keypad — in my case, a ridiculously solid CEECO solid metal keypad designed for institutional use — into a simple USB keyboard. Plug it into any machine (including a Raspberry Pi) and it will be identified as a keyboard. No drivers are required.
The code is based on the standard Arduino Keypad library basic demo. That code was meant for a different keypad, so I eventually found a configuration that worked in the Sparkfun 12 button keypaddatasheet. Rather than printing characters to the serial port, I used calls to Teensy’s USB Keyboard library instead.
The pinout is (from left to right, key side up):
do not connect
Column 2
Row 1
Column 1
Row 4
Column 3
Row 3
Row 2
n/c
There’s no reason why this wouldn’t work with those very cheap 4×4 button matrix keypads for Arduino too with only minor modifications. Those keypads use 8 data lines, and they’re arranged (I think) as rows 1-4 on pins 1-4 and columns 1-4 are pins 5-8. columns 4-1 then rows 1-4 from the top of the pin connector down:
The Teensy USB keyboard isn’t limited to sending single characters: a single button press could trigger sending a whole string. I haven’t yet thought out any major uses for this (except “Crypto!â€, which is my usual idea when I have no idea what I’m doing), but you might have better plans.
I found a copy of Eudora Mail 1.44 for Windows (bundled up in an archive quaintly called “internet.zipâ€) here. The EUDOR144.EXE file is itself a Zip archive, and contains several files. The important one is WEUDORA.EXE (722,944 bytes; SHA256 checksum a35f2ef1e95242228381d9340fff0995f4935223f88a38b9200717107252dfb9).
This is a Windows 16 “New Executable†(NE) file, and I used panzi/mediaextract to scan and extract the RIFF/WAV data:
They sure sound similar. But are they … the same?
Comparison
I made sure that both samples were set to the same rate, and I applied simple amplification in Audacity so that they both had a peak volume of -3 dB. Aligning the tracks as best I could, I got this:
Log audio on top, Eudora chime underneath
The Eudora sample is very slightly slower than the Log one. It might have been that the Eudora authors sampled the chimes from an analogue video tape. The match is remarkable, however, as they play together with only very slight phasing effects:
As if it weren’t nerdy enough, the 6502 40th Anniversary Computer Badge runs Lee Davison’s EhBASIC. There are 1024 whole bytes free for your programs, so it’s not exactly spacious. It’s got useful floating point support, though:
Yup, that’s the second most boring BASIC example program, after the quadratic root finder.
100 REM HERON ROOTS
110 EP=0.0001
120 INPUT "X";X
130 N=1:RN=X/2
140 PRINT"COUNT","ROOT","DELTA":PRINT"======","======","======"
150 DE=ABS(RN*RN-X)
160 PRINT N,RN,DE
170 RN=(RN+X/RN)/2
180 N=N+1
190 IF DE>EP THEN GOTO 150
Update: Josh got my badge working again (it wasn’t, for $reasons …) and I re-ran this code. If you try the code for X=100000 and larger, it won’t converge. You might want to add:
185 IF N>25 THEN PRINT "EPSILON TOO LARGE, EXITING":END
so that the loop will exit after 25 times. Alternatively, make the value of EP depend upon the size of X. Aren’t numerical analysis and floating point foibles fun?
Since the Verbal Machines VM-CLAP1 sensor is an open collector type — that is, it sinks current when triggered — it behaves like a simple button to gpiozero, the Raspberry Pi Python GPIO library. If you attach a callback function to the sensor’s when_pressed event, your Python script will call that function every time it registers a clap.
The wiring is as simple as it could be:
VM-CLAP1: Raspberry Pi:
 ========= =============
 GND → GND
 PWR → 3V3
 OUT → GPIO 4
This example code just prints clap! when the board picks up a ðŸ‘:
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Raspberry Pi gpiozero test for
# Verbal Machines VM-CLAP1 clap sensor
# scruss - 2017-06
#
# Wiring:
#
# VM-CLAP1: Raspberry Pi:
# ========= =============
# GND → GND
# PWR → 3V3
# OUT → GPIO 4
from gpiozero import Button
from signal import pause
def clapping():
print("clap!")
clap = Button(4)
clap.when_pressed = clapping
pause()
This is a trivial example, but at least it shows that anything you can do with a button, you can also do with this hand-clap sensor.
I just made and uploaded this to FontLibrary: mnicmp.
This is meant more as an exercise in learning FontForge‘s programming back-end, and definitely showed me that FontForge is incredibly powerful. After the learning comes silliness, so I ended up turning the dots into something like:
I learned you really have to consider a dot-matrix font to be an array of points rather than a glyph, because otherwise you get the dots coming out the wrong sort of oval:
Blue font has been italicized as a whole, while the black dots were done properly
You don’t want to know what it did to the stars …
Building and installing the linapple-pie Apple IIe emulator is relatively easy on the Raspberry Pi:
sudo apt install libcurl4-openssl-dev libzip-dev zlib1g-dev libsdl1.2-dev libsdl-gfx1.2-dev libsdl-image1.2-dev libsdl-sound1.2-dev build-essential git
git clone https://github.com/dabonetn/linapple-pie.git
cd linapple-pie/src
make
sudo make install
This also works on an x86_64 Ubuntu machine. It does also install on a PocketCHIP (even if it takes a really long time) but I can’t get the display resolution to fit correctly.
I’ve found that OpenSCAD is really good for producing 2d designs in a very small amount of code. Here are three examples to play with:
Diagonal Section through Menger sponge (SVG) (OpenSCAD source) — this may take a while to render, as it’s making a Menger sponge in 3D and then slicing through it to make the projection.
(If you take out the projection() clause, it looks like this in 3D:
Yep, Marcus Gipps is at it again with a new Kickstarter campaign:
As part of my research into the JP Martin archives, I discovered both a biography of JPM himself, written by his daughter Stella Currey, and around 50 pages of unpublished Uncle stories which either didn’t make it into the finished books, or were heavily reworked. I’m now running a kickstarter to publish these two things in one volume of around 400 pages, which will be available in paperback, ebook or a limited hardback with the same specifications as THE COMPLETE UNCLE. The details are all here:
My latest kickstarter campaign, to publish a biography of JP Martin, creator of UNCLE, is now live!
If you’re able to back this new kickstarter, thank you very much – we’ve already hit our goal, but the more support I get now, the more copies I can print for the bookshops. And apologies if you’ve already backed, or have had this email more than once.
Getting the backing paper off laser cut acrylic is a pain. Some people recommend d-limonene, a citrus-derived solvent that is the main active ingredient of Goo Gone.
Pour a little Goo Gone into a tough freezer baggie, and place your acrylic part inside. Seal it up, and lay it flat for a few minutes. After that, flip it over and let the other side soak for a few. Open the bag and fish out your work. The backing paper should just slough off. Now rinse off the acrylic with washing-up liquid/dish detergent and warm water, taking care not to scrape the surface. You should now have a perfectly clean and shiny acrylic object. The d-limonene has the pleasant side-effect of de-stinkifying the cut plastic, too.
You should be able to re-use the Goo Gone baggie many times if you’re careful. You might not be able to rinse Goo Gone down the drain where you are; please check local regulations.
I’d tried making several Raspberry Pi Zero enclosures, but none of them quite worked. My needs are pretty simple, but I do need to be able to fit a full 40 pin strain-relieved (possibly keyed) header into the device while keeping questing fingers and dropped conductors off the circuit board.
Conserves material: The Coo~Coo uses just under 80 × 80 mm of 3 mm ply or acrylic, plus four nylon machine screws, nuts and washers.
Takes a full-sized GPIO header with a little headroom.
Provides edge protection for the µSD and connectors.
Has only a single cut layer, with no time-wasting engraved rasters.
Needs only simple tools to make: really only needs diagonal cutters to snip off half of the nylon screw heads. Needle-nose pliers might help too, as there are some fiddly small parts.
Free as in CC0. Yup, since this is derived from the Raspberry Pi Foundation’s copyrighted drawing, my modifications didn’t really add anything of value. Thus I waive all copyright and related or neighbouring rights on my additions:
To the extent possible under law, Stewart C. Russell has waived all copyright and related or neighbouring rights to the “Coo~Coo†Raspberry Pi Zero Case. This work is published from: Canada.
Why the odd “Coo~Coo†name? Well, look at the pattern of spacer washers and half-spacer washers:
To save material, I arranged these washers inside the GPIO cutout. I realised that I could spell COO~COO. It’s even clearer on the cutting document:
Coo~Coo — PDF for cutting is linked under the image
Update: here’s a revised path that cut well with acrylic and probably will work slightly better on plywood, too: coo-coo-rpi_zero-acryl.zip
(If you do use acrylic, let me introduce you to one of the marvels of backing-paper removal: d-limonene. This fruity solvent — present in products like Goo Gone — causes backing paper to slough off with only a few minutes’ soaking. It washes off to a clean shine with water and dish soap/washing up liquid. I have just saved you fingernails from certain damage!)
The cutting path in the PDF could use a little clean up if you want to try this design in acrylic. The base of the design has been flipped so that any laser flare will be hidden inside the case.
You’ll need four M2.5 or M3 nylon screws of 20 mm length, plus 8 washers and 4 nuts. M3 screws of this length are easier to get, but the mounting holes in the Raspberry Pi Zero are only 2¾ mm in diameter. You can thin the M3 screws down slightly by lightly twisting them inside a piece of folded fine sandpaper. You’ll still have to push them through the Raspberry Pi Zero circuit board with a little force, though.
Cutting & Assembly Instructions
If you have it, place some fine wire mesh or sacrificial heavy card-stock between the laser cutter honeycomb bed and the plywood. The spacer washers are just the right size to fall through the cutter bed and be lost inside the discard hopper.
Cut the piece as normal.
Remove the work from the laser cutter. Masking tape applied over the washers will stop them falling out.
Take the top piece, and thread the other two screws through the holes by the HDMI and PWR labels.
(It may be easier to do these one at a time)
Place two of the full spacer washers over each screw.
Push the screws through the Raspberry Pi Zero board. M2.5 screws won’t need any force, but M3 will need some coaxing, possibly even cajoling.
Place a nylon washer on each of the two screws under the Raspberry Pi Zero board.
Take the base and flip it horizontally so the screw holes match the top.
Very loosely attach the nuts to each of the screws.
(You’ll need the slack to fit the top two screws and their C-shaped spacers)
Feed the top two screws through the half-holes by the GPIO cutout in the case and the Raspberry Pi Zero board. Again, coaxing and/or cajoling may be required if you used M3 ones.
Put nylon washers over the screws between the Raspberry Pi Zero board and the base.
Very loosely attach the nuts to the top two screws.
(This is the fiddly bit) Stack two of the half spacers and put them on each screw. You need to get the screws tight enough to just grip the spacers against the case, but not too much or you won’t be able to align them to let the GPIO connector fit in the gap. Tightening the screws at the HDMI and PWR ports can help with this, too.
Nip off half of the heads from two of the nylon screws. This will allow the GPIO connector to fit easily.
Tighten all the screws (finger tight is fine) and make sure the trimmed heads align with the edge of the GPIO cutout.
Raspberry Pi Zero in Coo~Coo case showing GPIO and spacers
The new Raspberry Pi Zero with camera connector should also fit, but I don’t have one to test it.
Following on from FifteenTwenty, I made a hairline/single stroke version of the font especially for CNC use. This is a slight misuse of the OpenType format, but if you’re plotting/CNCing/laser cutting, the filled paths of standard fonts don’t work so well. Single-line (or stroke) fonts used to be possible in PostScript — the version of Courier shipped with early Apple LaserWriter printers was composed of strokes, rather than filled paths — but have fallen out of favour. If you have a device with a defined tool width, it’s better to let the tool make the width of the mark/cut. Here’s the hairline font plotted with a 0.7 mm pen to illustrate what I mean:
This font is almost invisible on screen or on a regular printer, so I don’t recommend installing it unless you have specific CNC/plotting needs. Please note that the font will cause your device to follow the tool path of each letter twice.
The Teensy USB keyboard isn’t limited to sending single characters: a single button press could trigger sending a whole string. I haven’t yet thought out any major uses for this (except “Crypto!â€, which is my usual idea when I have no idea what I’m doing), but you might have better plans.
)
