Reviving My Netduino 2 (without the .Net MF) The Netduino series of boards have been around for several decades and saw a limited level of success for the first decade or so. However, as a development ecosystem they haven't stood the test of time. The original development toolchain has gone into abandonment and been archived. But as a hardware platform, they are a still great boards, especially the Netduino 2 and later, with fully supported mainstream processors. You might not be able to use .Net or C#, but with toolsets from Arduino and STMicroelectronics you can still create amazing things with these easy-to-use Arduino compatible boards. Don't throw them away! The notes below describe how I rediscovered their usefulness, albeit with a different set of tools. Some History I've had two Netduino 2's sitting in my electronics box for years, more years than I'm willing to admit. During that time, I'd done very little with them. When I originally bought them, Visual Studio was my daily development environment, and I knew my way around it quite well. I'd tinkered for a bit with an Arduino, but I was eager to use .Net and Visual Studio on this new device. I did build a few things with them, but frankly they didn't grab my interest and at the time, the much more powerful Raspberry Pi was drawing my attention away. So, these boards were relegated to the back of my toolbox. They seemed to be pretty content there, and I kept them cool and dry, so we were all happy for the time being.

Reviving My Netduino 2 (without the .Net MF)

AIO-Connected Workshop Thermal Camera An Adafruit IO - connected, CircuitPython remote thermal camera. Project Objective To observe thermal conditions out in my remote laboratory (i.e., the workshop bench in the detached garage), I previously installed an Adafruit IO (AIO) connected corrosion monitoring system that watches conditions inside and outside of the garage. The corrosion monitor consists of an interior temperature/humidity sensor and, thanks to AIO Plus, correlates with exterior weather conditions. However, from the temperature/humidity sensor's perspective, if a door or window is left open it takes far too long to detect the issue. It would be ideal to be able to "see" if a relatively small area inside the workshop has experienced a temperature change relative to the bulk of the air in the space. An added benefit would be to detect human motion in the workshop area or to discover if the soldering iron was accidentally left on. Requirements Periodically capture and upload a thermal image of a critical portion of the workshop. Monitor for temperature extremes and upload an image when exceeded. Detect human motion and upload an image. Provide a local color display with automatic brightness control. Continuously update the local display image at least twice a second to quickly detect motion and respond to thermal events. Upload the captured thermal image on a remotely accessible AIO dashboard page via the local WiFi network. Upload bitmap image payload to AIO in less than 10 seconds. Power from a USB 5-volt wall wart. Future and Nice-to-Have Blank the screen when motion has not been detected for a preset amount of time (screen saver). SD Card storage of images and temperature statistics with historical view UI. Trigger AIO notification events related to motion or alarm settings. Upload minimum, average, maximum temperature values with image; display on dashboard. Interface to Apple HomeKit. Capture local audio. Live MEMENTO photo overlay. To speed up prototyping and algorithm development, CircuitPython was the choice for the software side of things. Besides, the code needed for creating images with a thermal camera and for reliable communication with AIO already exists in other projects that I've recently developed.

AIO-Connected Workshop Thermal Camera

GPS Tracker Coding in CircuitPython - Going Down the AI Rabbit Hole The Idea I've lately been dabbling with AI coding assistance and have been impressed with what it can do. So, I thought I'd do a whole project from scratch using several boards I have been meaning to do something with. I thought I'd also take you all on the journey and maybe you will find this useful. I will use this Playground article to document the process. I will go through the components and assembly, list the prompts I used with the AI tool to build the code, and share what value this new tool gives me.  The Build The project is a GPS tracker. In a nutshell a GPS module, an OLED display and an AdaLogger board. Here are the components I used: Design Choices I chose these components for simplicity. Choosing an AdaLogger for the microprocessor gives me an SD card to log the output and gives me one Neopixel, a separate LED I can use as an indicator and an extra input button with board.BUTTON. The OLED display, although small (128x32), can convey a lot of information if done well, plus it gives me three input buttons for controls. The GPS board just works well with little effort.   Assembly Since the Feather ecosystem is perfectly modular, assembly was simple: Solder headers on to the microprocessor, GPS FeatherWing and the OLED FeatherWing Solder the sockets on to the Feather Tripler Prepare the AdaLogger by inserting a formatted SD card and attach the LiPo battery to the connector.  Insert a coin cell into the GPS module Plug the three boards into the Tripler - I used a couple of rubber bands and a small piece of foam on the bottom to hold it all together That's all there is to it! With that - we are (almost) ready to code.

GPS Tracker Coding in CircuitPython - Going Down the AI Rabbit Hole

Sword of Shannara on Microbit I enjoy programming little projects on the Microbit and CircuitPlayground because I find it easy to work on them "on the go"! This project meant I was able to start working on a computer, then continue the initial Makecode work using the iOS Makecode app - saving work to Github when switching from PC to phone and back. It came about because I recently was reading through the Shannara stories, and that lead me to come up with some Microbit programs for this simple "Sword of Shannara" game in python and Makecode. This is a vastly (!) simplified version of the classic fantasy "The Sword of Shannara." Github Repository Here Screen above shows "you," representing the hero, Shea Ohmsford, who is searching for the Sword of Shannara. You move left/right through a scrolling landscape (100 cells wide) displayed on the 5x5 LED micro:bit screen. Overhead are dots that represent the "Skull Bearers" (think Tolkien's Nazgul). If you delay when one is overhead, it will attack and you can lose one of your five lives. So either move past quickly, or hit A+B to unleash the Elfstones to eliminate the Skull Bearer. Faint dots along the bottom of the "screen" represent landscape and serve to show your movement left/right. Somewhere in the middle of the 100-element landscape is the "Sword" represented by three lit pixels.

Sword of Shannara on Microbit

Countdown Complete: It's finally here! 🎉 Upgraded Actions on IO - How to do Math(ematics) Blockly has been slowly worming it's way into Adafruit IO, with a first edition replicating the old Action forms. Now the latest release brings the wealth of features we've been dreaming of, allowing great complexity! Will you be the first to bring down the house of cards/servers? Let us know in the forums if you do (or run into other issues)! Let's start off with something simple, how to subtract one from a feed value (as a countdown)... We'll explore a quick yet complex multi-action example, changing LED colour based on air quality, and additionally a Utility Light mode using the onboard button to request 30seconds of Bright White Light (useful in a kitchen). Setup a Wippersnapper device Adafruit IO has a devices page, which shows the special "Wippersnapper" devices, these run the arduino firmware that allows wifi connected boards to easily connect and configure components (inputs/outputs/sensors) with no code. Each component then has associated feeds for interacting with, so using the on board button becomes child's play. Install wippersnapper, you're best off finding the learn guide for your board and then locate the Wippersnapper pages. Alternatively there is a quick start guide, or just do the usual hacky thing and have a go with no prior knowledge... Visit this link (https://io.adafruit.com/devices/new) when signed in to be taken to the New Device setup page, then select your board and follow the onscreen instructions. (You need an IO page open when the board first connects to accept the registration request).

Countdown Complete: It's finally here! 🎉 Upgraded Actions on IO - How to do Math(ematics)

The Many Possibilities of Adafruit IO Actions and an Arcade Button Overview As we get closer to launching the new Adafruit IO Actions, it has been fun thinking of the many fun ways it can be used. Here is a really simple project that has a ton of potential without writing a single line of code. With this project, I simply added a NeoPixel to a simple arcade button (using the below Learn guide), and then use that LED and button to communicate information in different ways. The more I play around with this project, the more ideas I come up with. So be sure to check back here often as I will post more ideas as I come up with them. Parts Used I used the NeoPixel Mini Button as shown in the guide above, but used the QT Py ESP32-S3 board with the NeoPixel BFF to drive the NeoPixel, then just soldered one side of the button to 3V on the QT Py, and the other side of the button to A2. You could also simply skip modifying the arcade button, and just use the built in NeoPixel on the QT Py. You could even just use the built in pushbutton on the QT Py and skip the Arcade Button all together. This guide isn't so much about the specific project, as it is about the possibilities of the new Adafruit IO Actions. You can set this up with any NeoPixel and button. With that in mind, here are the products I used:

The Many Possibilities of Adafruit IO Actions and an Arcade Button

Adafruit Memento Time-lapse w/ online upload & email notification Adafruit Memento Time-lapse Camera with Online Upload and Email Notification This guide shows how to turn your Adafruit Memento (ESP32-S3) board into a time-lapse camera that: - Captures images on a schedule or with a button press - Uploads them to Adafruit IO over Wi-Fi - Triggers email notifications using a feed - All using CircuitPython and the PyCamera library! What You Need - Adafruit Memento Board: https://www.adafruit.com/product/5843 - microSD card (optional, for GIF recording) - USB-C cable - Wi-Fi network - Adafruit IO account: https://io.adafruit.com - CircuitPython is installed on the Memento Setup 1. Installing CircuitPython To install CircuitPython on the Adafruit Memento, I followed this official guide by Anne Barela and John Park: 🔗 [Memento Camera Quick Start Guide – Install CircuitPython](https://learn.adafruit.com/memento-camera-quick-start-guide/install-circuitpython) That page walks you through how to: - Put the board into bootloader mode (double-tap reset) - Drag the `.uf2` file onto the board - Verify that the **CIRCUITPY** drive appears Make sure you use **CircuitPython 9.0.0 or later** to avoid filesystem corruption issues. 2. Install Libraries - adafruit_io  - adafruit_requests.mpy   - adafruit_ntp.mpy - adafruit_logging.mpy  - adafruit_pycamera   - adafruit_ov5640   - adafruit_connection_manager.mpy   - gifio.mpy   - bitmaptools.mpy   - ulab (folder) 3. Create settings.toml file on CIRCUITPY with this: CIRCUITPY_WIFI_SSID = "YourNetworkName" CIRCUITPY_WIFI_PASSWORD = "YourNetworkPassword" ADAFRUIT_AIO_USERNAME = "your_username" ADAFRUIT_AIO_KEY = "your_aio_key" 4. Main Code Paste the following into code.py on your CIRCUITPY drive: What I did - I used the fancy camera CircuitPython code by Anne Barela and John Park, and the Doorbell Camera code by Brent Rubell to help create the code above.  - My main focus was to get photos uploaded to Adafruit IO with the timelapse and camera shutter options. How It Works - The camera connects to Wi-Fi and Adafruit IO - Takes snapshots using the shutter button or on a time-lapse interval - Encodes image data as base64 and uploads to Adafruit IO feed - Sends a "trigger" signal to another feed to notify you via email 5. Set up Feeds on Adafruit IO - Go to io.adafruit.com - Click on the tab 'IO' - Go to Feeds and create two. I set up a 'camera' feed and a 'camera-trigger' feed. - The "camera" feed will take photo uploads, and the "camera-trigger" feed gets a 1 or 0; this is used to trigger an automated email action.

Adafruit Memento Time-lapse w/ online upload & email notification

🎵️ Media hub 2.0: Media control w/opt Bluetooth Overview Physical controls for a more enjoyable media playback experience. Features Responsive volume knob & mute button. Transport controls (play/pause, stop, FF/REW, skip tracks). Pair up with your favourite Bluetooth® speakers. Quick, physical connection (don't have to go through menu system to pair with keypad & speakers). Customizable controls/scheme. This project tries to improve over the original "Media hub" presented here. More compact design Bigger volume knob - not interfering with macropad keys. 🛒️List of main material/hardware (See section "More tools/materials/hardware" near the end of this note for extras)

🎵️ Media hub 2.0: Media control w/opt Bluetooth

Zephyr Quest: IoT Toggle Switch for Feather TFT Overview This guide shows how to make an IoT toggle switch with an Adafruit Feather TFT ESP32-S3, Zephyr, and Adafruit IO. Key features include: GPIO input for Boot button, LVGL graphics, MQTT over WiFi with TLSv1.2, and USB serial shell commands for saving WiFi and MQTT configuration settings to NVM flash. This guide is intended for people who want to learn how to write applications in C using Zephyr APIs. Demo video: IoT toggle switch: Zephyr + Feather TFT + Adafruit IO

Zephyr Quest: IoT Toggle Switch for Feather TFT

No-Code Easy Ambient Smart Lights Overview With all the newest features of Adafruit IO, WipperSnapper firmware, and the new Blockly Actions, you can create really complex projects without writing a single line of code. I've been working on a couple versions of smart lights to notify me of different things using NeoPixels. This project will focus on a super easy smart ambient lighting system that you can stick to the back of your computer monitor. Components Using just a few Adafruit components is all you need to create a really simple, but pretty powerful little notification system. We are gonna use a QT Py ESP32-S2 WiFi Dev Board to talk to Adafruit IO, a NeoPixel BFF for the QT Py, and finally a short NeoPixel strip with a JST connector pre-attached (so you can connect right up to the BFF board. The only soldering you will need to do is to attach the boards together. You can solder the boards together with the included pins, or pick up some female headers so you can detach the boards and use them on any future projects.

No-Code Easy Ambient Smart Lights

A Node Based CAD Add-in for Fusion 360 Gradient is a node-based editor designed for use with Autodesk Fusion 360.  I started working on Gradient after playing with the node based geometry in Blender. The nodes in Blender are fantastic (frankly they work much better than mine do right now) but I wanted  to create algorithmically defined geometry right in Fusion 360 using solids and surfaces which are better suited to making 3D models for technical and engineering parts. I wanted to be able to make algorithemic structures that are user defined but and can be finely controlled and tuned to the design needs. Models like this would be very time consuming to model by hand. However they can be quickly generated and re-generated with different parameters or random seeds. If you are interested in trying Gradient for yourself you can download it from the github repository below. Please be aware currently Gradient is in an early development stage, meaning only a small fraction of its functionality has been implemented, and there are likely a few bugs to sort through. Gradient github

A Node Based CAD Add-in for Fusion 360

Zephyr Quest: ST7789 Display with Feather RP2350 Overview As part of a series on Zephyr with Adafruit hardware, this guide shows how to configure Zephyr to use an ST7789 TFT display with a Feather RP2350. By connecting the display with a breadboard, we can use a logic analyzer to verify that the Zephyr display driver pin configuration agrees with the CircuitPython display driver. This guide is meant for people interested in adding support for Adafruit displays to Zephyr.

Zephyr Quest: ST7789 Display with Feather RP2350

Zephyr Quest: SWD Pogo Adapter for CLUE Overview

Zephyr Quest: SWD Pogo Adapter for CLUE

Media hub: Media control w/opt Bluetooth Overview Direct physical control for a more enjoyable media playback experience. Features Responsive volume knob & mute button. Transport controls (play/pause, stop, FF/REW, skip tracks). Pair up with your favourite Bluetooth® speakers. Quick, physical connection (don't have to go through menu system to pair with keypad & speakers). Customizable controls/scheme. Customizable setup: Optionally connect USB hub/dock for added features, for example: mirror phone to TV w/HDMI out: Watch videos on a bigger screen add keyboard: Better typing experience for texts/emails. Solderless project. Main hardware

Media hub: Media control w/opt Bluetooth

Zephyr Quest: Feather RP2350 Board Def Overview

Zephyr Quest: Feather RP2350 Board Def

Weather Display Using Open-Meteo's API Overview This desktop local weather monitor is the next in the continuing quest to update John Park's original openweathermap-based PyPortal weather station project with a free weather information service that doesn't need a credit card paywall account. Thanks to some investigative work done by @DJDevon3, this latest version uses the free non-commercial Open-Meteo (OM) API service. Bonus: No account or key is required to access the API if used for non-commercial projects.

Weather Display Using Open-Meteo's API

Guide: Build a 'MiniMarquee' WiFi Text Scroller In the last few years that I've been hacking on microelectronics, one of my favorite types of project has been the humble text scroller. While these devices are usually simple to build, I've found that the process of actually getting the text onto the devices can be anything but simple! Often, it requires the user perform one or more of the following: Connecting the device to a computer and editing/compiling/reinstalling firmware source code Connecting the device to your main Wi-Fi network Using an custom-built application on your phone, or something like Adafruit's Bluefruit Connect Making an account with some sort of IoT service (such as Adafruit IO) and/or use an MQTT server Opening the browser and typing a strange URL in the address bar (such as an IP address) That's a lot of work just to get some text to scroll across a screen! Especially if the text scrolling gadget is intended as a gift for a friend or family member who may not be tech savvy. It's no fun giving a gift to someone who can't figure out how to use it!

Guide: Build a 'MiniMarquee' WiFi Text Scroller

Digital Clock with WiFi and Weather (Huzzah & 128x64OLED) I had an Adafruit Huzzah and an OLED FeatherWing 128 x 64 in my box of goodies and decided to make a smart digital clock for my study. The clock is connected to internet via WiFi, synchronises the time and via an api displays the temperature in my area. It is set to update every 5 minutes. Also displays an icon of the current weather.  These are parsed from the api response: {"coord":{"lon":yyyyyy,"lat":xxxxx},"weather":[{"id":800,"main":"Clear","description":"clear sky","icon":"01n"}],"base":"stations","main":{"temp":1.03,"feels_like":-1.33,"temp_min":0.57,"temp_max":2.64,"pressure":1039,"humidity":76,"sea_level":1039,"grnd_level":1034},"visibility":10000,"wind":{"speed":2.06,"deg":170},"clouds":{"all":0},"dt":1738790391,"sys":{"type":1,"id":1440,"country":"GB","sunrise":1738742403,"sunset":1738773892},"timezone":0,"id":3333224,"name":"xxxxxx City","cod":200}

Digital Clock with WiFi and Weather (Huzzah & 128x64OLED)

CNC Rotary Encoder Internals I was working with one of Adafruit's CNC Rotary Encoders and made a mistake wiring. Well, long story short, I killed it. I am not sure exactly what I did, but I suspect I accidentally drove its outputs with an improper voltage. To prevent the experience from being a total loss, I took the time to partially disassemble it.

CNC Rotary Encoder Internals

Getting Started with Zephyr on Linux This is for folks interested in learning about Zephyr. The first section shows, step by step, how to work through the Zephyr Getting Started Guide to install Zephyr on Linux, build the hello world sample, and run it on an Adafruit QT Py ESP32-S3. The second part has notes for tuning the default settings to use fewer resources for faster CI builds.

Getting Started with Zephyr on Linux

Remix: Cedar Grove Weather Architecture v2.0 (AIO Throttling for the Win) Project Objective The object of this project is to refactor the CircuitPython code in the existing devices to accommodate AIO transaction throttling and to convert the Workshop Corrosion Monitor and Matrix Weather Display to become display-only devices, ultimately combining both into a single device. Overview The first version of the weather system architecture (Display AIO Local Weather Conditions: MatrixWeather System) worked nicely, but reliability suffered when the multiple transmitter and receiver devices competed to access the Adafruit IO (AIO) feeds. To prevent access collisions using the first architecture, each independent device was designed to only transmit or receive at fixed rates well below the AIO+ subscription rate limit of 60 data point transactions per minute. However, since each device operated autonomously, there were occasions when two transactions would heterodyne and stress the limit and cause feed failures. To remedy the reliability issue, the new architecture design was switched from using MQTT to the HTTP protocol. Even though MQTT makes it relatively easy to "subscribe" to AIO feeds, HTTP provides more control granularity that includes a relatively new feature for independent devices to monitor feed access activity. Collisions can be avoided by watching how many data point transactions remain and waiting until enough are available for the queued transaction event. The primary change to the architecture was to incorporate throttling.  A secondary goal was to reduce the number of devices in the system by combining the existing Corrosion Monitor sensor with the REPEATER device, creating the new Weather SOURCE device. The Weather SOURCE extracts local weather conditions from AIO+ Weather and combines it with the local sensor's temperature, humidity, dew point, and corrosion detection data. Weather SOURCE then publishes the information to a collection of standard AIO feeds. The other devices in the system are displays that extract data stored in the AIO feeds. One display replaces the existing Workshop Corrosion LCARS Monitor (PyPortal M4) that lives in the workshop and now is named Workshop Corrosion Monitor Display. The second is our living room MatrixWeather Display (upgraded from a Matrix Portal M4 to the S3 version). Since AIO feed access rates are monitored, it will be possible to create additional task-customized displays, perhaps for the studio or kitchen. An advantage of the new architecture is that some display devices will not require large PSRAM for retaining the huge JSON file that AIO+ Weather provides, with the exception of a Matrix Portal. The single Source device with a large PSRAM extracts only the essential information needed by the displays -- and stores the extraction into the AIO feeds.

Remix: Cedar Grove Weather Architecture v2.0

GFFA - Aurebesh! I really enjoy coming up with new ways to combine my appreciation for Science Fiction linguistics with Adafruit products (especially the neotrinkey!) and CircuitPython. For this project I combined a classic tool "FIGlet" with the Aurebesh, the alphabet from the Galaxy Far, Far Away... (GFFA). I started with FIGlet, the  computer program that generates text banners, in a variety of typefaces, composed of letters made up of conglomerations of smaller ASCII characters. I modified an existing font file (standard.flf), replacing the letters a-z with my handmade versions of the letters seen above (note: anyone know of a good editor for FIGlet fonts? I'd love to improve the above). That file was rather big for the neotrinkey - so I just extracted the Aurebesh and made it into an array for aure.py, a module to convert alphabetic English into Aurebesh. Then I made a program, aurebesh.py which could call aure.py's function doAure() for displaying different sayings or the alphabet, character by character - a useful training tool to become familiar with the alphabet. That's an important skill if you come across warnings like this:      

GFFA - Aurebesh!

Build patterns: IR receiver variants Overview This note presents a few different ways of building an microcontroller-based IR receiver. It is meant as a complement to the "PC media remote" note. The idea is to somewhat parallel "Software design patterns" -- only for physical hardware builds. The note provides a variety of implementation examples for an IR receiver project. These examples try to make use of different mechanical/mounting systems to provide structure, associated with some practical connectivity solutions. Hopefully these options will make builds feel a bit more approachable. Regarding the overall design philosophy: Attempts were made not to solder everything together in one monolithic block. Design often involves making mistakes, so having a way to easily re-configure your solution as it develops really helps.  More specifically, I find that building "blocks" in a somewhat modular/generic fashion is preferable to building something that is completely "application-specific".  As a bonus, if your blocks don't quite work out the way you want, they can more likely be re-purposed in later projects.

Build patterns: IR receiver variants

Option Map: Microcontroller form factors Overview This page gives an overview of microcontroller form factors typically used by the maker community (at a beginner/intermediate-level). The intention is to assist in finding the right fit for your projects. To achieve this, a high-level introduction of said form factors, and simple feature/property matrices will be presented. Naturally, coverage will be limited by the author's personal knowledge of available options (even if popular in other circles). The focus is primarily on Adafruit products (tends be available in these popular form factors), but also makes associations to names used by other companies (aliases). Common form factors (FF) The following sections present common form factors in decreasing order of size. A few different feature/property matrices will follow (Sorry. Not sure how to link to a lower section). FF: Mega/Grand Central

Option Map: Microcontroller form factors

CircuitPython "Ring Oscillator" RNG with SN74AHCT14 I've long had an interest in random number generation. In fact, a very early PCB I designed and built was exactly for this purpose: Arduino Random Number Generator. That project used a property of transistors called "avalanche noise". Inconveniently, it required a supply of +-10V to work properly. Avalanche noise is sometimes explained as being a "quantum effect" and thus is supposed to be a source of true randomness. There are other types of physical randomness. One actually exists inside the RP2040 chip already: It has a Ring Oscillator peripheral built in. However, this project shows how to build a Ring Oscillator from a simple "78*14" chip and process it into an infinite unguessable string of bytes using CircuitPython. I built this project with a QT Py RP2040. It's very simple; the only other required parts are the 74*14 chip, a breadboard, and some wire. This is not a truly robust RNG and you shouldn't use it for anything serious. For example, someone could tamper with it and just remove the connection between the RP2040 and the ring oscillator; the code wouldn't notice, but its outputs would be exactly the same each time it was powered on. Real RNG products will have part of the software that verifies that the random source is behaving like a random source and is not fixed at a single value, or otherwise trivially predictable.

CircuitPython "Ring Oscillator" RNG with SN74AHCT14

EPS32 V2 eInk / ePaper Daily Calendar and Clock I oh so wanted to build Liz Clark's QTPy CH32V203 eInk / ePaper Daily Calendar & Clock but I didn't have much luck with booting and programming the CH32V203 board.  I am no expert on how to do this. So I reversed engineered the code to Circuit Python and put in on the Huz/zah ESP32 V2 board.  I also wanted some color and used the 1.54" 3 color e-ink display. I don't have a 3-D printer so I cut a strip of plexiglass and used a heat gun to put a 45-degree bend so it looks like a paper calendar.   Below is my parts list I used to make this calendar.   The code is fairly simple, and I just pieced it together from Adafruit web pages.  Granted I could have used WiFi to pull the time down and I may but for now I wanted to get used to playing around with DS3231 board. I used a wire wrap pen which you can get off of Amazon fairly cheap.  I've added the code here as well.  I am just a NOOB to programming and mostly hack at it to get it working.  If you find this helpful, great.  It was a fun little project. Huz/zah ESP32 V2 Feather ID 5400 Adafruit EYSSPI Flex Cable 50mm ID 5462 Adafruit EYESPI Breakout Board 18 Pin Connector ID 5613 Adafruit 1.54" Tri-Color eInk / ePaper Display 200x200 with EYESPI ID 4868 Adafruit DS3231 Precision RCT Breakout Board ID 3013 STEMMA QT / Qwiic JST SH 4 pin Cable 50MM  ID 4399 Rainbow Wire Wrap ID 4730 Black Nylon Machine Screws and Stand offs M2.5 ID 3299   Wire connection table EYESPI connector   -->  ESP32 V2 VIN        --->    3v Gnd       --->    Gnd SCK       --->    SCK MOSI     --->   MOSI MISO     --->   MISO DC         --->   TX TCS       --->   RX SDCS    --->   Pin 33 * SDCS    --->   Pin 27 * Note: *  I will comment, and maybe someone could tell why but Pin 22 and 37 are not in the code but without them the display would not update.  So I am guessing the pins are either floating or pulled to ground.    

EPS32 V2 eInk / ePaper Daily Calendar and Clock

Option Map: Powering your circuit Overview This page gives an overview of available options to power your projects: alternatives that go beyond the development board's built-in USB connector. Broad categories, and simple product matrices will be presented. The intention is to make it easier to find the right product/solution without having to continuously re-read all product description pages. My interpretation of these pages might not be fully accurate. Unfortunately, there appears to be no way for others to inform me of such mistakes. I am hoping a similar document in "Explore & Learn" section will eventually replace this one. Regulation: Linear/Buck/Boost

Option Map: Powering your circuit

Calibrate Your 3D Printer for Dimensional Accuracy If you want to 3D print press-fit or snap-fit project enclosures, there are a few tricks you can use to get better dimensional accuracy. Unless you print in an extremely dry climate, it helps to dry your filament. You can also calibrate your printer's motion system, filament extrusion, and X-Y hole/contour compensation.

Calibrate Your 3D Printer for Dimensional Accuracy