Drawing On An OLED With An ATtiny85, No RAM Buffers Allowed

November 1, 2018 by Donald Papp 24 Comments

Small I2C OLED displays are common nowadays, and thanks to the work of helpful developers, there are also a variety of graphics libraries for using them. Most of them work by using a RAM buffer, which means that anything one wants to draw gets written to a buffer representing the screen, and the contents of that buffer are copied out to the display whenever it is updated. The drawback is that for some microcontrollers, there simply isn’t enough RAM for this approach to work. For example, a 128×64 monochrome OLED requires a 1024 byte buffer, but that’s bad news if a microcontroller has only 512 bytes of RAM in total like the ATtiny85. [David Johnson-Davies] has two solutions: a Tiny Graphics Library that needs no RAM buffer and an even slimmer Tiny Function Plotter, which we’ll discuss in order.

*Tiny Function Plotter* works on both SSD1306 and SH1106-based displays.

[David]’s Tiny Graphics Library works by taking advantage of a feature of SH1106 driver-based displays: the ability to read the display over I2C as well as write to it. With the ability to perform read-modify-write on a section at a time, using a large RAM buffer can be avoided. The only catch is that the library only works with OLEDs using the SH1106, but the good news is that these are very common at the usual Chinese resellers. ([David] notes that SH1106 is sometimes misspelled as “SSH1106”, so keep that in mind when searching.)

What about all those other SSD1306-based OLED displays out there? Are they out of luck? Not quite. [David] has one more trick up his sleeve: his Tiny Function Plotter works on the SSD1306 and also requires no RAM buffer. It’s unable to write text, but it can easily handle drawing graphs plotting things like values over time while needing very little overhead.

Another approach we’ve seen for using OLEDs driven by microcontrollers with limited memory is the solution [Michael] used in Tiny Sideways Tetris, which was done in part by realizing the smallest screen element he needed was a 4×4 block, and using that premise as the basis of a simple compression scheme.

Want To Learn Ethernet? Write Your Own Darn AVR Bootloader!

October 30, 2018 by Elliot Williams 25 Comments

There’s a school of thought that says that to fully understand something, you need to build it yourself. OK, we’re not sure it’s really a school of thought, but that describes a heck of a lot of projects around these parts.

[Tim] aka [mitxela] wrote kiloboot partly because he wanted an Ethernet-capable Trivial File Transfer Protocol (TFTP) bootloader for an ATMega-powered project, and partly because he wanted to understand the Internet. See, if you’re writing a bootloader, you’ve got a limited amount of space and no device drivers or libraries of any kind to fall back on, so you’re going to learn your topic of choice the hard way.

[Tim]’s writeup of the odyssey of cramming so much into 1,000 bytes of code is fantastic. While explaining the Internet takes significantly more space than the Ethernet-capable bootloader itself, we’d wager that you’ll enjoy the compressed overview of UDP, IP, TFTP, and AVR bootloader wizardry as much as we did. And yes, at the end of the day, you’ve also got an Internet-flashable Arduino, which is just what the doctor ordered if you’re building a simple wired IoT device and you get tired of running down to the basement to upload new firmware.

Oh, and in case you hadn’t noticed, cramming an Ethernet bootloader into 1 kB is amazing.

Speaking of bootloaders, if you’re building an I2C slave device out of an ATtiny85¸ you’ll want to check out this bootloader that runs on the tiny chip.

Short Length Of Wire Turns STM32 Microcontroller Into Good-enough Wireless UART Blaster

October 29, 2018 by Brian Boucheron 22 Comments

Hackaday regular [befinitiv] wrote into the tip line to let us know about a hack you might enjoy, wireless UART output from a bare STM32 microcontroller. Desiring the full printf debugging experience, but constrained both by available space and expense, [befinitiv] was inspired to improvise by a similar hack that used the STM32 to send Morse code over standard FM frequencies.

In this case, [befinitiv]’s solution is both more useful and slightly more legal, as the software uses the 27 MHz ISM band to blast out ASK modulated serial data through a simple wire antenna attached to one of the microcontroller’s pins. The broadcast can then be picked up by an RTL-SDR receiver and interpreted back into a stream of data by GNU Radio.

The software for the STM32 and the GNU Radio Companion graph are both available on Bitbucket. The blog post goes into some detail explaining how the transmitter works and what all the GNU Radio components are doing to claw the serial data back from the ether.

[cover image cc by-sa licensed by Adam Greig, randomskk on Flickr]

A Multifunction ESP8266 Smartwatch

October 26, 2018 by Tom Nardi 11 Comments

Most of the DIY smartwatch projects we feature here on Hackaday aren’t exactly what most people would consider practical daily-use devices. Clunky designs, short battery life, limited functions: they’re more a wearable display of geek cred than they are functional timepieces. Oddly enough, the same could be said of many of the “real” smartwatches on the market, so perhaps the DIY versions are closer to the state-of-the-art than we thought.

But this ESP8266 smartwatch created by [Shyam Ravi] is getting dangerously close to something you could unironically leave the house with. It’s still missing an enclosure that prevents you from receiving PCB acupuncture while wearing it, but beyond than that it has a more than respectable repertoire of functions. It even seems to be a fairly reasonable size (with the potential to be even smaller). All that with a total build cost of less than $20 USD, and we’re thinking this might be a project to keep an eye on.

Not content with a watch that simply tells the time, [Shyam] added in a weather function that pulls the current conditions for his corner of the globe from the Yahoo weather API and displays it above the time and date on the watch’s multi-color OLED display when the center button is pressed. Frankly, given the state of DIY watches, that would already have been impressive enough; but he didn’t stop there.

The left and right buttons control Internet-connected relays which [Shyam] uses to turn his lights and air conditioner on and off. When he presses the corresponding button, the watch will even display the status of the devices wherever his travels might take him.

A smattering of DIY watches pass by our careful gaze, though it’s been a while since we’ve seen an ESP8266 watch. More recently we’ve seen an Arduino watch, and some downright gorgeous analog creations.

Continue reading “A Multifunction ESP8266 Smartwatch” →

Turning The Deep Note Into A Game

October 21, 2018 by Brian Benchoff 13 Comments

One of the most famous pieces of computer-generated music is the Deep Note, the audio trademark for THX. It begins with a dozen or so voices, randomly tuned between 200 and 400 Hz, then glissandos to a frequency spread of three octaves. Put that through a few thousand watts of a speaker system, play it before Jedi, and the audience will be listening.

The original THX Deep Note was created on hundreds of thousands of dollars worth of hardware running 20,000 lines of code, but that was in 1983. Now we have cheap microcontrollers, so of course, you can now fit the Deep Note in your pocket. You can even make it a game. That’s exactly what [Bob] did with his Deep Synth. It’s the Deep Note, in a Game Boy-ish format.

The hardware for this build is the 1Bitsy 1UP, a retro-inspired handheld game console from [Bob]’s friend [Pitor]. Onboard the 1Bitsy is an STM32 F4 running at 168 MHz with a 2.8″ LCD, SD card reader, and the traditional Game Boy control scheme. All the games are up to you.

[Bob] wrote an audio driver for the 1UP, but needed a good audio demo. Since the Deep Note was a good enough demo for Lucasfilms, it would obviously be a good enough demo for a microcontroller. In far less than 20,000 lines of code, [Bob] made the 1UP polyphonic, and it was surprisingly fast enough to synthesize around thirty oscillators. It actually sounds like the Deep Note, too. You can check out a video (and audio) of that after the break.

Continue reading “Turning The Deep Note Into A Game” →

I2C Bootloader For ATtiny85 Lets Other Micros Push Firmware Updates

October 20, 2018 by Donald Papp 15 Comments

There are a few different ways of getting firmware onto one of AVR’s ATtiny85 microcontrollers, including bootloaders that allow for firmware to be updated without the need to plug the chip into a programmer. However, [casanovg] wasn’t satisfied with those so he sent us a tip letting us know he wrote an I2C bootloader for the ATtiny85 called Timonel. It takes into account a few particulars of the part, such as the fact that it lacks a protected memory area where a bootloader would normally reside, and it doesn’t have a native I2C interface, only the USI (Universal Serial Interface). He’s just released the first functional version for the ATtiny85, but there’s no reason it couldn’t be made to work with the ATtiny45 and ATtiny25 as well.

Timonel is designed for systems where there is a more powerful microcontroller or microprocessor running the show (such as an ESP8266, Arduino, or even a board like a Raspberry Pi.) In designs where the ATtinys are on an I2C bus performing peripheral functions such as running sensors, Timonel allows the firmware for these peripheral MCUs to be updated directly from the I2C bus master. Embedded below is a video demo of [casanovg] sending simple serial commands, showing a successful firmware update of an AVR ATtiny85 over I2C.

Continue reading “I2C Bootloader For ATtiny85 Lets Other Micros Push Firmware Updates” →

A New Kid On The Mini ARM Block

October 11, 2018 by Jenny List 30 Comments

The breadboard microcontroller experimenter has a host of platforms to work with that can be had in the familiar DIP format. Old-school people can still find classic 8-bit platforms, the Ardunisti have their ATMegas, and PIC lovers have a pile of chips to choose from. But ARM experimenters? Out of luck, because as we have previously reported, popular past devices such as the LPC810 in a DIP8 package are now out of production.

News comes from China though of a tiny ARM Cortex M0 for pennies that may not be in a DIP8, but is in almost the next best thing. The Synwit SWM050 can be had in a TSOP8, which though it’s not quite as friendly as its larger SOIC8 cousin, is still easily solderable onto a DIP8 adaptor for breadboard use. Spec-wise it’s 5 V tolerant, has an 8 kB FLASH and 1 kB of RAM, 6 GPIOs, and can clock away at a not incosequential 36 MHz.

We have [Sjaak] to thank for the discovery of this device, and for doing a lot of work including getting some die shots taken to dig up and make sense of the Chinese documentation, and to provide some dev tools should anyone want to play with it. There’s even a small breakout board for the experimenter unwilling to design their own.

Earlier this year we marked the passing of the DIP8 version of the LPC810 microcontroller, and for those mourning it we made an important point. It’s now normal to use one of the vast array of single board computers instead of a bare microcontroller, you might wish to ask yourself why you would do so.

Thanks [Ziew] for the tip.