Author: scruss

  • INA219 Current Sensor and MicroPython

    More Micropython programmers — and especially beginners — should know about Awesome MicroPython. It’s a community-curated list of remarkably decent MicroPython libraries, frameworks, software and resources. If you need to interface to a sensor, look there first.

    For example, take the INA219 High Side DC Current Sensor. It’s an I²C sensor able to measure up to 26 V, ±3.2 A. It does this by measuring the voltage across a 0.1 ohm precision shunt resistor with its built-in 12-bit ADC. I got a customer return from the store that was cosmetically damaged but still usable, so I thought I’d try it with the simplest module I could find in Awesome MicroPython and see how well it worked.

    I guess I needed a test circuit too. Using all of what was immediately handy — a resistor I found on the bench and measured at 150.2 ohm — I came up with this barely useful circuit:

    simple circle with 3.3 V DC supply ad two resistors of 150.2 ohms and 0.1 ohms in series
    Should indicate a current of 3.3 / (150.2 + 0.1) = 21.96 mA

    The INA219 would be happier with a much higher current to measure, but I didn’t have anything handy that could do that.

    Looking in Awesome MicroPython’s Current section, I found robert-hh/INA219: INA219 Micropython driver. It doesn’t have much (okay, any) documentation, but it’s a very small module and the code is easy enough to follow. I put the ina219.py module file into the /lib folder of a WeAct Studio RP2040 board, and wrote the following code:

    # INA219 demo - uses https://github.com/robert-hh/INA219
    
    from machine import Pin, I2C
    import ina219
    
    i = I2C(0, scl=Pin(5), sda=Pin(4))
    print("I2C Bus Scan: ", i.scan(), "\n")
    
    sensor = ina219.INA219(i)
    sensor.set_calibration_16V_400mA()
    
    # my test circuit is 3V3 supply through 150.2 ohm resistor
    r_1 = 150.2
    r_s = 0.1  # shunt resistor on INA219 board
    
    # current is returned in milliamps
    print("Current       / mA: %8.3f" % (sensor.current))
    # shunt_voltage is returned in volts
    print("Shunt voltage / mV: %8.3f" % (sensor.shunt_voltage * 1000))
    # estimate supply voltage from known resistance * sensed current
    print("3V3 (sensed)  / mV: %8.3f" % ((r_1 + r_s) * sensor.current))
    
    

    with everything wired up like this (Blue = SDA, Yellow = SCL):

    breadboard with RP2040 pico board and INA219 sensor board benath it, and the 150 ohm wired as a circuit on the side
    all of the wires

    Running it produced this:

    I2C Bus Scan:  [64] 
    
    Current       / mA:   22.100
    Shunt voltage / mV:    2.210
    3V3 (sensed)  / mV: 3321.630
    

    So it’s showing just over 22 mA: pretty close to what I calculated!

  • Kennedy Station roads are open to bikes again!

    OpenStreetMap image of a route from north to south through Kennedy Station on roads that have been dug up for the last few years
    rather dodgy GPS trail of me riding a bike from Gatineau Trail through Kennedy Station

    It feels like forever, but it was probably 2018 that the roads through Kennedy Station were closed to dig the huge hole for the Eglinton Crosstown. So for all that time, I’ve been braving the deadly intersection at Kennedy and Eglinton to get back home from my daily bike ride.

    But as of late last week, the roads reopened and I’ve been enjoying the wheee! instead of constant fear of dying. There’s still some work needed, so it’s not all sunbeams and cucumbers:

    • there’s still a misplaced Buses Only sign eastbound on North Service Road. Since this is countermanded by bike and taxi signs on South Service Road continuing the same way, it’s clearly a mistake
    • Transway Crescent is in a horrible state, with nearly six years of heavy construction traffic turning the surface into a knobbly mess. This can, and must, be fixed
    • Perhaps most worrying is permanent signs that suggest the sidewalks will be designated shared-use. They’re far too narrow for that, and have none of the necessary safe entry/exit points. As I’m a road user, the road I will use
    • You still (as before) have to mix it with buses. Bus drivers are professionals, though, and part of the solution.
  • It works! It works!

    on a messy desk, a small USB midi keyboard is connected to a Korg NTS-1 mini synthesizer via a small micro-controller board that acts as a USB host for the Akai keyboard, converting USB MIDI to traditional MIDI for the Korg
    Akai LPK25 keyboard has USB MIDI out, but the Korg NTS-1 only has regular MIDI in. The little board in the middle acts as a USB host for the Akai and MIDI source for the Korg

    This is great: gdsports/midiuartusbh: MIDI DIN to MIDI USB Host Converter allows your USB MIDI instruments to act as traditional MIDI controllers. It uses a Adafruit Trinket M0 to act as the USB host and MIDI output.

    I modified gdsports’ design very slightly:

    1. Instead of using a 74AHCT125 Logic level converter and driver, I used a FET-based SparkFun Logic Level Converter
    2. Instead of a 5-pin DIN socket, I used a 3.5 mm stereo socket.

    And it works!

    breadboard showing Trinket M0 microcontroller board, logic level shifter, audio socket breakout and two resistors
    Breadboard layout for MIDI-standard 3.5 mm output (Korg). The resistors are both 220 ohm, and the boards need 5 V power
  • Mystery lockdown phone message

    “Just a test call. Time to stay home. Stay safe and stay home.”

    This message from an unknown caller has sat on our landline answering machine since 2020 or 2021. No idea who or what sent it. All I know is it came in just before noon on a Tuesday morning. The entirely synthesized voice makes me think it’s a junk call, but there’s no scam attached. Just this message, slightly eerie, quite inexplicable.

  • The Quite Rubbish Clock, mk.2

    this is bad and I should feel bad

    In early 2013, I must’ve been left unsupervised for too long since I made The Quite Rubbish Clock:

    It still isn’t human readable …

    Written in (Owen Wilson voice) kind of an obsolete vernacular and running on hardware that’s now best described as “quaint”, it was still absurdly popular at the time. Raspberry Pis were still pretty new, and people were looking for different things to do with them.

    I happened across the JASchilz/uQR: QR Code Generator for MicroPython the other day, and remembered I had some tiny OLED screens that were about the same resolution as the old Nokia I’d used in 2013. I wondered: could I …?

    small microcontroller board with USB C cable attached and an OLED screen on top. The OLED is displaying a QR code which reads '172731'
    OLED Shield on a LOLIN S2 Mini: very smol indeed

    The board is a LOLIN S2 Mini with a OLED 0.66 Inch Shield on top, all running MicroPython. One limitation I found in the MicroPython QR library was that it was very picky about input formats, so it only displays the time as HHMMSS with no separators.

    Source, of course:

    # -*- coding: utf-8 -*-
    # yes, the Quite Rubbish Clock rides again ...
    # scruss, 2022-06-30
    # MicroPython on Lolin S2 Mini with 64 x 48 OLED display
    # uses uQR from https://github.com/JASchilz/uQR
    # - which has problems detecting times with colons
    
    from machine import Pin, I2C, RTC
    import s2mini  # on Lolin ESP32-S2 Mini
    import ssd1306
    from uQR import QRCode
    
    WIDTH = 64  # screen size
    HEIGHT = 48
    SIZE = 8  # text size
    r = RTC()
    
    # set up and clear screen
    i2c = I2C(0, scl=Pin(s2mini.I2C_SCL), sda=Pin(s2mini.I2C_SDA))
    oled = ssd1306.SSD1306_I2C(WIDTH, HEIGHT, i2c)
    oled.fill(0)
    
    
    def snazz():
        marquee = [
            "   **",
            "   **",
            "   **",
            "   **",
            "   **",
            "********",
            " ******",
            "  ****",
            "   **",
            " quite",
            "rubbish",
            " clock",
            "  mk.2",
            "<scruss>",
            " >2022<"
        ]
        for s in marquee:
            oled.scroll(0, -SIZE)  # scroll up one text line
            oled.fill_rect(0, HEIGHT-SIZE, WIDTH,
                           SIZE, 0)  # blank last line
            oled.text("%-8s" % s, 0, HEIGHT-SIZE)  # write text
            oled.show()
            time.sleep(0.25)
        time.sleep(5)
        oled.fill(1)
        oled.show()
    
    
    snazz()  # tedious crowd-pleasing intro
    
    qr = QRCode()
    while True:
        qr.add_data("%02d%02d%02d" % r.datetime()[4:7])
        qr.border = 1  # default border too big to fit small screen
        m = qr.get_matrix()
        oled.fill(1)
        for y in range(len(m)):
            for x in range(len(m[0])):
                # plot a double-sized QR code, centred, inverted
                oled.fill_rect(9 + 2*x, 1 + 2*y, 2, 2, not m[y][x])
        oled.show()
        time.sleep(0.05)
        qr.clear()
    
    

    If your output is glitchy, you might need to put the following in boot.py:

    import machine
    machine.freq(240000000)
    

    This increases the ESP32-S2’s frequency from 160 to 240 MHz.

    Update: there’s a fork of uQR that provides better character support, particularly those required for sending Wi-Fi Network config.

  • Hydraulic Tiles

    (decorative pattern)
    recreated from the Threlkeld Granite Co Ltd’s Album: Ornamental Granitic Tiles (1898), sheet 8

    The Internet Archive has Threlkeld Granite Co Ltd’s Album of ornamental granitic tiles online, and I’m really digging the patterns of the hydraulic tiles they made. I’ve recreated some of their patterns in InkScape, and made this small demo by tiling bitmapped renderings.

  • Canada’s longest running radio program is wrong!

    Rob Cruickshank noted the other day:

    https://twitter.com/robcruickshank/status/1504142948039987200

    Naturally, I had to verify this. So I tuned to the WWV 10 MHz time signal on my amateur rig, tuned a portable radio to CBC Radio 1 FM, which broadcasts on 99.1 MHz in Toronto and recorded them together:

    Noisy recording of two radios. The WWV 13:00:00 EDT tone is at roughly 9 seconds, and the NRC tone broadcast by CBC is at 19 seconds

    Yup: Rob’s right – CBC is broadcasting the NRC 13:00:00 signal at 13:00:10, which for time nerds might as well be the change from Julian to the Gregorian calendar.

    Waveform from Audacity showing a low tone at 9s recorded from WWV, and CBC's long beep coming at 19 seconds
    Annotated waveform: the CBC long beep is ten seconds after the WWV tone

    This recording was made directly from the airwaves. There should be effectively no difference between the signal broadcast times, but here we are with the “National Research Council official time signal” going out at a very wrong time indeed.

    Update, October 2023: Well, CBC has noticed, and rather than trying to fix it, they’re going to end it: The end of the long dash: CBC stops broadcasting official time signal | CBC News

  • Adding RGB LEDs to an illuminated arcade button

    Somewhat painterly view of the button doing its thing. The weird clunking sound is my camera’s continuous focus. For a clearer but more flickery view, see here

    Following on from a customer query at Elmwood Electronics, I can confirm that one can install install addressable RGB LEDs/NeoPixels inside one of these large buttons. It’s not the easiest build, so whether one should attempt this is another matter entirely.

    You’ll need:

    • Large Arcade Button with LED – 60 mm White (tall version) – this is larger and more domed than the flat-top one that Adafruit sells
    • RGB LEDs – I used a generic 8 LED ring, but anything not too tall and under 45 mm in diameter should fit. Either a 7 X WS2812 5050 RGB LED Ring or Adafruit’s NeoPixel Ring – 12 x WS2812 5050 RGB LED with Integrated Drivers could also work
    • Thin (and I mean thin: I used 28 AWG) Silicone Cover Stranded-Core Wire in several colours. You’ll want to cut this quite long at first, as you have to ease it through some tiny holes in the button assembly. If you solder connectors on the end, you won’t be able to disassemble or install the button without cutting them off. Do I speak from experience here? You betcha!
    • The usual soldering/hot gluing/bending/prying/grabbing/cutting tools you already know and love. In addition, you might consider a non-marring spudger and a pair of small(ish) arterial forceps (aka hemostats, aka Kelly forceps, aka fishing hook removal pliers)

    I’m not going to cover soldering the wires to the LED PCB in any depth here. You’ll need three wires: 5 V power, Ground and Data. Even though the LEDs I used need 5 V power, they are quite happy with 3.3 V logic on the data line. They need more than 3.3 V power to light, though.

    a large arcade machine style button on the left: it has a clear domed top and a threaded base. On the right is the combined microswitch and LED holder that fits into the button base
    The button in two pieces, as you might expect to receive it
    the top of the button disassembled into its main parts: bezel ring at top left, threaded lock ring at bottom, and main button mechanism. The mechanism is upside down, so the return spring and button actuators can be seen inside the threaded shaft
    Main parts of the button top, once you’ve removed the lock ring
    Close up of inside the shaft: return spring and its retainer tabs, and button actuators can be seen
    First step is to ease the spring out without bending it too much or breaking the retainer tabs
    Close up of inside the shaft: the tips of a pair of forceps have eased the top of the spring past its retainers
    I used small forceps to ease the spring out. Once you get it started, it unscrews easily from behind the retainers
    Close up of inside the shaft: the button actuators have been pushed down the shaft, allowing the top of the button to be pulled out
    Now the spring is out the way, you can squeeze in the actuator tabs and push them down the shaft to liberate the button top
    button top components arranged: black threaded button base on left, return spring in the middle, and domed clear top with white underside and white actuators sticking down
    The button top disassembled
    clear button top attached to its white underside. A blunt metal tool (spudger) is pointed at the push-fit join between the two parts
    Carefully lever off the clear top with a blunt tool like a spudger. Now would have been a great time to clean dust and other wee bits off your workspace, as they’ll surely end up inside the button, looking nasty
    clear button top separated from its white base. A translucent white diffuser is inside the clear top. The white base has a hollow centre and a circular cavity
    The button top opened up. The cavity is about 45 mm in diameter and only a few millimetres deep
    The microswitch with the LED holder attached on top. The blade of a blunt metal spudger is inserted under a plastic tab that holds the LED holder onto the switch
    Removing the LED holder from the microswitch is done by levering open (gently) the plastic tab that clamps the holder onto the switch.
    the LED holder at left, and the bare microswitch. The LED holder has an LED in a white plastic retainer, and below it two spade contacts. The switch has three spade connectors: Com(mon) on the base, and "NO 3" (Normally Open) and "NC 2" on the right side. Normal operation connects COM and NO
    LED holder and microswitch separated. For normal button operation, the contacts NO and COM become connected when the button is pressed. The spade contacts on the LED holder look like they should come out, and they will (soon)
    LED holder disassembled into two parts. The black LED holder base is on the left, with the two conenctor clips slightly blurry at top. On the right is the LED in its white support, pulled out of the holder base
    Pull the LED out from the holder, and you’ll see the metal clips that held it in place. These clips have to come out: I found the pushing them in slightly while pulling down on the spade connector eased them out eventually
    White button top underside with an 8 RGB LED ring hot glued into it. Three thin insulated wires (from top: yellow (data), red (5 V) and black (GND)) are previously soldered behind the LED board, and are secured against strain with a large deposit of hot glue
    LED ring hot glued into place. Make sure that the wires are properly secured, as you don’t want to take this apart again
    threaded button base with clear top fitted, seen from underneath. The white button actuators have been pushed back into place, and the three coloured wires are feeding through the hole in the shaft. The return spring is outside the wires, and is being fitted around the retainers inside the shaft
    Fit the clear button top back inside the base, feeding the wires through the shaft. Fitting the return spring back in is a bit more chaotic than getting it out. I ended up jamming it in with forceps, and it seemed to sort out okay despite that
    underside of the button shaft, with microswitch attached to LED holder. The wires coming from the LED ring inside the button top have been fed through the small cavities where the original LED holder clips/contacts have been removed. The red/black power wires are on the side towards us, while the yellow data wire is behind the microswitch
    The really fiddly bit: feeding the wires through the tiny gaps where the LED holder clips/contacts used to be. Even using thin (28 AWG) silicone covered wire, all three wires couldn’t fit down one side. Make sure the wires are pulled gently through, and aren’t snagged anywhere
    Fully reassembled button, with microswitch installed into its bayonet connector in the threaded shaft, and the button actuator lined up with the microswitch lever on the left. The yellow data wire is in front of the microswitch at bottom
    Finished! Make sure that the switch actuates properly by lining up the LED holder in the bayonets inside the shaft. Of course, you’ll have wanted to install the button in your project before doing this assembly, as you’ll have to feed those pesky wires back through again if you haven’t …
  • you can colour this in if you want to

    lattice of intersecting squares on diagonals
    Jali pattern, as noted from the sleeve of Garifulla Kurmangaliyev’s recording of Asylzhan (Kazakhstan, 1958) in “Excavated Shellac: An Alternate History of the World’s Music” notes, p.173

    PDF, too, if you like such things: record_label_jali.pdf. Made with OpenSCAD.

  • More Magic Designer Nonsense

    This is what I simulated earlier – except drawn on a real Magic Designer. Something’s off with what I modelled …
    All of these are drawn with the Magic Designer angle set to 57, which puts the crank discs exactly in phase. The blue circle in the middle is an exactly image of a crank disc, if perhaps a very dull plot.
  • Slightly imperfect Hoot-Nanny/Magic Designer simulation

    round figure with three interlaced 6-fold curves picked out in red, green and blue
    I even emulated the locating notches at the edge of the paper …

    Simulated (and not quite right yet) output from a “HOOT-NANNY” or Magic Designer, a proto-Spirograph toy that drew six-sided curves on round paper sheets. It was made by Howard B. Jones and Co. of Chicago, IL and first sold in 1929. The company’s better known for producing Jones Plugs and Sockets, sometimes known as Cinch-Jones connectors. The “HOOT-NANNY” name was dropped when production moved to the Northern Signal Company of Saukville, WI.

    My eBay-acquired Magic Designer is quite beaten up, and doesn’t always produce accurate results. Here’s how one should look, from the instruction pamphlet:

    diagram of the Magic Designer toy: central turntable holding paper is rotated by crank at bottom right. On the left are two crank discs (upper and lower) each with a crank pin that can fit into holes along two arms. These arms are joined at a pivot, and in the centre of this pivot is a pencil.

The upper crank disc can be moved in an arc relative to the lower disc. This is controlled by a locking shift lever on the right
    I can’t shake the feeling this was originally something like an artillery ranging tool or suchlike

    As far as I’ve been able to work out, the parameters of the machine are:

    • central turntable is 6″ in diameter, with 192 gear teeth around the edge;
    • (paper diameter is 5¾”);
    • each crank disc is 1″ diameter (32 teeth), with the crank pin at ⅜” radius;
    • the handle can only be turned clockwise. Consequently, the turntable can only turn anticlockwise;
    • fixed pins at 90° and 180° are 6½” apart;
    • distance between handle centre and fixed crank centre is 5″ on a 7″ PCD. Handle is therefore at ~225.585° and fixed crank at ~134.415°
    • the shift lever has a 10-70° scale, which corresponds to moving the upper crank disc between 30-90° of arc from the lower (fixed) crank disc;
    • the pencil arms have 18 holes labelled A to R, at ¼” spacing from 5¾ to 1½”. The perpendicular distance from the pivot holes to the pencil is 5/16″. This small offset makes very little difference to the overall arm length.

    If we model the toy with a fixed turntable:

    • the crank pins describe epitrochoids around the edge of the paper;
    • the pencil point traces the intersection of two circles of radius the lengths of the pencil arms, each centred on a crank pin.

    Here’s a very simple model in Python that emits a hard-coded (but editable) pattern in HP-GL: Slightly imperfect Python simulation of the “HOOT-NANNY” (or Magic Designer) drawing toy (static local copy: hootnanny.zip). It doesn’t do anything with the fixed circle studs (yet)

  • A new old calendar

    simulated dot-matrix printer on ruled paper layout of an ASCII-art Snoopy in WW1 Air Ace regalia yelling "Curse you Red Baron!" at his imaginary nemesis, and a 2022 calendar laid out on the facing page
    not seen the likes of this since ’78, I’ll be bound

    It’s unlikely anyone wanted a faux-lineprinter ASCII art calendar for 2022, but you’re getting one anyway. You can print this yourself:

    If you want to make your own, here’s a script: snoopycal.sh

    Credits:

    • Original “WW1 Fighter Pilot” Snoopy ASCII art from “SNOOPY.BA” for the DEC PDP-8, written by Mr Kay R. Fisher of DEC some time before July 1973. It’s referred to in the first printing of the “101 Basic Computer Games” book, which was published in 1973.
    • ncal, banner: their respective authors
    • pstext an ascii to PS filter by Dan Judd, usenet comp.lang.postscript, December 1989. I had to really mess around with the output of this program to use a custom font and add the music ruling, but it produces cleaner PostScript than the giant messes that enscript and a2ps have become
    • Font: mnicmp, by me. Based on the DecWriter II font.
    • iffy scripting, scribbly lines: also me.

  • looks like your dodgy uncle

    the dried, lumpy and in places mouldy remains of a carved turnip head lantern
    time hasn’t been kind to the neep lantern‘s fizzog
  • I (U+1F494, BROKEN HEART) UTF-8

    Something has gone very wrong with the database encoding on this blog after a recent update, so all my lovely UTF-8 characters have gone mojibake.

    Trying to find ways to fix it. It may have to be manual. Remember, kids: have backups before letting WordPress upgrade!

    Here’s the Python equivalent of what I think the database has done:

    bytes("I ???? UTF-8", encoding='utf-8').decode(encoding='cp1252')
    'I 💔 UTF-8'

    Quite why my hosting thought a character encoding from last century was appropriate, I’ll never know.

    Update, November 2023: kinda-sort fixed the backend, but the encoding is still weird — can we…?

  • I spent all of yesterday calculating circular key grids …

    12 green forked twig-like motifs arranged around a circle
    a green thing

    … only to realize I don’t really like circular key grids.

  • Autumn in Canada: PicoMite version

    Autumn in Canada: PicoMite version

    So I ported autumn in canada from OpenProcessing to PicoMite BASIC on the Raspberry Pi Pico:

    a small black screen images with text in the centre: autumn in canada scruss, 2021-11 just watch ...
    no leaves
    a small black screen images with text in the centre: autumn in canada scruss, 2021-11 just watch ... with one red and one orange maple leaf sitting on top of it
    a couple of leaves
    a small black screen images with text in the centre: autumn in canada scruss, 2021-11 just watch ... with four red/yellow/orange maple leaves sitting on top of it
    more leaves
    a small black screen images with text in the centre: autumn in canada scruss, 2021-11 just watch ... with sixteen simulated fallen maple leaves mostly covering it
    plenty of leaves
    a small black screen image completely covered with many simulated fallen maple leaves
    far too many leaves

    The biggest thing that tripped me up was that PicoMite BASIC starts arrays at 0. OPTION BASE 1 fixes that oversight. It would have been nice to have OpenProcessing’s HSV colour space, and an editor that could handle lines longer than 80 characters that didn’t threaten to bomb out if you hit the End key, but it’ll serve.

    Source below:

    ' autumn in canada
    ' scruss, 2021-11
    ' a take on my https://openprocessing.org/sketch/995420 for picomite
    
    OPTION base 1
    RANDOMIZE TIMER
    ' *** initialize polar coords of leaf polygon and colour array
    DIM leaf_rad(24), leaf_ang(24), px%(24), py%(24)
    FOR i=1 TO 24
        READ leaf_rad(i)
    NEXT i
    FOR i=1 TO 24
        READ x
        leaf_ang(i)=RAD(x)
    NEXT i
    
    DIM integer c%(8)
    FOR i=1 TO 8
        READ r%, g%, b%
        c%(i)=RGB(r%,g%,b%)
    NEXT i
    
    ' *** set up some limits
    min_scale%=INT(MIN(MM.HRES, MM.VRES)/8)
    max_scale%=INT(MIN(MM.HRES, MM.VRES)/6)
    min_angle=-30
    max_angle=30
    min_x%=min_scale%
    min_y%=min_x%
    max_x%=MM.HRES - min_x%
    max_y%=MM.VRES - min_y%
    
    CLS
    TEXT MM.HRES/2, INT(MM.VRES/3), "autumn in canada", "CM"
    TEXT MM.HRES/2, INT(MM.VRES/2), "scruss, 2021-11", "CM"
    TEXT MM.HRES/2, INT(2*MM.VRES/3), "just watch ...", "CM"
    
    kt%=0
    DO
        cx% = min_x% + INT(RND * (max_x% - min_x%))
        cy% = min_y% + INT(RND * (max_y% - min_y%))
        angle = min_angle + RND * (max_angle - min_angle)
        sc% = min_scale% + INT(RND * (max_scale% - min_scale%))
        col% = 1 + INT(RND * 7)
        leaf cx%, cy%, sc%, angle, c%(7), c%(col%)
        kt% = kt% + 1
    LOOP UNTIL kt% >= 1024
    
    END
    
    SUB leaf x%, y%, scale%, angle, outline%, fill%
        FOR i=1 TO 24
            px%(i) = INT(x% + scale% * leaf_rad(i) * COS(RAD(angle)+leaf_ang(i)))
            py%(i) = INT(y% - scale% * leaf_rad(i) * SIN(RAD(angle)+leaf_ang(i)))
        NEXT i
        POLYGON 24, px%(), py%(), outline%, fill%
    END SUB
    
    ' radii
    DATA 0.536, 0.744, 0.608, 0.850, 0.719
    DATA 0.836, 0.565, 0.589, 0.211, 0.660, 0.515
    DATA 0.801, 0.515, 0.660, 0.211, 0.589, 0.565
    DATA 0.836, 0.719, 0.850, 0.608, 0.744, 0.536, 1.000
    ' angles
    DATA 270.000, 307.249, 312.110, 353.267, 356.540
    DATA 16.530, 18.774, 33.215, 3.497, 60.659, 72.514
    DATA 90.000, 107.486, 119.341, 176.503, 146.785, 161.226
    DATA 163.470, 183.460, 186.733, 227.890, 232.751, 270.000, 270.000
    ' leaf colours
    DATA 255,0,0, 255,36,0, 255,72,0, 255,109,0
    DATA 255,145,0, 255,182,0, 255,218,0, 255,255,0
    

    You could probably use AUTOSAVE and paste the text into the PicoMite REPL. I used an ILI9341 SPI TFT LCD Touch Panel with my Raspberry Pi Pico along with some rather messy breadboard wiring.

    Fun fact: the maple leaf polygon points are derived from the official definition of the flag of Canada.

  • p-touch Pico pin labels

    breadboard with Raspberry Pi Pico attached, and two labels running down the sides with the pin names
    Pico pin labels: not bad for a first try

    This worked better than I expected. The tricky parts are trimming the edges and getting it them straight.

    Here’s the image to print on your label maker:

    combined Pico pin labels printed sideways on a tape label
    print on 12.7 mm tape
  • Raspberry Pi Zero 2 W: slides and thermals

    Raspberry Pi Zero 2 W: slides and thermals

    Slides from last night’s talk:

    It’s impossible to have a Raspberry Pi Zero overheat unless you overclock it. That’s why you don’t get any cases for it with fans or heat sinks. The quad-core Raspberry Pi Zero 2 W, though, has the potential to do so. Here are some numbers:

    • Used official case with lid fitted: increases SoC temperature +3 °C over free air
    • Test – CPUBurn: https://github.com/pmylund/cpuburn
    • Tested 4, 3 and 2 cores burning in 32-bit and 64-bit modes: time from idle to throttling (80 °C) measured
    • GPU overheat not tested.
    line graph of cpu temperature against time. Temperature rises sharply from about 47 degrees C to 82 degrees C in around four minutes
    All 4 cores burning, 64-bit mode: time to overheat = under 3½ minutes
    line graph of cpu temperature against time. Temperature rises sharply from about 47 degrees C to 82 degrees C in just over four minutes
    All 4 cores burning, 32-bit mode: time to overheat = just over 4 minutes
    line graph of cpu temperature against time. Temperature rises moderately from about 47 degrees C to 81 degrees C in around seven minutes
    3 out of 4 cores burning, 64-bit mode: time to overheat = just over 7 minutes
    line graph of cpu temperature against time. Temperature rises slowly from about 47 degrees C to 81 degrees C in around ten minutes
    3 out of 4 cores burning, 32-bit mode: time to overheat = 9½ minutes
    line graph of cpu temperature against time. Temperature rises very slowly, reach 70 degrees C in 40 minutes and then only rising very slightly to about 73 degrees C in the entire run time of 3 hours 20 minutes
    2 out of 4 cores burning, 32-bit mode: time to overheat = basically never

    Unless you’re doing things that might indicate you should be using a bigger computer, a Raspberry Pi Zero 2 W won’t overheat and doesn’t need any form of cooling. If you’re overclocking, well … it’s your choice to have cooling equipment worth more than the computer it’s trying to cool.

  • Neep Lantern 2021

    carved swede/turnip with eyes cut out as crosses, two nostrils and a lopsided grin lit from inside by a small candle.

(the smell is fairly atrocious, but emotive of the day)
    My neep lantern for Halloween 2021

    What you can’t see is the smell of Halloween: the hum of charred turnip from the candle inside.