Last year, I learned of a new Kickstarter that solved a significant problem with using a Raspberry Pi for embedded “turn key” projects. The Raspberry Pi is a disk-based Linux system, using a microSD card in place of a hard drive. If you kill power to a Raspberry Pi without safely shutting down Linux first, file system corrupt can occur. I have seen this dozens of times over the years on my devices. When it happens, I just reformat the memory card and re-image it and continue.
But now we don’t have to — at least not if we are using the Pi Zero.
Abhinav Shukla created the PiZ SuperCap and launched it as a Kickstarter in 2021. The device is a small circuit board with a capacitor. It connects to a Pi Zero via the I/O header. Instead of plugging the USB power cable directly in to the Pi, you plug it in to the PiZ SuperCap board. This charges the capacitor then begins powering the Pi.
PiZ SuperCap by Abhinav Shukla
If power is disconnected, the capacitor has enough power to run the Pi Zero for a short amount of time (about 15 seconds). It also toggles a GPIO pin to indicate that power has been lost. By running a simple Python script on the Pi, you can now detect when power has been lost and, if it is not resumed in a set amount of seconds, safely shut down the Pi Zero by issuing a “shutdown” command.
I backed ten of these units, and I am glad I did. They work great! Now I can use a Pi Zero for any type of embedded project I want and just kill power when I want to shut down.
How it works
Here are some things to be aware of:
When you first apply power, the Pi Zero will not immediately power up like you are used to. It must first charge the capacitor. The Pi Zero won’t actually start up until about 8 seconds after you apply power.
When you turn off power, if no shutdown script is installed, the Pi won’t turn off until the capacity runs out. On my Pi Zero W (first version), I timed it at 75 seconds when just sitting at a text console login prompt. If you are running a graphical desktop or any programs using the CPU, it won’t last that long.
The PiZ SuperCap will toggle GPIO pin 4 to indicate a power loss. To enable safe shutdown, you need some form of program or script that will monitor GPIO pin 4 and shut the system down when power goes away. The sample code provided uses a 9 second delay before deciding to power off, making the unit act like a mini UPS rather than shutting down on any temporary power blip. Clever.
Shutdown script
The designer provides some sample Python code on the project page, but here is a shorter one I came up with. I am not a Python programmer, so I have no idea if my technique is good. I just wanted it to block until it sees a power loss, and either shut down (after a delay) or continue:
supercap_shutdown.py
#!/usr/bin/python3
import RPi.GPIO as GPIO
import time
import os
GPIO.setmode(GPIO.BCM)
GPIO.setup(4, GPIO.IN)
while True:
# Wait for power to drop.
print ("Waiting for power loss...");
GPIO.wait_for_edge(4, GPIO.FALLING)
print ("Power loss")
# Give user 9 seconds to restore power.
print ("Waiting to see if power is restored...")
time.sleep(9)
if GPIO.input(4) == 0:
print ("Power not restored.")
os.system("sudo shutdown -h now")
break;
else:
print ("Power restored.")
The above script has print statements in it so you can run it from the console to verify it is working. Those can be removed (or commented out) once you are sure it works.
You will need to do a “chmod +x supercap_shutdown.py” to make it executable.
If you want to make it run on startup, edit the /etc/rc.local file:
sudo pico /etc/rc.local
…and add this line at the end before “exit 0”:
# Pi Z SuperCap monitor script:
python /home/pi/supercap shutdown.py
You can then restart the system (“sudo restart now”) and when it reboots, the script should be running. Disconnect power and after 9 seconds (or whatever time you modify the script to use) it will issue a safe “shutdown” command.
3-D printed enclosure
I have created a very simple 3-D printer enclosure that holds a Raspberry Pi Zero and the PiZ SuperCap. Let me know if this is something you might want.
PiZ SuperCap by Abhinav Shukla in a custom 3-D printed enclosure by Sub-Etha Software.
Support the designer
If one of these might be of interest to you, consider backing the project at:
I have received my FLSUN SuperRacer 3-D printer. It is very large, and must be assembled. Assembly is simple (maybe 28 screws, of two sizes, plus connecting plugs) but took me almost an hour. Others (who have done this) say it should take about 20 minutes.
The first thing I did was follow the steps in the manual to upgrade the firmware on the printer and the display. Each requires formatting a microSD card in a specific way (32K sectors for the printer, 4K sectors for the display). Updating the display requires opening it up (four screws) to access the card slot on the circuit board.
After this, I printed the included demo — a nut and bolt:
FLSUN SuperRacer SR 3-D printer demo file – nut and bolt.
It turned out exceptionally nice, even using generic Amazon Basics filament I had.
To better visualize how large it could print, I used Tinkercad.com to create a ring that was almost as large as the print surface. Since my SImplify3D did not have a profile for this printer (you have to e-mail them to receive it), I downloaded and installed the Mac version of Cura and used it’s SuperRacer profile to slice it. I then printed it, just fine:
FLSUN SuperRacer SR 3-D printer demo file – large ring.
So far, so good. I’ll be posting more about this printer as I have time. Until then, if you want to get one…
Here is a snapshot of the most-viewed articles on this site for 2021. Some of these even had dozens of views.
The most popular article continues to be my writeup on using a cheap ESP8266 module as a WiFi modem via a .99 cent RS-232/TTL adapter.
Several of my C programming articles top the charts as well, including simple things like how to split up a 16-bit value into two 8-bit values.
My “fix” for Arduino Ethernet has dropped down a few places, after being one of the most-viewed articles for years since I first published it. Perhaps they have finally updated the library to support multiple connections from the same IP address so my hack is not needed.
Even my bicycle LED POV light page (which hasn’t been updated in years) still shows up.
And although Sub-Etha Software was created in 1990 to offer software or the Radio Shack Color Computer (“CoCo”), you will see that content barely make an appearance in the list. But, it at least makes an appearance.
To the dozen or so folks who visited my site in 2021, thank you for visiting :)
2025-05-15 – The stem/post of my G5 broke. I no longer have a working G5, and have not been able to find any source for replacement parts. I now am trying a Segway Max G3 but the throttle control on it is awful.
I received a Kugoo G5 electric scooter to review. It seems to have died after a few minutes. And I can’t find any references to it anywhere on YouTube or the internet beyond a bunch of Kugoo websites, Alibaba and Amazon. This, this post.
When powering up, the display and lights come on for a second, there is a beep, then it shuts back off. The app can still connect via Bluetooth, but trying to power up via the app has the same result.
It’s weird not being able to find something on the internet.
I have been making a list of errors in the manual, as well, which I will provide back to Kugoo when the review is complete. Assuming their support responds and can get this review unit running for me.
Here is a Facebook group I created just for discussing this model. So far, no one has found it…
That uses 66 byte of BASIC program space (though will use more RAM for strings as it runs).
It appears there are still optimizations to make! In the comments. Stewart Orchard pointed out this one:
Not a big gain but two bytes can be saved by removing the third argument from MID$().
The two argument version of MID$() returns the remainder of the string starting from the specified position, and ASC() returns its result based on the first character of its argument.
– Stewart Orchard
In Color BASIC, MID$ can accept three parameters:
Color Computer 3 BASIC Quick Reference Guide, page 11
If you had as string of 10 characters, and wanted to print the third character, you could do it like this:
A$="ABCDEFGHIJ"
OK
PRINT MID$(A$,3,1)
C
Stewart pointed out that if you left off the final parameter, it returns the rest of the string:
A$="ABCDEFGHIJ"
OK
PRINT MID$(A$,3,1)
CDEFGHIJ
Now that I look at it, it appears MID$ with two parameters is sort of like an inverted RIGHT$. MID$ would give you all the characters starting at the one you specify, and RIGHT$ gives you the number of ending characters you specify.
PRINT MID$(A$,3)
CDEFGHIJ
PRINT RIGHT$(A$,3)
HIJ
I don’t recall using MID$ like this, but I have simulated the same behavior using RIGHT$ like:
I am a bit embarrassed to admit I think I even did something like this:
PRINT MID$(A$,3,LEN(A$)-3)
CDEFGHIJ
…but let’s not speak of that.
And if MID$ can work like RIGHT$, it can also work like LEFT$:
PRINT LEFT$(A$,3)
ABC
PRINT MID$(A$,1,3)
ABC
But I digress…
If MID$(A$,3,1) gives you one character starting as location 3, and MID$(A$,3) gives you all the characters starting at position 3, how does that work? Stewart explained that ASC will still work if you pass it a string since it only works on the first character of the string. It is even documented that way:
Thus, ASC(“HELLO”) produces the same result as ASC(“H”) — the ASCII value of letter H.
With that in mind, we can remove “,1” from the program and reduce it by two bytes:
The challenge is simple: Write a program that prints out a centered text Christmas tree using the same layout of their example program. I thought it would be fun to work through several methods to do this.
PRINT
We start with their simple example, which displays the centered tree using PRINT statements. Here is their example with spaces altered so it centers on the CoCo’s 32 column screen:
You will see one memory optimization they did was leaving off the ending quote. BASIC will stop parsing a quoted string if it reaches the end of a line, so the ending quote is only necessary if more statements follow the PRINT.
I do not know if the space between PRINT and the quote is required for the system they wrote this example, but on the CoCo we could remove it and save 23 bytes of program space right there.
PRINT TAB
Speaking of spaces, each space takes up a character. BASIC has a command that will jump forward a certain amount of spaces — TAB. It works like this:
PRINT TAB(5);"FIVE SPACES OVER"
From my test, it appears TAB takes up one byte(for the “TAB(” portion, then a byte for each digit, then a byte for the closing parenthesis. If tabbing a single digit of spaces, it takes three bytes of program space. Thus, any time we are spacing over more than 3 spaces, it would save memory to use TAB. Also, the semicolon between TAB and the item being printed is optional, so we can leave that out as well.
For the tree example centered on a 32 column screen, every line starts with at least 4 spaces, so using TAB should save memory. Let’s try this:
It is drawing three sections, with the first expanding on each side by 1 (adding two asterisks to each row), then the next section expanded each side by 2 (adding four asterisks to each row), then the final section expands each side by 3 (adding six asterisks to each row).
There is probably a simple way to math it. But first…
Centering
Since one of the requirements is centering the tree on the screen, let’s look at how we center a string. To do this, we simply subtract the length of the string we want to center from the width of the string then divide the result by two:
A$="CENTER THIS"
PRINT TAB((32-LEN(A$))/2);A$
Or, to eliminate some parenthesis, we can start with half the width of the screen (the center of the screen) and subtract half the length of the string:
A$="CENTER THIS"
PRINT TAB(16-LEN(A$)/2);A$
With that out of the way, now we need to figure out how to draw the three triangle shapes of the tree, each time getting wider.
Numbers and patterns.
I decided to lookat the number sequences of each line length for each section of the tree (skipping the trunk lines).
I could easily create the first pattern by doing a FOR/NEXT loop with a step of 2:
FOR I=1 TO 7 STEP 2:PRINT I:NEXT
And then I could do 3 to 15 with a STEP 4, and 5 to 23 with a STEP 6.
FOR I=1 TO 7 STEP 2:PRINT I:NEXT
FOR I=3 TO 15 STEP 4:PRINT I:NEXT
FOR I=5 TO 23 STEP 6:PRINT I:NEXT
This would generate the number sequence I need, and then I could simply print a centered string of that many asterisks, and manually print the tree trunk at the end.
10 FOR I=1 TO 7 STEP 2:GOSUB 50:NEXT
20 FOR I=3 TO 15 STEP 4:GOSUB 50:NEXT
30 FOR I=5 TO 23 STEP 6:GOSUB 50:NEXT
40 I=3:GOSUB 50:GOSUB 50:END
50 PRINT TAB(16-I/2)STRING$(I,42):RETURN
127 bytes.
That’s much better! Though, I saved a bit more by combining lines, and I could save even more by removing spaces and combining lines further:
Now we’re getting somewhere! But ignoring the compressing, can we do better than 127 using better math?
Math. Why did there have to be math?
I am slow and bad at math, but I am convinced there is a math solution to this, as well.
Let’s look at how the numbers for START value and STEP value work. I know there are going to be three sections of the tree, so it seems logical I’d start with something like this:
10 FOR I=1 TO 3
20 PRINT I*2-1
30 NEXT
That would print out 1, 3 and 5, which is the start width of each section of the tree. I could have also done the FOR loop using 0 to 2 and added 1 to get the same result:
10 FOR I=0 TO 2
20 PRINT I*2+1
30 NEXT
Maybe one will be more useful than the other depending on what comes next…
Once we know how wide a section starts, we need to know how much the length increases for each line.
Section 1 increases by 2 each row, section 2 increases by 4 each row, and section 3 increases by 6 each row. That is a pattern of 2, 4, 6. It looks like I could get those values by taking the section (1 to 3) and multiplying it by 2. This will print 2, 4, 6:
10 FOR J=1 TO 3
20 PRINT J*2
30 NEXT
I am bad with math, as I mentioned, but I was able to work out that taking a value of 1 to 4 (for each layer of a section) and multiply that by the section (1 to 3), and subtracting one, I could get this:
10 FOR I=1 TO 3
20 FOR J=1 TO 4
30 PRINT J*I*2-1
60 NEXT
70 NEXT
To print the row of asterisks, I use the STRING$ function. It takes the number of characters to print, then the ASCII value of the character. The asterisk is ASCII character 42 so it I wanted to print ten of them I would do:
PRINT STRING$(10,42)
I can now print the layers of the tree like this:
10 FOR I=1 TO 3
20 FOR J=1 TO 4
30 W=J*I*2-1
50 PRINT TAB(16-W/2);STRING$(W,42)
60 NEXT
70 NEXT
But that still doesn’t handle the “trunk” at the bottom of the tree.
Since the trunk does not follow any pattern, I will simply treat it like an extra section, and increase the section loop (FOR I) by one, and add an IF that says if we are on that layer, the width will be 3. Then, since I don’t want this section to be four layers thick, I can use a second IF after the one that checks for the fourth section to know when to exit (checking for J to be larger than 2):
10 FOR I=1 TO 4
20 FOR J=1 TO 4
30 W=J*I*2-1
40 IF I>3 THEN W=3:IF J>2 THEN END
50 PRINT TAB(16-W/2);STRING$(W,42)
60 NEXT
70 NEXT
162 bytes.
Ah, well, being clever seems to have increase beyond the 127 bytes of just using three FOR/NEXT loops. I suspect it’s the overhead of the way I am trying to print the trunk section. Indeed, without it (like 40, above, and adjusting the I loop to 3) makes it 125.
Sometimes being clever doesn’t help. Even without trying to be clever about the trunk section, the “W=J*I*2-1” stuff takes up as much space as just doing another FOR/NEXT and a GOSUB to print the line.
DATA
We could just have a table to line lengths, and do it like this:
10 READ W
20 IF W=0 THEN END
30 PRINT TAB(16-W/2);STRING$(W,42):GOTO 10
40 DATA 1,3,5,7,3,7,11,16,5,9,13,17,3,3,
98 bytes.
Not bad at all! And that is before compressing it to fewer lines. Here’s a 79 byte attempt, removing spaces, removing the semicolon, altering the logic just a bit to be on LINE 0 (so you can just say GOTO) and changing the IF so there is no END token:
Another “DATA” technique which I have seen Jim Gerrie use is to simply encode the line lengths as characters in a string, and use that as data. For example, ASCII “A” (character 65) will represent 1, “B” will represent 2, and so on. Make a string of the appropriate characters and retrieve them using MID$() and get the ASCII value using ASC() then subtract 64 from that value and you have something like this.
10 FOR C=1 TO 14
20 W=ASC(MID$("ACEGCGKOEKQWCC",C,1))-64
30 PRINT TAB(16-W/2);STRING$(W,42)
40 NEXT
97 bytes.
If we compress the lines together, we can shrink it even further:
Is this as small as it gets? (Technically, this uses more memory, since string space has to be used to create temporary strings for MID$(), but we are only looking at program size and not memory usage.)
Although I had heard of this new-fangled “spatial audio” now supported by Apple, my devices are all so old they are limited to good old-fashioned stereo.
And I like it that way.
I mean, just because you give “surround sound” a new name doesn’t mean I’m gonna fall for it.
And “surround sound” doesn’t work in headphones, in spite of all the demos trying to convince you that this ultra-separated stereo recording can make you think a sound is coming from in front of, behind, or above you.
I was wrong.
While I still don’t think headphone based “surround sound” is anything more than two-speaker stereo with fancy mixing, spatial audio turns out to be something quite different. And I discovered it by accident.
A few months ago, I picked up some Apple AirPods to use as noise cancelling headphones while spending many weeks working in a noisy warehouse. Being able to turn noise cancelling on and off was, on its own, a slight form of magic. At least, that’s how I felt when I first got to demo the BOSE noise cancelling headphones in the Denver airport two decades ago. Today, however, noise cancelling is built in to even cheap headphones.
I read that these AirPods supported spatial audio, but when I tried to listen to the demos it just sounded like stereo to me.
New name, same scam. Or so I thought.
Later I read that spatial audio was only supported on newer devices that the ancient ones I had. This intrigued me. Why would the device’s horsepower matter?
I learned why, quite by accident.
I swear I heard something…
I got to use a new-model iPad and was watching HULU using my AirPods. I thought nothing of it, until I turned my head to look at something. I heard the sound in my right ear.
Oops. Had I actually notturned these headphones on, and was blaring HULU through the speakers? How embarrassing.
I checked and my speakers were silent. What just happened?
I resumed playing the video, this time paying attention to the sound to see if, somehow, the iPad speakers were turning on. As I turned my head to test again, the sound was heard to shift to the closer ear.
I felt a tad bit of magic, as I realized turning my head was shifting how the audio was playing, simulating listening to a TV at a fixed point in space. I had never heard anything like this before in headphones. After all, headphone sound doesn’t move.
And now I know what makes spatial audio more than just surround sound. Sensors in the headphones, combined with processing in the playback device, are able to create custom mixes of the audio as your head moves. It’s difficult to describe, beyond just saying “it’s as if the sound was real and you weren’t wearing headphones.”
If your iDevice supports it, there is even a test built in to the Bluetooth connection settings for the AirPods:
When I first tried this demo, I switched from Stereo Audio to Spatial Audio and it just sounded like a better stereo mix. But when I tried again, now aware of what spatial audio was, I found I could turn my head away from the screen and the audio mix sounded like it was coming from the screen to the left or right of me, depending on where I turned.
Magic.
Very cool magic.
While I was a two-speaker surround-sound denier (I still am), I am definitely a believer of spatial audio.
Not all apps support it, but the ones that do provide a very new experience when using headphones to listen to audio.
Apparently, if you use a composite monitor or TV set on a CoCo 3, you can just put bytes on the 640x192x4 color video mode and they create artifact color. You can get over 200 artifact colors that way with no special tricks other than a palette translation to know what byte value is what color.
In case you ever wondered what the VIC-20 character set would like like on a CoCo 1…
VIC-20 PETSCII (Uppercase 0-511) on a CoCoVIC-20 PETSCII (Lowercase 0-511) on a CoCo
It would look like that.
And if you wanted to know what the VIC-20’s 22×23 screen would look like on a CoCo…
VIC-20 20×32 screen displaying PETSCII on a CoCo
That. It would look like that.
When I moved from the VIC-20 to the CoCo, I lost colors and sound, but gained a “huge” screen that was 32 columns wide instead of 22. But I lost horizontal lines (23 down to 16). It felt more usable (wider screen) but smaller.
It wasn’t until I started revisiting the VIC-20 this past year that I realized since each screen block was eight bytes tall, the VIC’s native “resolution” for that 22×23 screen would be 176×184 (22*8 by 23*8). The CoCo’s 256×192 was larger and could fit the VIC-20 screen with room to space (but without the colors).
When I tried to do a quick port of my VIC Sky-Ape-Er game, the different text resolution (22×23 versus 32×16) made all my levels need to be redesigned. It would not be the same game — but the same game engine with different sized levels that resembled the original.
It might be fun to come up with an assembly routine to handle VIC-20 custom characters on a 256×192 graphics screen. It would likely be slower (blitting out 8 bytes instead of printing one byte) than text mode, but I could then port my games over (minus color and sound) much more accurately.
