Shameless Self Promotion

What You Should Read (October 2020)

2020-10-10T00:00:00-04:00

Lenses – Squinting harder never cured my ADHD. (glyph)

Sitting up night after night destroying my mental and physical health, depriving myself of sleep, focusing with every ounce of my will on tasks that I absolutely hated doing but was forcing myself to complete at all costs: it doesn’t seem to line up with the popular conception of what “laziness” might be like! Yet, I absolutely believed that I was lazy. If I were not lazy, surely Doing The Thing wouldn’t be so difficult!

This is the post that got me to try going all-in on a single to-do list that everything I need to do goes into. (It happens to be Todoist, but anything with reasonable tags and saved searches could probably do).

I don’t have ADHD but I often feel lazy. I’ve made a good career in computing and I obviously do get things done, or else nobody would employ me, but my career has been one long square wave – where I oscillate between doing almost nothing and bouts of intense productivity. Good news: you can be successful doing this! Bad news: it’s really fucking taxing on your well-being.

It’s not rare to spend four days of a work week getting almost nothing done, finishing several 8 hour days exhausted and frustrated, blaming this lack of progress on interruptions or succumbing to shallow work. Then, when I’m lucky, I nail things in the last day and it averages out to an okay week and I can start the cycle again. Sometimes that four days is more like 8 days, and that one “good day” is one sleepless night. It’s not always like this, but … it’s not uncommon, either.

So, as is probably clear, my kind of lazy is actually hard work. I totally agree with Glyph’s premise that tools and techniques meant for people who are not neurotypical have value for everyone else, too.

(A related version of this: I am dyslexic and the techniques I was taught by my primary school’s remedial teacher have allowed me to learn to read and distill information quickly. But what if everyone learned how to read like this? Wouldn’t it provide a boost to non-dyslexic people?)

20 questions to ask children about ghosts (revdancatt)

Sometimes I find myself in a situation where I need to talk to a child. For some people talking to kids comes naturally, I am not one of those people. My usual gambit is to ask them what they’re interested in and taking it from there. But sometimes that just doesn’t work, they’re not interested in anything, or they’re not interested in sharing it, or they’re too intimidated by my beard to say anything.

All Our Selves in One Basket (InvisibleUp)

This is a great article and it’s long. I wouldn’t want to TL;DR it, but one element that I agree with the most is the importance of communities owning their own “third places” online, through a combination of decentralization, federation, and rejecting algorithmic engagement.

It reminded me that Telford in Staffordshire (150,000~ people) just has a shopping centre for its town centre, and when the mall is closed there’s basically nowhere for people to go.

A Clean Start for the Web (Tom MacWright)

Linked from the InvisibleUp article, Tom makes the case for a split between the document oriented and application oriented web.

Processed World 32 - Feb ‘94

It’s fun to read zines from the 90’s and see that not everything turned out as bad as we thought (or, they’ve taken longer to turn out that badly than people expected).

Evolution of a Scheme Programmer

Only Lisp Kids Will Remember.

The Downfall of Rosewater, Once America’s Favorite Flavor (Atlas Obscura / Jaya Saxena)

I love me some trivia about some topic that’s totally irrelevant to my life.

The Golden Age of Computer User Groups (Ars Technica / Esther Schindler)

(More nostalgia). I got in on what feels like the tail end of this – Ireland Online had city-specific user groups who would meet up in pubs and talk about being on the Internet, in person. The mailing lists were actually useful and a springboard for a bunch of people’s careers on the early web.

I remember the Irish Linux User Group setting up, and while I wasn’t active beyond one or two meetings, the idea of getting together to talk about Linux seems so weird to me now – especially as Linux kind-of won and is the dominant tech for building things on the web.

It’s like the air that I breathe, and I rarely specifically think about how I use it – even using it on the desktop does not feel like an act of rebellion / self-sabotage like it used to do.

Livermore California’s Centennial Light

Home of the world’s longest burning lightbulb!

I am so glad that this website exists.

Hello again, world

2020-08-14T00:00:00-04:00

Some stuff that I wrote about recently on tilde.town – about being inspired by seeing some modern day tumblelogs – that has lead me down a rabbit hole.

I rediscovered some 2005-era blogs from around the time of the dawn of Ruby on Rails and have read some and followed links and it has made me feel like 15 years is a very short and very long time.

We still had Ubuntu back then! I remember Ubuntu being new! But also we didn’t have Twitter or smartphones, two things that I intellectually know weren’t invented or popular yet, but are such a part of 00’s culture that it doesn’t feel like they were introduced in the last couple of years of the decade.

Anyway, I’ve become slightly jealous of those people who either never left blogging or who have tended their old blogs well. I have not done this, and numerous times I have just blanked my blog or moved to another domain or something.

That said, I am enough of a digital pack-rat that I kept the original files in most cases – I may not have a functioning blog archive back to 2004, but I do have the files. Before 2004, I suppose I could try for the wayback machine?

-rwxr-x---  1 aaron www-data  31K Jul 25  2004 ConjuringFireball.jpg*
-rwxr-x---  1 aaron www-data 4.4K Jul 25  2004 PythonFame.png*
-rwxr-x---  1 aaron www-data 7.8K Jul 25  2004 SolarisExpress.png*

Pictured: Some files I have dutifully rsynced from machine to machine, preserving the timestamps, from before my teenage son was born.

Fun fact: one of the first entries in my 2004 blog is an announcement that I have moved off Bloxsom and onto my own blogging software (I later went through MovableType, Jekyll, WordPress, then my own thing again, then Hugo when I archived the site in 2015). I said I would be backfilling my new blog with the old entries from my Bloxsom blog. Spoiler: I did not do that.

I’ve copied a couple in from web.archive.org and the Artima site which appears to have been dutifully archiving my RSS feed for nearly 15 years. Thanks, Artima!

The funny thing is that you don’t know what’s historically interesting or personally important until a bunch of time has passed. This is mostly why I almost never delete photos (or throw the physical ones away).

It makes me smile that I’ve got a (mildly cringey) post talking about how Ruby on Rails will be the next big thing (2005) and 11 years later I started work at (arguably) the world’s largest Rails-powered company.

Looking back at my link-blog posts from years ago lets me see the well-worn grooves in my thinking, topics I come back to again and again like minimalism and social media addiction.

Like a lot of bloggers, the first fatal blow to regular posting was Twitter. So convenient, compared to writing a whole blog post! I was an early adopter in 2007, keen advocate and heavy user but dropped off in 2015 when the level of discourse around Britain’s proposed referrendum on leaving the EU depressed me.

I downloaded and kept my archive and I still sometimes refer back it (most recently: to figure out when I broke my collar bone, which obviously I tweeted about from A&E). I’m back on there now, but with retweets turned off for almost everyone, a bunch of accounts blocked, and a heavily curated list of people I follow. I delete my tweets after a couple of weeks. Having to “twitter defensively” is probably a bad sign.

It’s not all Twitter’s fault though; I also started to subconsciously raise the bar for what was a good blog post. I would write a post, read it back and think “Is this adding to the public discourse? Does this need to be written?” and then just never publish it. It seemed like there was enough information in the world and adding more low quality posts was lowering the SNR.

Finally, as most of what I was posting was related to my own electronics/radio/manufacturing projects, I realised that I liked making things, but then I resented writing about those things. The two were totally linked in my mind, to the point that I would avoid doing projects that wouldn’t make an interesting write-up or that were “done before”. I still think the right call was to just ditch the blogging part and carry on making things, but now I’m looking back at the last ~3 years and I feel a little sad because I made a few cool things and there’s no real record of them on my blog.

(Conclusion): Blogging about blogging sucks but whatever, it’s my website. I’m not going to make some pronouncement that I’m back or anything, but now that I have the whole site back in Jekyll and it’s reasonably low friction for me to post, I hope I will post here more, and might even back-fill some of the stuff I’ve learned or done during my fallow years.

<3

Building and fixing the Dreadbox Hades

2018-01-01T00:00:00-05:00

This is a finished Dreadbox Hades DIY, a monophonic Eurorack compatible synthesizer from Greece, which was briefly available in kit form. (It’s no longer available for purchase)

It was substantially more involved as a build than I expected - it didn’t ship with resistors so I used some from my stash. There’s nothing especially tricky about the build, there’s just a lot of small parts and a lot of individual solder joints. Here’s the populated board:

The resistors and the capacitors took the most time – stuffing a board with ICs and big moving parts is a doddle in comparison.

So, The End right? I built someone elses synth kit, big deal!

That picture was really just the start of the most fun part of building the kit: putting it together and finding out it doesn’t quite work.

Control Voltage

I put the case on, even tightening the nuts which hold the potentiometers and jacks in place, and found that when I hooked everything up to MIDI – nothing happened. It didn’t react to MIDI notes at all. This was made a little more frustrating because it was a new, cheap, MIDI-USB cable, so it could be the cable. And I’m not very familiar with MIDI routing in OSX or Linux, so it could just be user error. Luckily it was neither.

The Dreadbox people make the schematic for this kit available online, which was a priceless debugging tool. I located the pins on the 24 pin connector that I needed to trace and got ready to test it on the oscilloscope.

I decided to dig in, took the board out of the case and… the control voltage worked. I put it back in the case, and it didn’t. And then it sometimes worked if I pressed on the board, but sometimes it didn’t. There was clearly an intermittent connection somewhere. Either something was shorting out which shouldn’t, or a circuit was being opened where it shouldn’t.

The schematic let me trace the CV to the C and D parts of the TL074 quad op-amp on the top left of the board. The signal was fine at pin 10 – running a MIDI sequence in a loop in seq24 showed edges of transitions – but by the time it was output to the 1V/Octave 3.5mm jack on the board it was gone. Outside of a defective op-amp, the only really obvious component that could be at fault is the glide 1M&ohm; slider.

I didn’t grab a photo of it, but that slider (and others!) had dry joints. It made contact, but once the case was put on the pressure on the sliders broke that contact. I’m not used to soldering big parts that need this much heat – I just went over all those joints and melted them again, adding a little more solder for good luck, and the CV issue was fixed.

(These are still pretty bad solder joints, I should have melted and solder-suckered them and then started over. But this works!)

No Gate

Once I was able to hear the tone changing reliably, the other issue was that neither of the two parts of the synth which should be triggered by the gate signal were working. There’s a gate output on 3.5mm jack, and checking it with the oscilloscope just showed a constant DC signal. I traced back to the pin on the 24pin connector – still dead, and back to the pin on the microcontroller – working just fine! There’s only one part between the connector and the microcontroller, a 1N1007 diode. I believe that it’s there to stop an external gate source feeding back into the microcontroller. Gate voltages don’t need to be TTL, so an external gate could kill the chip.

As I wasn’t using an external gate, I bridged the diode with alligator clips (which made the gate work) and then replaced the diode with a signal diode from my spares box. It’s not an 1N1007 but that diode was massively over-specified, being able to cope with 1000V and 1A of current.

This fixed the the voltage controlled amplifier (VCA), but the filter (VCF) wasn’t working properly at all.

Filter not triggering

This one is pretty embarassing.

I traced the bias on pin 9 of the TL074 op-amp used near the gate input to the filter – the bias voltage was fine, but pin 10 showed a barely perceptible square wave on top of a wall of DC. It was like the positive input of the op-amp was really biased badly, or the positive feedback was all wrong.

The construction manual for the Hades says “be careful not to mix up 1K&ohm; and 1M&ohm; resistors” and I thought, “how would you even do that?” and yet…

Once I replaced this resistor with an actual 1M&ohm; one (and not a 1K&ohm;) – the filter sprang into action. All fixed!

This is a pleasant ramp being output by the envelope generator (which is an A D/R S type).

Miscellaneous Bad Things I Did

I didn’t have all the right resistors in stock, so I had to either add resistors in series (R₁ + R₂) or in parallel (1/R₁ + 1/R₂). Look at some of the lovely stacked / joined messes that lead to:

PS/2 to USB convertor from an Arduino

2017-06-28T00:00:00-04:00

I picked up a 90’s era Microsoft Ergonomic keyboard from Value Village after Christmas 2016. The keyboard is in amazingly good condition and, of course, it’s built like a tank. It’s actually not a mechanical keyboard, my usual preference, but it is worth saving and making useful again.

The First Attempt

At the time I did have one computer which actually still had a PS/2 connector (an HP G5 from 2009-or-so). I tested the keyboard out over PS/2 and all the keys worked. This wasn’t going to have to be a repair, just a conversion.

The last time that I made a PS/2 to USB convertor, I used the excellent [tmk_keyboard][]. That was using an ATmega32U4 microcontroller.

These have USB hardware on board (which is why they are very popular in the keyboard hacking community) and using one to create a PS/2 adaptor is basically a case of flashing [tmk_keyboard][] and soldering the PS/2 wires to some pins.

Back then I had a depleted electronics stash: my container of stuff had arrived from the UK but there was still a load of stuff that I had sold or given away that I hadn’t replaced yet. I didn’t have an ATmega32U4 microcontroller. All I had was Arduino (clones), an FTDI cable and some passive parts.

Despite having very few basic parts, I did actually have a 50MHz oscilloscope, which was a leaving present from iWeb, this was actually pretty useful in diagnosing USB problems.

I compiled tmk_keyboard for the ATmega328p, making sure to edit Makefile.vusb and change the CPU speed to 16MHz (it defaults to 12MHz). I didn’t have an ATmega programmer, so I had to just upload it via the Arduino bootloader.

This meant that when the power turns on to the board there is short pause before the microcontroller executes the convertor firmware. I think this was one of several factors which made the convertor unreliable to the point of useless. The other was not using quite the right diodes, and so voltages were slightly out of specification:

(Sometimes 3V, 3.3V or maybe up to 3.6V?)

It did work, at least once:

but you can see all of the kernel errors from failed negotiations in the screenshot. I think, maybe, that the wiring played a part, too:

The Second Attempt

I still had the keyboard, but I got rid of the HP. I wanted to use the keyboard with a Raspberry Pi, anyway, so PS/2 was never going to be good enough.

I also had some ATmega328p TQFP parts at 0.8” pitch, and a toaster oven I wanted to try out for reflowing. I took the schematic from the README:

                +---+   +---------------+
USB            GND  |   |   ATmega168   |
===                 C3  |               |
5V <-------+--------+---|Vcc,AVCC       |        PS/2
           R1           |               |        ====
D- <----+--+-----R2-----|INT1        RXD|------->DATA
D+ <----|---+----R3-----|INT0        XCK|------->CLOCK
        Z1  Z2          |               |      ->5V
GND<----+---+--+--+-----|GND            |      ->GND
               |  |     |               |
               |  C2-+--|XTAL1          |
               |     X1 |               |
               +--C3-+--|XTAL2          |
                        +---------------+

And I recreated it in Kicad:

And I even got as far as starting to mill the PCB before realising my mistake:

(Spoiler: There is nowhere to program the chip. I omitted ICSP pins).

The main missing part was an actual ATmega programmer, which is why the whole project took six months to finish off. I was definitely going to need to connect it somehow.

So, basically I gave up on the PCB, and decided to just sacrifice an actual Arduino clone. It’s easy to program and you can just solder it straight into some perf-board:

Just substitute the raw ATmega pin names for the Arduino equivalents:

ATmega Pin Name	Arduino Pin
RXD	0
INT0	2
INT1	3
XCK	4

Using a USBasp clone I wrote the firmware directly, overwriting the Arduino firmware but also getting rid of that ~1 second start-up delay which was causing so many USB errors before.

This actually worked first time, pretty unexciting stuff but I can move on with my life with a working keyboard. The only part left was to insulate the board. There is more than enough space inside the cavernous Microsoft keyboard case, but it’s also got some massive metal sheets.

This also had a quick fix:

There is a lot to be said for keeping ziploc bags as quick insulation. It’s even more of a cheat that wrapping everything in heat-shrink tubing.

Making your own private Internet

2017-04-02T18:00:00-04:00

blows dust off blog

It’s not that I haven’t been busy! I’ve built and upgraded, and broken, a CNC mill. I’ve converted a 70’s toy to accept WiFi and speak Python. I even converted another PS2 keyboard to USB .. kinda. I just haven’t written any of it up on my blog.

I knew I had to write up the even older stuff about FPGAs etc., and I think that was holding me back.

This is not that post.

This is a post about using WireGuard, VXLANs and Linux bridge devices to make your own private network between hosts that can neccessarily all talk to each other.

The WireGuard quickstart is pretty comprehensive, so I’m not going to duplicate it here. For my part, I have five machines:

Machine	Location
rho	Paris, FR
epsilon	Eastern US
vorke	Ottawa, CA
bob	Stafford, UK
pi0	Roaming

Rho, Epsilon and Bob have static IP addresses and are reachable from the outside. Vorke has a dynamic IP address which is reachable from the outside. Pi0 could be anywhere, has a dynamic IP and is usually behind NAT.

I checked out the WireGuard source and built the kernel module. Because I’m a lesson to others, I am using a mix of x86, amd64 and armel. I’m also using a mix of Debian, Ubuntu and VoidLinux, and my Paris machine is a Marvell Armada SoC. Don’t be like me.

Let’s assume that

cd WireGuard/src ; make ; sudo make install

does the right things for you. You’ll have a wg utility on your path, a new kernel module in the directory that matches your running kernel and an /etc/wireguard directory, waiting for a config.

I changed to /etc/wireguard on each machine and generated my keys:

wg genkey | tee privatekey | wg pubkey > publickey

Then I assigned 10.88.88.0/24 out of thin air. (It’s in an RFC1918 network, so this is fine. Anything starting with 10. is fair game as long as no other network you are connected to is using it).

Each machine has a config which lists the other nodes in it:

# Rho
[Interface]
PrivateKey = REDACTED
ListenPort = 56560

# Bob
[Peer]
PublicKey  = REDACTED
AllowedIPs = 10.88.88.1/32
Endpoint   = 86.188.161.69:56560

# Epsilon
[Peer]
PublicKey  = REDACTED
AllowedIPs = 10.88.88.4/32
Endpoint = 104.196.99.86:56560

# Vorke
[Peer]
PublicKey  = REDACTED
AllowedIPs = 10.88.88.3/32

# Pi0
[Peer]
PublicKey  = REDACTED
AllowedIPs = 10.88.88.5/32

You don’t have to always list every node in the config, only the other nodes that you expect that machine will talk to. For example, I’ve only put Pi0 in Rho’s config, because those two machines only talk to each other via WireGuard.

You’ll notice that Endpoint is only filled in for machines which are publically reachable on a static IP. The other machines will initiate a connection out to the static ones. Once that happens, the static ones know to use that existing UDP socket pair to talk back to them.

I create and configure the WireGuard network interfaces on every machine:

modprobe ipv6
modprobe udp_tunnel
modprobe ip6_udp_tunnel
ip link add dev wg0 type wireguard
wg setconf wg0 /etc/wireguard/config
ip link set up dev wg0
ip addr add 10.88.88.4/24 dev wg0 # pick a unique IP for each machine

You can verify that everything is working now by pinging from place to place. If you’re okay with the wg kernel module making routing decisions for you, and having to have all nodes be able to talk to all other nodes, you could stop now.

I wasn’t happy with this, and I also wanted to deal with the issue of MTU. On my network, the wg0 device has an MTU of 1420. This should be fine, because we have path-MTU discovery, but we live in crappy times and between overzealous filtering of ICMP, refusal to route fragmented packets and anycast IPs that do the wrong thing, this will cause problems at some point.

My solution for this is to run VXLANs over the encrypted point-to-point tunnels that WireGuard have given us. They are effectively VLANs which are implemented in UDP instead of at layer 2.

These act more like regular network devices, their routing (and switching) decisions work in standard ways, and I can tell the kernel to make the devices have 1500-byte MTUs and just send fragmented packets over WireGuard. It won’t neccessarily be efficient, but it will work.

Each of these VXLANs is going to form a point to point network of their own. I like to think of them as “virtual wires”. Or cloud Ethernet. Or something. Given a bunch of virtual wires which connect between each other but don’t form a complete mesh, I thought of a few ways to make this work:

Static routing over the IPs. I don’t have a lot of hosts, but I have enough for this to become annoying, and it wouldn’t provide any form of redundancy.
Use a dynamic routing protocol (like BGP). Because the hosts don’t form a full mesh, they couldn’t live inside the same autonomous system, but I could allocate a bunch of ASes from the test range (64512 and above). This could be cool because I could join my BGP based Calico network in. It does mean configuring some routing software (probably Quagga). I may still revisit this, but it wasn’t what I chose to do.
Solve this at layer 2 by using Linux bridges and the spanning tree protocol.

Spanning tree will mean that I really can just treat these VXLANs like cables – connect them all to a core switch, connect them to each other, and let STP avoid switching loops.

In real network gear, if you have two connections between Switch A and Switch B, you would cause a switching loop – packets going to Switch B from A would end up going back to A and then back to B and bad, bad things would start to happen.

To avoid this, when a layer 1 connection comes up on an STP enabled switch it sends some broadcast packets called BPDUs. If it receives that packet back on another interface, it will disable one of the two interfaces to avoid a loop. No real traffic can flow until this process has run its course, which takes around 30 seconds.

Apart from avoiding pain when connecting network equipment together, STP also gives you a layer of redundancy – if the active port stops sending packets, your switch can attempt to bring the port which was disconnected (‘Blocked’ in STP speak) into to use (‘Forwarding’).

This is going to be great for my internetwork, because if one of the nodes is unavailable then all of the rest of the nodes which have cross connects will eventually notice and reconfigure themselves into a mostly working network.

Because it doesn’t require every node to talk to every other, connections like Pi0 – which only has one upstream connection, are treated just like an access port on a switch. They have no redundancy, but they are considered down-stream of which every Linux bridge they are connected to.

brctl addbr internet
brctl stp internet on
case $(uname -n) in
epsilon)
    ip addr add 10.99.99.4/24 dev internet
    ip link add vorke   type vxlan remote 10.88.88.3 id 1 dstport 4789
    ip link add bob     type vxlan remote 10.88.88.1 id 2 dstport 4789
    ip link add rho     type vxlan remote 10.88.88.2 id 4 dstport 4789
;;
vorke)
    ip addr add 10.99.99.3/24 dev internet
    ip link add bob     type vxlan remote 10.88.88.1 id 3 dstport 4789
    ip link add epsilon type vxlan remote 10.88.88.4 id 1 dstport 4789
    ip link add rho     type vxlan remote 10.88.88.2 id 5 dstport 4789
;;
sudo ip link set up dev internet
for i in epsilon bob vorke rho pi0; do
    ip link set up $i
    brctl addif internet $i
    ethtool -K $i tx off
done

The above establishes VXLANs between the different hosts (only two are included, for brevity), adds them to an STP enabled bridge and configures IPs on the bridge devices.

Because of a bug … somewhere (I suspect WireGuard) I had to disable hardware accelerated tx checksums, that’s what the ethtool line is doing.

Epilogue

We can view the status of things with brctl showstp internet:

EPSILON:~$ sudo brctl showstp internet
internet
 bridge id              8000.5299c5e0d97b
 designated root        8000.16500a8e632a
 root port                 1                    path cost                100
 max age                  20.00                 bridge max age            20.00
 hello time                2.00                 bridge hello time          2.00
 forward delay            15.00                 bridge forward delay      15.00
 ageing time             300.00
 hello timer               0.00                 tcn timer                  0.00
 topology change timer     0.00                 gc timer                 276.72
 flags


bob (1)
 port id                8001                    state                forwarding
 designated root        8000.16500a8e632a       path cost                100
 designated bridge      8000.16500a8e632a       message age timer         19.86
 designated port        8002                    forward delay timer        0.00
 designated cost           0                    hold timer                 0.00
 flags

rho (3)
 port id                8003                    state                  blocking
 designated root        8000.16500a8e632a       path cost                100
 designated bridge      8000.3a3bee4c8584       message age timer         19.87
 designated port        8002                    forward delay timer        0.00
 designated cost         100                    hold timer                 0.00
 flags

vorke (2)
 port id                8002                    state                  blocking
 designated root        8000.16500a8e632a       path cost                100
 designated bridge      8000.42031e2df8ce       message age timer         19.88
 designated port        8002                    forward delay timer        0.00
 designated cost         100                    hold timer                 0.00
 flags


EPSILON:~$ ping vorke.vpn.insom.me.uk
PING vorke.vpn.insom.me.uk (10.99.99.3) 56(84) bytes of data.
64 bytes from 10.99.99.3: icmp_seq=1 ttl=64 time=196 ms
64 bytes from 10.99.99.3: icmp_seq=2 ttl=64 time=196 ms
64 bytes from 10.99.99.3: icmp_seq=3 ttl=64 time=197 ms

You can see from the above the Epsilon (US) isn’t using its connection to either Rho (FR) or Vorke (CA). It’s only using Bob (UK). And that means when I use ping, even though Canada and the US share a land mass, my packets take nearly 200ms to return: the traffic is going over to England and back, crossing the Atlantic twice.

The full script for this is available in this gist.

Measuring Frequency Response

2016-12-27T11:00:00-05:00

In my short electronics career, I’ve built headphone and power amplifiers, including a valve amp, and a microphone pre-amp of my own (extremely simple) design. I’ve modified others, too.

I like the sounds of these devices to a greater or lesser degree, possibly for pretty unscientific reasons.

One thing I’ve wanted to do for a while is stick some science on it and actually measure their frequency responses.

I recently had a good excuse because I found my microphone pre-amp and I was going to rebuild it properly and put it in a box but I also found this SSM2019 chip that I’d received a sample of from Analog.

The SSM2019 is effectively a pre-amp on a chip, only requiring power, signal and a 10K variable resistor to control gain. Its datasheet promises a flat frequency response past 20KHz, which is about as good as human hearing range

There was no point in rebuilding my basic LM348N-based amp if the SSM was going to be better and even simpler.

Curiously, the LM348N doesn’t list frequency response on its datasheet (as available from Digikey). I found a Fairchild version on a Russian website which suggests it falls off well before 10KHz.

As a happy coincidence, Hackaday recently ran an article called “Controlling Your Instruments From A Computer: Doing Something Useful”. In it, Jenny List measured a filter she designed against the simulation (and found the real one wanting). She used a Rigol oscilloscope for the readings and a Raspberry Pi as a signal generator. I have both of those! This was all going to be a walk in the park!

Nope.

I checked out her fork of freq_pi and used the Rigol to verify that GPIO4 on the Pi was outputing some very stable square waves. Then I found it’s only capable of generating waves from 61KHz to 250Mhz. (Well, I say only. That’s incredibly useful, just not for me).

It was time to completely switch tack.

Last Christmas I was given an Analog Devices ADALM1000. This is a combination two channel signal generator / oscilloscope aimed at the educational market.

The basic idea is that you build some filters or op-amp designs and have one channel generate a signal, and then measure it with the other channel.

That sounds great for testing an amplifier too, and it’s capable of generating a sine-wave from 1Hz to 20KHz, so it perfectly matches the range I’d like to test.

This is everything held together with crocodile clips. This photo actually shows me testing my NP100v12 valve amp, but the basic set up is the same.

I connected channel A to the ground and input of the pre-amp and channel B to ground and output. I powered the amp from a 9V battery to avoid introducting any mains hum.

This is the Alice software for the ADALM1000. It’s all written in Python and pretty hackable. It’s not as polished as the Pixelpulse software which is also available from Analog, but once you get used to it this software is far easier to control accurately.

In this screen shot I’ve set channel A to be AWG (arbitrary waveform generator). The shape is sine (you can’t see that, it’s hidden under the shape menu). Input amplitude is from 0 to 0.1V, and we’re generating a 100Hz wave as a test.

Channel B is measuring voltage. It’s set to display the waveform as well as the peak voltage (V^max – 1.01V here). Our gain (G) here is 10.

By changing the frequency I created a table of Hz vs. V^max:

Hz	V^max
10	1.03
50	1.03
100	1.01
500	1.005
1000	1.015
2500	1.00
5000	0.98
10000	0.92
15000	0.84
20000	0.75

This isn’t very clear, although even I can see the drop-off starting after 5000Hz.

A little Python script to generate a plot will help with visualising what this means.

Oh.

Expect a follow up when I build the SSM2019 based pre-amp, I guess.

ESP8266 and MicroPython Temperature Logger

2016-12-19T11:00:00-05:00

My furnace is broken. Again.

I have internal temperature graphs that show what’s going on, courtesy of a BME280 Adafruit board that I bought:

You can see the slow build up to temperature, the rapid cycling at or near the top of the cycle and when the furnace gives up and the temperature creeps down. Oh, and by the way, it’s pretty cold out.

Google reckoned it was down to -20 last night, but I honestly can’t get my brain around a temperature like that and I always feel it’s milder at my house than Google (or the Weather Channel) say it is.

It’s time to science this up.

I had actually ordered another BME280 board from eBay more than a month ago, at the same time as the Adafruit order from BuyAPi.ca, and it just showed up yesterday. What perfect timing.

I already had a couple of ESP8266 boards which had arrived with my belongings from the UK, so I followed the tutorial to compile and install MicroPython on one, grabbed this great MicroPython library for the BME280 part and wired it all up.

I needed to use the WebREPL server to upload both the library and my new boot.py file which contains all of the Python I had to write for this. Basically it just sends a UDP packet to my Raspberry Pi every few seconds.

There’s a tiny Ruby script on the Pi submitting the data that it receives into Graphite, and Grafana makes the pretty graphs.

I used the Xiaomi battery pack I blogged about before to power the whole lot. As that previous post mentions, the battery pack will turn off if there isn’t enough current being drawn. Unfortunately the ESP8266 and the BME280 are too damned power efficient, only drawing 73mA. This is less than the 90mA that we need.

I added the four-200&ohm; resistor pack, bringing the consumption (according to my ammeter) to 170mA total. This is wasteful but, meh, this is a quick hack. It also gives me a nice LED to see that the power is on.

This is a useful feature because I threw the whole thing into a transparent box to weather proof it, and now I can see if it’s on or not without going out into the cold.

Here’s the completed graph:

You can see that it took a little while for the unit to get down to outside temperature, it dropped to -18C at the lowest point, and the battery ran for 16 hours.

The current consumption is (0.17A × 5.1V) 0.87W, so the power should have run for ~18 hours, but given that it was -18C below, I think it’s fair to say that the battery did pretty well.

Z80 BASIC on a Cyclone IV FPGA

2016-12-13T00:00:00-05:00

With a vague idea that FPGAs are cool and that I’d like to learn how to use them I picked up a cheap Cyclone IV development board and a knock-off Alter USB Blaster clone from AliExpress.

I didn’t really know what I was buying, this was simply the cheapest thing I could find. The spec is alright, 6272 logic elements and 256Kbits of RAM. The bit part is important – you’re going to construct your own RAM from IP blocks, and the bus could be any number of bits wide.

The programmer is exactly like the picture, it’s Altera branded but, you know, fake.

Inside it’s a PIC microcontroller and a 74LVC244A octal buffer. I guess it emulates an FTDI because when I configured OpenOCD to use it I use the FTDI driver.

VHDL

There’s two major languages for FPGA development, Verilog and VHDL. I’m not experienced enough to have an opinion on which is better, but the project that I extended was already written in VHDL, so that’s what I carried on with.

This is an Altera chip, so you need to use their Quartus software. Luckily, it’s available for Linux as well as Windows. It’s big, and you need to download an also-very-big board support package for the Cyclone IV after installing it, but that’s proprietary software for you.

I followed Grant Searle’s Multicomp instructions, updating them for the board that I have and the current version of Quartus.

Nothing I’ve done so far would have been possible without this excellent resource, you should read his whole site if you’re into retrocomputing or understanding how a microcomputer works.

I’ve put my own VHDL microcomputer definition in a commented gist, which should help explain what’s going on a little better. This build is for a Z80 running BASIC and 4K of internal 8bit RAM. It has a UART (a 6850 compatible one) and an IO device called “aaron” which I’ll explain later.

In fact, my whole project file is available for download.

Quartus is as powerful as it is kind-of ugly:

When I imported Grant’s project Quartus asked me to upgrade the IP, which I’ve done. I regenerated the the RAM and ROM using the wizard interface, as they are built using “off the shelf” Altera IP blocks.

You just specify how much RAM you want to use, how many ports it should have (you can have dual port RAM, useful for framebuffers) and how wide the data bus should be.

For the ROM you can see I picked 8K of 8bit words, and it’s going to have 12 address signals and 8 data signals:

I also had to define which pins on the chip I wanted to use for each of the external signals – not every pin can be used for every function but it’s surprisingly flexible:

Congratulations! This should be all you need to synthesise your design. If you were on Windows, you could even use the built in programmer software to upload it, but for some reason, that didn’t work for me.

Tune in next time to see how I got JTAG programming working, and for the exciting “Hello, World”.

Void Linux CDC Ethernet on the Raspberry Pi Zero

2016-11-20T11:00:00-05:00

A quick howto. Void Linux is a minimal Linux distribution that aggressively tracks upstream software with a rolling release model. They use runit as their init and have the option to use musl as their libc.

Binaries are available for x86_64 and ARM platforms, with a distribution available for the Raspberry Pi 1 (which is close enough to the Zero).

Unfortunately, it looks like the default Pi build expects you to have a console and keyboard on the machine. As I only have a serial terminal, the first thing that I did was set it up to print console messages to the built-in UART, and set up a getty on /dev/ttyACM0.

Follow the installation instructions, and while you have the filesystem mounted, change boot/cmdline.txt to:

root=/dev/mmcblk0p2 rw rootwait console=ttyAMA0,115200 kgdboc=ttyAMA0,115200 smsc95xx.turbo_mode=N dwc_otg.lpm_enable=0 loglevel=4 elevator=noop

That will take care of the boot messages. To be able to actually log in, we’re going to need to change to etc/runsvdir/default (relative to your mount-point, /mnt/rootfs for me) and create a symbolic link to a file which won’t actually exist for you:

ln -sf /etc/sv/agetty-ttyAMA0

That’s going to make sure that a getty on ttyAMA0 loads on boot. This was already included in the distribution, it just wasn’t enabled by default.

The next step was enabling CDC Ethernet – I think that this is one of the best features of the Zero, you can have a little computer that you plug in with a Micro USB lead and you can SSH straight to it.

To make the module load at boot time create the modules-load.d folder and list the modules in the order that we need them (dwc2 for gadget support, g_ether for CDC Ethernet support)

mkdir -p etc/modules-load.d
tee etc/modules-load.d/ether.conf << EOF
dwc2
g_ether
EOF

Because I like the device to always get the same DHCP lease and show up as the same network device when plugged into my laptop, I also set the host and device addresses:

tee etc/modprobe.d/ether.conf << EOF
options g_ether host_addr=32:70:05:18:ff:78 dev_addr=46:10:3a:b3:af:d9
EOF

Finally, I make sure that the Zero will DHCP for this new network device the first time that I plug it in:

cd etc/sv
cp -r dhcpcd-eth0 dhcpcd-usb0
ex dhcpcd-usb0/run
:%s/eth0/usb0/g
:wq
cd ../../etc/runit/runsvdir/default
rm dhcpcd
ln -sf /etc/sv/dhcpcd-usb0 # this absolute path won't exist yet

That’s it for the Zero, just unmount the filesystems and pop the MicroSD card into your Raspberry Pi.

I use Ubuntu on my laptop, so when I plugged in my Zero, it detected a new network device. Select ‘Edit Connections…’ in the Network Manager applet to reconfigure this new USB device that has shown up - you’ll want to go to ‘IPv4 Settings’ and then choose ‘Shared to other computers’. Okay your way out an wait a few seconds for everything to catch up.

The IP address of your Zero should in /var/lib/misc/dnsmasq.leases – SSH in and enjoy!

Just another Arduino weather monitor

2016-11-06T00:00:00-04:00

Just a quickie project, mostly consisting of smushing Adafruit modules and eBay modules together in hardware, and a few choice libraries in software.

I’ve moved to Canada and I have a garage with mains power. I’ve never been through this kind of winter before, so I thought it would be interesting to log the inside and outside temperature and outside barometric pressure.

While there is power, there’s no connectivity in the garage, so I’m following in the footsteps of some of my friends back in England, and using a pair of Nordic nRF24 modules to establish a reliable radio link.

The source code to the whole thing is on GitHub, and it depends on the RF24 and Adafruit Sensor libraries.

I tested my set up by starting with low power amplifier settings on the radios and using an example sketch provided with the library. It might seem like setting power to the maximum is the best, but that also puts the most load on your 3.3V voltage regulator, and some Arduinos and clones don’t deal well with that.

Luckily, I was able to verify that mine does, and use that. I also only transmit at 250Kbps, which results in acceptable performance at higher ranges.

Sensor Node

Arduino Pin	BMP180 Pin	nRF2401+ Pin
GND	GND	GND
VCC	VCC	-
3.3	-	VCC
7	-	CE
8	-	CSN
11	-	MOSI
12	-	MISO
13	-	SCK
A4	SDA	-
A5	SCL	-

Receiver Node

Arduino Pin	nRF2401+ Pin
GND	GND
3.3	VCC
7	CE
8	CSN
11	MOSI
12	MISO
13	SCK

Reading the Output

As long as the Receiver node can pick up the signal from the Sensor node, you’ll get regular data output over the USB serial:

picocom --baud 9600 /dev/ttyUSB0
...
OHAI
P1022.41T4.30

That’s 1022.41 hPa and 4.30C outside.

Because I have a local Graphite install, I can just send metrics to 127.0.0.1:2003 with a tiny Ruby script, which parses the serial output and spits Carbon formatted data over TCP to my Graphite install.