Earlier this week, my yearly Claude Pro subscription auto-renewed. This seems to have triggered a “service improvement”, making me subject to weekly limits. I had heard of these, but had until then only been subject to the 5h session limits.

With this came a new form of anxiety summarized as “OMG I think I might be ahead in my consumption of the weekly limit, compared to the passage of time.”

To fight this new existential dread and live with facts not fear, I overlay the week’s time elapsed against the token usage progress, directly on the Claude usage page.

I use a bookmarklet for this: tgif-claude. It auto-refreshes, but obviously requires to be clicked on when the page is loaded (a userscript manager or full-on browser add-on seemed overkill).

Copy it from here:

javascript:(function%20()%20%7B%20%5B'tgif-claude-marker'%2C%20'tgif-claude-label'%5D.forEach(function%20(id)%20%7B%20var%20el%20%3D%20document.getElementById(id)%3B%20if%20(el)%20el.remove()%3B%20%7D)%3B%20var%20resetEl%20%3D%20Array.from(document.querySelectorAll('p')).find(function%20(p)%20%7B%20return%20%2F%5EResets%20%5Cw%7B3%7D%20%5Cd%7B1%2C2%7D%3A%5Cd%7B2%7D%20%5BAP%5DM%24%2F.test(p.textContent.trim())%3B%20%7D)%3B%20if%20(!resetEl)%20%7B%20alert('tgif-claude%3A%20weekly%20reset%20text%20not%20found')%3B%20return%3B%20%7D%20var%20row%20%3D%20resetEl.parentElement.parentElement%3B%20var%20barContainer%20%3D%20row.querySelector('.bg-bg-000')%3B%20var%20fillEl%20%3D%20barContainer%20%26%26%20barContainer.querySelector('.bg-accent-secondary-200')%3B%20if%20(!fillEl)%20%7B%20alert('tgif-claude%3A%20progress%20bar%20elements%20not%20found')%3B%20return%3B%20%7D%20var%20lastUpdatedEl%20%3D%20Array.from(document.querySelectorAll('p')).find(function%20(p)%20%7B%20return%20p.textContent.trim().startsWith('Last%20updated%3A')%3B%20%7D)%3B%20var%20refreshBtn%20%3D%20document.querySelector('button%5Baria-label%3D%22Refresh%20usage%20limits%22%5D')%3B%20var%20m%20%3D%20resetEl.textContent.trim().match(%2FResets%20(%5Cw%2B)%20(%5Cd%2B)%3A(%5Cd%2B)%20(%5BAP%5DM)%2F)%3B%20var%20DAY_MAP%20%3D%20%7B%20Sun%3A%200%2C%20Mon%3A%201%2C%20Tue%3A%202%2C%20Wed%3A%203%2C%20Thu%3A%204%2C%20Fri%3A%205%2C%20Sat%3A%206%20%7D%3B%20var%20targetDay%20%3D%20DAY_MAP%5Bm%5B1%5D%5D%3B%20var%20hour%20%3D%20parseInt(m%5B2%5D%2C%2010)%3B%20var%20minute%20%3D%20parseInt(m%5B3%5D%2C%2010)%3B%20if%20(m%5B4%5D%20%3D%3D%3D%20'PM'%20%26%26%20hour%20!%3D%3D%2012)%20hour%20%2B%3D%2012%3B%20if%20(m%5B4%5D%20%3D%3D%3D%20'AM'%20%26%26%20hour%20%3D%3D%3D%2012)%20hour%20%3D%200%3B%20var%20WEEK_MS%20%3D%207%20*%2024%20*%2060%20*%2060%20*%201000%3B%20barContainer.style.position%20%3D%20'relative'%3B%20var%20marker%20%3D%20document.createElement('div')%3B%20marker.id%20%3D%20'tgif-claude-marker'%3B%20marker.style.cssText%20%3D%20'position%3Aabsolute%3Btop%3A0%3Bheight%3A100%25%3Bwidth%3A3px%3B'%20%2B%20'background%3A%23f97316%3Bpointer-events%3Anone%3Bborder-radius%3A1px%3B'%3B%20barContainer.appendChild(marker)%3B%20var%20label%20%3D%20document.createElement('div')%3B%20label.id%20%3D%20'tgif-claude-label'%3B%20label.className%20%3D%20resetEl.className%3B%20label.style.marginTop%20%3D%20'4px'%3B%20row.insertAdjacentElement('afterend'%2C%20label)%3B%20function%20update(reason)%20%7B%20var%20usagePct%20%3D%20parseFloat(fillEl.style.width)%20%7C%7C%200%3B%20var%20now%20%3D%20new%20Date()%3B%20var%20reset%20%3D%20new%20Date(now)%3B%20reset.setHours(hour%2C%20minute%2C%200%2C%200)%3B%20var%20daysUntil%20%3D%20(targetDay%20-%20now.getDay()%20%2B%207)%20%25%207%3B%20if%20(daysUntil%20%3D%3D%3D%200%20%26%26%20reset%20%3C%3D%20now)%20daysUntil%20%3D%207%3B%20reset.setDate(reset.getDate()%20%2B%20daysUntil)%3B%20var%20elapsed%20%3D%20WEEK_MS%20-%20(reset%20-%20now)%3B%20var%20timeElapsedPct%20%3D%20Math.max(0%2C%20Math.min(100%2C%20(elapsed%20%2F%20WEEK_MS)%20*%20100))%3B%20var%20msLeft%20%3D%20reset%20-%20now%3B%20var%20daysLeft%20%3D%20Math.floor(msLeft%20%2F%20(24%20*%2060%20*%2060%20*%201000))%3B%20var%20hoursLeft%20%3D%20Math.floor((msLeft%20%25%20(24%20*%2060%20*%2060%20*%201000))%20%2F%20(60%20*%2060%20*%201000))%3B%20var%20minsLeft%20%3D%20Math.floor((msLeft%20%25%20(60%20*%2060%20*%201000))%20%2F%20(60%20*%201000))%3B%20var%20remainingParts%20%3D%20%5B%5D%3B%20if%20(daysLeft%20%3E%200)%20remainingParts.push(daysLeft%20%2B%20'd')%3B%20if%20(hoursLeft%20%3E%200%20%7C%7C%20daysLeft%20%3E%200)%20remainingParts.push(hoursLeft%20%2B%20'h')%3B%20remainingParts.push(minsLeft%20%2B%20'm')%3B%20var%20remainingStr%20%3D%20remainingParts.join('%20')%3B%20var%20delta%20%3D%20usagePct%20-%20timeElapsedPct%3B%20var%20overPace%20%3D%20delta%20%3E%200%3B%20var%20statusColor%20%3D%20overPace%20%3F%20'%23dc2626'%20%3A%20'%2316a34a'%3B%20var%20statusText%20%3D%20overPace%20%3F%20'over%20pace'%20%3A%20'under%20pace'%3B%20console.log('%5Btgif-claude%5D%20usage%3D'%20%2B%20usagePct%20%2B%20'%25%20elapsed%3D'%20%2B%20timeElapsedPct.toFixed(1)%20%2B%20'%25%20delta%3D'%20%2B%20(delta%20%3E%3D%200%20%3F%20'%2B'%20%3A%20'')%20%2B%20delta.toFixed(1)%20%2B%20'%25')%3B%20marker.style.left%20%3D%20timeElapsedPct.toFixed(2)%20%2B%20'%25'%3B%20label.innerHTML%20%3D%20'Time%20elapsed%3A%20%3Cb%3E'%20%2B%20timeElapsedPct.toFixed(1)%20%2B%20'%25%3C%2Fb%3E'%20%2B%20'%20%7C%20Resets%20in%3A%20%3Cb%3E'%20%2B%20remainingStr%20%2B%20'%3C%2Fb%3E'%20%2B%20'%20%7C%20Delta%3A%20%3Cb%20style%3D%22color%3A'%20%2B%20statusColor%20%2B%20'%22%3E'%20%2B%20(delta%20%3E%3D%200%20%3F%20'%2B'%20%3A%20'')%20%2B%20delta.toFixed(1)%20%2B%20'%25%20('%20%2B%20statusText%20%2B%20')%3C%2Fb%3E'%3B%20%7D%20update('init')%3B%20if%20(lastUpdatedEl)%20%7B%20var%20observer%20%3D%20new%20MutationObserver(function%20()%20%7B%20update('lastUpdated%20mutation')%3B%20%7D)%3B%20observer.observe(lastUpdatedEl%2C%20%7B%20childList%3A%20true%2C%20subtree%3A%20true%2C%20characterData%3A%20true%20%7D)%3B%20%7D%20%7D)()%3B

Or check the readable code on github.

The gym I go to requires you to scan a small key tag with a barcode, to check in. I don’t like bulky keychains, so I keep taking it off and tend to forget it when I need it.

To solve this very important and relatable issue, I built gymcode, which allows me to display that barcode on my watch.

Gymcode is a Garmin widget, written in Monkey C. It can be accessed from the “at a glance” menu of the watch by pressing the down button from the watch face, making it quick to pull up at the gym’s entrance.

The app is not distributed through the Connect IQ store. The membership barcode value is hardcoded in GymCodeView.mc and needs to be set before building. The resulting binary must be manually uploaded to the watch as described in the README.

class GymCodeView extends WatchUi.View {
    private const MEMBERSHIP_ID = ""; // FIXME SET YOUR MEMBERSHIP ID HERE

I have the fenix 7 pro, which has a fairly large screen. Barcodes are one-dimensional, so height doesn’t matter too much (except to give me “reading surface”). I was able to use nearly the full watch screen, despite its roundedness, to make it as readable as possible by the scanner.

The fenix 7 pro has a decent backlight, and I have had no issues getting the code scanned properly at my local gym.

YMMV depending on watch model, barcode type (gymcode’s current implementation supports Code 39) and your gym’s barcode scanner.

I have a Dreame L40 Ultra to vacuum and mop around my home.

The Dreame app requires the robot to have internet access to receive commands, send status information, or modify scheduling. Not being a fan of audio-video recording devices roaming freely in my home, I keep it offline. Unfortunately, this means no Home Assistant integration possibilities, and painful schedule changes (log in to firewall, temporarily allow traffic, open the app, update schedule, block again…).

However, this robot (and many others) recognizes a set of voice commands (a feature that works fully offline), so I built jacadi, a Go HTTP server that maps endpoints to audio file playback, to play these voice commands on demand.

Note: I am aware of Valetudo, which solves this problem and more. However, Valetudo requires rooting the robot, losing OTA firmware updates, potentially voiding the warranty, and accepting that not all features are implemented. For now, I wanted a quick zero-modification approach that leaves the robot’s software and hardware untouched.

Overview

Home-assistant performs a POST request to jacadi. Jacadi plays the wake word + the command using aplay on the USB speaker connected to the raspberry pi. The Dreame robot hears the wake word followed by the command, and performs the action.

Setup

Hardware

I connected a USB speaker to a raspberry pi located near the robot’s homebase.

Software

On the raspberry pi, we need to install alsa-utils, and add the user the container will be running as to the audio group.

With the USB speaker plugged into the raspberry pi, aplay -l will help us figure out which card to use (card 1 here):

A simple test will confirm we have this right:

speaker-test -D plughw:1,0 -t wav

If the volume blasts your eardrums, adjust:

amixer -c 1 sset PCM 20%

We can then deploy the jacadi api using ansible (or simply run the docker-compose.yml from the repo):

- hosts: raspberry-pi
  roles:
    - role: ansible-role-jacadi
      jacadi_audiodev: "plughw:1,0" # adjust to match your card

Supporting new devices

The shipped image only contains commands for the Dreame L40 Ultra, but this can easily be expanded for other devices.

Add commands to the image

Create a new set of commands in jacadi’s routes/ folder (check dreame.json for reference), then build your custom image:

docker build --target slim --build-arg ROUTES=mydevice -t jacadi:mydevice .

The new audio files will be generate during build and baked into the image.

Add commands through mounted volume

The docker images tagged full embed piper and can generate text to speech audio files at runtime or startup. Creating and mounting an extra_routes file to your container will generate the missing audio files at start up. See jacadi’s README for details

Home Assistant

Generating the rest_command yaml list

With the API up and running, we can generate the corresponding Home-Assistant rest_command using the generate-homeassistant script in the jacadi repo:

go run cmd/generate-homeassistant/main.go -base-url="http://jacadi.local:8080" -device=dreame

This will generate the ha-config/homeassistant-rest.yml file that contains a mapping of all the routes to home-assistant rest commands. We paste them in the configuration.yml’s rest_command entry:

rest_command:
  jacadi_dreame_battery_level:
    url: http://jacadi.local:8080/play/dreame/battery-level
    method: post

  jacadi_dreame_clean_balcony:
    url: http://jacadi.local:8080/play/dreame/clean-balcony
    method: post
[...]

Wake word script

For the Dreame vacuum, all commands need the wake word (“Okay Dreame”) spoken before, so we can add this small script to our HA config:

script:
  vacuum_command:
    alias: "Vacuum Command with Wake"
    fields:
      command:
        description: "The rest_command to execute after wake up"
        example: "jacadi_dreame_clean_balcony"
    sequence:
      - service: rest_command.jacadi_dreame_ok_dream
      - delay:
          seconds: 2
      - service: "rest_command.{{ command }}"

Dashboard

This dashboard makes all of the vacuum cleaner’s commands easy to invoke.

Caveats

Audio annoyance

Audio playback on the Pi’s USB speaker from Go within Docker was frustrating. Getting the right audio encoding, bitrate, and device mapping working through Go audio libraries added complexity that wasn’t worth it for this hack. Calling aplay with pre-generated wav files was the path of least resistance.

Unilateral communication

The robot listens to us, and acts, but we don’t get any confirmation it has heard our command, or that the command was successfully performed.

Limited controls

We are limited to the set of commands Dreame has set up for voice recognition. They cannot be combined or chained. We cannot ask the robot to “Vacuum only” and “Clean the bathroom”. The “Clean the bathroom” command will clean the bathroom with whatever setting was last used through the app. We cannot ask for multiple rooms to be cleaned (and as we have no feedback when the cleaning is over, we need to add time buffers between manually chained tasks).

Inconsistent names

The room names in the app don’t always map to the voice commands. Here are a few mappings I figured out:

• Saying “clean the hallway” cleans the corridor
• Saying “clean the bedroom” cleans all bedrooms
• Saying “clean the master room” cleans the primary bedroom
• Saying “clean the guest room” cleans the second bedroom

Conclusion

Despite a few caveats, this set up has allowed me, through Home-Assistant, to set up and easily update my home’s cleaning schedule, fire one off cleaning actions whether I am home or not, and build some simple automations (like “clean around the litter box after a cat has been in there”), while keeping the vacuum cleaner fully offline and preserving some feeling of privacy.

A somewhat obvious next step would involve adding voice recognition to jacadi, and registering the robot’s (very verbose) vocal feedback to home-assistant to get information about task success, things the robot wants me to fix or clean, etc. Although that would mean adding a new device listening in…

Although the only non-human voice activated device in my home is the Dreame, I am sure more applications can be found for this type of voice bridging with air-gapped devices.

My two cats recently acquired a Litter-Robot 4, and are now using it mostly full time after a few weeks of transition.

Apart from promising to save precious manual scooping energy, shielding from the smell of the cats expertly timing their bowel movements with dinner time, the Litter-Robot 4 boasts a “SmartScale®”.

The SmartScale® promises, through an advanced algorithm to identify which cat is using the litter when, track their weight through time, and bathroom habits.

As silly as the need for tracking these metrics on a cat sounds, they were actually a pretty big selling point for us:

• Cat 1 has a history of urinary tract issues (which apparently is common for male ginger cats), which tends to manifest itself with him visiting the litter an unusual number of times (as he is unable to actually urinate).
• Cat 2 is picky, and will pee on anything but litter if the box is not clean enough. This is mostly handled by the robot’s autocleaning, but keeping track of his bathroom visits (or lack thereof) should warn us of a possible incident.

After a few days of usage however, I was disappointed to notice that the SmartScale® is not actually that smart. To Litter-Robot’s own admission, “Cats within 1 pound of each other may register incorrectly”.

As a casual home-assistant user, I built litter-ha-DumbScale, which relies on the Litter-Robot integration. SmartScale®’s ‘advanced algorithm’ is apparently too clever for its own good. DumbScale does the obvious thing: compare the current weight to each cat’s last recorded weight, assign the visit to the closest match, and update accordingly.

There will still be limitations with cats that are very close in weight, especially as the scale doesn’t appear to be of great accuracy, but this has worked well for me so far (Cat 1 and Cat 2’s weight differ by slightly less than a pound).

I must also say that as Litter-Robot mentions here, the cat detection does get better with time, and after a few weeks I see less cat confusion.

There are also other issues where the SmartScale® will just skip attribution of box usage like these, which DumbScale fixes as well.

A month in, DumbScale hasn’t misattributed a single visit. If you’re running into the same issues, the repo has everything you need to set it up.

For the past few years, I have been keeping track of most of the books I read.

It gives me some feeling of accomplishment and progress, adding a notch to the reading log, but also helps me keep track of what I’ve read, and where I am in the backlog of prolific authors or book series.

I initially tracked these books on goodreads, but it was acquired by amazon and later deprecated its API, making the platform less desirable. Instead, I have been tracking them in a simple markdown file I run through some templating/pandoc and push to my personal site.

Being French and living in the US, I tend to mostly read books by French or American and British authors, but wanted a clearer picture. So I built around-the-word to put the authors of the books I read on a map.

The map is an interactive HTML country-level map — hover over countries to see counts.

The python script that generates it takes a goodreads export or a simple markdown list and looks up each author on Wikidata (with a lazy Wikipedia parser fallback) and maps their birthplace. Results get cached to JSON, so you can manually fix the inevitable historical and geopolitical edge cases: borders change, colonization and decolonization happened. George Orwell was born in India, but is considered British.

The map is rendered using D3 and topojson’s world atlas. The resulting HTML file embeds all the javascript it needs.

uvx around-the-word -i goodreads_export.csv -f goodreads -c cache.json -o map.html

The result confirms what I suspected: my reading is overwhelmingly Western. The US dominates (partly due to technical books), followed by France, the UK, and Canada. Beyond that, the map is sparse — a few books from South America, the rest of Europe and a handful of other countries leaving entire continents close to empty.

If you have suggestions from regions I haven’t explored, send them my way!

Téléfonefix is a kid-friendly telephone system allowing kids to safely call relatives, locally and abroad.

The main features I sought when building téléfonefix were:

• Do not expose the user to a screen (no apps or fancy phones).
• Use a physical phone.
• Perform calls locally and internationally.
• Permit/decline calls based on a ruleset. Specifically:
  • only permit calls to be made to an adult-controlled set of numbers.
  • timezones and “awake/asleep” schedules, to avoid calling Europe at their 1am
  • prevent inbound calls entirely.
• As user-friendly as possible.

Shopping list

• A corded phone: any phone with an RJ11 connector will work. A rotary dial phone would add cool factor for kids old enough to dial them. I used this “Telephone for Seniors”. The pictured speed dial numbers are perfect for very young kids to choose who they want to call.
• An analog telephone adapter: I use the Grandstrean HT801. It is well-documented and reliable.
• A Raspberry Pi (or any compute really) to run the software PBX asterisk on. For this setup, I used a Pi 4 B. It embeds WiFi and an ethernet port making it easy to connect both to your network and directly wire the HT801 to the Pi.
• A twilio account with a number purchased (~ $1.15/month).

Architecture

Hardware setup

Phone to HT801

We simply plug an RJ11 cable in between the Phone and the HT801.

HT801 to Raspberry Pi

I opted to connect these two directly with an RJ45 as we will see below.

Phone

On the phone itself, to make updating phone numbers easier, I assigned each of the 9 speed dial picture buttons with a number from 100 to 107 and assigned 200 to the last one (which I keep for debugging). Those extensions will be translated later on to actual numbers by a small golang program I built for the occasion, allo-wed.

Twilio setup

First, you will need to create an Elastic SIP Trunk in twilio.

Once created, in the Termination tab, set up the Authentication. Create a new set of credentials (your telefonefix_twilio_user and telefonefix_twilio_password in asterisk’s configuration’). IP Access control lists are also available.

In the Numbers tab, buy a new number and assign it to the trunk. That number will be your telefonefix_twilio_phone_number value (formatted as '+15555555555'). Note that numbers have a monthly cost independent of usage (~ $1.15/month).

Incoming calls are not something I am looking for, so I did not change Origination.

Téléfonefix stack configuration

I built ansible-role-telefonefix to handle the configuration. Let’s look at a telefonefix.yml playbook example and detail each task:

- hosts: telefonefix
  become: true
  gather_facts: false
  vars:
    telefonefix_asterisk_playback_patterns:
      connecting:
        fr: "Un instant, je vous connecte à \"${contact_name}\""
        pt: "Só um momento. Ligando para \"${contact_name}.\""
      not-allowed:
        fr: "\"${contact_name}\" fait dodo, rappelle plus tard!"
        pt: "\"${contact_name}.\" está dormindo, ligue mais tarde!"
      currently-busy:
        fr: "\"${contact_name}\" est occupé, rappelle plus tard!"
        pt: "\"${contact_name}.\" está occupado, ligue mais tarde!"
      unavailable:
        fr: "\"${contact_name}\" est occupé, rappelle plus tard!"
        pt: "\"${contact_name}.\" está occupado, ligue mais tarde!"

    telefonefix_voice_map:
      en: "en_US-amy-low"
      fr: "fr_FR-siwis-low"
      pt: "pt_BR-cadu-medium"

    telefonefix_network_subnet: "192.168.100.0/24"
    telefonefix_gateway_ip: "192.168.100.1"
    ht801_mac: # TODO
    ht801_static_ip: "192.168.100.20"
    telefonefix_dns_servers:
      - "8.8.8.8"
      - "8.8.4.4"
    telefonefix_ethernet_interface: "eth0"

    telefonefix_asterisk_extra_sounds_folder: /tmp/telefonefix/extra_sounds
    telefonefix_super_user_override_prefix: '23'

    telefonefix_public_ip: # TODO
    telefonefix_asterisk_phone_user: '6001'
    telefonefix_asterisk_phone_password: # TODO
    telefonefix_twilio_domaine: # TODO
    telefonefix_twilio_phone_number: # TODO
    telefonefix_twilio_user: # TODO
    telefonefix_twilio_password: # TODO
    ht801_password: # TODO

  tasks:
    - name: Generating asterisk voices
      include_role:
        name: ansible-role-telefonefix
        tasks_from: asterisk_playbacks_generate.yml
    - name: DHCP config
      include_role:
        name: ansible-role-telefonefix
        tasks_from: dhcp.yml
    - name: Asterisk setup
      include_role:
        name: ansible-role-telefonefix
        tasks_from: asterisk.yml
    - name: HT801 setup
      include_role:
        name: ansible-role-telefonefix
        tasks_from: ht801.yml

The variables are mostly self-explanatory and can be updated to fit different needs and setups.

We will review the Generating asterisk voices task at the end, and start with the main tasks first.

Task DHCP config

Configures a dhcp server on the raspberry pi, and has it assign a fixed ip to the HT801 in their own shared very local LAN to keep things isolated and simple.

We can also easily run asterisk on a VPS, and have the HT801 point directly to it.

Task Asterisk setup

This is the main task. It:

• installs docker.
• pushes the main configuration files.
• pushes optional sound files for asterisk.
• launches the asterisk docker container (asterisk + allo-wed).

Let’s review the main configuration files.

File extensions.conf

extensions.conf defines what happens when a number is dialed.

On the physical phone, I have defined each speed dial pictured number to dial a number from 100 to 107. The last picture is defined as 200, and currently used for debugging.

Calls coming in using one of those numbers are handled here:

; Pattern _1XX matches any three-digit number starting with 1
exten => _1XX,1,NoOp(Calling extension ${EXTEN})
exten => _1XX,n,Set(TRANSLATED_NUMBER=${SHELL(allo-wed -config /opt/asterisk/allo-wed.yml -is-allowed -phone ${EXTEN})})
exten => _1XX,n,NoOp(Translated to: ${TRANSLATED_NUMBER})
exten => _1XX,n,GotoIf($["${TRANSLATED_NUMBER}" = ""]?not_allowed)

We call the allo-wed script with the dialed extension as a parameter. If calls are allowed to this number, it returns the 1XX number to real world number translation, based on its configuration file.

If the call is denied, we let the user know:

; Call not allowed or no mapping found
exten => _1XX,n(not_allowed),Playback(extra/${EXTEN}/not-allowed)
exten => _1XX,n,Hangup()

Otherwise, we announce success and perform the call:

; Call is allowed and number was translated
exten => _1XX,n,Playback(extra/${EXTEN}/connecting)
exten => _1XX,n,Dial(PJSIP/${TRANSLATED_NUMBER}@twilio,30,L({{ telefonefix_call_duration_limit_minutes * 60 * 1000 }}))
exten => _1XX,n,GotoIf($["${DIALSTATUS}" = "BUSY"]?busy)
exten => _1XX,n,GotoIf($["${DIALSTATUS}" = "NOANSWER"]?noanswer)
exten => _1XX,n,GotoIf($["${DIALSTATUS}" = "UNAVAILABLE"]?unavailable)
exten => _1XX,n,Hangup()

A parental override can be enabled by setting a telefonefix_super_user_override_prefix value.

For example, with telefonefix_super_user_override_prefix = 23, you will be able to bypass call restrictions on the 101 extensions by dialing 23101.

File pjsip.conf

This is where we configure the actual communication stack.

First we setup our local extension [6001], our physical phone, and set up authentication for it so the HT801 can connect to asterisk.

Then we set up the Twilio trunk for outbound calls, linking and authenticating to our domain.

File rtp.conf

The RTP configuration is lightly edited to reduce the port range. We have a single user, and not having to add port forwarding for the full range can make home router/firewall configuration easier.

File allo-wed.yml

You need an asterisk/allo-wed.yml file alongside your calling playbook (eg in files/asterisk/allo-wed.yml). A configuration example is available in the allo-wed repo.

This file will define who each speed dial extension will call, their language and name (for fancy spoken messages), their timezone and awake hours, and the number to dial.

Number format tends to be the tricky part here. I have had success putting the full number with country code and leading +. For example, to dial a French cell: '+336XXXXXXXX'.

Task HT801 setup

We send a POST request to the HT801’s administration API, essentially setting up communication and authentication with the asterisk server.

Bonus: Generating asterisk voices

Using my previous Text To Speech Setup and asterisk’s Playback feature, I generate custom messages that asterisk will play for different occasion. For example, when dialing a specific contact, asterisk will announce in the callee’s language “Dialing XXX, please hold”.

The messages are generated based on these variables:

    telefonefix_asterisk_playback_patterns:
      connecting:
        fr: "Un instant, je vous connecte à \"${contact_name}\""
        pt: "Só um momento. Ligando para \"${contact_name}.\""
      not-allowed:
        fr: "\"${contact_name}\" fait dodo, rappelle plus tard!"
        pt: "\"${contact_name}.\" está dormindo, ligue mais tarde!"
      currently-busy:
        fr: "\"${contact_name}\" est occupé, rappelle plus tard!"
        pt: "\"${contact_name}.\" está occupado, ligue mais tarde!"
      unavailable:
        fr: "\"${contact_name}\" est occupé, rappelle plus tard!"
        pt: "\"${contact_name}.\" está occupado, ligue mais tarde!"

Using these voices, which I found to be the best for each language I was interested in:

    telefonefix_voice_map:
      en: "en_US-amy-low"
      fr: "fr_FR-siwis-low"
      pt: "pt_BR-cadu-medium"

The Generating asterisk voices task will start gopipertts on the local machine, generate all the messages we need, and convert them to be playable by asterisk.

Firewall configuration

Twilio needs to be able to reach asterisk on the following ports, you will need to configure your firewall and port forwarding accordingly:

• 5060/udp: SIP port.
• 10000-10100/udp: the RTP port range.

Conclusion and future improvements

The phone has been a huge success, and the concept easily graspable by young kids!

A few potential improvements:

• preventing hangups… Kids get excited, pick up the phone, hang it up, pick it up again. Being able to prevent premature call end would be useful (twilio starts charging immediately too, so you’ll be billed the full minute for that 3s call-hang-up).
• limiting calls per day/hours? It could be useful to have allo-wed prevent the user from calling the same contact 15 times within a minute.
• better error handling. There are cases where calls fail with little to no feedback. I’m not sure where the issues come from, but gathering more information from twilio/asterisk and speaking it to the user would be helpful.
• forcing speaker mode… But that would require tweaking with the phone itself.

If you implement this and have feedback, please reach out!

Links

Core Components

• Asterisk - The open source PBX system
• Twilio - SIP trunking and phone number provider
• Grandstream HT801 - Analog telephone adapter

Software & Configuration

• allo-wed - Extension translation and call scheduling
• ansible-role-telefonefix - Ansible automation for the entire setup
• docker-asterisk - Ubuntu-based Asterisk container
• gopipertts - Text-to-speech voice generation

References & Inspiration

• Connecting a Grandstream HT80x to Twilio SIP - Helpful setup guide
• Twilio + Grandstream Setup - Another useful walkthrough
• Astérix et Obélix - Naming convention inspiration

Using the same jira-buddy from earlier and combining it with claude code, we can stop writing commits entirely and let the LLMs do it.

This gist suggests two bash functions to add to your bashrc to never write commits again!

This first function, ai-commit, passes:

• the staged changes (whatever you git add‘ed)
• the current directory’s name (you’ll want to run this at the root of the repo, so this would likely be your project name, which adds some context to your change)
• anything you pass to the command as extra context

to claude code and asks it for a concise commit message.

For example:

host:~/dev/superapp> ai-commit ai powered security

ai-commit() {
  local profile="${DEFAULT_CLAUDE_COMMIT_PROFILE:-claude}"
  local context="$@"
  echo "Generating commit message with Claude using profile '$profile'... with extra context: '$context'"
  local project_dir_name="${PWD##*/}"
  local commit_message
  local prompt="Analyze the staged git changes for the '$project_dir_name' project and generate a concise commit message following conventional commit format (type: description). Keep the message under 72 characters for the first line. Only output the commit message, nothing else - the output goes directly to git commit -m."
  
  if [[ -n "$context" ]]; then
    prompt="$prompt

Additional context: $context"
  fi
  commit_message=$(docker run --rm \
    --volume "$PWD:/home/node/dev/$project_dir_name" \
    -w "/home/node/dev/$project_dir_name" \
    --volume "$HOME/.${profile}:/home/node/.claude" \
    --volume "$HOME/.${profile}.json:/home/node/.claude.json" \
    nbr23/claudecode -p "${prompt}" | awk '{$1=$1;print}')
  if [[ -z "$commit_message" ]]; then
    echo "Error: Failed to generate a commit message from Claude. Aborting."
    return 1
  fi

  echo "Committing..."
  git commit -m "$commit_message" && git commit --amend
}

ai-jira-commit works similarly to ai-commit but also calls jira-buddy to fetch the list of open tickets assigned to ourselves on Jira. It passes this list as extra context to claude code, and asks it to delivery a commit message prepended with the most appropriate ticket ID.

ai-jira-commit() {
  local profile="${DEFAULT_CLAUDE_COMMIT_PROFILE:-claude}"
  local context="$@"
  echo "Generating Jira-aware commit message with Claude using profile '$profile'... with extra context: '$context'"
  local project_dir_name="${PWD##*/}"
  local commit_message
  local jira_tickets
  
  jira_tickets=$(uvx jira-buddy --own --json --fields key,summary,status,issuetype)
  if [[ -z "$jira_tickets" ]]; then
    echo "Error: Failed to fetch Jira tickets."
    return
  fi
  
  local prompt="CRITICAL INSTRUCTIONS: You MUST respond with ONLY a single line containing the commit message. NO explanations, NO reasoning, NO additional text, NO line breaks.

Analyze the staged git changes for the '$project_dir_name' project. Based on the changes and the following Jira tickets JSON, pick the most appropriate ticket and generate a commit message in the format 'TICKET-KEY - commit message'. Keep under 72 characters total.

IMPORTANT: Only pick a ticket if you have confidence it matches the changes or that the changes could be a subtask of. If no ticket clearly matches, respond with exactly 'None' instead."
  
  if [[ -n "$context" ]]; then
    prompt="$prompt

Additional context: $context"
  fi
  
  prompt="$prompt

Jira tickets:
$jira_tickets

RESPOND WITH ONLY THE COMMIT MESSAGE LINE. NOTHING ELSE."
  
  local claude_response
  claude_response=$(docker run --rm \
    --volume "$PWD:/home/node/dev/$project_dir_name" \
    -w "/home/node/dev/$project_dir_name" \
    --volume "$HOME/.${profile}:/home/node/.claude" \
    --volume "$HOME/.${profile}.json:/home/node/.claude.json" \
    nbr23/claudecode -p "$prompt" | awk '{$1=$1;print}')
  
  if [[ -z "$claude_response" ]]; then
    echo "Error: Failed to generate a commit message from Claude. Aborting."
    return 1
  fi
  
  if [[ "$claude_response" == "None" ]]; then
    echo "No appropriate Jira ticket found."
    return
  fi
  
  commit_message=$(echo "$claude_response" | grep -oE '^[A-Z]+-[0-9]+ - .*$' | head -n 1)
  
  if [[ -z "$commit_message" ]]; then
    echo "Error: Claude response doesn't match expected commit message format."
    echo "Claude response: $claude_response"
    return
  fi

  local line_count
  line_count=$(echo "$commit_message" | wc -l)
  
  if [[ $line_count -gt 1 ]]; then
    echo "Error: Commit message must be only one line long."
    echo "Generated message:"
    echo "$commit_message"
    return 1
  fi

  local ticket_key
  ticket_key=$(echo "$commit_message" | grep -oE '^[A-Z]+-[0-9]+' | head -n 1)
  
  if [[ -z "$ticket_key" ]]; then
    echo "Error: Commit message must start with a ticket number (e.g., ABC-123)."
    echo "Generated message: $commit_message"
    return 1
  fi

  echo "Selected Jira ticket: $ticket_key"
  echo "$jira_tickets" | jq -r ".[] | select(.key == \"$ticket_key\") | \"Key: \(.key)\nSummary: \(.summary)\nStatus: \(.status)\nIssue Type: \(.issuetype)\""
  echo

  echo "Committing..."
  git commit -m "$commit_message"
}

Both run claude inside docker, but can be easily modified to run natively.

YMMV, and sometimes you need to run it a couple of times before it accepts to deliver a commit message and not a monologue on git (despite the ALL CAPS instructions!!!), or figures out which LLM-generated ticket your PM created matches the LLM-generated code you staged.

Navigating Jira’s UI to find your Task/Epic/Bug is a pain. Even copying the ticket ID is its own quest. You end up switching tabs, losing focus, and forgetting what you were doing.

To skip all that, I use a jira-buddy and a Vim function to hit the Jira API, look up the ticket, and insert the ID directly into my document. I use it to insert the ticket ID for the current work in my commit messages.

I tried without success to figure out which scopes my scoped API token needed. So I just use a personal API token instead.

Now that we know how to listen to other people’s content, let’s make sure other people can listen to our content!

This blog is generated using hugo and uses a theme based on catafalque.

Leveraging my piper api wrapper, I created a hugo-shortcodes-tts. The shortcode sends the hugo post’s content to the TTS API, saves it as a static file, and embeds a player into the post’s page as can be seen at the top of this article.

Setup and configuration documentation is available in the shortcode’s README for the hugo setup and in gopipertts’s README for the TTS API.

For a while, I had been using a simple keyboard shortcut for xclip -o | espeak-ng as my TextToSpeech setup. I mostly use it in-browser, highlighting text and using the shortcut to speak the highlighted text.

I have been meaning to update it, get more modern voices and make it easier to setup on heterogenous environments (fancy way to say I struggle to have reliable hotkey actions on my work macbook).

After setting up a voice assistant on homeassistant using piper, and being impressed with the quality of the voices, I decided to give piper a go.

New Setup

I am now using this simple Firefox Addon I built to grab the highlighted text, and send it to this API wrapper I built around the piper binary.

Firefox Addon

The addon simply adds a keyboard shortcut and context menu. When executed, the addon’s background script sends the highlighted text to the TTS API through a POST request (along with the saved voice and speech speed preferences) to the /api/stream endpoint. The API instantly returns a unique URL for the stream. The Addon then injects through the content script an audio player pointing to the returned URL into the current page. It then starts the playback.

I initially tried relying only on the background script to play the speech, but audio playback would get cut after a few seconds (it seems background scripts are not meant to run for this long). Combining the background script with a content script turned out to be a better option with the UI allowing the user some control on the playback.

Piper API Wrapper

The /api/stream endpoint accepts POST requests with playback options (voice, speed, …) and text. It assigns a UUID to the request, saves it in memory, and returns a URL referencing this stream UUID.

When a stream UUID url is accessed, the options are fetched from the cache and passed to the piper binary to start generating the raw audio.

Streaming compatible WAV headers are sent back to the client. Raw audio chunks are sent back to the client as soon as piper starts generating them.

The /api/stream endpoint returning a unique stream URL trick allows us to easily play the audio in the browser using an <audio> tag (which performs a GET request).

I initially opted for an HTTP to wyoming bridge. This worked fine, but wyoming was an unnecessary overhead, and waited for the full text to be processed to start returning audio, resulting in long delays (especially running this on a raspi) before the TTS started its speaking. Calling directly the piper binary from my wrapper allowed me to pass the --output-raw flag, and start getting audio data much earlier, streaming it back to the client without waiting for the entire potentially large text to be processed.

Final thoughts

Even with streaming, there’s still slightly more delay on speech start with piper compared to the local xclip to espeak. YMMV if you use a beefier box than me.

Overall I like the in-browser integration and the html interface on gopipertts if I need to quickly TTS from a non browser source.

The piper voices are a real improvement over what espeak provides… In English.

French is a different story… or perhaps this is what we sound like when saying “tartine”?

After stumbling upon this post I decided to give XSLT a go.

A few examples

1. Making my blog’s RSS feed look like my front page: This site’s RSS feed visually mimics its front page.

2. Prettifying the output of my feed generator.

3. Beautiful Podcast Feed with embedded episode player for my youtube to podcast project.

Some notes after playing with XSLT in a few projects:

1. Styling your site’s feed to match your site’s appearance is trivial, but probably confusing when a user expects to have clicked on an RSS feed (thus the orange banner on this site’s feed).
2. Poor support across browsers:

• Safari appears to ignore Content-type, doesn’t want to display the XML at all:

• Embedding the xsl file into the xml page is possible, and works on Firefox but not Chrome.

On Firefox this can be achieve easily:

<?xml-stylesheet type="text/xsl" href="#rss-stylesheet"?>
<rss>
  ...
  <xsl:stylesheet id="rss-stylesheet">
    ...
  </xsl:stylesheet>
</rss>

But on Chrome it will only show a white page. Some background on why here.

• Firefox does not support disable-output-escaping:

This flag should prevent escaping of <> characters, allowing HTML from the feed’s content to be rendered. Firefox does not seem to be supporting it, contrary to Chrome.

Note that if disable-output-escaping is off, <script> tags won’t get escaped either and Chrome will execute their content!

Links and References

• [0] - Style your RSS feed
• [1] - Wikipedia - XSLT
• [2] - RSS Banquet - A Modular Atom/RSS Feed Generator
• [3] - Ydl-Podcast - A simple tool to generate Podcast like RSS feeds from youtube (or other youtube-dl supported services) channels, using youtube-dl
• [4] - This blog’s RSS Feed
• [5] - This blog’s RSS Feed’s XSLT template/stylesheet (which you will note is an XML file and could be, itself, styled…)

Some of my CI/CD deployments need to be triggered when a new docker image is pushed with a specific tag for a specific architecture, to stay up to date.

A lot of these image updates can be dealt with dependabot/renovate, creating a PR with the new release, or with tools like watchtower.

In more “complex” cases however, I need my Jenkins instance to be aware of the new image being pushed to perform actions before and after pulling the image and recreating the container.

I built DockerRSS (now rss-banquet) for this, polling the Dockerhub API and formatting the image pushes data into an RSS feed. Its best use for me is in generating a feed for a specific tag (typically latest) and filtering for a specific platform (linux/arm64 in my case), to only get the image pushes I am interested in.

Using the UrlTrigger Jenkins plugin, my pipelines get triggered by new pushes to DockerHub:

pipeline {
    agent any

[...]

    triggers {
        URLTrigger(
            triggerLabel: 'my-agent',
            labelRestriction: true,
            cronTabSpec: 'H/15 * * * *',
            entries: [
                URLTriggerEntry(
                    url: 'https://banquet/dockerhub/nbr23/rss-banquet:server-latest?platform=linux/arm64',
                    requestHeaders: [
                        RequestHeader( headerName: "Accept" , headerValue: "application/atom+xml" )
                    ],
                    contentTypes: [
                        XMLContent(
                            [
                                XMLContentEntry( xPath: 'feed/entry[1]/id' )
                            ])
                    ]
                )
            ]
        )
    }

[...]
}

I also enjoy having the feed of DockerHub image pushes in the ‘Releases’ section of my RSS Reader, at least for now. This allows me to keep track of interesting images or images that I maintain.

2024-02-01 Update:

I have consolidated dockerRSS and other RSS/Atom feed tools into rss-banquet, and archived dockerRSS.

Problem

I live with two cats:

• cat 1, who has food anxiety and can meow for hours if his eating schedule is disrupted;
• cat 2, who eats faster than his own shadow.

To fix cat 1’s food anxiety, we purchased two food dispensers online (each has a different branding but they are exactly the same product). These “robots” are simple, non-connected devices. Current time, meal sizes and schedules are manually configured through a rudimentary interface.

As a result of this manual setup, it is near impossible to have them perfectly synced, and even if achieved, they get out of sync quickly.

This leads us to the second problem:

• If both robots dispense the scheduled meal even just a second apart, cat 2 will gulp the first dispensed meal and rush to the second robot to eat the other meal, leaving cat 1 dumbfounded and hungry (bringing us back to square 0).

Solution

To perfectly synchronize the two robots, I gutted them and replaced the internals with a Raspberry Pi Zero W each.

Both robots are now ntp synchronized, and they pilot the motor for the dispensing mechanism through GPIO.

Scheduling is done through a crontab on each Raspberry Pi, which I push using ansible.

This solution also permits remote one-shot meals for emergency through ssh/ansible.

3 GPIO pins are used:

• One input: the position trigger sensor for the dispenser wheel;
• Two outputs:
  • one for the transistor triggering the motor which rotates the dispenser wheel;
  • one for a buzzer to “announce” meals to the cats.

Side effect

The python GPIO initialization appears to be driving a slight current during initialization, which is inaudible to me, but allows the cats to anticipate the actual buzzing: they now rush to their respective feeder before the buzzer even announces the upcoming meal.

Happy Ending

With both robots perfectly synced, cat 1 and cat 2 now enjoy their meals worry-free.

Links

• GPIO controller Bistrobot’s github repository
• Handy RbPi GPIO pins guide