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 dexter_starboard
    CircuitPython and ChatGPT Code Interpreter

    Overview

    GPT Code Interpreter allows you to run your own code on a GPT server. It's great for trying out simple functions. Did you know that you can upload your own interpreter and have GPT run it? It takes some work, but you can have GPT write code and tests, then run them on an actual CircuitPython interpreter. Not all the features are there, and you don't have access to any real hardware. This is highly experimental at this point. Difficulty level: Advanced.

    Equipment

    • CircuitPython interpreter binary ports/unix x86-64. Follow the instructions for Building CircuitPython. You need to build with the same GLIBC as Code Interpreter which is currently 2.31. I was able to build it using Debian 11 (bullseye).
    • The interpreter is named 'micropython' but it is CircuitPython.
    • ChatGPT+ account: Code Interpreter is a plus feature.

    Instructions

    Follow these instructions to start a chat with access to your CircuitPython interpreter. commands should be entered directly into the chat.

    • Start a new ChatGPT 4 session.
    • Attach your CircuitPython interpreter 'micropython'. Click the 'paperclip' to upload it.
    • Use this command: Please make /mnt/data/micropython executable.
    • Use this code to check that the interpreter is working:
    import sys
print("Version:", sys.version)
print("Platform:", sys.platform)
    • Flex some Python skills: Use introspection to list the features in the <os> module

    How it Works

    The code interpreter is like a Jupyter Notebook that GPT controls. When you ask it to run some code it writes the script and executes it as a notebook 'cell'. It adds an icon that allows you to view the script and the output.

    For the CircuitPython interpreter it will embed the CircuitPython code in the cell as a string, then use the shell to execute the CircuitPython interpreter with the embedded script and capture the output. It can then interpret the output or return it to you directly.

    It's pretty code-inceptiony and may take a while to figure out. Be sure to click on the icons to view the code and output for each 'cell'.

    Observations

    I'm still in awe that it even works. You will have to use some prompting to make sure it is running the interpreter and not just calculating the responses in some other way. It can use introspection to figure out which features are available and which are not present.

    This is still very experimental at this point!

    Conclusions

    Building a CircuitPython interpreter that can run within GPT is an interesting and at times mind-bending exercise.

    Code Interpreter could be a useful tool for testing different builds or even different versions of the CircuitPython core.

    Future Work

    • Figure out how to add library packages to Code Interpreter.
    • Implement some hardware-in-software modules (fake temperature and humidity sensor, fake I2C and SPI peripherals, fake board with a few pins etc.)
    • Make the interaction traceable so we know if the interpreter is used or not.
    • Wrap it in a GPT application.
    • Figure out how to call it via the GPT API.

    Hug Reports

    Bookmark
  • By dexter_starboard
    ProtoEngineer's Guide to the Guide

    Title

    Pick your title wisely.

    Introduction

    In this section, you should aim to:

    1. Capture Interest: Start with an engaging opening sentence or question to draw readers in.
    2. Explain the Purpose: Briefly describe what your guide is about and what readers will learn.
    3. Set Expectations: Mention the target audience and the level of difficulty (beginner, intermediate, etc.).
    4. Motivate the Reader: Highlight the benefits or exciting aspects of what you’re going to cover.

    For example, if your guide is about building a specific electronic project using CircuitPython, you might start with something like this:

    "Have you ever wanted to create your own electronic gadget that can interact with the world around it? In this guide, we'll walk you through building a [specific project], a perfect blend of coding and electronics that will sharpen your skills in CircuitPython. Whether you're a beginner or have some experience, this guide will offer valuable insights and hands-on experience with real-world applications."

    Now, let's move on to the "Background" section.

    Background

    In the Background section, you should aim to:

    1. Provide Context: Offer some historical or technical background relevant to your topic.
    2. Explain Key Concepts: Introduce and briefly explain any essential concepts or terms that are necessary for understanding the guide.
    3. Establish Relevance: Explain why this topic is important or useful for the reader.

    For instance, if your guide is focused on a specific application of CircuitPython, you might include:

    • A brief overview of what CircuitPython is and its significance in the world of microcontrollers.
    • How the project or topic you’re covering fits into the larger context of electronics or coding.
    • Any specific events or developments that have made this topic particularly relevant or interesting at the current time.

    An example paragraph might be:

    "CircuitPython is a version of Python designed to run on tiny computers called microcontrollers, making it a perfect tool for creating interactive electronic projects. This guide focuses on [specific project or topic], a project that showcases how CircuitPython can bring electronics to life. With the increasing popularity of DIY electronics and the accessibility of tools like CircuitPython, understanding these concepts has never been more relevant for hobbyists and professionals alike."

    Next, we'll draft the "Equipment" section.

    Equipment

    In the Equipment section, you should aim to:

    1. List Necessary Items: Clearly enumerate all the tools, components, and materials required for your project or topic.
    2. Provide Details: Offer specific details such as model numbers, sizes, or capacities when relevant.
    3. Suggest Alternatives: If applicable, mention alternatives for some items to accommodate different availability or budget constraints.

    For example, if your guide is about a CircuitPython-based project, your list might include:

    • Specific microcontroller board (e.g., Adafruit Feather M4 Express)
    • Sensors or actuators relevant to the project (e.g., temperature sensor, LEDs)
    • Power supply (e.g., batteries, USB cable)
    • Additional tools or materials (e.g., soldering iron, breadboard, jumper wires)
    • Software requirements (e.g., latest version of CircuitPython, specific libraries)

    An example entry could be:

    "To embark on this exciting journey, you'll need an Adafruit Feather M4 Express, which serves as the brain of our project. Alongside this, you'll require a DHT22 temperature sensor, a small breadboard, and some jumper wires for connections. Don't forget a USB cable to power your board! If you don’t have a DHT22, a similar temperature sensor will suffice, though you may need to adjust the code accordingly. Ensure you have the latest version of CircuitPython installed on your board, along with the necessary libraries which we'll discuss in the Instructions section."

    Now, let's proceed to the "Instructions" section.

    Instructions

    In the Instructions section, your goal is to provide clear, step-by-step guidance for the reader to follow. Here’s how you can structure it:

    1. Sequential Steps: Break down the process into individual, numbered steps. Each step should be concise and direct.
    2. Detailed Explanation: Provide enough detail in each step so that even a beginner can follow along without confusion.
    3. Visual Aids: If possible, include images, diagrams, or screenshots to visually support the instructions.
    4. Code Snippets: For any coding involved, include code snippets and explain what each part does.

    For instance, if your guide is about a CircuitPython project:

    • Step 1: Setting Up the Microcontroller: Explain how to install CircuitPython on the microcontroller and how to prepare the development environment.
    • Step 2: Assembling the Hardware: Detail how to connect the sensors and other components to the microcontroller.
    • Step 3: Writing the Code: Guide the reader through writing the CircuitPython script. Break down the code into smaller sections and explain each part.
    • Step 4: Testing and Debugging: Provide tips on how to test the setup and debug common issues.

    An example step could be:

    *"Step 3: Writing the Code: Now, let's bring our project to life with some code. Open your code editor and create a new Python file. First, we'll import the necessary libraries: import board, import adafruit_dht. Next, initialize the sensor by adding sensor = adafruit_dht.DHT22(board.D4). This line sets up our DHT22 sensor connected to pin D4. Now, write a loop to read temperature and humidity data from the sensor and print it out. Here's a snippet to get you started: ..."

    After completing the Instructions, we will move on to the "Observations" section.

    Observations

    In the Observations section, focus on:

    1. Documenting Results: Describe what kind of results or output should be expected when following the instructions.
    2. Analyzing Behavior: Offer insights into why certain results occur, especially if they might not be intuitive.
    3. Encouraging Exploration: Suggest ways the reader might experiment or modify the project to observe different outcomes.

    For example, if your guide is about a CircuitPython sensor project:

    • Expected Results: Describe what the output of the sensor should be under normal circumstances. For instance, "Upon successfully running the script, the temperature and humidity readings from the DHT22 sensor will be displayed on your console at regular intervals."
    • Understanding the Data: Explain any interesting patterns or anomalies that might be observed in the data. For example, "You may notice that the humidity readings fluctuate more than temperature. This is typical due to environmental factors such as airflow or nearby objects."
    • Experimentation Ideas: Propose some variations they could try, like "Try placing the sensor in different environments – like near a window or in a closed cabinet – and observe how the readings change. This can help you understand the sensor's sensitivity and range."

    Next, let's proceed to the "Conclusions" section.

    Conclusions

    In the Conclusions section, your goal is to:

    1. Summarize Key Points: Briefly recap the main objectives and findings of your guide.
    2. Reflect on the Learning Experience: Share what you or a reader should have learned or gained from completing the project.
    3. Encourage Further Exploration: Suggest additional projects, further reading, or areas of exploration related to your topic.

    For instance, if your guide is about a project in CircuitPython:

    • Project Recap: Summarize the main achievements of the project, such as successfully integrating a sensor with CircuitPython and interpreting its data.
    • Learning Highlights: Reflect on the skills and knowledge gained, like understanding how to read sensor data with CircuitPython and the basics of electronic circuitry.
    • Next Steps: Suggest how this project could be a stepping stone to more complex projects, or recommend resources for deepening knowledge in specific areas, such as advanced CircuitPython programming or exploring different types of sensors.

    An example conclusion might be:

    "In completing this project, you've not only learned how to integrate a DHT22 sensor with CircuitPython but also gained practical skills in reading and interpreting sensor data. This experience lays a solid foundation for diving into more complex electronics projects. Consider exploring projects that involve multiple sensors or add data logging capabilities to your current setup. For further learning, check out [relevant resources or books on advanced CircuitPython techniques]."

    After drafting the Conclusions, we'll move on to the "Troubleshooting" section.

    Troubleshooting

    The Troubleshooting section is crucial for helping readers overcome common obstacles they might encounter. Here's how to structure it:

    1. List Common Issues: Identify frequent problems or errors that may arise during the project.
    2. Provide Solutions: Offer clear, step-by-step solutions or workarounds for each issue.
    3. Encourage Problem-Solving: Give tips on how to approach and solve unexpected problems independently.

    For a CircuitPython project, this might include:

    • Hardware Connection Issues: Describe what to check if the microcontroller is not responding or if the sensor data is not being read correctly. For example, "Ensure all wires are securely connected and the sensor is correctly wired to the specified pins on the microcontroller."
    • Software and Code Errors: Address common coding mistakes or errors, such as syntax errors or library issues. For instance, "If you encounter a 'ModuleNotFoundError', make sure you have installed all the required CircuitPython libraries."
    • Sensor-Specific Troubleshooting: Offer advice specific to the sensor or components used, like handling sensitivity or calibration issues.

    An example troubleshooting tip could be:

    "If the temperature readings seem off, first check that the sensor is not placed near heat-generating devices. Calibration might also be necessary for more accurate readings. Refer to the sensor's datasheet for specific calibration instructions."

    Finally, after completing the Troubleshooting section, we will focus on the "Credits" section.

    Credits

    In the Credits section, it's important to acknowledge and give due credit to all the resources, individuals, or communities that contributed to your guide. Here’s how you can approach it:

    1. Reference Sources: List any books, articles, online resources, or tutorials that you referred to while creating your guide.
    2. Acknowledge Contributions: If anyone assisted you with the project, whether through advice, testing, or feedback, mention their contributions.
    3. Credit Community Resources: If you used any open-source code, libraries, or drew inspiration from community projects, make sure to acknowledge these sources.

    For a CircuitPython project, this might include:

    • Referencing Adafruit Resources: If you used any Adafruit libraries or followed any Adafruit tutorials, give them credit. For example, "This project was built using Adafruit's CircuitPython libraries, particularly for the DHT22 sensor."
    • Acknowledging Individual Contributors: If fellow hobbyists, friends, or online community members provided help or inspiration, mention them by their preferred names or usernames.
    • Open Source Acknowledgments: If your project includes open-source code that isn't your own, cite the original authors and provide links to the source.

    An example of a credit entry might be:

    "Special thanks to the Adafruit community for the extensive resources and tutorials, which were invaluable for this project. I’d also like to acknowledge [Username] from the CircuitPython forum for their insightful suggestions on optimizing sensor readings. This guide also utilizes open-source code from [Source], originally authored by [Author's Name]."

    With the completion of the Credits section, your guide is now fully fleshed out! You can now review it, make any necessary edits or additions, and then prepare it for publishing on Adafruit Playground. Remember to keep the language clear and engaging to ensure it's accessible to a wide range of readers.

     

    Credits (for real)

    Dexter created the outline for this note.

    ProtoEngineer, a GPT application, wrote this note.

    Chat about this note, or the Adafruit Playground in general, on the #show-and-tell channel of the Adafruit Community Discord. Visit https://adafru.it to join!

    Bookmark
  • By squid_jpg
    Guide: Build a WiFi Matrix Keypad Remote

    Circuit Diagram

    The diagram below provides a general visual reference for wiring of the components once you get to the Assembly page. This diagram was created using the software package Fritzing. Note that we will be using all available GPIO pads on the QT Py, so there will be a good bit of soldering involved.

    Overview

    Modern electronics are capable of incredible things. Even the simplest gadgets now have clocks, gyroscopes, radios, GPS, touch screens, literally anything you can imagine, built right in. Sometimes though, the devices that are capable of doing several things don't do all of them particularly well. Touch screens are often bolted onto things that really don't benefit from them, or even worse, detract from the experience. Anyone who has accidentally grazed the touch panel on an Apple TV remote while grasping for it in the dark knows exactly what I'm talking about. Sometimes I just want to have a remote with a few simple buttons I can press to make things happen, and that's it!

    Most of the lights in my apartment are WiFi-connected, and offer MQTT capability. I took advantage of this and set up a local MQTT broker (https://mosquitto.org/) on a Raspberry Pi 4 wired to an old Apple Airport router/hub I had lying around (my internet provider makes me use their router for my internet). Now, it's easier than ever to control my lights...from a browser. Or some phone interface. Or an app. Wait a second...each of those still requires multiple steps just to get me to the point where I can actually control anything. And I probably still have to use a touch screen. Leading me back to my original point, and thus the motivation for the imaginatively named:

    WiFi Matrix Keypad Remote

    I've been a DIY remote control enthusiast for almost as long as I've been hacking around with microcontrollers (at least a few years now). One thing that I've found really hard to source as a hobbyist is good, pre-made button panels intended to be mounted into a small space, such as a remote control. So far, one of my favorite sources for a dense panel of decent quality, inexpensive buttons are these old-school 3x4 matrix keypads:

    Bookmark
    common-parts-sliced.png
  • By delchi
    CB Microphone for your PC - Breaker Breaker any takers?

    Part one : Where's the mic? 

    "Breaker breaker , any takers? This is the the one and only Delchi hunting for bear on I-95 South , keeping that double nickel and keeping the sunny side up & the greasy side down! We gone!" 1

    I was looking for some new gaming frontiers when I came across truck simulators! All the skill & thrill of a big rig from your PC. As with all simulators there are button boxes and realistic cockpits to buy, but one thing I didn't see was a CB radio mic! They expect us to use desktop mics, headsets or some other hoo-haw instead of the ol jabberjaw microphone! A little deeper digging showed that you can buy adapters, but they ranged from $180 to $300! ( Granted the $300 one is an awesome button box and has a lot of realistic controls along with the mCB mic.) 

    Well the first thing I did was say "Belgium" to that, and pulled Rolling Thunder across the room to my workbench and got to work. This was going to be a project that would work with Truck simulators, sub simulators and more! Grab that soldering iron, the wire clippers and that drill over there! It's time to start making! 

     

    Notes : 

    1. CB radio jargon was around long before IRC , and was its own language designed to obfuscate communication and have a grand ol time. "Handles" were common, and yes CB radio handles are where the hacking community got the term handles for hacker aliases! 

    Translation? Why not ? 

    • "Breaker breaker , any takers?"
      • In cb radio ( less formal than ham radio ) it was common to ask permission before talking on an open channel. Calling for a "break" was like requesting permission to chime in , and was normally answered with "Go ahead breaker"
    • "This is the the one and only Delchi"
      • Handles were a point of pride and very often unique, but when they did collide they politely adjusted to be like "The New Orleans Joker " vs "The Chicago Joker" and so on.
    • "hunting for bear on I-95 South"
      • Truckers took great lengths to avoid being caught by the police in speed traps. "Smokey Bear" referred to the Smokey The Bear hat most often worn by police patrolling the interstates. If you were hunting for bear that meant you were on the lookout for police, and sometimes were asking for a "Smokey report" if anyone had seen any police.  You usually followed this with the interstate you were on and the direction you were traveling and sometimes the mile marker you had passed most recently.
    • "keeping that double nickel"
      • This referred to the speed limit of 55 miles per hour that was enforced back then. Sadly there is no clever phrase for the 65 mph speed limit.
    • "keeping the sunny side up & the greasy side down!"
      • Multiple meanings here, but for the most part this meant keeping your truck upright ( sunny side was the cabin, greasy side was the road ). It was like wishing someone safe travels and no accidents. 
    • "We gone!"
      • When a conversation ended people would signal this with a number of phrases like "we gone" , or "On the side". Sometimes it also included the "10-code" messages such as "10-10 Till I see you again"

    Related Links : 

     

    Part Two : Requirements

    So then at the workbench with graph paper and pencil in hand ( or Lucidchart if you will ) let's determine what we need to make this CB mic project roll down the road : 

    • Utilizing a CB Microphone
      • Be able to attach the microphone to the computer
      • Be able to use the button on the microphone to activate the  PTT ( Push to talk ) feature on the computer / in game
      • Make it look realistic! 
      • Make it as clean as possible ( minimum number of wires / software / configuration )

     

    Bookmark
    pinout.jpg
  • By trevorflowers
    Retro blinkenlights: driving 4 charlieplex LED matrices

    I recently released another retrocomputer miniature that incorporates a handful of Adafruit boards so I thought that I'd share the details here.

    The original Connection Machines were built in the late 80s and early 90s to provide a few thousand hyper-connected processors which at the time was rather unique. If you're interested, here's a wikipedia page about them.

    My Patreon supporters vote for which miniatures I make and I was pretty happy when the Connection Machine was chosen. I was also happy to find that Adafruit sells pretty much exactly what I needed to make the blinking light panels:

    Assembly requires me to solder the four matrix driver boards to the four LED matrix boards and then plugging in the Stemma QT cables between the QT Py and a chain of the driver boards.

    Then I assemble these printed parts. The little C shaped parts on the lower left of this photo are what hold the two-board sandwich of the LED maxtrix board and the driver board.

    Then I install CircuitPython on the QT Py and then load it with my code from Codeberg. There you'll find the default blinkenlights script but also a script that uses the network to fetch the time and then turn the Connection Machine into a clock. It took a bit of work to figure it all out so hopefully the code will be a handy starting point for similar projects.

    Once everything is assembled I box it up and put it on my gumroad store.

    I post pretty much every day about what I'm working on over on Mastodon at @[email protected] and for maker-y types of conversations I like that place much more than the other social media sites. Maybe I'll see you there!

    Bookmark
    connection-machine-quarter-view-levels-1.jpg
  • By tyeth
    When Black and White QRCodes don't work: Qualia Touch Example Dual QRCodes for Wifi + WebWorkflow
    • Logs onto network if present, showing QRcode for the Wifi Access point for easy joining and remote configuration, also displays SSID. 

      Next to that is the Web Workflow QRcode, built from the IP address of the device and web workflow port if specified.

     

    • If the user hasn't configured SSID or fails to get an IP in 5seconds, then the help page QRcode is displayed along with a touch sensitive Circuitpython logo.

     

    • There is code to adapt the returned touch events to be rotated (the BAR 320x820 display is vertically orientated so coordinates of touch events need adjusting).

      The touch code cycles through the tilegrid and group objects looking for a callback on a tilegrid to trigger if the x + y (plus tile_width and tile_height) match the touch point.

      It works for the bitmap, but not the qrcode tilegrids, nor labels.

    Feature List:

    Bookmark
    IMG_20231119_001742_326_(Custom).jpg
  • By wiz0
    Hello Pi: Finding the IP Address of Headless Raspberry Pis (and Other Devices)

    The Problem:

    A frequent problem I have when creating a new Raspberry Pi-based project is determining the IP address of the device.  I am often working with Pi projects in a "headless" (no monitor) configuration using SSH to log in from a PC on the same LAN network.  But to log in this way, I need the Pi's IP address, which sets up a chicken-and-egg problem that goes like this:

    I want to connect (SSH) to a headless Raspberry Pi, but before I can do so, I first need to attach a monitor and keyboard to it to login locally and get its IP address (with 'ifconfig'). 

    This is the very thing I would like to avoid since the system will ultimately be "headless".  In truth, while it is only a minor inconvenience, it is one I'd like to do without.  The more new RPi systems that you set up, the more tedious it is to pull out a monitor and keyboard to find the IP address of each one before you can begin remotely connecting to it over the LAN using SSH.

    My Solution:

    I would like to be able to find the IP address of a headless RPi without having to connect a monitor and keyboard to it.  Ideally, I would be able to connect my new RPi to my network, and know the IP address that is it assigned.  Then, I could simply connect directly to it using SSH from my PC on the same network.

    As is the case for many others, my minor annoyance at "the problem" turned into a full-blown project to solve it.  I created a program I called Hello Pi that can be run on a Linux or Windows computer to identify the IP address of a Pi (or other device) connected to the same network segment.

    Bookmark
    IMG_2984.jpeg
  • By dexter_starboard
    Sound for Qualia RGB666

    I heard that you can do I2S audio with the Qualia RGB666 board, but I didn't find any instructions. Well, now you won't have the same problem. Let's get this thing beeping! This is a Dexter Starboard project, with assistance from ProtoEngineer

    Description

    This project explores the implementation of digital audio output using the MAX98357 I2S Class-D Mono Amplifier in conjunction with the Qualia ESP32-S3 RGB666 board. The goal is to produce a sine wave tone through a speaker connected to the amplifier.

    Equipment

    1. Qualia ESP32-S3 RGB666 board - A versatile microcontroller board based on the ESP32-S3 chip, ideal for projects requiring WiFi and Bluetooth connectivity along with powerful processing capabilities.
    2. MAX98357 I2S Class-D Mono Amplifier Breakout - An easy-to-use digital amplifier perfect for adding high-quality sound to your projects.
    3. Speakers compatible with the amplifier.
    4. Connecting wires. I used 6" female jumper wires.
    5. Header pins for the Qualia board and the MAX98357 breakout. Go ahead and attach the headers now.
    6. Personal computer with CircuitPython installed.

    ::closeup of the Qualia board showing pins::
    ::closeup of the MAX89357 showing pins::

    Bookmark
  • By Gamblor21
    CircuitPython Animated GIFs on a Matrix Portal

    Playing animated GIFs was added to CircuitPython in early 2023 and I had successfully had them running on TFT displays and even to a monitor via HDMI. I recently setup my MatrixPortal and two 64x32 matrices that I had been using to show animated GIFs. But the MatrixPortal was running Arduino code.

    Time for an update and to take the code from Using Animated GIF Files in CircuitPython and Creating Projects with-the CircuitPython MatrixPortal Library and smush them together to play animated GIFs on a MatrixPortal with CircuitPython. Both guides do a great job of explaining the details of their own area and the code here combines them both.

    The first half of the code sets up the matrix on DisplayIO and the second half uses OnDiskGif from the gifio module to display the animated GIF.

    The code displays all GIFs found in the /gifs/ directory on the MatrixPortal. Each animated GIF will display for 30 seconds before moving to the next animation.

    One major difference from the Animated GIF guide: for speed, the code in the guide sends the raw bitmap data directly to an attached display. In theory that is possible to do on the MatrixPortal but it is more complicated and likely would be slower then using DisplayIO. This is because the matrices have fewer pixels then most screens and the speed of the protomatter library that powers the matrix display.

    Bookmark
  • By CGrover
    Symbols for synthio Objects

    In the process of learning to use CircuitPython synthio, it was a challenge to understand the myriad of possible connections between modules. As a result, project design notes and sketches became a rat's nest of entangled symbols and wiring. Although simple single-voice designs without filters or LFOs were easy to deploy and document, it became clear that there was more to discover inside the extensive versatility of synthio.

    Perhaps a set of symbols with consistent notation (and color-coded arrows, of course) would be useful to further learn about synthio and to develop project conceptual diagrams.

    Here's the beginning of some symbols for synthio objects with class properties and methods together with data types. Essential tools such as audiomixer and audiobusio are also included.

    Attribution: Patch Symbols from PATCH & TWEAK by Kim Bjørn and Chris Meyer, published by Bjooks, are licensed under Creative Commons CC BY-ND 4.0. Some Patch Symbols were modified to create the synthio symbols BlockInput, MixerVoice, Note, Synthesizer, sample, and voice.

    Bookmark
    synthio_object_descriptions.001.png
  • By BlitzCityDIY
    Using Android with CircuitPython

    Recently there was a PR merged into CircuitPython that allows for the mounting of a CIRCUITPY drive on an Android device. Previously this was not possible, so I wanted to try it out. For my testing, I used a Samsung Galaxy A13 phone running Android version 13. The board I used was a Circuit Playground Express running CircuitPython 9.0.0-alpha.4.

    The REPL

    I asked our resident Android expert FoamyGuy for some advice on where to start to access the REPL. He suggested the Serial USB Terminal app (Google Play Store). The key feature for CircuitPython that this app has is the ability to create macros. With macros, you can setup CTRL+C and CTRL+D shortcuts that otherwise are impossible to do with the default Android keyboard.

    To create the macros, you'll long press on the macro button. Select HEX as the edit mode and value 03 for CTRL+C. On a second macro, follow the same procedure and value 04 for CTRL+D.

    Bookmark
    driveView.jpg
  • By squid_jpg
    Extending the Talking HAL-9000, literally and figuratively

    3D files and (lack of) code

    You can find the 3D files for the modified HAL parts, as well as the case for the QT Py on Printables. The wiring is pretty basic; in addition to the wiring from the learn guide, I wired one of the RP2040 Feather's UARTs to the headphone (TX, RX, GND) jack, and the other to a 4-pin JST connector (5V, GND, TX, RX) with a few inches of wire. A corresponding JST connector is soldered on to the QT Py, with the 5V and GND wires connected to the battery power pads on the bottom of the board, and the TX/RX wires connected to the corresponding RX/TX pins.

    I did not post any code for this as it is highly specific to my situation, however, to be honest, none of the code is particularly special. I used the CircuitPython MQTT learn guide to figure out how to get connected to my local MQTT network, and the CircuitPython essentials guide to work out how to use the UART (for communication) and PWM (for animating the LED).

    Overview

    I love this make of HAL-9000 from the Ruiz Bros:

    Bookmark
    hal-9000-w.jpeg
  • By DJDevon3
    ESP32-S3 MQTT Feather Weather

    This has been my main project since 2019 which started on the Adafruit Bluefruit Sense microcontroller with Arduino. I eventually ported it to Circuit Python... and I've never used Arduino since. There are many different versions of this project on my github that are either offline only, offline with GPS, offline & online, offline & online with MQTT. 

    The project I'm detailing today is offline & online with MQTT to AdafruitIO.  This means if for whatever reason your WiFi goes down, OpenWeatherMap.org servers go down, or AdafruitIO goes down it will still display local sensor data and function in an offline capacity waiting patiently until communication is restored. 

    The display sits in front of my PC monitor and has been running 24/7 for about 3 years now. I've had a lot of time to debug all of the things that might cause it to crash, error, and gracefully fail in a never ending loop.  It's not perfect but it's solidly coded. 

     

    This is the Feather Weather GUI.  It incorporates API data from OpenWeatherMap.org (labels in blue) and real-time sensor data from an Adafruit BME280 module (labels in orange).  It then collates the data from the BME280 sensor and whisks it away to my AdafruitIO dashboard using MQTT.

    It has some additional features like showing the battery voltage and severe weather warnings.  This project was designed as a battery powered weather station during hurricanes and storm related power outages.

    Skill Level: Advanced: 600 lines of code

    • This is not a beginner friendly project. This one is targeted at advanced Circuit Python users that have experience with JSON parsing, MQTT broker, and GUI design. There are potentially a lot of errors that might crop up during the course of this project that could get you stuck without prior experience. Help is always available in the Adafruit Discord if you want to tackle this project anyway.
    • If this project seems too daunting and you'd like to try an easier version aimed more at beginners (because i was a beginner when I wrote it) then check out my Offline Feather Weather. It's only 200 lines of code.

    Requirements:

    • TFT display of your choosing (I'm using a 3.5" TFT Featherwing)
    • OpenWeatherMap.org (free) account & API token
    • AdafruitIO (free) account & API token (key)

    Optional:

    • Temperature/Pressure/Humidity Sensor (BME280)
    • Display with built-in SDCard or SDCard module used for screenshots of your GUI.
    • Adafruit LiPo battery (I'm using a 10,000 mah)
    Bookmark
    screenshot.jpg
  • By BlitzCityDIY
    Accurately Calculating Coordinated Mars Time with CircuitPython

    I'm currently working on a clock using a Qualia S3 board with a 4" 720x720 round display. The idea is to display an "analog" clock face on it. The clock will show your timezone on Earth and coordinated Mars time (MTC). In looking into MTC, I found the Mars24 Sunclock, which is a piece of desktop software from NASA that shows your local time, UTC time and then MTC.

    The algorithm for calculating MTC was published by NASA researcher Michael Allison in 1997 and then updated in 2000 by Michael Allison and Megan McEwen. It is nicely summarized on the Timekeeping on Mars Wikipedia page:

    The Mars Sol Date (MSD) can be computed from the Julian date referred to Terrestrial Time (TT), as[46]

    MSD = (JDTT − 2405522.0028779) / 1.0274912517

    ...This leads to the following formula giving MSD from the UTC-referred Julian date:

    MSD = (JDUTC + (TAI−UTC)/86400 − 2405522.0025054) / 1.0274912517

    where the difference TAI−UTC is in seconds. JDUTC can in turn be computed from any epoch-based time stamp, by adding the Julian date of the epoch to the time stamp in days. For example, if t is a Unix timestamp in seconds, then

    JDUTC = t / 86400 + 2440587.5

    It follows, by a simple substitution:

    MSD = (t + (TAI−UTC)) / 88775.244147 + 34127.2954262

    MTC is the fractional part of MSD, in hours, minutes and seconds:[3]

    MTC = (MSD mod 1) × 24 h

    I wish I could tell you that I can read through that and understand it and as a result write a block of Python code that performs that calculation without a lot of trial and error. Unfortunately, I really struggle with math so I turned to ChatGPT-4. I was incredibly reticent about using ChatGPT or any other LLM but I have to say that I've found ChatGPT-4 to be a very helpful tool when writing code that saves a lot of time for tasks like this. I entered that algorithm into ChatGPT-4 and asked it to convert it to CPython and it popped out a script that worked perfectly when compared to the Mars24 clock. You can see my full chat log here.

    Bookmark
    mars24.PNG
  • By tcooper
    Ultimate Omnifixo Pinecil Travel Case

    After watching this Tested video on YouTube showing of the Omnifixo helping hands, I decided to pick one up. I have found it incredibly useful when soldering small electronics. After a bit of use I decided to 3d print the case recommended in the video, but wasn't happy with it. I looked around for other designs, and found some better options, but still not exactly what I was looking for. So, decided to design my own.

    With the included Pinecil soldering iron, solder, and brass sponge, this design carries everything I need to solder on-the-go.

    This version will require 4x 10mm ball bearings. These ball bearings are the same diameter as the balls at the end of the Omnifixo clamps. So I embed the ball bearings into the printed case and the Omnifixo magnet mounts snap to these bearings nicely to hold everything together. No other magnets are required.

    The metal tin I used for the brass sponge is a ½ oz round tin I purchased off of Amazon.com here. It is a 4cm round tin, and I cut off a bit of brass sponge to fit inside. Also, this is the solder that fits perfectly in the case, but you could just bundle up any solder and throw it in that slot.

    I printed this with a .4mm nozzle at .2 layer height using carbon fiber PLA (though PETG is probably a better choice). You can print the entire thing then using some force push the ball bearings into the print in the corners. They should kind of snap into place.

    Note: if you stick the yellow Omnifixo magnets to the embedded ball bearings with the flat side they will stay stuck to the Omnifixo base plate when it is removed.

    Bookmark
    Case_Opened.jpg
To have your work shown off click the Show and Tell toggle when viewing your note.
224 notes and counting
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.