Drive 1024×600 Pixels Via I2C With An ATtiny85

January 8, 2026 by Tyler August 10 Comments

If you need to drive a big screen for a project, it’s fair to say your first thought isn’t going to be to use the ATtiny85. With just 512 bytes of RAM and 8 kilobytes of flash memory, the 8-bit micro seems a little cramped to drive, say, a 10″ screen. Yet that’s exactly what [ToSStudio] is doing with TinyTFT_LT7683: 1024 x 600 pixels of TFT goodness, over I2C no less.

With the right TFT controller, this little micro-controller can do magic.

The name kind of gives away the secret: it won’t work on just any TFT display. It’s using properties of the LT7683 display driver, though if you don’t have one of those, the RA8875 is also compatible. Those drivers can take more than just a pixel stream– a good thing, since you’d be hard pressed to get that many pixels streaming from an ATtiny. These are character/graphic display drivers, which means you can get them to draw both characters and graphics on the screen if you speak the lingo.

It’s still not blazing fast; the documentation suggests “static or moderately dynamic UIs” as the suggested use case, and a clock is of the pre-programmed examples. From that, we can surmise that you can get 1 FPS or better with this code. You’re limited both by the simple micro-controller and the bandwidth of the I2C bus, but within those limits this seems like a very powerful technique.

This isn’t the first ATtiny graphics library to blow our minds, but if you really want an impressive graphics demo from the little micro that could, you really need to race the beam.

Thanks to [Thomas Scherer] for the tip!

ATtiny85 Mouse Jiggler Lets You Take A Break

June 3, 2024 by Tom Nardi 53 Comments

The good news is that more and more people are working from home these days. The bad news is that some of the more draconian employers out there aren’t too happy about it, to the point of using ~~spyware~~ software to keep tabs on their workers. Better make that bathroom break quick — Big Brother is watching!

One simple way to combat such efforts is a mouse jiggler, which does…well it does exactly what it sounds like. If you find yourself in need of such a device, the WorkerMouse from [Zane Bauman] is a simple open source design that can be put together with just a handful of components.

The WorkerMouse is designed to be assembled using through-hole parts on a scrap of perfboard, but you could certainly swap them out for their SMD variants if that’s what you have on hand. The circuit is largely made up out of passive components anyway, except for the ATtiny85 that’s running the show.

[Zane] decided to embrace modernity and couple the circuit with a USB-C breakout board, but naturally you could outfit it with whatever USB flavor you want so long as you’ve got a cable that will let you plug it into your computer.

The project’s C source code uses V-USB to connect to the computer and act as a USB Human Interface Device (HID). From there, it generates random speed and position data for a virtual mouse, and dumps it out every few seconds. The end result is a cursor that leaps around the screen whenever the WorkerMouse is plugged in, which should be enough to show you online while you step away from the computer. As an added bonus, [Zane] has put together a nice looking 3D printable enclosure for the board. After all, the thing is likely going to be sitting on your desk, might as well have it look professional.

If you’ve got the time to get a PCB made, you might also be interested in the MAUS we covered last year, which also keeps the ATtiny85 working so you don’t have to.

Photo of a smartphone with the ATTiny85 inserted into it, with a screen unlock pattern being drawn on the screen

ATtiny85 Automates Your Smartphone

March 2, 2023 by Arya Voronova 14 Comments

It might not seem too impressive these days, but when microcontrollers with hardware USB support were more expensive and rare, the VUSB library was often used to create USB devices with an ATtiny85. It became so popular that the ATtiny85 even got packaged into USB dongle formfactors, like the DigiSpark boards. Well, you might not know this, but your Android smartphones can also work with USB mice and touchscreens in lieu of the built-in touchscreen display. [ErfanSn] combined these two ideas, creating a library to automate smartphone touchscreen events and keyboard input with an ATtiny85 — open for all of us to use, and with examples to spare.

The library is called DigiCombo, and it comes with plenty of examples for any screen touch event emulation that you might want. For instance, check out the README — it has video examples for Instagram page scrolling, unlock screen brute-forcing with random coordinates, playing the Stack rhythm game, and pinch zoom — all the building blocks for your smartphone touch emulation needs are covered pretty well! Of course, all of these have example code corresponding to them, that you can download and base your own ideas on. What’s more, the library is available in current Arduino IDE under the DigiCombo name. So if you need to, say, make a quick autoclicker for your phone, the library is a few steps away!

If your smartphone project was stalled because you needed to emulate touchscreen input, this library is your chance to get it done! We appreciate projects that let us get more from smartphones — there’s a lot of those laying around, they’re pretty functional and self-sufficient devices, so it makes sense that some projects of ours could do with a phone instead of a Raspberry Pi. Some manufacturers let us get a bit more of our phones, but this hasn’t really caught on, which means we have to make do with help of libraries like these. Or, perhaps, you rely on your phone day-to-day, and you’d like to add a touchpad to its back?

Swap The Clock Chip On The Mac SE/30 With An ATTiny85

January 13, 2023 by Tom Nardi 20 Comments

As [Phil Greenland] explains in the first part of his excellent write-up, the lithium battery used to keep the real-time clock (RTC) going on the Macintosh SE/30 has a nasty habit of exploding and leaking its corrosive innards all over the board. Looking to both repair the damage on a system that’s already had a battery popped and avoid the issue altogether on pristine boards, he started researching how he could replace the battery with something a bit more modern.

It turns out, the ATtiny85 is pin-compatible with the Mac’s original RTC chip, and indeed, [Andrew Makousky] had already written some code that would allow the microcontroller to emulate it. This is actually a bit more complex than you might realize, as the original RTC chip was doing double-duty: it also held 256 bytes of parameter random access memory (PRAM), which is where the machine stored assorted bits of info like which drive to boot from and the mouse cursor speed.

But after getting the mod installed, the computer refused to start. It turns out the project targeted earlier machines like the Macintosh Plus and SE, and not his higher-performance SE/30. Thanks to community resources like this KiCad recreation of the SE/30’s motherboard, contemporary technical documents, and his trusty logic analyzer, [Phil] was able to figure out that the timing was off — the code was simply struggling to respond to the faster machine. Continue reading “Swap The Clock Chip On The Mac SE/30 With An ATTiny85” →

Hackaday Podcast 164: Vintage NASA Soldering, Mouse Bites, ATTiny85 Graphics, And PVC Pontoons

April 15, 2022 by Tom Nardi 1 Comment

Join Hackaday Editor-in-Chief Elliot Williams and Managing Editor Tom Nardi as they review the most interesting hacks and stories of the previous week. This time we’ll start things off by talking about the return of in-person events, and go over several major conventions and festivals that you should add to your calendar now. Then we’ll look at a NASA training film from the Space Race, an interesting radio-controlled quirk that Tesla has built into their cars for some reason, a very promising autonomous boat platform, and some high performance visuals generated by an ATtiny85. Stick around to find out what happens with an interplanetary probe looses its ride to space, and why the best new enclosure for your Raspberry Pi 4 might be a surveillance camera.

Check out the links below if you want to follow along, and as always, tell us what you think about this episode in the comments below!

Direct Download

Continue reading “Hackaday Podcast 164: Vintage NASA Soldering, Mouse Bites, ATTiny85 Graphics, And PVC Pontoons” →

Mindblowing Graphics From An ATtiny85

April 12, 2022 by Elliot Williams 24 Comments

[Görg Pflug] wrote in with his really nice graphics library. It’s got multiple layers, two text consoles, greyscale, internal halftoning, and sprites. It can pull off a number of classic graphics tricks and demos. Oh yeah, and did we mention it runs on a freaking ATtiny85 and an I2C OLED screen?!

This is an amazing piece of work — if you’d asked us if this was possible, we would have probably said “no”. And now it’s yours to use in your own projects. The GitHub repo is full of demos showing off everything from switching between multiple layers, extremely rapid text scrolls, animations, boing balls, and even a Wolfenstein-style raycaster. On an ATtiny85.

There’s a demo video, embedded below, that shows it all off, but honestly you have to think about what’s going to to be suitably wowed. The first demo just seems to have a graphic wave over static text, for instance. No big deal? It’s blending the greyscale layers together and dithering them out to black and white for the OLED in real time! On an ATtiny85.

While the library is written in straight C++, there are even a couple examples of how you’d integrate this with Arduino’s Wire library if you so wished. We don’t know about you, but this makes us want to whip together an ATtiny85 and SSD1306 OLED demo board just to start playing around. This isn’t just an amazing hack, but it would also be a useful way to add graphics and a nice console to any project you’re working on.

Did we mention it’s all done on an ATtiny85? Over I2C? Kudos!

Continue reading “Mindblowing Graphics From An ATtiny85” →

ATtiny85 Snake Game Is A Circuit Sandwich

March 26, 2022 by Kristina Panos 3 Comments

If there’s any looming, unwritten rule of learning a programming language, it states that one must break in the syntax by printing Hello, World! in some form or another. If any such rule exists for game programming on a new microcontroller, then it is certainly that thou shalt implement Snake.

This is [__cultsauce__]’s first foray away from Arduinoville, and although they did use one to program the ATtiny85, they learned a lot along the way.

It doesn’t take much to conjure Snake with an ’85 — mostly you need a screen to play it on (an OLED in this case), some buttons to direct the snake toward the food dot, a handful of passives, and a power source.

[__cultsauce__] started by programming the microcontroller and then tested everything on a breadboard, both of which are admirable actions. Then it was time to make this plywood and cork sandwich, which gives the point-to-point solder joints some breathing room and keeps them from getting crushed. Be sure to check it out in action after the break, and grab the files from GitHub if you want to charm your own ‘tiny Snake.

There’s a ton you can do with this miniature microcontroller, and that includes machine learning.

Continue reading “ATtiny85 Snake Game Is A Circuit Sandwich” →