Building An ESP8266 Game System With MicroPython

After a seemingly endless stream of projects that see the ESP8266 open doors or report the current temperature, it can be easy to forget just how powerful the little WiFi-enabled microcontroller really is. In fact, you could argue that most hackers aren’t even scratching the surface of what the hardware is actually capable of. But that’s not the case for [Brian Wagner] and his students from the Kentucky Country Day School.

Their project, the GamerGorl, is a completely custom handheld game system running on a Wemos D1 Mini development board. The team’s PCB, which was developed over several iterations, is essentially a breakout board which allows them to easily connect up peripheral devices. Given the low total component cost of the GamerGorl and relative simplicity of its construction, it looks like a phenomenal project for older STEM students.

Beyond the ESP8266 board, the GamerGorl features a SSD1106 1.3″ OLED display, a buzzer for sound effects, two tactile buttons, and an analog joystick originally intended for an Xbox controller. Around the backside there’s a WS2812B RGB LED strip that’s at least partially for decoration, but it’s also actively used in some of the games such as the team’s take on Simon.

Even if you aren’t in the market for a portable game system, the GameGorl does provide an interesting case study for MicoPython applications on the Wemos D1 Mini. Browsing through the team’s source code as well as the helpful hints that [Brian] gives about getting the software environment up and running could be useful if you’re looking to expand your ESP8266 programming repertoire. We’d also love to see this device running the “ESP Little Game Engine” we covered recently.

Continue reading “Building An ESP8266 Game System With MicroPython”

The Galaxy Fold, Or Why Flexible OLED May Not Yet Be Ready For Prime Time

Samsung’s fancy new high-end smartphone with a flexible, foldable OLED display has been failing in worrying numbers for the first reviewers who got their hands on one. Now iFixit has looked into the issue using their considerable amount of smartphone tear-down experience to give their two cents. They base many of their opinions on the photos and findings by the Verge review, who were one of the (un)lucky ones to have their unit die on them.

The Galaxy Fold was supposed to be this regular smartphone sized phone which one can open up fully to reveal a tablet-sized display inside. The use of a flexible OLED display was supposed to create a seamless display without the annoying center line that having two individual displays would produce. Unfortunately it’s this folding feature which produces issues.

As iFixit notes, OLEDs are rather fragile, with their own tear-downs of regular OLED-equipped devices already often resulting in the damaging of the display edges, which spells doom for the internals of them as oxygen and other contaminants can freely enter. This means that maintaining this barrier is essential to keep the display functioning.

This is probably the reason why Samsung chose to install a screen protector on the display, which unfortunately was mistaken for a protective foil as found on many devices. The subsequent removal of this protector by some reviewers and the mechanical stress this caused destroyed some screens. Others had debris trapped in the fold between both halves of the display, which caused visible bumps in the display when opened.

The relatively massive spacing between the hinge and the display seems almost purposefully engineered to allow for the ingress of debris. This combines with the lack of any guiding crease in the center of the display and the semi-random way in which humans open and close the Fold compared to the perfectly repeating motion of the folding robots Samsung used to test the display. It seems that Samsung and others still have some work to do before they can call folding OLED displays ready for production.

Finally, have a look at this video of Lewis from UnboxTherapy pulling a folding robot with opening and closing a Fold one-thousand times:


A Year-Long Experiment In OLED Burn-In

If you need to add a small display to your project, you’re not going to do much better than a tiny OLED display. These tiny display are black and white, usually found in resolutions of 128×64 or some other divisible-by-two value, they’re driven over I2C, the libraries are readily available, and they’re cheap. You can’t do much better for displaying a few numbers and text than an I2C OLED. There’s a problem, though: OLEDs burn out, or burn in, depending on how you define it. What’s the lifetime of these OLEDs? That’s exactly what [Electronics In Focus] is testing (YouTube, in Russian, so click the closed captioning button).

The experimental setup for this is eleven OLED displays with 128×64 pixels with an SSD1306 controller, all driven by an STM32 over I2C. Everything’s on a breadboard, and the actual display is sixteen blocks, each lit one after another with a one-second display in between. This is to test gradually increasing levels of burnout, and from a surface-level analysis, this is a pretty good way to see if OLED pixels burn out.

After 378 days of testing, this test was stopped after there were no failed displays. This comes with a caveat: after a year of endurance testing, there were a few burnt out pixels. correlating with how often these pixels were on. The solution to this problem would be to occasionally ‘jiggle’ the displayed text around the screen, turn the display off when no one is looking at it, or alternatively write a screen saver for OLEDs. That last bit has already been done, and here are the flying toasters to prove it. This is an interesting experiment, and although that weird project you’re working on probably won’t ping an OLED for a year of continuous operation, it’s still something to think about. Video below.

Continue reading “A Year-Long Experiment In OLED Burn-In”

Vintage Camera Flash Turned OLED Desk Clock

After covering a few of his builds at this point, we think it’s abundantly clear that [Igor Afanasyev] has a keen eye for turning random pieces of antiquated hardware into something that’s equal parts functional and gorgeous. He retains the aspects of the original which give it that unmistakable vintage look, while very slickly integrating modern components and features. His work is getting awfully close to becoming some kind of new art form, but we’re certainly not complaining.

His latest creation takes an old-school “Monopak” electronic flash module and turns it into a desk clock that somehow also manages to look like a vintage television set. The OLED displays glowing behind the original flash diffuser create an awesome visual effect which really sells the whole look; as if the display is some hitherto undiscovered nixie variant.

On the technical side of things, there’s really not much to this particular build. Utilizing two extremely common SSD1306 OLED displays in a 3D printed holder along with an Arduino to drive them, the electronics are quite simple. There’s a rotary encoder on the side to set the time, though it would have been nice to see an RTC module added into the mix for better accuracy. Or perhaps even switch over to the ESP8266 so the clock could update itself from the Internet. But on this build we get the impression [Igor] was more interested in playing with the aesthetics of the final piece than fiddling with the internals, which is hard to argue with when it looks this cool.

Noticing the flash had a sort of classic TV set feel to it, [Igor] took the time to 3D print some detail pieces which really complete the look. The feet on the bottom not only hold the clock at a comfortable viewing angle, but perfectly echo the retro-futuristic look of 50s and 60s consumer electronics. He even went through the trouble of printing a little antenna to fit into the top hot shoe, complete with a metal ring salvaged from a key-chain.

Late last year we were impressed with the effort [Igor] put into creating a retro Raspberry Pi terminal from a legitimate piece of 1970’s laboratory equipment, and more recently his modern take on the lowly cassette player got plenty of debate going. We can’t wait to see what he comes up with next.

Continue reading “Vintage Camera Flash Turned OLED Desk Clock”

DIY Six Channel Arduino RC Transmitter

It’s wasn’t so long ago that RC transmitters, at least ones worth owning, were expensive pieces of gear. Even more recently than that, the idea of an RC transmitter running an open source firmware would have been considered a pipe dream. Yet today buying cheap imported transmitters and flashing a community developed firmware (if it didn’t come with it pre-installed to begin with) is common place. It’s not much of a stretch to say we’re currently in the “Golden Age” of hobby RC transmitters.

But what if even cheap hardware running customizable software isn’t enough? What if you want to take it to the next level? In that case, [Electronoobs] has an Arduino powered RC transmitter with your name on it. But this is no scrap of protoboard with a couple of cheap joysticks on it, though he has made one of those too. The goal of this build was for it to look and perform as professional as possible while remaining within the hobbyist’s capabilities. The final product probably won’t be winning any design awards, but it’s still an impressive demonstration of what the individual hacker and maker can pull off today with the incredible technology we have access to.

So what goes into this homebrew radio control system? Inside the back panel [Electronoobs] mounted the batteries, charging module, and the voltage regulator which steps the battery voltage down to the 3.3 V required to drive the rest of the transmitter’s electronics. On the flip side there’s an Arduino Nano, an NRF24 module, and an OLED display. Finally we have an assortment of switches, buttons, potentiometers, and two very nice looking JH-D202X-R2 joysticks for user input.

As you might have guessed, building your own transmitter means building your own receiver as well. Unfortunately you won’t be able to bind your existing RC vehicles to this radio, but since the receiver side is no more complicated than another Arduino Nano and NRF24 module, it shouldn’t be hard to adapt them if you were so inclined.

Low-cost consumer RC transmitters can be something of a mixed bag. There are some surprisingly decent options out there, but it’s not a huge surprise that hackers are interested in just spinning up their own versions either.
Continue reading “DIY Six Channel Arduino RC Transmitter”

Custom Calculator Rolls D20 So You Don’t Have To

There are a number of sticking points that can keep new players away from complex tabletop games such as Dungeons & Dragons. Some people are intimidated by the math involved, and of course others just can’t find enough friends who are willing to sit down and play D&D with them in 2019. While this gadget created by [Caleb Everett] won’t help you get more open minded friends, it will take some of the mental gymnastics out of adding up dice rolls.

In its current form the device saves you from the hassle of not only having to roll various combinations of physical dice, but adding up all the faces after the fact as well. In the future [Caleb] plans on adding more advanced software features which will allow for tricks not possible with real dice, such as increasing the likelihood of rolling numbers which haven’t been seen in awhile. Now that the hardware is put together, he’s free to dig into the software side of things and really get creative.

Inside the 3D printed case of his calculator there’s a Adafruit Feather M0 Express, a 128 x 32 OLED display, and a 2200 mAh lithium ion battery that lets him go mobile. The keys, which are Cherry MX clones, are wired directly to the digital pins of the Feather board as [Caleb] found that easier to wrap his head around than doing a matrix. This ended up working out as he had enough pins, but does stifle future expansion a bit.

Even if you aren’t into the sort of tabletop gaming which would benefit from an automatic dice roller and tabulator, we think [Caleb] has come up with a very neat form factor for similar pocket sized gadgets. It reminds us of the Handlink fromĀ Quantum Leap; before the prop department swapped it out for a jumble of gummy bears later on in the series, anyway. Since he’s shared the link to the OnShape project, you can even tweak the design a bit without having to suffer through modifying the STLs.

Many of the electronic dice we’ve seen in the past have tried to emulate the size and appearance of traditional dice, so it’s interesting to see this approach which goes in the opposite direction entirely. Critics might say that at some point you’d be better off just using a software application for your smartphone, but we’re not in the business of complaining when people produce interesting pieces of hardware.

Multiple OLEDs? Save Pins By Sharing the I2C Clock

Inexpensive OLED displays with I2C interfaces abound, but there is a catch: they tend to be stuck on I2C address 0x3C. Some have a jumper or solder pads to select an alternate (usually 0x3D), but they lack any other method. Since an I2C bus expects every device to have a unique address, this limits the number of displays per bus to one (or two, at best.) That is all still true, but what [Larry Bank] discovered is a way to get multiple OLED displays working with considerably fewer microcontroller pins than usually needed.

While bit-banging I2C to host one display per bus on the same microcontroller, an idea occurred to him. The I2C start signal requires both clock (SCL) and data (SDA) to be brought low together, but what would happen if the displays shared a single clock line? To be clear, each OLED would — logically speaking — still be on its own I2C bus with its own data line, but they would share a clock signal. Would a shared clock cause attached devices to activate unintentionally?

A quick test consisting of four OLED displays (all with address 0x3C) showed that it was indeed possible to address each display with no interference if they shared a clock. Those four individually controlled displays needed only five I/O lines (four SDA, one shared SCL) instead of eight. The Multi_OLED library is available on GitHub, and in case it is useful for devices other than OLED displays, bit-banged I2C with support for shared clock lines is available separately.

There’s more to do with OLEDs than get clever with signals: check out these slick number-change animations, and that even looks to be a project that could benefit from a few saved GPIO pins, since it uses one small display per digit.