PineTime Smartwatch And Good Code Play Bad Apple

October 16, 2021 by Brian McEvoy 11 Comments

PineTime is the open smartwatch from our friends at Pine64. [TT-392] wanted to prove the hardware can play a full-motion music video, and they are correct, to a point. When you watch the video below, you should notice the monochromatic animation maintaining a healthy framerate, and there lies all the hard work. Without any modifications, video would top out at approximately eight frames per second.

To convert an MP4, you need to break it down into images, which will strip out the sound. Next, you load them into the Linux-only video processor, which looks for clusters of pixels that need changing and ignores the static ones. Relevant pixel selection takes some of the load off the data running to the display and boosts the fps since you don’t waste time reminding it that a block of black pixels should stay the way they are. Lastly, the process will compress everything to fit it into the watch’s onboard memory. Even though it is a few minutes of black and white pictures, compiling can take a couple of hours.

You will need access to the watch’s innards, so hopefully, you have the developer kit or don’t mind cracking the seal. Who are we kidding, you aren’t here for intact warranties. The video resides in the flash chip and you have to transfer blocks one at a time. Bad Apple needs fourteen, so you may want to practice on a shorter video. Lastly, the core memory needs some updating to play correctly. Now you can sit back and…watch.

Pine64 had a rough start with the single-board computers, but they’re earning our trust with things like soldering irons and Google-less Linux mobile phones.

Continue reading “PineTime Smartwatch And Good Code Play Bad Apple” →

Making OLED Displays In The Home Lab

September 4, 2021 by Dan Maloney 13 Comments

Just a general observation: when your project’s BOM includes ytterbium metal, chances are pretty good that it’s something interesting. We’d say that making your own OLED displays at home definitely falls into that category.

Of course, the making of organic light-emitting diodes requires more than just a rare-earth metal, not least of which is the experience in the field that [Jeroen Vleggaar] brings to this project. Having worked on OLEDs at Philips for years, [Jeroen] is well-positioned to tackle the complex process, involving things like physical vapor deposition and the organic chemistry of coordinated quinolones. And that’s not to mention the quantum physics of it all, which is nicely summarized in the first ten minutes or so of the video below. From there it’s all about making a couple of OLED displays using photolithography and the aforementioned PVD to build up a sandwich of Alq3, an electroluminescent organic compound, on a substrate of ITO (indium tin oxide) glass. We especially appreciate the use of a resin 3D printer to create the photoresist masks, as well as the details on the PVD process.

The displays themselves look fantastic — at least for a while. The organic segments begin to oxidize rapidly from pinholes in the material; a cleanroom would fix that, but this was just a demonstration, after all. And as a bonus, the blue-green glow of [Jeroen]’s displays reminds us strongly of the replica Apollo DSKY display that [Ben Krasnow] built a while back. Continue reading “Making OLED Displays In The Home Lab” →

Why You Can’t Make A Wearable Display With A Transparent OLED

August 19, 2021 by Danie Conradie 37 Comments

After seeing the cheap transparent OLED displays that have recently hit the market, you might have thought of using them as an affordable way to build your own wearable display. To save you the inevitable disappointment that would result from such a build, [Zack Freedman] took it upon himself to test out the idea, and show why transparent wearable displays are a harder than it looks.

He put together a headband with integrated microcontroller that holds the transparent OLED over the user’s eye, but unfortunately, anything shown on the display ends up being more or less invisible to the wearer. As [Zack] explains in the video after the break, the human eye is physically incapable of focusing on any object at such a short distance. Contrary to what many people might think, the hard part of wearable displays is not in the display itself, but rather the optics. For a wearable display to work, all the light beams from the display need to be focused into your eyeball by lenses and or reflectors, without distorting your view of everything beyond the lens. This requires, lightweight and distortion-free collimators and beam splitters, which are expensive and hard to make.

While these transparent OLEDs might not make practical heads-up displays, they are still a cool part for projects like a volumetric display. It’s certainly possible to build your own smart glasses or augmented reality glasses, you just need to focus on getting the optics right.

DIY Handheld Game Puts Its Brains On A Removable Cart

August 16, 2021 by Tom Nardi 10 Comments

Over the years we’ve seen plenty of homebrew handheld game systems that combine an AVR microcontroller, a few buttons, and an small OLED display. Some of them have even been turned into commercial products, such as the Arduboy. They’re simple, cheap, and with the right software, a lot of fun. But being based on an MCU, most of them share the same limitation of only being able to hold a single game at any one time.

But not the Game Card, by [Dylan Turner]. This handheld was specifically designed so that games could be easily swapped out using physical cartridges. But rather than trying to get the system’s microcontroller to boot code from an external flash chip, the system relocates the MCU to the removable cartridge. That might seem a bit overkill, but given how cheap the ATTINY84A on each cartridge is, it’s not exactly going to break the bank.

With the microcontroller on the cartridge, the only hardware that stays behind on the Game Card is the SSD1306 128×64 OLED display, buttons, and the battery. That means the handheld is effectively non-functional unless a game is slotted in, but that could be said of most early cartridge-based game systems as well. On the other hand, it also opens up the possibility of producing cartridges with more powerful microcontrollers down the line.

Using a different microcontroller for each game is a neat hack, but it’s not the only solution to the problem. We previously saw a community effort to add expandable storage to the Arduboy in the form of a DIY cartridge, which ultimately led to the development of an official flash chip upgrade for the handheld.

Continue reading “DIY Handheld Game Puts Its Brains On A Removable Cart” →

Improving OLED VU Meters With A Little Physics

August 9, 2021 by Tom Nardi 23 Comments

Last month we featured a project that aimed to recreate the iconic mechanical VU meter with an Arduino and a common OLED display. It was cheap and easy to implement, and promised to bring a little retro style to your otherwise thoroughly modern project.

[sjm4306] liked the idea, but thought it was a tad too stiff. So he’s been experimenting with adding some physics to the meter’s virtual needle to better approximate the distinctive lag and overshoot that’s part and parcel of analog indicators. Obviously it’s something that can only be appreciated in motion, so check out the video below for an up-close look at his quasi-retro indicator.

Unfortunately there’s no code for you to play with right now, but [sjm4306] says he’ll release it on the project’s Hackaday.IO page once he’s cleaned things up a bit. We know it will take more than a few wiggling pixels to pry real analog indicators out of some hacker’s tool boxes, but anything that helps improve the digital approximation of this sort of vintage hardware is a win in our book. Continue reading “Improving OLED VU Meters With A Little Physics” →

Working LEGO Space Computers Are A Chip Off The Old Block

August 4, 2021 by Kristina Panos No comments

We all have our favorite classic LEGO bricks, and wouldn’t be surprised if one or more of the various space computers showed up on pretty much everyone’s list. [dyoramic] loves them so much that they built two different working versions that do different things.

The first one is about six times the size of the original brick. Inside the 3D printed case is an ESP32 and a 1.5″ OLED display. [dyoramic] wired up the top six buttons as inputs and the rest are just for looks. The screen defaults to the classic white cross on green that just sits there looking legit. But start pushing buttons and you’ll find other modes — the cross becomes a radar screen in one, the computer spits out space facts in another, there’s a falling bricks game, and finally, a time and date screen.

The second LEGO space computer build is even bigger — both were designed around the size of their screens. It has a Raspi 4 and shows a dashboard with the weather, time, date, latest xkcd, and a few cryptocurrency prices. [dyoramic] has an even bigger version in the works that will use a 720 x 720 screen and a handful of brown key switches as inputs. We can’t wait to see that one! For now, check out the build and demo of the first two after the break.

What can’t you do with LEGO? It feels like we’ve seen it all, from cameras to microscopes to continuously variable transmissions. Wouldn’t you love to drive one of those around the block?

Continue reading “Working LEGO Space Computers Are A Chip Off The Old Block” →

An OLED Photo Frame Powered By The ATtiny85

July 19, 2021 by Tom Nardi 10 Comments

Rolling your own digital picture frame that loads images from an SD card and displays them on an LCD with a modern microcontroller like the ESP32 is an afternoon project, even less if you pull in somebody else’s code. But what if you don’t have the latest and greatest hardware to work with?

Whether you look at it as a practical application or an interesting experiment in wringing more performance out of low-end hardware, [Assad Ebrahim]’s demonstration of displaying digital photographs on an OLED using the ATtiny85 is well worth a look. The whole thing can put put together on a scrap of perfboard with a handful of common components, and can cycle through the five images stored on the chip’s flash memory for up to 20 hours on a CR2032 coin cell.

As you might expect, the biggest challenge in this project is getting all the code and data to fit onto the ATtiny85. To that end [Assad] wrote his own minimal driver for the SSD1306 OLED display, as the traditional Adafruit code took up too much space. The driver is a pretty bare bones implementation, but it’s enough to initialize the screen and get it ready for incoming data. His code also handles emulating I2C over Atmel’s Universal Serial Interface (USI) at an acceptable clip, so long as you bump the chip up to 8 MHz.

For the images, [Assad] details the workflow he uses to take the high-resolution color files and turn them into an array of bytes for the display. Part of that it just scaling down and converting to 1-bit color, but there’s also a bit of custom Forth code in the mix that converts the resulting data into the format his code expects.

This isn’t the first time we’ve seen somebody use one of these common OLED displays in conjunction with the ATtiny85, and it’s interesting to see how their techniques compare. It’s not a combination we’d necessarily chose willingly, but sometimes you’ve got to work with whats available.