In 1968, I participated in my first Science Fair, and I saw a working Tricorder! It was another student's project, an assembly of different instruments for sensing things.  I know it included radiation as well as temperature. It had a form of an electrical analog computer as well for calculations. It was all wrapped in a case modeled after the imaginary Tricorders on Star Trek. Pretty impressive for the time (the show was only in it's second season)!

Of course, that was a fun project that many have improved upon - there was an X Prize awarded for creating a mobile device that can "diagnose patients better than or equal to a panel of board certified physicians". And fans have constructed working props - even ones that can provide a variety of sensor readings. It's a great example of how the art of an SF program has inspired real-world engineering and development.

My own efforts are pretty modest, but it's fun to think about ways to craft a sort-of Tricorder device, given platforms like micro:bit or Circuit Playground Express with their multiple built in sensors. Early on I made a micro:bit version that displayed compass reading, light level and temperature, along with a small vocabulary of "alien" words; easy to do with the 5x5 LED matrix on the micro:bit (this was V1 micro:bit, so it didn't use the microphone). There was even an animated picture of the Enterprise.

Now, the Circuit Playground Express has good sensors but there is no graphic display, just the ring of ten neopixels - so how do you display readings? I wrote functions to display numbers by converting them to a string, and then, digit by digit, lighting up enough pixels to indicate the value. In addition, for the Circuit Python version I recorded the digits 0-9, and "point" and "minus" so I could have the device speak the number. I also think it's fun to use Morse code to display info, so for the Makecode version, I added the ability to display a number of sayings (maybe not too practical, but it was fun).

I've saved all this in a repository - here's the README

Tricorders

Code for Circuit Playground "tricorders"

• pycorder.py - "tricorder" program; toggle through idle/temp/light/gees with button A, get reading with B
• bach.py - provides musical notes, random music with touch A7, Star Wars Tune with A1

---

save .wav files in "digits/" directory 0.wav 1.wav 2.wav 3.wav 4.wav 5.wav 6.wav 7.wav 8.wav 9.wav gees.wav light.wav minus.wav point.wav temp.wav idle.wav

• Tricorder.js - Javascript version of CircuitPlayground Tricorder - toggle through idle/light/temp/gees/text modes with A+B, get reading with button A. when in "text" mode, tilt left/right to choose what phrase to display, press A to get morse code version

 

Tricorder.js

To use the Javascript code, open up https://makecode.adafruit.com start a new project, switch to Javascript mode and paste in the code. (You can also go directly to this link)

When you run the Makecode version, the program starts by blinking "hello" in Morse, then in "idle" mode, swirling a rainbow. Press A+B to jump to the next mode. Each mode shows a distinctive color:

• Light (yellow)
• Temperature (red)  - note, switching the CPX switch left, gives Fahrenheit, right give Celsius
• Sound (green)
• Text (blue)

When in a sensing mode, you'll see a real time graphing of the current value - press "A" to read the current numeric value.

When you are in "text" mode, tilt left and right to choose the phrase:

   0:  spock = "live long and prosper"
   1:  yoda = "do or do not"
   2: yoda2 = "size matters not"
   3: yoda3 = "luminous beings are we"
   4: kirk = "to boldly go"
   5: picard = "engage"

Press A to see the words displayed in Morse code.

 

CircuitPython version: pycorder.py

This requires you start with a Circuit Playground running Circuit Python (well, of course). Copy all the .wav files to a directory "digits/" and pycorder.py to code.py and bach.py on the CPX.

When it starts, it will flash a few colors, then announce "idle", going into swirling colors.

Advance modes by pressing "A" button. Again, a signal color announces the mode switch, along with a voiced "temp", "light", "gees", "idle". When in a sensing mode, press B to get the current reading.

• Temp (red) - note, switching the CPX switch left, gives Fahrenheit, right give Celsius
• Light (yellow)
• Gees (green) - note, "gees" willl announce THREE different values; the X, Y and the Z axis values

For fun, the A1 touch pad will render a Star Wars tune, and A7 will play a snatch of random tones.

-------------------------------------------------

So there you have it, my version of "Tricorder" - I'd love to see how others take that idea and make the imaginary real!

 

This demo uses Web Serial to receive video frames from a Pi Pico and show them in a web GUI. It works like a virtual display. The video frames go over the normal CircuitPython USB serial port as base64 encoded text with start and end markers.

I developed this technique so I could have an easy way to monitor video from my PiCowbell Camera Breakout. But, this approach could probably be adapted for use as a virtual displayio display.

This uses the same hardware setup as my CamTest: PiCowbell Camera Breakout Demo project:

A frame-capture demo with Pi Pico, OV5640 camera, and CircuitPython.

This is a simple camera demo project to capture a 240x240 px grayscale frame every 2 seconds, convert the 8-bit pixel data to 1-bit, then print pixels to the serial console with Unicode Block Element characters.

Hardware

The Pocket 386 is the latest tiny retro PC to be available from China, joining the Book8086 and the Hand 386. I have read that the Hand 386 was discontinued due to part shortages.

The unit is small, but calling it something that fits in a pocket is stretching it.

Resources

The following resources are available online as of the time this Note was written:

8086cpu.com:

• Main Page
• 8086 Store on AliExpress
• User's Guide (PDF version 1.0)
• Schematic (PDF version 1.2)
• ISA Expansion Card and Cable

AliExpress:

• DZT's Store - where this line usually shows up first.
• ISA Expansion card and cable

Third party sites:

• Thread on Vogons  - Pocket 386, the brother of Hand386 and Book8088, the story so far
• Thread from Foone - Mastodon
• Thread from Vintage Computer Federation (VCF)

Hacking:

• Reverse engineered LCD OSD/S-OSD control protocol
• RTC problem: the fix is to remove R38 next to the M6117D. The schematics say this component shouldn't be installed (NC), but they installed it anyway!

Resources:

• 3D printing files for port covers

Hardware:

• Datasheet for the Ali M6117 CPU chip
• POST codes for the Ali M6117

 

The weather API of openweathermap.org has been a trusted source of local weather, reliably feeding my projects for quite a few years. Their API design is very complete and easy to understand, not to mention that it interfaces nicely with CircuitPython.

They recently changed the API service model for openweathermap.org. Although there is a "free" service tier, a credit card is required just in case the usage exceeds the free use threshold. My projects only need a single query response every 20 minutes, clearly falling in to the lower portion of the lowest tier, but I didn't like having to share a credit card number when no money would need to change hands. Call me old-fashioned, I guess. I started looking for better alternatives.

The National Weather Service API

After reviewing many of the free-ish weather API offerings, I stumbled on the mythological metrological holy grail, the NOAA National Weather Service (NWS) API Web Service. The NWS API provides free access to alerts, observations, and forecasts without the need for a user account or API key. I was pretty excited to find that NOAA's NWS data was available to the general public since I assumed that other weather APIs use NOAA NWS as an essential data source for their services.

 

The NWS API incorporates the entire national network of NWS offices and stations. A large range of services are available through the API including alerts, forecasts, aviation weather advisories, and summary report products. For my projects, I'm primarily interested in obtaining current local weather observations such as temperature, humidity, and wind speed/direction. We'll focus on that limited data scope for this Playground Note.

Queries are requested with a simple URL call to https://api.weather.gov, such as

 https://api.weather.gov/stations/KSEA/observations/latest

to see the latest weather values for the Seattle-Tacoma airport in Washington state. You can test the query by pasting the URL into your browser.

When I was in High School

1. People  were walking on the moon,
2. I was learning to program with BASIC and,
3. I learned about Cellular Automata from Scientific American, and I thought it was really neat.

Now, no one is on the moon, I mostly don't program in BASIC... but I still think Cellular Automata is pretty neat. So much so, it's one of my go-to things to fool around with on different tiny devices - micro:bit, Circuit Playground, and, of course, my favorite NeoTrinkey!

I've got a repository with some of my experiments.

The first is lca.py .  This lets you run a linear cellular automata on the Neo. Run it as "code.py" or, in Thonny, load it up and click the "run" icon. It's a simple program that will run 10 generations every time you touch pad #1. Touching pad #2 randomizes the universe. Output is printed to the REPL - but the four pixels of the Neo will show four of the cells with random colors.

Output looks like this:

Recently I learned of the mathematician Nils Barricelli, who did early work in the 1950's to simulate life

George Dyson described Barricelli's first experiments at Princeton:^[8]

At 10:38 p.m. on March 3, 1953, in a one-story brick building at the end of Olden Lane in Princeton, New Jersey, Italian-Norwegian mathematical biologist Nils Aall Barricelli inoculated a 5-kilobyte digital universe with random numbers generated by drawing playing cards from a shuffled deck. "A series of numerical experiments are being made with the aim of verifying the possibility of an evolution similar to that of living organisms taking place in an artificially created universe," he announced.

This inspired me to create simbio.py. Running this as code.py (or in Thonny, opening it and "running it") will go through successive generations. Touch pad #1 to toggle on/off the running of generations. Touch pad #2 to randomize the universe - the four pixels show a glimpse of the generations, but the REPL will show:

 

My Xerox 820 CP/M computer has a large external drive enclosure with two 8" SS/DD floppy drives in it. They have a "shugart" interface inside, brought out to a proprietary-but-documented 37-pin D-style connector. Because the data signals used by floppy drives changed very little over the decades (at least in the CP/M and PC worlds; Commodore and Apple users, don't @ me) all the signals mostly map closely enough onto IBM PC 34-pin connector.

I previously made a passive adapter board so that a "Gotek" floppy drive emulator could replace the drive enclosure, and it worked! (and is a LOT less loud than 2 8" floppy drives spinning all the time!!!)

That got me thinking: could I make a 2nd adapter board that would let me archive 8" floppies? Then, inspiration struck: I didn't even need a 2nd board design. Instead of fitting a plug ("male") connector on the board's top side, I could simply fit a socket ("female") connector on the board's bottom side.

Since I'd gotten 5 boards in my PCB order, I just had to wait for delivery of the connector and solder everything up.

Both archiving and writing worked on the first try, with greaseweazle host software and an Adafruit Floppsy prototype board; a genuine GreaseWeazle should work just the same.

You can grab the kicad design files from my xerox 820 repository on github and order them from the board house of your choice.

Soldering the PCB

• Take a 2x36 pin header strip and snip off a 2x17 portion of it, reseving the rest for another project
• Solder this header on the top side of the board (where the silk is visible)
• Solder a 37-pin receptacle ("female") connector on the bottom side of the board (opposite the silk)
• The "mod" area is unused
• The 4-pin floppy power connector is ununsed

Connecting the board

Plug the floppy enclosure into the "D" connector; this is polarized so it can go only one way. Then, noting the "pin 1" location on both the GreaseWeazle/floppsy and the converter PCB, connect a straight through 34-pin ribbon cable.

Invoking greaseweazle

First, install greaseweazle host software according to the directions, and install a greaseweazle-compatible firmware on your device. Check that "gw info" can find and report your device info; you may need to provide a "--device" flag to all greaseweazle commands if you are using a greaseweazle-compatible device, not a genuine greasweazle. (e.g., "gw info --port COM31")

To archive a floppy:

• For safety against unintentionally writing to a floppy, the Adafruit Floppsy has a write enable switch. Slide it to the "OFF" position.
• Insert a floppy. For Floppsy, use the "B" drive. For a genuine GreaseWeazle you can use either "A" or "B" via the --drive flag. 
• Create the disk image: gw read --format dec.rx01 cpm.img

When the process completes, you will be shown a summary of any parts of the floppy that could not successfully be read.

To write a previously read floppy image note that this will irrevocably destroy the data previously on the floppy:

• If you're using an Adafruit Floppsy, make sure the write enable switch is in the ON position
• The floppy must also be write-enabled. On 8" floppies, this is done by covering the "write protect" notch on the right side of the bottom edge. Some 8" floppies were manufactured with no notch, in which case they are never write protected (this is opposite to the situation with 5.25" floppies)
• Insert the floppy you want to write to. For Floppsy, use the "B" drive. For a genuine GreaseWeazle you can use either "A" or "B" via the --drive flag. 
• Write the disk image: gw write --format dec.rx01 cpm.img

When the process completes, you will be shown a summary of any parts of the floppy that could not successfully be verified. All 8" floppy media is decades old, and unreadable/unwritable sectors are an unfortunate fact of life.

On the internal organization of image files

These images come out in the correct format & organization to use with the flashfloppy configuration I posted on my earlier playground note. CP/M had some complicated rules relating to sector numbering & interleaving, and each manufacturer could actually use different formats & organizations from every other manufacturer! Different conventions for archival images can place the sectors in a different organization, so when it comes to using images from the internet you may have to use conversion software to make sure the data is in the correct order. Unfortunately, the only way to do this is by trial and error.

Do you want to build CircuitPython MIDI drum sequencer? Maybe one like this (Lego style), or like this (plaintext style)? To play sounds, you'll need a MIDI synthesizer or sampler. But, with all the sampler and synth options, which one should you pick? To start with a simple browser-based drum synth, you could try web-midi-drumkit.

Quick Start

To try it out, connect a USB MIDI controller or sequencer to your computer and open the web-midi-drumkit demo page in Chrome (Web MIDI is relatively new, and not all browsers support it). You'll need to click the "Unmute Sound" button and probably also answer a security prompt to allow MIDI access.

Set your MIDI controller or sequencer to send notes on channel 10 using the following note mapping:

MIDI Note	Note Name	Drum Sound
51	D#3	Ride Cymbal
49	C#3	Crash Cymbal
48	C3	Tom 1 (high)
46	A#2	Hi-hat (open)
45	A2	Tom 2 (low)
43	G2	Tom 3 (floor)
42	F#2	Hi-hat (closed)
38	D2	Snare
36	C2	Kick

The solar-powered security light spent many years in the sun, charging its batteries to protect from the darkness. It is highly valued for its reliable and selfless vigilance. The unit is completely self-contained and requires no electrical wiring. It was perfect for temporarily replacing wired security lights when they were disconnected during a recent house remodeling project. The solar light also spent time strapped to a tree to surprise nocturnal raiders in the garden.

Of course, to work at its peak, the solar charger needs at least 6 hours of direct sunlight to prepare for the next nighttime watch. But after 15 or more years in the sun, the plastic enclosure became yellowed by UV light. That should be an easy fix: apply some masking tape to the passive infrared (PIR) detector lens, LED flood array, and solar cell, then spray on a couple of coats of glossy white paint. All went well until the PIR detector lens was touched. It was very brittle and disintegrated into Fresnel dust.

Sadly, I figured that the lens was unique and manufactured specifically for the PIR detector enclosure of that old light and couldn't be replaced. Oh well, since it was working before, the unit could at least be kept for spare parts.

The Lens is Indeed Unique

The usually flexible frosted plastic detector lens is pretty special. It doesn't just protect the electronics and optics from the weather, it also concentrates and directs IR energy onto the internal thermopile sensor using a custom pattern of refracting grooves (a Fresnel pattern) molded onto one side of the thin plastic. The lens pattern provides greater sensitivity for detecting movement than would be possible through a clear window, increasing the range from 1 meter to almost 15 meters. The lens also concentrates the field-of-view to approximately 120 degrees.

SevenSeg is a CircuitPython displayio -compatible collection of four ultra-compact monospaced .bdf fonts that mimic the look of a seven segment LED display. To keep the font file size small, only the numeric characters that a seven-segment display can represent are included in the font, including uppercase and lowercase hexadecimal. Okay -- there are a couple of other useful things in there, too.

Supported characters:

+ - . 0 1 2 3 4 5 6 7 8 9 : A B C D E F _ a b c d e f °

SevenSeg Font GitHub repository

 

Revisiting some of my Neo Trinkey experiments, I've been modifying code that no longer works with CircuitPython 9.x. This is another story generator I created using names and items generated with fantasynamegenerators.com.

Like "Tell me a story, Neo Trinkey" you get random stories by touching tab #2. Tab #1 chooses the hero name, class and race. 

The repository is here

and includes 

• magicquest.py - program file, rename to code.py
• prt.py - helper file for prt("text",REPL) function. REPL=True to send output to REPL and False for keystroke output

Data files for story input :

• destination.mq
• enemy.mq
• forest.mq
• names.mq
• treasure.mq
• weapon.mq

Load these on your NeoTrinkey and you can get stories like this:

 

The dwarf burglar Polo Littlefoot

 gets lost at

Corftey Fortress

discovering Black Magic Tome

Polo Littlefoot is surprised when The Black-Eyed Cinder Spider attacks from Jagged Covert

Stumbling badly, Polo Littlefoot somehow manages to find the Mournblade, Gift of Ancient Power and dispatch them!

 

No, not great literature, but I had fun creating it!

 

note: illustration above from

https://www.publicdomainpictures.net/pictures/190000/velka/medieval-fantasy-castle-2.jpg

Some design notes:

• The top of the cube (yellow, top facing down) has a bevel. This matches the:
• LED top section (pink) bevel - this keeps the top from sliding through the outer cube.
• The bottom layer of the bottom section (tan) is about 4mm thick. The switches are about 4mm tall, so they would be flush with the bottom, except in order to make one switch more prominent (the power switch) I carved out about 1mm so that switch protrudes about 1mm below the bottom.
• There is a box just large enough to squeeze in the battery holder keeping it firmly in the place in the assembled cube.
• On the outside of the battery holder box is a shallow half-box which supports the Pico vertically, with the USB facing downward. The box is about 5mm wider than the Pico itself so there is room for the wiring to extend bast the edge of the board connected to the GPIO pins. The wired Pico is hot-glued to the support plate to keep it firmly in place when connecting a USB cable.
• There is also 4mm groove in the base to allow the Pico's USB port to sit only 1mm above the bottom so a cable can be plugged in the assembled cube for updating the code without having to disassemble the cube. 

3D Case Design

I used TinkerCad (https://www.tinkercad.com) for my 3D design work. The original thought was to make two halves - a top and bottom that overlap/slide together. but I ran into some difficulties with this design. Ultimately, I broke it down into 3 parts - an outer 70x70x85mm cube with a 50mm square "hole" through the middle. Then I made two 50mm cubes for the top and bottom that mate open end to open end and slide into center of the cube. The heights of each are one half the depth of the cube so when assembled the closed ends are flush with the top and bottom of the cube. The top has the 9 holes which just fit the 10mm LEDs. The bottom had places to support the Pico and battery back with cut-outs for the slide switches and the USB connector on the Pico.

Here are what the three parts look like in TinkerCad: