Hello, I'm Jonah on jonah.id

Anki Deck for AWC Weather Symbols

Mon, 16 Feb 2026 00:00:00 +0000

Shared: https://ankiweb.net/shared/info/2142527470

Weather Symbols for Graphical Aviation Forecasts

This is a deck containing the graphical symbols and METAR/TAF codes for various weather conditions and chart features. It is produced from the AviationWeather.gov website.

Reproduction/Update Instructions:

Navigate to https://aviationweather.gov/gfa/help/#symbols
Open the browser inspector
Paste the script at the bottom into the console
Copy the text output
Paste into a text file and save as a .csv file
Use “Import File” feature in Anki Desktop. All options should be set automatically.

Script:

Designing the Orange Pi Enclosure

Sun, 05 May 2024 20:51:00 -0700

With the pivot to a new SBC, a new enclosure is in order.

To meet my adjusted goals (including no custom cabling and a more comfortable assembly), I’ve made some adjustments to the approach. The biggest is the separation of the back peripheral panel. On the last design, it was not easy to get the board in/out of the enclosure because the ports needed to protrude into the peripheral holes. In this design, the back panel is built into the bottom part, which means the board only need to fit into one port panel at a time.

Switching the Home Box to Orange Pi

Sat, 27 Apr 2024 18:53:00 -0700

After running into too many roadblocks on this project (due to my tight design constraints) and burning out, I’ve finally come back to this project with renewed interest. The hardware space has improved since I left off, and I’m willing to make some compromises this time to increase the chances of following through to completion.

New constraint: no soldering or custom cable making. If I can’t buy a component off-the-shelf (besides the 3D printed enclosure), too bad, figure out something else.

Doorbell

Mon, 11 Mar 2024 05:39:27 +0000

Intro & Assets

A hardware and software project to monitor/control my building’s doorbell/lock panel.

Repository: sr.ht/~jonahbron/doorbell

Motivation & Background

I’m never home when the mail comes.

I love the USPS and use them whenever I have a choice for shipping. They have the key to my building’s lobby. UPS and Fedex do not. Package theft is not uncommon, thus they often will not leave a package if nobody answers the door. They almost always deliver during weekday in work hours, which is pretty reasonable considering the delivery workers are… working. The problem is that I’m working too. And not at home.

Ultimate Home Box: Plan

Fri, 23 Dec 2022 10:41:40 -0800

There should be a box in every home.

Background

There have been some major benefits to the centralization of always-on computing power (i.e. the cloud). The ability to shift resources from one customer to another as needed means a net reduction in actual resources needed. Allowing fewer companies to specialize in the skill of maintaining compute infrastructure results in less skill duplication, and so lower costs.

But it comes with some vulnerabilities too, mainly to the customer. Those vulnerabilities include:

Hacking the Rollova: The Nuclear Option

Sat, 01 May 2021 13:40:47 -0700

(part one of hacking the Rollova 2.0)

Not being satisfied with giving up (and always keen to acquire a new tool), I decided to take the nuclear option: remove the original MCU and replace it with a suitable equivalent.

Having already determined with a fair level of certainty that the original is an STM32L series MCU, I ordered a STM32L562. It has 512KB of flash, which should be plenty for anything I might want to put on here. This job could be done with just a soldering iron, but my research indicated that a hot air rework station would be better for SMD soldering. I picked up the one from Sparkfun.

This does not end well

Thu, 01 Apr 2021 19:12:54 -0700

For my birthday, I was given a Rollova 2.0. It is an electronic measuring tape, except that instead of a physical tape, the circumference orbits. The number of revolutions are measured, and converted to a linear distance which is shown on an LCD. It also has the ability to store measurments that the user has taken. It’s a neat gadget, but to me the potential was entirely untapped.

The product’s website advertises that it has an STM32 microcontroller unit (MCU). This is a fairly common family of 32-bit ARM chips made by STMicroelectronics. Inspired by the now famed Doom on a pregnancy test, I determined to hack this thing. After all, it has plenty of inputs: a rotation encoder, and two buttons. That’s gotta be enough to play doom, or at least something simpler like Snake.

Building Rust

Fri, 22 May 2020 22:11:20 +0000

I’ve compiled the Rust compiler a lot of times now. That’s necessary because the AVR fork of Rust is not officially supported, and the fork does not distribute a release.

It’s been a huge pain, and very often I find myself unable to compile it for one reason or another (wrong branch, mismatching compiler versions, etc.). To relieve myself (and hopefully others), I’ve created a Docker image designed with the ability to reliably compile Rust. It’s on Docker Hub.

USB Serial Mod

Sun, 15 Mar 2020 21:21:17 +0000

A project I’m working on with the ESP8266 requires a USB module. The one I bought from Sparkfun has a USB C port, and 6 pin-outs.

Unfortunately, to be able to wire up the ESP for flashing, the ESP needs access to the RTS pin, which is not made available by this usb/serial breakout. However, the chip itself does have that pin.

With some inspiration from others, and some confirmation of the concept, I decided to add an extra terminal soldered to the correct pin on the chip. I tested by holding the jumper manually, and it worked great.

Resume

Sat, 08 Feb 2020 00:00:00 +0000

Jonah Dahlquist

My excellent problem solving skills and broad experience allow me to develop elegant, creative solutions. My interpersonal and communication skills make me an outstanding team member, both productively and socially.

Working UDP Listener in Rust (finally)

Wed, 31 Jul 2019 02:35:35 +0000

After much wailing and gnashing of teeth, I figured out what the problem with my program was. The W5500 driver’s ability to edit registers is not broken, it was my own mistake. In my simple example set up to write/read to/from a register, I forgot to alter the configuration of the SPI instance to match what the W5500 chip expects. Fixing this instantly yielded results.

https://github.com/jonahbron/smart-plug/blob/0655b0671ad76788fccc0043198b9e15e715d753/src/main.rs

Hello from Arduino!
initialized
activated
IP: 192.168.86.30

This gave me new-found hope in the possibility of using the driver and not needing to implement my own. So I pushed forward to try receiving a UDP packet again. After messing around with the same compiler/linker errors I’ve been getting around the library, I found that passing in a buffer 16 bytes in length or less fixes the problem with receive.

W5500 Driver for Rust Embedded-HAL on AVR

Sun, 28 Jul 2019 23:10:57 +0000

Edit: this post is kind of hopeless, so skip to the next one in which I figure out the problem!

In the last post, I was optimistic that implementing a SPI library for my AVR chip would get the currently-available W5500 Embedded-HAL driver crate working. Alas, after much testing and experimentation, I have not been successful in making it do… well, anything. Even the simple task of writing to a single register and reading it back out does not behave as expected. The value read back is just zeros. Serial output:

Rust on Arduino

Sun, 14 Jul 2019 02:00:00 +0000

Last time we started writing some C code using the Arduino IDE. Arduino IDE provides a great interface, and it’s an excellent way to get started writing embedded code. However, it has a drawback for me: I don’t want to write in C. Instead, I would prefer to take this opportunity to learn Rust. Because Rust’s run-time performance can be comparable to C and I’ve been wanting to learn it for a while, this seems like a really good opportunity to try it out.

Smart Plug Prototype 2.0

Wed, 05 Jun 2019 05:00:00 +0000

Now that we have a working proof-of-concept, it’s time to take this project into the prototype stage. I’ve demonstrated that the idea can work using off-the-shelf components. Now it’s time to start simplifying and refining the product. That means bye-bye Beaglebone Black, and hello Arduino. An entire computer and OS is wholly unnecessary for a task as simple as this. Arduino is the most popular (and best supported) platform of which I’m aware for developing embedded systems. There may be a point at which this project outgrows even that, but for now it will do what we need.

Sherman Hill Internet

Fri, 31 May 2019 10:40:00 +0000

My Internet sucks.

Well, it’s not that bad. But it’s not great either. I can only buy up to 80Mbps, and have a monthly data cap of 400GB per month. I hit the cap every month.

This is by design. Because Mediacom is the only cable provider in the area, the service they provide must be just poor enough and just expensive enough to maximize the profit of the company while avoiding attempts at competition. While I cannot begrudge them for this (that’s the system in place currently), I don’t have to like it. I want to do something about it.

Smart Plug Prototype 1.0

Thu, 04 Apr 2019 19:07:00 +0000

The initial proof-of-concept is officially working.

The above video demonstrates the POC working as expected end-to-end.

Client <-> Router <-> Powerline Ethernet <-> Microcomputer <-> Relay <-> Appliance (i.e. lamp)

Without any wireless technology, we were able to control a lamp that’s ultimately only plugged into the wall.

The full list of materials is:

Material	Cost
High-voltage Electrical Relay	$27
Beaglebone Black	$55
TP-Link AV600 Powerline Ethernet Adapter (pair)	$38
Total	$120

Here is the update on the improvments we’re trying to make with this approach.

Smart Plug Prototype 0.6

Fri, 29 Mar 2019 19:01:00 -0500

We’re almost there to the full POC. Here we connect the Beaglebone up via Ethernet directly to the LAN. Once that’s done, we can open a TCP connection over WiFi from a laptop, now with no physical connection between server and client.

We’re so close to the POC now. The last step is to connect the Beaglebone over powerline Ethernet (i.e. HomePlug AV).

Smart Plug Prototype 0.5

Wed, 27 Mar 2019 23:27:00 -0500

Here we finally do the real thing. We wire up a GPIO pin and a ground pin to a commercial relay¹.

Using the control protocol written for the Beaglebone’s onboard LEDs (and pointing the code to a different pin), we can now fully control a lamp remotely. We now have a usable prototype; however, this is only a demo of controlled, high-voltage switching. There are a couple more steps before we have a full proof-of-concept. The next is controlling over the home network, not over a USB network.

Smart Plug Prototype 0.4

Fri, 22 Mar 2019 14:16:00 -0500

In this verison, we’ve now created a server that can open a duplex communication channel with a client. The server will send update the client on its state every 10 seconds, or any time its state changes. State is represented as a UTF-8 encoded 0 (off) or 1 (on) byte. In addition to the server updates, the client can at any point send a 0 or a 1 to the server, which will change the state of the light and update all other connected clients.

Smart Plug Prototype 0.3

Fri, 22 Mar 2019 09:20:00 -0500

The next phase of usefullness is turning the light off. In this next version, we keep track of whether the light is on or off, and toggle it upon receiving a TCP connection.

var b = require('bonescript');
var net = require('net');
var LEDS = [
  'USR0',
  'USR1',
  'USR2',
  'USR3'
];
var state = b.LOW;
LEDS.forEach(function (LED) {
  b.pinMode(LED, b.OUTPUT);
  b.digitalWrite(LED, state);
});
var server = net.createServer(function(connection) {
  console.log('Received connection');
  state = Number(!Boolean(state));
  LEDS.forEach(function (LED) {
    b.digitalWrite(LED, state);
  });
  connection.end();
});
server.listen(9999, function () {
  console.log('Ready for commands');
});

This works, but it’s fairly crude. What would be better is defined protocol beyond just listening for connections.

Smart Plug Prototype 0.2

Fri, 22 Mar 2019 09:14:00 -0500

This next phase of the prototype is adding the ability to control the light over a network. Importing Node’s standard net package allows us to listen for simple TCP connections, and to activate the light in response.

The way we’re communicating with our application is with Telnet. Telnet is a simple application that can open a TCP socket and provide an interactive text-based interface for sending and receiving data. Here we’re not even using it to send any data, it’s only being used to connect and immediately close, and that connection being established is enough of a command at this point.

Smart Plug Prototype 0.1

Fri, 22 Mar 2019 08:58:00 -0500

After busting out the old Beaglebone Black and writing a few lines of JavaScript, I have a super simple LED toggle sequence on a timer running.

All it does is run a timer that switches the LEDs on and off at a fixed rate. Obviously nowhere near useful, but this is a simple building block. Next up we need to be able to control it.

var b = require('bonescript');
var net = require('net');
var LEDS = [
  'USR0',
  'USR1',
  'USR2',
  'USR3'
];
LEDS.forEach(function (LED) {
  b.pinMode(LED, b.OUTPUT);
});
var on_led_index = 0;
setInterval(function () {
  b.digitalWrite(LEDS[on_led_index], b.LOW);
  on_led_index = (on_led_index + 1) % 4;
  b.digitalWrite(LEDS[on_led_index], b.HIGH);
}, 1000);

Smart Plug Intro

Thu, 21 Mar 2019 04:26:30 +0000

Consummer smart plugs/bulbs available currently are exclusively controlled over WiFi. While easy for the user in some ways, I see several drawbacks in it.

Bandwidth usage - Having many smart plugs in your home means lots of devices using up WiFi bandwidth.
Ease of setup - Smart plugs must be given the SSID/password. This is usually done by an app that connects to a hotspot created by the plug which then configures it.
Usable scenarios - Good WiFi signal is needed at that point for it to be usable.
Cost - The plug must contain WiFi hardware, increasing the cost of materials (and by extension, the cost of the product).

I have a vision for an alternative product that I’m certain I would buy myself were it available. This vision lies at the intersection between powerline Ethernet (i.e. HomePlug AV) and smart devices.

Mon, 01 Jan 0001 00:00:00 +0000

Hello

world

Mon, 01 Jan 0001 00:00:00 +0000

Autumn Leaves Candle

Mon, 01 Jan 0001 00:00:00 +0000

jonah.id/alcandle

This candle was hand-made by me, Jonah. It is made of hybrid paraffin/vegetable wax, mixed with approximately 1 tablespoon of “autumn leaves” fragrance oil per pound of wax. The wick is made of wood, fastened to the bottom of the vessel with a small metal clip. The vessel itself is a threaded glass jar, paired with a metal lid.

The containing jar can be reused. Any excess wax inside after use can be totally removed with dish detergent.

Quire-to-Git Notes

Mon, 01 Jan 0001 00:00:00 +0000

markdown
front-matter
show the comment log, as a rough work log
maybe even pull it git logs?

Could make as an app just for myself, or could make as a public service.

Considerations if made public

Needs hosting; if it needs to commit directly to a Git repo
Can do a shallow clone with fetch
Needs to be authorized with Quire for each user
Needs to have authentication for Git repo (ssh only?)
It must have storage for auth per user
Could use cloud free tier and serverless if git can run

There is a Node library for interacting with Git, but it only supports HTTP remotes.

Sine Tattoo

Mon, 01 Jan 0001 00:00:00 +0000

I have a tattoo that is the first 5 curves in the series that approaches a square wave. I chose this because 1) it looks cool, and 2) computers have been a substantial part of my life and the idea of the clock cycles passing from my body to the machine is neat. The reason it's the sine series is that a real microchip clock composes multiple sine waves from oscillating piezoelectric crystals to produce the square wave clock signal. I chose a count of 5 because it is a good balance between producing a usefully square wave and having so many curves that they obscure each-other.

This File Came from Quire

Mon, 01 Jan 0001 00:00:00 +0000

I drafted this task in Quire and it was published automatically.

https://git.sr.ht/~jonahbron/quire-to-git

Winter Function 2022 Gift

Mon, 01 Jan 0001 00:00:00 +0000

jonah.id/wf22/gift

All guests to the Winter Function 2022 were given a gift bag. The entire gift is either recyclable or compostable in nature. It consists of a black paper sack with a handle, a hand-made hot cocoa mix, and a hand-made candle.

Candle

The candle is made of approximately 150 grams of hybrid paraffin/vegetable wax, mixed with a low amount of “autumn leaves” fragrance oil. The wick is made of wood, fastened to the bottom of the vessel with a small metal clip. The vessel itself is a threaded straight-sided 8oz glass jar, paired with a metal lid.

Winter Function 2023 Gift Bag

Mon, 01 Jan 0001 00:00:00 +0000

jonah.id/wf23/bag

All guests to the Winter Function 2023 were given a gift bag. The entire gift is either recyclable or compostable in nature. It consists of a paper sack with a handle, a hand-made hot cocoa mix, home-made dairy-free coconut macaroons, and a hand-poured candle.

Candle

The candle is made of hybrid paraffin/coconut/vegetable wax, mixed with a low amount of mahogany teakwood fragrance oil (to be frank, I could have used more, it’s more faint than I would like). The wick is made of wood, fastened to the bottom of the vessel with a small metal clip.

Zero Trust Stateless Secret Santa 🎅🥸

Mon, 01 Jan 0001 00:00:00 +0000

About

This is a zero-trust Secret Santa algorithm & implementation.

The goal is to create a single web page that can distribute assignments via out-of-band communications executed by the participants, with no server-side state, and no ability to alter or observe the results besides one's own.

This is done in three cycles:

Accumulating a collection of public keys: each subject receives a hyperlink, which then gives them a hyperlink to send to the next subject. The new hyperlink contains a newly generated public key, the private key of which has been saved into a browser cookie. The public key is first encrypted with a public key provided by subject A. This prevents any agents from inferring key ownership by elimination. By the end of the cycle, all subjects have inserted their public key into the URL. This insertion is done in a securely random order to conceal key ownership from subject A.
Assignment encryption: subject A uses its private key to decrypt all subject public keys. Each subject again receives a hyperlink, which generates a new hyperlink to send to the next subject. The new hyperlink contains the subject's own name, encrypted twice: once with the next shuffled subject's public key, and again with the public key proveded by subject A. This prevents any agents from inferring assignment origin by elimination. By the end of the cycle, every subject has inserted an assignment into the URL. This insertion is done in a securely random order to conceal key ownership from subject A.
Assignment distribution: subject A uses its private key to decrypt all assignments. Each subject receives a hyperlink one final time, which includes all encrypted assignments. Each subject can decrypt only their own, shows the user their assiged name, and the same link to pass to the next subject. After this third cycle, everyone is aware of who they are assigned, and has no possible knowledge of any other assignments.

An extra layer of complexity is introduced by the ability for some agents to infer the ownership of a key. Specifically the second agent and the second-to-last agent can know who the first key's owner is and the last keys owner, respectively. This can be resolved by encrypting the public keys and the assignments with another public key, generated by the first agent. Only when all keys or assignments are added are they all decrypted by the first agent in the ring.