Skip to main content
Sign In to create your own notes.

Getting Started

Adafruit Playground is a wonderful and safe place to share your interests with Adafruit's vibrant community of makers and doers. Have a cool project you are working on? Have a bit of code that you think others will find useful? Want to show off your electronics workbench? You have come to the right place.

The goal of Adafruit Playground is to make it as simple as possible to share your work. On the Adafruit Playground users can create Notes. A note is a single-page space where you can document your topic using Adafruit's easy-to-use editor. Notes are like Guides on the Adafruit Learning System but guides are high-fidelity content curated and maintained by Adafuit. Notes are whatever you want them to be. Have fun and be kind.

Click here to learn more about Adafruit Playground and how to get started.

New
Featured
  • By cadet702
    Stuff My Dog Said (via AdafruitIO)

    Inspiration

    This project is an extension of the original doggy buttons project where I'll be showing how to make a public dashboard that publishes everything my dog says.  This project is just one example of how to extend the features of my doggy buttons and perhaps one of the silliest IOT devices ever made.  If you want to know about the buttons themselves, see the original project writeup.

    With a project like this, it's also important to think about privacy.  I don't want my dog making it possible to tell when we're away from home, so I'll also show how to add a delay so that activity is only published once it's sufficiently stale.

    Setup Challenges

    User Space vs Admin Space

    The first version of my program was kicked off by /etc/rc.local on boot, but this had the side effect of running the program as root.  That was fine for my original project, but I had followed best practice and not used sudo when pip3 installing the Python libraries needed for loading data to AdafruitIO.  If I logged in to run the program as my user, it would end when I logged off but root no longer had all the Python libraries needed to run.

    Lennart (Binary Labs) suggested the simple and elegant solution of adding sudo -u MY_PI_USERNAME before the command that would launch my code in /etc/rc.local.  This allows the program to be run as my user without having to login and was much simpler and cleaner than the other solutions I was considering.

    Concurrency

    The first version of my code simply added a call to aio.send_data(...) in the same loop that processed button presses, but I quickly discovered that the upload process could take 3 - 4 seconds leading to very delayed sounds when more then one button was pressed.  Things like "water outside walk later" became "water ... outside ... walk ... later".  This was starting to confuse my dog because the sounds weren't immediately connected with the button presses and would sometimes sound when she had gone to push something else entirely because the button "wasn't working".

    To fix this it was going to be necessary to introduce separate queues, one for playing sounds that could respond quickly, and one for uploading button presses that could slowly upload data to AdafruitIO in the background.

    Bookmark
    The
  • By DJDevon3
    Web API's & You

    Below is a test of the Playground Note code embed directly from Github (must be .md or .py file).  If you see the full code below it is working as intended.  If the example in the library gets updated this Playground Note might not be kept up to date with future changes. The code below will always be the most up to date as it is pulled directly from the adafruit_requests examples library.

    Full Example Code

    • An uncomprehensive & comprehensible guide to using Adafruit Requests with web API's.

    The amount of online API examples for the Adafruit_Requests library is growing. If you're interested in using an API but an example does not exist and you're unsure how to start I will help walk you through the process.

    I wrote the majority of the web API examples currently in the examples directory. I'm a pretty good source on how to approach a new unknown web API and wrangle out some basic data. 

    JSON

    Data is malleable, it can be shaped and formed in a variety of ways.  The most common format currently used with REST API's is JSON. The Adafruit_Requests library is particularly good with JSON data.  If you don't know how to read or write in JSON don't worry, you won't need to.  The library handles all the format conversions for you.  All you need to know is how to get at the data you want and I will walk you through how to do that.

    Before we begin there are some glossary terms that you'll need to know in order to make sense of JSON for the web.

    REST

    Representational State Transfer (REST) is a software architecture that imposes conditions on how an API should work. Most web API's use the REST architecture.  All a beginner needs to know about REST is it's the way a website allows you to retrieve data from an API.

    Endpoint

    An endpoint refers to the data to retrieve from an API. This can be part of the JSON heirarchy path or a key:value pair. For web API's typically this refers to the JSON Key:Value pair.

    Key:Value

    • Key:Value (always a pair separated by a colon)

    A key is a unique identifier associated with data and the value is the actual data.  An example would be if you're working with a weather API and might want to return current:temperature for a geographic area to display freedom units on a TFT. It would return as `current:70.0` (in Fahrenheit) or if you're living in a sensible country using the metric system it would return `current:21.1` (in Celsius). 

    Key Error

    It's useful to know the above terms because an error that a website or Circuit Python might return is `invalid key:value pair` or simply `key error`. That error means you requested a key:value that does not exist, you spelled it incorrectly, or the request was otherwise incorrectly formatted.

    Bookmark
    WebAPI_and_you.jpg
  • By justmobilize
    SocketPoolLogger

    Have you ever needed to troubleshoot why you are having issues with your MCU and the internet? Ever been curious how internet requests work? Well this might get you a little closer.

    Introducing: SocketPoolLogger

    What is SocketPoolLogger? it's a little class, that allows you to log everything that happens with a socket.

    And instead of the normal message we get from the response.text, we get all of this:

    Bookmark
  • By danak
    Raspberry Pi Pico Dice Programmed with CircuitPython

    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:

    Bookmark
  • By SamBlenny
    Tiny Plaintext MIDI Sequencer for SAMD21

    When playing with synthesizer patches, it helps to have a MIDI sequencer to generate note triggers for you. One option is to use a DAW on a laptop, like Ableton or whatever. But, it can also be nice to go DAWless with a hardware sequencer, because buttons and knobs and blinking lights are fun. With DIY sequencer projects in mind, I wrote a plaintext music notation sequencer module for CircuitPython, called txtseq.

    The sequencer can read a song from a text file on your CIRCUITPY drive, parse the music notation into an array of MIDI note on and off events, then play the MIDI events in an event loop (allowing time to run other code). The music notation is loosely based on a subset of the abc standard. Notation for note pitch, accidentals, octave, and duration is very similar to abc. For everything else, the sequencer uses a simpler grammar and syntax that is easy to parse on a microcontroller.

    CircuitPython + GarageBand Audio Demo

    In my GitHub repository for the sequencer, the demonstration track I wrote is named track1.txt. To hear what the commit 9c73ec4 version of track1.txt sounds like when played from a Trinket M0 over USB MIDI into a MIDI drum instrument in GarageBand, you can listen to demos/track1-180bpm.mp3.

    How to Run the Code

    I've been testing this with CircuitPython 9.0.5 on a Trinket M0 (SAMD21), but most of the code (all but MIDI out) also runs on desktop python3.

    CircuitPython Version

    1. Prepare a host computer with something that can play sounds for incoming USB MIDI notes on channels 10, 11, 12, and 13. For example, on macOS, you can use the GarageBand app by adding a MIDI track to an empty project, then selecting a drum kit as the MIDI track's instrument.

    2. Update CircuitPython and bootloader the normal way. (no additional libraries are needed)

    3. Fetch a local copy of txtseq using git clone or by downloading a release archive.

    4. Copy the txtseq/txtseq directory to your CIRCUITPY drive (see docs at Welcome to CircuitPython! > The CIRCUITPY Drive)

    5. Copy txtseq/code.py, txtseq/boot.py, and txtseq/track1.txt to your CIRCUITPY drive

    When code.py runs, it will parse music notation from track1.txt into an array of MIDI note event data, then start playing the notes over USB MIDI. The parser and playback code print a variety of debug info to the serial console to help with measuring memory and CPU use along with MIDI playback latency.

    Desktop Version

    This will give debug prints only, without actual MIDI playback. But, you could easily modify the code to use a library that is capable of sending MIDI. (see definition of midi_tx(data) callback function in txtseq/__main__.py)

    1. Clone the txtseq repo

    2. cd txtseq

    3. python3 -m txtseq track1.txt

    Example Output

    This is from running code.py on a Trinket M0 with CircuitPython 9.0.5:

    10: ppb=4
11: bpm=180
19: 1 ................
20: 1 ...................
21: 1 ...............................
22: 1 ................
23: 1 ...................
24: 1 ......................
[parse time: 517 ms]

00009924 00078924 0010992A 0017892A 00189924 001F8924 0028992E 002F892E 00309928 00378928
0040992A 0047892A 00489924 004F8924 0058992E 005F892E 00609924 00678924 0070992A 0077892A
00789924 007F8924 0088992E 008F892E 00909928 00978928 00A0992A 00A7892A 00A89924 00AF8924
00B8992E 00BF892E 00C09924 00C78924 00D0992A 00D7892A 00D89924 00DF8924 00E8992E 00EF892E
00F09928 00F78928 0100992A 0107892A 01089924 010F8924 0118992E 011F892E 01209924 0120992E
01278924 0127892E 0128992A 012F892A 0130992E 0137892E 01389924 013F8924 0140992E 0147892E
0148992A 014F892A 01509928 01578928 0160992A 0167892A 01689924 016F8924 01789924 017F8924
01809924 01838924 01849924 01878924 01889924 018B8924 018C9924 018F8924 01909924 01938924
01949924 01978924 01989924 019B8924 019C9924 019F8924 01A09924 01A38924 01A49924 01A78924
01A89924 01AB8924 01B09933 01B38933 01B49933 01B78933 01B89933 01BB8933 01BC9933 01BF8933
01C09933 01C38933 01C49933 01C78933 01C89933 01CB8933 01CC9933 01CF8933 01D09933 01D38933
01D49933 01D78933 01DC9924 01DF8924 01E09924 01E38924 01E49924 01E78924 01E89924 01EB8924
01EC9924 01EF8924 01F09924 01F38924 01F49924 01F78924 01F89924 01FB8924 01FC9924 01FF8924
02049931 020F8931 02109924 02178924 0220992A 0227892A 02289924 022F8924 0238992E 023F892E
02409928 02478928 0250992A 0257892A 02589924 025F8924 0268992E 026F892E 02709924 02778924
0280992A 0287892A 02889924 028F8924 0298992E 029F892E 02A09928 02A78928 02B0992A 02B7892A
02B89924 02BF8924 02C8992E 02CF892E 02D09924 02D78924 02E0992A 02E7892A 02E89924 02EF8924
02F8992E 02FF892E 03009928 03078928 0310992A 0317892A 03189924 031F8924 0328992E 032F892E
03309924 0330992E 03378924 0337892E 0338992A 033F892A 0340992E 0347892E 03489924 034F8924
0350992E 0357892E 0358992A 035F892A 03609928 03678928 0370992A 0377892A 03789924 037F8924
03889924 038F8924 03909924 03938924 03949924 03978924 03989924 039B8924 039C9924 039F8924
03A09924 03A38924 03A49924 03A78924 03A89924 03AB8924 03AC9924 03AF8924 03B09924 03B38924
03B49924 03B78924 03B89924 03BB8924 03C09933 03C38933 03C49933 03C78933 03C89933 03CB8933
03CC9933 03CF8933 03D09933 03D38933 03D49933 03D78933 03D89933 03DB8933 03DC9933 03DF8933
03E09933 03E38933 03E49933 03E78933 03F09931 03FB8931
[midi event dump time: 191 ms]

mem_free: 10976 10880 9728   diffs: 96 1152

Playing on USB MIDI ch10-13...
Done

    1. The top section has debug print output from the parsing functions.

    2. The second section is a dump of the array of timestamped midi events created by the note parsing code.

    3. The third section summarizes mem_free() measurements. (see code.py)

    4. The last section has debug prints from the MIDI event player.

    Reading the Code

    This section is for people who are interested in how the sequencer works. It's kind of technical, and I used a variety of optimization tricks to get it to fit and run well on a non-Express SAMD21 board.

    1. The txtseq module exports a function, sequencer(f) (see txtseq/sequencer.py) which expects its argument, f, to be a binary mode file object (e.g. open('some-song.txt', 'rb')). For usage examples, see code.py or txtseq/__main__.py.

    2. The seqencer() function parses its input file to find top level commands, which it then uses to call further parsing functions. For example, the commands 1, 2, 3, and 4 call the p_staff() function defined in txtseq/staff.py. The numbers correspond to each of the four voices (tracks). Note on and off events generated by the parser get packed as uint32 values in an array.array('L'). The most significant 16 bits have a timestamp (units of MIDI pulses). The low 16 bits have MIDI status and data bytes. This allows for adding note events one voice at a time without worrying about out-of-order events. I sort the array at the end to merge all the events from different voices into one list ordered by ascending timestamps.

    3. To get all the parser code to compile and run on a SAMD21, the module is split into several files of less than 150 lines each. Also, I used several MicroPython optimization techniques from Damien George's 2018 PyCon AU talk, "Writing fast and efficient MicroPython".

    4. The txtseq/util.py file holds parsing functions for dealing with comments (# ...), semantically irrelevant whitespace, and setting of header options (B for bpm, U for time unit)

    5. Parsing of note pitch and duration for staff lines happens in the p_staff() function of txtseq/staff.py. The parsing style is based on state machine loops that examine one byte at a time, reading bytes with readinto() to limit heap allocations. When one of the parser functions or state machine branches recognizes a byte that should be processed by a different function or state branch, it will rewind the file's cursor position by one byte using the f.seek(mark) idiom.

    6. Playback uses a generator defined in txtseq/player.py. By using the generator as the iterator for an event loop, it's easy to run your own code interleaved with the MIDI player (see main() in code.py). Also, holding playback state in the local scope of a generator makes it possible to avoid many heap allocations and dictionary lookups that would add jitter and latency if the MIDI player used a class instance.

    Music Notation Grammar and Syntax

    This section is for people who want to write songs for the sequencer to play as MIDI events.

    For examples of how the plaintext music notation works, check out the comments in txtseq/track1.txt.

    The ASCII note transcription style used here is loosely based on the abc music standard, but the two notations are not compatible. In particular, this notation uses {} for chords, requires chord durations to be specified after the closing }, and omits a lot of abc's features such as configurable key signature.

    The short summary:

    • Single note: <accidental><pitch><octave><duration> (e.g. C _B, c2)

    • Rest: z<duration> (e.g. z z2 z16)

    • Chord note: <accidental><pitch><octave>

    • Chord: {<chord note><chord note>...}<duration> (e.g. {C^DA}4 {ceg})

    • Accidental: _ (flat), ^ (sharp), or the empty string (natural)

    • Note: C D E F G A B c d e f g a b (C is middle-c, c is 1 octave up)

    • Note aliases: you can use some shorter aliases to write percussion parts: h for ^F _G (closed hi-hat), H for _B ^A (open hi-hat), and r for _e ^d (ride cymbal)

    • Octave: , (lower by 1 octave), ' (raise by one octave), repeated commas or single-quotes are cumulative (,, lowers 2 octaves, ''' raises by 3). Examples: C,,, d'

    • Duration: An integer representing the length of a note or chord as a multiple of the current time unit. Duration is optional with a default value of 1. With the time unit set for 1/8, C2 would mean a quarter note of middle-c, and C would be an eighth note.

    • Staff: staff lines start with a voice number then have an arbitrary sequence of whitespace, bar lines (|), notes, and chords. Bar lines and whitespace are ignored by the parser, but you can use them to help organize your notes for better readability. It's fine to make long notes that last for more than one measure (e.g. C,16 with time unit set to 1/8 would be played the same as 2 tied whole notes in 4/4 time)

    Example: 2 | {CDG}4 {ACD}4 | C2 C2 D2 G2 |

    For more examples, see txtseq/track1.txt

    Setting BPM and Time Unit

    The B command sets bpm, which is a global setting that gets applied during playback. For example, a line with B 120 would set the playback speed to 120 beats per minute.

    The U command sets the time unit, which relates to the duration numbers. For example, You can set the time unit to 1 eighth note with U 1/8 command. In that case, if you wrote C2 in a staff, that note's duration would be 2 eighth notes (1 quarter note). Or, for quarter note triplets, you could use the U 1/4T command. In that case, the duration of a C2 would be 2/3 of one quarter note.

    The time unit options are: 1/4, 1/8, 1/16, 1/32, 1/4T, 1/8T, 1/16T, and 1/32T

    Bass Clef Percussion Notes on Voice 1

    The General MIDI standard includes a mapping of percussion sounds for MIDI channel 10, notes 35 to 81. The sounds for a typical Western drum kit (kick, snare, hi-hat, cymbal, etc) use notes in the bass clef, starting approximately 2 octaves below middle C. To avoid having to write things like B,,, or C,, every time you want a kick drum, voice 1 uses bass clef note names.

    Bass clef note names are 2 octaves (24 MIDI notes) lower than the equivalent treble clef note names. So, bass clef C is the same MIDI note as C,, in treble clef.

    Also, because the hi-hats and ride cymbal would otherwise need to be spelled with a flat or sharp prefix, I included the aliases h, H, and r. For quick reference, these are the notes for some common drum sounds:

    Bass Note MIDI # Sound
    C 36 Electric Bass Drum
    E 40 Electric Snare
    ^F _G h 42 Closed Hi-Hat
    _B ^A H 46 Open Hi-Hat
    _e ^d r 51 Ride Cymbal

    Priority Scheduling of MIDI Messages

    For a MIDI link that can move 1 message per 1 ms, playing a chord of 3 notes would take 3 ms to send. If the chord was meant to play on the same beat as a drum strike and a CC update, the whole group would take 5 ms to send. But, if the drum messages get sent first, the timing will sound tighter.

    Considering that low latency matters more for percussion, giving scheduling priority to messages for the percussion (usually MIDI channel 10) should help to make the most of available MIDI bandwidth.

    To allow for efficient percussion-priority sorting of MIDI events, I hardcoded the player to use the following txtseq voice to MIDI channel mapping:

    voice MIDI channel Scheduling Priority
    1 10 1
    2 11 2
    3 12 3
    4 13 4
    Bookmark
  • By CGrover
    SevenSeg: Create an Instrumentation Vibe for Displayio

    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

     

    Bookmark
    SevenSeg-12_social.jpeg
  • By jepler
    Archiving Xerox 820 8" Floppies

    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.

    Bookmark
    PXL_20240620_143224219.MP.jpg
  • By CGrover
    weather.gov: A Truly Free Weather API

    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.

    Bookmark
    Screenshot_2024-06-30_at_3.25.31 PM.png
  • By AnneBarela
    Getting Started with the Pocket 386

    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:

    AliExpress:

    Third party sites:

    Hacking:

    Resources:

    Hardware:

     

    Bookmark
    U0y1shIM.jpg
  • By SamBlenny
    CamTest: PiCowbell Camera Breakout Demo

    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

    Bookmark
    hardware.jpg
  • By SamBlenny
    Virtual Display Over Web Serial

    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:

    Bookmark
    screenshot1.jpg
  • By mrklingon
    Tricorders!

    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!

     

    Bookmark
    image0_(1).jpeg
  • By squid_jpg
    Building a "Top-Secret" lunchbox

    Recently I introduced my current project, which I've been calling the "Top-Secret Lunchbox", on Adafruit's Show and Tell stream. I wrote this playground to go into more detail about how I built it.

    I mentioned in the stream that it took me about a week to design and build the lunchbox, but that's a pretty generous estimate that does not tell the entire story. For starters, it does not include writing any code beyond basic hardware bring-up (the game code is essentially an entire other project). It also doesn't account for the fact that this is my third attempt at such a project, building on roughly three months of prior learning and experimentation. I was able to reuse many solutions from that experience, including designs for 3D-printed panel mounts for various hardware. This allowed me to make more informed choices and reduced the amount of time needed for learning and experimentation.

    The short time frame also belies that this is a fairly complex gadget for a hobbyist project. It uses most of the hardware features of the RP2040 Propmaker Feather, as well as all of the available GPIO (except for the servo output, which I did actually consider using at one point for something like a haptic motor). It required designing and printing several parts for basic assembly. It required a lot of soldering, and some "clever" solutions to some interesting challenges.

    Given the overall complexity, and the fact that I was still "winging it" on several aspects of the project, this article will describe more "how I did it" than "how you should do it". I will provide as much detail as I can about the entire process, including designing, printing, wiring, and assembly. I will also provide CircuitPython source code for a full working game! You can find a walkthrough of the game at the end of this article.

    Bookmark
    enclosure-box-sliced.jpeg
  • By CGrover
    AIO+ Weather: A Premium Alternative for Local Observations

    This is the second chapter in the "Finding an openweathermap Alternative," my latest choose-an-adventure saga exploring the weather API wilderness. The first chapter,  weather.gov: A Truly Free Weather API, looked at the completely-free NOAA NWS API Web Service as a replacement for openweathermap.org's API. The next area in our search is the weather power-up module of the premium (not-free but affordable) Adafruit IO Plus (AIO+) service and its CircuitPython interface.

     

    We all know about AIO's ability to collect and display sensor data as well as its integration with messaging and control protocols such as MQTT, IFTTT, and Zapier. But did you realize that, besides increasing throughput and feed limits, AIO+ also adds SMS and Apple WeatherKit services to the mix?

    My Workshop Corrosion Monitor project needs 12 AIO feeds; 5 for locally connected sensors and 7 for external weather observations. The monitor can reliably detect a corrosion condition in real time by using its attached sensors. To predict when future corrosion events may happen, the monitor needs to know what's going on with the weather outside of the workshop. Rather than installing dedicated external weather sensors (requiring holes in the wall and reliable weather-proofing), openweathermap.org's API was initially used to obtain the outside weather conditions and trends. The API was an excellent implementation up until they served notice that a credit card would be required for the "free" tier of the service. That's when I started looking for alternatives.

    The large number of AIO feeds for this project had already caused me to upgrade to AIO+. At the time, I didn't realize Apple WeatherKit was included in the premium service. Now I know. Replacing the openweathermap.org API service with AIO+ weather was therefore a no-new-cost alternative for the monitor project. Besides, if I'm going to be paying for a premium service, I'd rather be sending the money to Adafruit who is committed to openly describing and supporting reliable service levels, providing tutorials, and other efforts to assure product longevity.

    Bookmark
    AIO_REPL_example.png
  • Bookmark
    image.png
Search

Getting Started

Adafruit Playground is a wonderful and safe place to share your interests with Adafruit's vibrant community of makers and doers. Have a cool project you are working on? Have a bit of code that you think others will find useful? Want to show off your electronics workbench? You have come to the right place.

The goal of Adafruit Playground is to make it as simple as possible to share your work. On the Adafruit Playground users can create Notes. A note is a single-page space where you can document your topic using Adafruit's easy-to-use editor. Notes are like Guides on the Adafruit Learning System but guides are high-fidelity content curated and maintained by Adafuit. Notes are whatever you want them to be. Have fun and be kind.

Click here to learn more about Adafruit Playground and how to get started.