Well, COVID19 is taking a hit on things at SUNY Brockport. The administration told students:

• Classes are in session next week
• If you get a negative COVID test, go home early and the faculty will deal with it

I’m dealing with it by taking some personal time and playing with blinky lights.

For a while now, I’ve been interested in exploring Internet-of-Things (IoT) sensors with the hopes of developing some type of platform that can be used for remote chemical education. I’ve also been making a lot of purchases at Adafruit because the pandemic, the state of our country, and the pile of grading on my desk have left me feeling depressed and in need of some comfort making.

This project is far from complete, but I know that I’ll get swamped with end-of-semester craziness and need to have some documentation of what I’ve done to date. Ideally, I’d put it into my maker logbook, but the piles on my desk (both ungraded papers AND unfinished electronics projects) have made it all but impossible to find that notebook. Thankfully, the keyboard is clear of debris.

# How deep are your pixels?

As I mentioned earlier, I just received my first Adabox, and I’ve been having fun getting back into blinky lights (as well as my favorite past time: procrastinating from grading). Now that I’ve gone through most of the tutorials, I am venturing out on my own.

One thing I noticed when playing around with drawing shapes of different colors, is that the default settings for the MatrixPortal resulted in the RGB LEDs being either on or off (essentially). My goal in this exercise it to figure out why that is the case and to find the settings that changed this behavior.

Once I learned how to navigate the documentation, it became clear that the bit_depth parameter was the culprit. It defaults to 2, which means that each color will have 4 different “shades” (my term), inclusive of completely on and completely off. Changing this value to a larger number (max = 6) allows for a deeper gradient.

Here’s the final version of the program I used to work through the problem.

import board # Required
import time
import displayio

matrixportal = MatrixPortal(status_neopixel=board.NEOPIXEL,
bit_depth=5, debug=False)
display = matrixportal.display

group = displayio.Group(max_size=32)

def makegroup(n):
global group
group = displayio.Group(max_size=32)
s = (8, 2048, 524288)
for j in range(0,4):
for i in range(0,8):
group.append(Circle(i*8+4,4+8*j,2,fill=s[n]*(i+8*j)))

counter = 0

while True:
makegroup(counter % 3)
display.show(group)
counter += 1
time.sleep(3)



This code creates 32 filled circles on the 64×32 pixel matrix. The circles cycle through the three colors and increase in intensity from 00 (off) to FF (on). Rather than use more human readable (if you are a human that reads HTML color codes) colors, I noticed that a simple linear relationship with an appropriately chosen slope s, allows me to streamline the code.

Once we get to about half intensity (80 in hexadecimal), I have a hard time differentiating the colors. This might be helpful in future designs as it will allow me to back off on power requirements if I don’t need to run the LEDs with high current and deal with image saturation.

Sure, it’s not riveting; however, sometimes you need to work on the basics, and (hopefully) putting those basics to words helps me remember them.

I recently decided to get an Adabox, which I like to refer to as a CSA for Makers. Rather than greens and veggies, I get a healthy dose of electronics gadgets to play with. Box 016 contains a 64×32 pixel RGB display, or in simple terms, 2000+ blinky lights!

In addition to a cool display, this is my first exposure to CircuitPython, which is Adafruit’s approach to programming microcontrollers via Python. I have to admit that I was hesitant at first, and spent much of my pre-unboxing time scouring the internet for tutorials that used Arduino sketches for controlling the display.

Man, when I gave CircuitPython a shot, it was amazing. Along with Mu, the simple Python text editor, I was up and running in no time. Mu recognized that I was using CircuitPython, and once I enabled serial communication to help me find the stupid syntax errors I often make, I was up and running. I hadn’t bought into the “not compiling saves time” argument of Python over C++ for microcontrollers, (especially given the lightweight programming I do) but it does turn out to be a nice feature to click save and watch my screen update (again, after those stupid syntax errors are wiped out).

Anyway, after bouncing through the tutorials, I modded one of the examples for a Skype call with my nephew. He’s 500+ miles away and it’s his birthday today (he’s 16). COVID prevented me from visiting him so I did the next best thing that a geeky uncle could do, make blinky lights blink for him.

We Skyped, ate cake (virtually) together and I watched as he opened his gifts (a tablet and accessories). I then faded into the background because, well, he’s 16, with a new gadget sitting in front of a screen with an old guy on it. I would do the same thing.

Happy Birthday, Nick.

# Learning UE4 Niagara

I’m working through some tutorials on how to use the video FX module in Unreal Engine. Here, I’ve outlined a static mesh of my favorite element with glowing embers and added a very rudimentary lens flare.