What is the Adafruit Connection Manager? It is a helper class designed around making connections to the internet easier and does this by simplifying a few things.

First, what are the underlying pieces we need to connect to the internet?

Sockets

Everything that connects to the internet needs a socket. A socket is what handles the basic sending and receiving of messages between 2 devices (like your microcontroller and a web API).

Microcontrollers, unlike desktop computers, have limited memory and can't have 100s of sockets open. The average chip can have maybe 2-3 and the bigger ones top out around 10.

Previously the sockets were controlled at a per library level. Meaning if you used adafruit_requests (to get info from the web) and adafruit_minimqtt (to send something to AdafruitIO) they both managed sockets separately, which means that one might block the other from getting one. And on top of that, the way you interfaced with them was different!

Here comes ConnectionManager to the rescue! Both these libraries now ask the ConnectionManager for a socket and it handles tracking what's open and what's not. And to make code even simpler, it's what's called a singleton. There is only one, where previously you needed to create your requests.Session() early in your code and use that one everywhere, now it doesn't matter.

Socket Pool and SSL Context Helpers

What are these?

The socketpool is what creates the sockets for each internet connected chip, and the ssl_context is what has all the certificate information to validate that the connection is secure.

For the Adafruit AirLift (which uses an ESP32 WiFi Co-Processor):

I just couldn't bring myself to use the standard practice of soldering pins onto breakout boards using a solderless breadboard in spite of the recommendations and endorsements of some famous solder artists. I would cringe thinking that the heat would eventually warp the plastic portion of the board. It is a solderless breadboard after all.

Fortunately, after placing many Adafruit orders over the years, I had build up quite a collection of free half-sized Perma-Proto breadboards. The solution for creating a non-destructive soldering jig became obvious. Stack four Perma-Proto PCBs together, use a couple of M3 nylon screws and nuts, and place some rubber feet on the bottom. Voilà!

Sadly, the Perma-Proto board is no longer offered as a free product promotion. That's okay; I still have enough in the inventory for many future projects. And coasters. I have coasters.

When troubleshooting serial bus communications like I2C, UART, or SPI, it can be handy to disconnect a chip select or data line to isolate external devices. Once isolated, the data can be viewed on a logic analyzer or oscilloscope to determine if the SPI or UART signal outputs are really connected to inputs or when examining the effects of multiple pull-up resistors on I2C. The Feather Isolator was designed to individually disconnect a Feather's pin with a switch to help with the troubleshooting effort.

Inspiration

This is a piece of "found art"; a multi-colored circuit board hiding inside some old discarded electronics.  It just needed a backlight and a frame to highlight its beauty.  From the beginning, I knew this would become a nightlight and held onto the board until I had acquired the perfect combination of discarded LEDs and a few other components needed to make it shine.

Case Design

My 3D printed case had 3 chambers.  One for the electronics, one for the LEDs, and a thin slot a the front to hold the circuit board and clear plastic cover.  The reason for the separation was to make sure the LEDs were the right distance to illuminate the board and to minimize the light that leaked out that back of the frame while still allowing hot air to escape.  The design was almost perfect, but I ended up having to cut a large slot in the back so I could replace the back wall with a slotted version for better ventilation (not pictured).

Before closing up the case, test that it can be dimmed appropriately.

I wanted a clock that would display the time in large yellow characters and display the week and day.  For fun added a 60 RGB neo-pixel ring to tick off the seconds.

The last part was to display the phase of the moon in a fun way and found these to be entertaining. 

I cut a sheet of plex-glass to 8x11 sheet.  I used miniature self-tapping screws to mount the RGB neo-pixel ring.  I used this same kind of screws to mount the 4-digit display and two of the Quad Alphanumerica Displays.

I drill large enough holes to plug the displays up to the Adafruit Qualia ESP32-S3 and daisy chained the rest.

I did solder 3 wires to the RGB neo-pixel ring a crimped a 3-pin connector on the other and plugged it in socket A0.

I used Photopea to create a 3x3 of the moon phases I found on the internet.  For the new moon phase I copied the full moon phase and changed its color from yellow to blue.  and its a seperate .bmp file.

I am not a very good coder anymore and new to python.  I am sure there are better coders out there than me for sure.  I hacked most of the code from other projects.

 

 

Parts Required for this project:

1. Adafruit Qualia ESP32-S3 for TTL RGB-666 Displays (PI - 5800
2. Round RGB TTL TFT Display -2.1" (PI - 5806)
3. NeoPixel 1/4 60 Ring 5050 RGB LED w/Integrated Drivers (PI -1768)
4. Quad Alphanumerica Display - Blue 0.54" Digits w/ I2C Backpack - Stemma QT / Qwiic (PI 1912)
5. Assembled Adafruit 0.56: 4-Digit 7 Segment Display -w/ I2c Backpack QT - Yellow (PI 5602)
6. Stemma QT JST SH 4-Pin Cable (50mm & 100mm)

The goal of this project is to build a Python based handheld and battery powered scientific calculator the size of a cigarette box (well, pocket calculator). Scientific, as in "reasonable precision". Float32 (single precision) is certainly acceptable for a display precision of, say 6 or 7 digits, but the follow-up rounding errors are not - at least not for me. I experimented with Decimal math before but ended up having to fight memory constraints with jepler-udecimal (https://github.com/jepler/Jepler_CircuitPython_udecimal) and my own extensions even on a Feather RP2040 with 256kB of user RAM. So I eventually decided to make a custom CircuitPython build and try to enable float64 (double precision) math. (Thanks to the Adafruit folks for their help!). Needless to say that float64 is entirely handled in C without the help of a potential floating-point unit (FPU) but then this approach is still much more CPU and memory efficient than implementing everything in Python.

The code for this project is on https://github.com/h-milz/circuitpython-calculator/ and will be discussed in this article.

The terminal window displays a couple of features of this tiny machine, from top to bottom: calculating pi using arctan(1), the arsinh of a complex argument, multiplying two numbers with uncertainties, and multiplying two fractions including reducing it to lowest (positive) denominator.

The dongle on the lower right is a PCF8523 RTC hanging off the Keyboard Featherwing's STEMMA Qt connector (which, sadly, is unusable if you want a handheld with a back cover ... What did arturo182 think?)

On the backside you can see the Adafruit Feather M4 Express and the LiPo battery, which is fixed to the Featherwing using a double-sided adhesive foam strip.

Introduction

Astronomy is my primary hobby and taking photographs of night-sky objects is my particular interest.  A downside to this hobby is that it is very weather dependent.  If it’s cloudy nothing can be seen.  Weather reports are important to monitor but they just serve the general area.  The sky conditions at my specific location are better monitored with an AllSky Camera.

An AllSky Camera is simply a camera with a fisheye lens that’s pointed up into the sky.  A program takes pictures of the sky all night long so checking the sky conditions can be done by looking at the latest sky image.  Is it too cloudy to take images?  Are clouds starting to move in?  Just check the AllSky Camera!

The Issue with Dew

Unfortunately, the dome of the AllSky Camera is prone to have dew forming on it when the humidity gets high.  Once that happens, the Allsky images are totally unusable.  To combat dew, many AllSky Cameras have a dew heater built into them.  The heater in my camera is very simple:  Apply 12 VDC and the heater is on.  Remove the voltage and the heater is off.  This applies about 10 W of power to the heater, and it does get hot enough to keep dew from forming on the dome.  Sometimes it gets too hot.

If the humidity is moderate the 10 W of power is way more than needed to keep the dome clear.  An unwanted side effect of too much heat is that cameras don’t like it.  The hotter a camera gets the noisier, or grainer, its picture becomes.  This is especially apparent with long exposures and AllSky Cameras can take up to 60-second exposures under a dark sky!  The better solution is to vary the amount of power applied to the heater so that only enough is applied to keep dew from forming, and no more.

 

This article is for Circuit Python developers that use PIP and CircuitPython-Stubs in a Windows environment. 

Stubs are helpers for code completion hints with IDE's such as PyCharm, VSCode, and others.

Unfortunately PIP & CircuitPython-Stubs do not automatically stay updated.  These are things you must manually update when a new version of Circuit Python is released or whenever your heart dictates you want to update it.  This is a problem because I never remember to keep them updated and recently found out my version of stubs was last updated in Circuit Python 7.3.3 (we're now at Circuit Python 9.0.1). 

This is assuming you already have PIP and CircuitPython stubs installed.

The manual way to update them is:

python -m pip install --upgrade pip

pip install circuitpython-stubs --upgrade

These are the types of things I do not want to be required to remember to update.  I consider these things minutia that should automatically stay updated.

Windows Task Scheduler can automate the process of keeping both PIP and circuitpython-stubs up to date every time you log into Windows.  First we need to create a batch script and put it in a directory/folder that will always be available to Windows. 

I chose to put it in the following folder:

\Downloads\CircuitPython-Stubs_Updater

You can name the script whatever you'd like.  You can edit a .bat file as easly as a .txt file, you don't need a special IDE to do it, Notepad works fine for it.

I named my batch file:

circuitpython-stubs.bat

It resides inside of the CircuitPython-Stubs_Updater folder and includes the following code in the .bat file.

The CG-35 is a CircuitPython emulation of the Hewlett Packard HP-35 Scientific Reverse-Polish Notation (RPN) calculator designed for the Adafruit ESP32-S3 Feather and 3.5-inch TFT FeatherWing capacitive touch display. The calculator consists of a 10-digit LED-like display backed-up with 20-digit internal calculation precision.

This emulation reproduces the HP-35 calculator's v2.0 firmware where the change sign (CHS) key is active only after digit entry has begun. And because of the udecimal and utrig classes, calculation accuracy of monadic, dyadic, and trigonometric functions was improved. As an added bonus not present on the original calculator, a status message will appear just below the primary display when a calculation error is encountered.

The calculator's graphical layout was designed to mimic the aspect ratio of the original calculator -- that's why the left and right sides of the display screen were left empty. However, to provide a more reliable touch screen experience, the keys are somewhat proportionally larger than the original.

This project was inspired by Jeff Epler's DIY Desktop Calculator with CircuitPython project and Jeff's work to create CircuitPython versions of udecimal and utrig. Thank you Jeff!

GitHub Repository: https://github.com/CedarGroveStudios/CG-35_Calculator

Primary Code Module

The primary code module cg_35_calculator.py, imported by code.py, instantiates the display, plots the calculator case and buttons, and implements all calculator operational processes. This module uses a state machine design with the following named states:

• IDLE -- Display results or wait for input
• C_ENTRY -- Coefficient entry (keys: 0-9, ., CHS, EEX)
• E_ENTRY -- Exponent entry (keys: 0-9, ., CHS)
• STACK -- Stack management (keys: ENTER, CLR, CLX, STO, RCL, R, x<>y, π)
• MONADIC -- Monadic calculator functions (keys: LOG, LN, e^x, √x, ARC, SIN, COS,TAN, 1/x)
• DYADIC -- Dyadic calculator functions (keys: x^y, -, +, *, ÷)
• ERROR -- Calculation error

The calculator's display precision and internal calculation precision are specified using the variables DISPLAY_PRECISION and INTERNAL_PRECISION. Although the internal precision exceeds that of the original HP-35 calculator, it is recommended to keep the existing default settings of 10 digits and 20 digits, respectively, to avoid rounding errors.

The variable DEBUG can be use to provide additional internal register status via the REPL. This boolean variable defaults to False (no additional register status).

 

This is a project that was years in the making, I went through many iterations that failed one way or the other. However, the final project was only started about a few months ago. It's great to see this project realized at last! The trigger really works, it has the appropriate sound effects, it has two firing speeds, and a "virtual ammo" system that you replenish by physically removing and reinserting the cartridge. So, where did it all begin?

The initial step of the process was to design the 3D printable case, which I did in blender. I found someone who extracted a model of the Necrochasm from the game itself and went to work sculpting out the finer details, hollowing out the interior, and adding LED areas. I also took this time to log into Destiny, and use my in-game Necrochasm to record the proper sound effects.

I exported the resulting pieces from blender to fusion 360 where I added the hardware mounting features. My vision for this prop was to have one area where most of the electronics were stored. This trapezoidal area at the bottom-front of the prop looked like it had the most storage capacity.

Overview

This page aims to illustrate and document how you can use PostgreSQL and PostgREST to store and access data generated by sensors connected to micro-controllers or other IoT devices. Before we dive in, I'll introduce the projects and utilities that we'll be using:

• PostgreSQL - A widely used, open source database system. It's very extensible and has many plugs and other utilities built "on top" of it. Client applications connect to it via a network port and send SQL commands to create, read, update, and delete data.
• PostgREST - A standalone web server that turns your PostgreSQL database directly into a RESTful API. The structural constraints and permissions in the database determine the API endpoints and operations. This web server allows us to create, update and access our data with HTTP requests from micro-controllers and other endpoints.
• NGINX - A widely used web server with reverse proxy, load balancing, and many other capabilities. This project will use it to host static HTML and JS files that can be viewed in a browser. It is good practice to use Apache or NGINX as a reverse proxy "in front" of other web server utilities like PostgREST.
• ApexCharts - A Javascript library for making charts and graphs. We'll use this to graph data that we read out of our database.

Setup PostgreSQL

Method 1: Docker

The official PostgREST tutorial skips the full PostgreSQL setup opting instead for a quick / easy setup running inside of a Docker container. If you already have or are familiar with Docker then this route is quite straight forward. The following command will create and launch a PSQL container:

 

Intro to the RA8875 Driver Board for Circuit Python

The Adafruit RA8875 driver in Circuit Python does not currently support displayio.  You must use read/write registers with a barebones ra8875 graphics library. The current feature set and how it is used is only for very advanced users. 

You can draw a bmp image and overlay text but you'll quickly find that's about all you can do with it.  There are only 2 examples provided and the driver board is unlike any other display device for Circuit Python. Any knowledge you have of displayio does not transfer over to this board; the RA8875 is unique.

The interest of using an 800x480 bare display with Circuit Python is typically due to the sheer size of it but it should come with fair warning:  You must be capable of programming with circuit python from scratch without displayio.

The bits and bytes of binary color

Since the RA8875 can only display a maximum of 16-bit color; the 24-bit image must be converted to 16-bit (color565).

The RA8875 stores color information in its memory with 2 bytes (2 pairs of 8 bits).  Here is a binary representation of how it stores the color. 11111111 00000000  There are 8 bits in 1 byte.

However the RA8875 actually stores them in what is known as swapped color565.  Each first byte must be swapped with the 2nd. This is not some type of color conversion error. These are the direct reads from the memory addresses for the stored colors. 

Need to add a simple diagnostic display to a Pico project? Or perhaps you want a quick and easy NeoPixel light show? Let's see what we can do!

Equipment

• Pi Pico board with headers
• NeoPixel Stick 
• Header Pins
• Under Plate PiCowBell