A YouTube Subscriber Counter With A Tetris Twist

When it comes to YouTube subscriber counters, there’s not much wiggle room for creativity. Sure, you can go with Nixies or even more exotic displays, but in the end a counter is just a bunch of numbers.

But [Brian Lough] found a way to jazz things up with this Tetris-playing YouTube sub counter. For those of you not familiar with [Brian]’s channel, it’s really worth a watch. He tends toward long live-stream videos where he works on one project for a marathon session, and there’s a lot to learn from peeking over his virtual shoulder. This project stems from an earlier video, posted after the break, which itself was a condensation of several sessions hacking with the RGB matrix that would form the display for this project. He’s become enamored of the cheap and readily-available 64×32 pixel RGB displays, and borrowing an idea from Mc Lighting author [toblum], he decided that digits being assembled from falling Tetris blocks would be a nice twist. [Brian] had to port the Tetris-ifying code to Arduino before getting the ESP8266 to do the work of getting the subs and updating the display. We think the display looks great, and the fact that the library is open and available means that you too can add Tetris animations to your projects.

None of this is to say that more traditional sub counters can’t be cool too. From a minimalist display to keeping track of all your social media, good designs are everywhere. And adding a solid copper play button is a nice touch too.

Continue reading “A YouTube Subscriber Counter With A Tetris Twist”

Buttery Smooth Fades with the Power of HSV

In firmware-land we usually refer to colors using RGB. This is intuitively pleasing with a little background on color theory and an understanding of how multicolor LEDs work. Most of the colorful LEDs we are use not actually a single diode. They are red, green, and blue diodes shoved together in tight quarters. (Though interestingly very high end LEDs use even more colors than that, but that’s a topic for another article.) When all three light up at once the emitted light munges together into a single color which your brain perceives. Appropriately the schematic symbol for an RGB LED without an onboard controller typically depicts three discrete LEDs all together. So it’s clear why representing an RGB LED in code as three individual values {R, G, B} makes sense. But binding our representation of color in firmware to the physical system we accidentally limit ourselves.

The inside of an RGB LED

Last time we talked about color spaces, we learned about different ways to represent color spatially. The key insight was that these models called color spaces could be used to represent the same colors using different groups of values. And in fact that the grouped values themselves could be used to describe multidimensional spacial coordinates. But that post was missing the punchline. “So what if you can represent colors in a cylinder!” I hear you cry. “Why do I care?” Well, it turns out that using colorspace can make some common firmware tasks easier. Follow on to learn how!

Continue reading “Buttery Smooth Fades with the Power of HSV”

Low-Resolution Display Provides High-Nostalgia Animations

High-definition displays are the de facto standard today, and we’ve come to expect displays that show every pore, blemish, and bead of sweat on everything from phones to stadium-sized Jumbotrons. Despite this,  low-resolution displays continue to have a nostalgic charm all their own.

Take this 32 x 16 display, dubbed PixelTimes, for instance. [Dominic Buchstaller] has gone a step beyond his previous PixelTime, a minimalist weather clock and home hub built around the same P10 RGB matrix. The previous build was a little involved, though, with a nice wood frame that took some time and skill to create.

Building your own version of PixelTimes is really approachable. The case is mostly 3D-printed, and the acrylic parts [Dominic] laser cut could just as easily be cut with a saw. And that P10 board can be source for peanuts direct from Chine. The software for the project has been upgraded since the original version, supporting flicker-free animations. Everything runs on a NodeMCU, and there are even scripts to convert your favorite GIF to an animation. Oh, and it still displays the weather too.

This looks great and seems like a lot of fun, and [Dominic] kindly provides all the files you’ll need to build your own. It shouldn’t take more than an hour to build once you’ve got all the parts.

Cutting Paper And Corners In Animation

Cutting every corner can lead to some shoddy projects, but [Terry Gilliam] shows us that cutting the right corners yields unforgettable animations when mixed with the right amount of quirky imagination. The signature animation style of Monty Python’s Flying Circus is a mixture of [Terry]’s artistic craft and doing it with as little work as possible. You can watch after the break.

For [Terry], cutout animation is the quickest and easiest way he knows to convey an idea, a joke, or a story. With his vocal repertoire, even the sound effects can be produced in a basement studio. Sometimes, he makes the artwork himself and sometimes he relies on found-media in magazines or print. Both of these resources have vast digital counterparts for the betterment or detriment of animators.

Cutout animations have limitations such as jerky movement and the signature paper-on-a-background look, but that didn’t stop South Park. Textures and gradients can be used, unlike traditional animation which leverages a simplified color palette so you can pick your poison.

If your story or idea is held back because it can’t be expressed, maybe it needs a cutout animation kick in the right direction, and it couldn’t hurt to illustrate your 2018 Hackaday Prize submissions. At the opposite end of the tech spectrum, we have an animation made with 3D printed objects.

Continue reading “Cutting Paper And Corners In Animation”

Amazing Mechanical Linkages and The Software to Design Them

Most of us are more bits-and-bytes than nuts-and-bolts, but we have the deepest appreciation for the combination of the two. So, apparently, does [rectorsquid]. Check out the design and flow of his rolling ball sculpture (YouTube, embedded below) to see what we mean. See how the arms hesitate just a bit as the ball is transferred? See how the upper arm gently places it on the ramp with a slight downward gesture? See how it’s done with one motor? There’s no way [rectorsquid] designed this on paper, right?

Of course he didn’t (YouTube). Instead, he wrote a simulator that lets him try out various custom linkages in real time. It’s a Windows-only application (sigh), but it’s free to use, while the video guides (more YouTube) look very comprehensive and give you a quick tour of the tool. Of special note is that [rectorsquid]’s software allows for sliding linkages, which he makes very good use of in the rolling ball sculpture shown here.

We’ve actually secretly featured [rectorsquid]’s Linkage software before, in this writeup of some amazing cosplay animatronic wings that used the program for their design. But we really don’t want you to miss out if you’re doing mechanical design and need something like this, or just want to play around.

If you’d like to study up on your nuts and bolts, check out our primer on the ubiquitous four-bar linkage, or pore through Hackaday looking for other great linkage-powered examples, like this automatic hacksaw or a pantograph PCB probe for shaky hands.

Anyone know of an open-source linkage simulator that can also output STL files for 3D printing? Or in any format that could be easily transformed into OpenSCAD? Asking for a “friend”.

Continue reading “Amazing Mechanical Linkages and The Software to Design Them”

Use a Drill to Power Your Flipbooks

[WolfCat] of Wolfcatworkshop is creating a hand-animated split-flap animation. But what do you use to test your animation once it’s on the split-flaps? Well, to test it out, [WolfCat] used a drill to give it motion. DoodlersAnonymous has some pics and an interview with [WolfCat] about his animation and there are some pictures on his Instagram page.

Technically, what [WolfCat] wanted to make is a “mutoscope,” a hand-cranked precursor to the movie projector that had its heyday in the late 19th and early 20th century. Originally installed in penny arcades and the like, mutoscopes were single-viewer apparatus. The viewer cranks the handle and the animated cards inside rotate around, stopped briefly by a bit of metal at the top in order to show a frame. The basic idea is similar to the way split-flap clocks or signs work.

[WolfCat] hand drew the animation for his movie and then scanned and printed out each frame. The frames were then transferred to a pair of flaps. [WolfCat] wanted to see how it would look when animated, but didn’t have any plans at the time for a case or a hand crank, so he found the closest tool that would do the job – a cordless drill. Attaching the drill and using a bit of card or wood as a stopper, [WolfCat] could see how the end result would look and could then start work on the case and crank.

The drill is a quick and easy way to see what the finished product would look like. Once he’s got it working, [WolfCat] could check out this 3D printed mutoscope case, or this flip dot animated display.

Continue reading “Use a Drill to Power Your Flipbooks”

Sense Hat Comes Alive

Remember the Raspberry Pi Sense Hat? Originally designed for a mission to the International Space Station, the board has quite a few sensors onboard as well as an 8×8 RGB LED matrix. What can you do with an 8×8 screen? You might be surprised if you use [Ethan’s] Python Sense Hat animation library. You can get the full visual effect in the video below.

The code uses an array to represent the screen, which isn’t a big deal since there are only 64 elements. Turning on a particular element to animate, say, a pong puck, isn’t hard with or without the library. Here’s some code to do it with the library:

for x in range(0,7):
 ect.cell(image,[0,x],[randint(0,255), randint(0,255), randint(0,255)],0.1)
 ect.cell(image,[0,x],e,0.1)
for x in range(7,0, -1):
 ect.cell(image,[0,x],[randint(0,255), randint(0,255), randint(0,255)],0.1)
 ect.cell(image,[0,x],e,0.1)

Each loop draws a box with a random color and then erases it before going to the next position. The second for loop makes the puck move in the opposite direction. You can probably deduce that the first argument is the screen array, the second is the position. The third argument sets the color, and the final argument sets an animation timer. Looking at the code, though, it does look like the timer blocks which is probably not going to work for some applications.

If that’s all there was, this wouldn’t be worth too much, but you can also draw triangles, circles, and squares. For example:

ect.circle(image,(4,4), 3, [randint(0,255), randint(0,255), randint(0,255)], 0.1)

We covered the Sense Hat awhile back. Of course, it does a lot more than just light up LEDs as you can see from this weather dashboard.

Continue reading “Sense Hat Comes Alive”