Revisiting the ATtiny1614#

Today I was taking a second look at some ATtiny1614 microcontrollers I found in my parts drawer from a previous project that never quite made it past the concept stage.

They are quite impressive for the price — around £0.67 each — and, in my case, are powerful enough to act as additional microcontrollers on a board if you want to offload certain tasks from the main controller.

They can operate as SPI or I2C slave devices, which is useful when working with multiple peripherals and you want to avoid overloading the main controller, or if you are developing some kind of modular or plugin-style architecture.

While the ATtiny1614 is an 8-bit microcontroller running at 20 MHz, which means it does not fall into the high-performance category, it still comes packed with features and is more than capable of handling a range of supporting tasks.

For example, it would be quite suitable for:

  • monitoring sensors
  • handling basic HMI inputs such as keyboards, joysticks, or capacitive touch inputs
  • driving simple OLED or LCD interfaces
  • managing smaller background control tasks that do not need to run on the main processor

In other words, they are the sort of chip that can quietly take care of the supporting work in a design, leaving the main controller free to focus on more demanding tasks — such as driving an LVGL-based display with a higher pixel count.

Using Small MCUs as Co-Processors#

One approach I’ve been considering is using small microcontrollers like the ATtiny1614 as dedicated co-processors within a larger system.

Rather than trying to do everything on a single MCU, responsibilities can be split:

  • Main controller → UI, networking, complex logic
  • ATtiny → real-time IO, input scanning, simple control loops

This keeps timing predictable and reduces the load on the main system.

There are, of course, alternatives to the ATtiny series of microcontrollers for these kinds of tasks, such as the Puya PY32F003 (Cortex-M0 based) or the CH32V003 (RISC-V based). These parts can offer more performance for a similar cost, but typically require additional development effort due to tooling, documentation, and ecosystem maturity. Availability and supply consistency may also need to be considered depending on where you are sourcing parts.

It also helps that the ATtiny is relatively simple to program. Using its one-wire UPDI interface (typically shared with the reset pin), it can be programmed with minimal hardware — for example by converting an Arduino Nano into a UPDI programmer, or by using a dedicated programmer such as the Adafruit UPDI Friend.

My Use Case#

I’m considering using these in a controller-based project. One device would monitor analogue joysticks, while another would handle buttons and switches. A higher-level controller, such as an ESP32-C3 or ESP32-C6, would aggregate and transmit the system state.

Communication between devices could be handled over I2C or SPI, depending on timing and system requirements.

The idea is not fully formed yet, but I like to keep a mental (or written) library of potential designs that can be used as a starting point for prototyping, before refining and moving towards production.

        +----------------------+
        |     ESP32-C3 / C6    |
        |  Comms / Display     |
        +----------+-----------+
                   |
               I2C / SPI
        +----------+-----------+
        |                      |
+-------+-------+      +-------+-------+
| ATtiny1614    |      | ATtiny1614    |
| Joysticks     |      | Buttons       |
+---------------+      +---------------+

This kind of structure allows input handling and timing-sensitive tasks to be isolated from the main application logic, reducing latency and simplifying the overall system design.

I run Protoworks (NI) in Northern Ireland, helping small businesses design prototypes and build custom software. If you have a hardware or software idea you’d like to sketch out, feel free to get in touch.