Here's another silly NeoTrinkey project - let's make some alien words! 

babel.py - generates "alien" words using a set of rules for Wookie, Klingon, Vulcan, Mando'a and Romulan.

ncount.py - blinks numbers

Touching pad #1 toggles between the five languages, and blinks the number (1..5) for the language choice. Each language defines a set of consonants, vowels and an array of word patterns (V for vowel, C for consonant, v 50% chance for a vowel, c 50% chance for consonant). When you touch pad #2, a list of words (random quantity, 1 to 10) is created following the rule sets. The rule sets were created using known words from those languages.

Change the variable REPL to direct the output: True means the program prints to the repl, False sends the output to the keyboard.

Example output:

Wookie: OUWA ROR HOH AROOAUW HOUW WOH ORAUW ORUUUUR WOR OWOUOOR

Klingon: laq noegh tSyIm DIyS mI Ho jaab

Vulcan: su tuai tiustoa het' tiy k' t

Mando'a: ary reara 'hr syc tmn cor khc

Romulan: ihf ki'vh ies lu'm m'ih ih eenh hieh uek

Note: These are generated words, and only by coincidence match vocabulary in any real lexicons.

For fun you can replace my rule sets for any other alien or fantasy language you wish to create.

 

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.

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

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. 

Hi. today i`m going to show you how to use the GPIO or pins on Arduino it doesn't matter witch one as long as it has GPIO.

First jumper weirs:     

I've been doing the hobbies of coding and circuit boards for three years now, I use Adafruit a lot and would love to help other people with the same hobbies on here with fun projects and useful info. I will be doing small and large guide projects. I will make sure to add all of the crucial info and extra detail to make it easier. thanks.

needed components during my tutorials:

1. led`s and resistors, transistors, capacitors

2. 3d printed software or cnc soft-where.

3. basic circuit boards and device to code them with Arduino ide or mu editor.

4. That`s all! thank you for your time.

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.

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).

 

The goal for this project is to get the display, touch screen, and sd card working on the Pi Pico by calibrating the touchscreen and printing the contents of the sdcard to serial console.

Learning how to share multiple SPI peripherals reduces the amount of pins you need which can increase the amount of available pins for other uses.  A SPI bus is very similar to an I2C bus except the SPI peripheral has a unique chip select pin assigned to it.  I find it easier to think of the chip select pin as a SPI address pin.  You can only have 1 address per device with I2C and the same holds true with SPI devices except the address is a physical pin.

Because SPI peripherals require a physical pin you will be limited to how many you can have based on how many free pins your microcontroller has.  What SPI lacks in chain ability it makes up for with speed.

• I2C devices are half-duplex
• SPI devices are full duplex

Because SPI communication is twice as fast as I2C it makes far more sense to use SPI for displays and sd cards!  Don't get me wrong, I2C definitely has its place for uses such as:

• temp sensors
• optical sensors
• 7-Segment displays
• 14-Segment displays
• small 16x9 matrix LED modules
• Neopixel strips
• and chaining a ton of devices on 1 bus without the limitation of physical pins per device.

When it comes to needing faster communication for a display that has 480x320 (153,600 total) pixels or sd card reading & writing for a single device that's where the SPI protocol outperforms I2C.

I recently worked on a project with a Raspberry Pi Pico that needed to have a Touchscreen TFT & SD Card.  That's actually 3 peripherals because the touchscreen controller chip requires pins too.  In the majority of scenarios when you have a SPI touchscreen you actually have 2 SPI devices, the display and the touchscreen.

In the Raspberry Pi Pico pinout diagram there are 2 separate SPI buses.  SPI0 and SPI1.  SPI0 peripherals cannot communicate with peripherals on the SPI1 bus and vice versa. A peripheral would be anything on the SPI protocol such as a display, sdcard, temp sensor, etc...  They are highlighted below with magenta labels. Please notice that each SPI bus is prepended with SPI0 or SPI1.

Here is the wiring setup using an Adafruit Proto Picow Doubler.  The doubler offers a maximum of 3 input headers per physical pin.  That means you can share up to 3 SPI devices per pin with their doubler. This is a very handy feature as I didn't have to use a breadboard to prototype this project, very cool.  The reset button also came in handy during prototyping.  If you have a Pi Pico I highly recommend getting one of these.  They're like Feather doublers but for the Pico. 

Basic premise:      Add lights (speed / noise / air-purity indicators, or needless dotstar+neopixel love), use small board to receive tachometer input and drive 24V fan PWM signal from particle sensor, along with new inputs for noise level.   Plus show off Blockly based programming on Adafruit IO, and update as and when the new maths functions become available, but for now write a quick CircuitPython version that illustrates all the desired functionality (to port to Adafruit IO).

Semi-finished code: - Functionally capable but no reactive light use, rainbow:
[Reproduced from https://github.com/tyeth/Ikea_ItsyBitsyEsp32_Air_Purifier/ ]

Wippersnapper

For those not in the know, WipperSnapper is Adafruit's plug-and-play firmware, which runs on their IO (think IOT) platform, offering free* data history(feeds) with graphs, dashboards, and automatic actions/triggers (along with integrating with other platforms like IFTTT). There is a paid upgrade for longer history, unlimited devices, SMS alerts, etc.

I love it because it's super quick and easy to test a sensor works, and to just get some data recording quickly. 

Goto a web-page, flash over usb, add sensors via control panel (feeds + graphs are automatic), done.

Under the hood it's an arduino sketch, so adding additional sensors via github pull requests is surprisingly easy (I've added a few because it makes my future tasks easier).

For this project I'm testing the Sensirion SEN55, which senses Nitrous Oxides (NOx), Volatile Organic Compounds (VOCs), with temperature and relative humidty as a reference (uses SGP40/41 inside), and measures particle counts at <1.0 micron, <2.5, <4.0, and <10.0 micron. The other models of this sensor have less features (SEN54: no NOx, SEN50: no NOx/VOC/Relative Humidity+Temp - only Particulate Counts).

From the standard drivers(arduino/Pi) created by Sensirion we can retrieve the typical particle size, along with the raw particle counts (or in SI units ug/m3), the temperature and humidity, and then two indexes for NOx and VOC. 
The NOx index has a baseline of 1.0, and if you hide the sensor under an upside down saucepan and use a lighter under the saucepan before sealing it back up then you will see a rise in the NOx index and then a return to baseline (1).
The VOC index is instead based at 100. You can detect VOC events from many things, the human breath can even be a source. I tested mine with a jar of clear nail varnish, but anything which you can smell, or smells chemically, is probably going to affect the sensor.

Connectivity-wise, it uses I2C, or other methods (UART?) which are as yet unpublished. The connector requires a JST-GHR 1.25mm 6 Pin compatible cable. The development kits include such a cable, but are heavily marked up cost-wise, like an additional 150% (£50 for kit, £20 for bare sensor). I advise getting a bare version with an additional cable from elsewhere (coolcomponents have a cable under £2). There is also a Grove connector version from seeedstudio.

Overview

Welcome to the Adafruit guide on creating a stunning Badger Mountain themed art piece! In this guide, we'll show you how to bring your artistic vision to life using the powerful Feather RP2040 microcontroller, along with an array of components including audio jacks, buttons, and LED strips.

Circuit Diagram

The Windows Github Desktop program is an easy to use Git GUI for Windows users and it works great in most situations.  However, it has a notorious history of converting every file in a Git repository checkout/clone to all CRLF (Windows Style) line endings.  Line endings are also known as EOL's (End of Line). 

To make line endings visible in Notepad++ go to

View > Show Symbols > Show End of Line

Here's an example of what CRLF's look like when made visible.

All Github Desktop had to do is add a preference option to checkout and commit with LF only.  No such option exists.  This behavior is not present in any other Git based tool so this is a problem unique for Windows Github Desktop users.  There are workarounds published online that include changing an environment variable and global git config. That workaround only works for 1 session, as soon as you close Github Desktop it will promptly ignore your previous changes. There are hundreds of issues filed about this in the Github Desktop repo over the past decade with no real solution.

There has to be a way to fix this!