💡 Overview
The ATTINY88 Micro Development Board is a compact, Arduino-compatible microcontroller board based on the Microchip ATtiny88 chip running at 16MHz. Think of it as a significant upgrade from the popular Digispark ATtiny85 — you get more I/O pins, more memory, and better peripheral support, all in a tiny Nano-like form factor with a convenient Micro-USB connector. Whether you're building a small sensor node, a wearable gadget, or just want a low-cost board to learn on, this little board punches well above its weight.
⭐ Key Features
- ATtiny88 Microcontroller — 8-bit AVR RISC architecture running at 16MHz
- Upgraded from ATtiny85 — Massively expanded I/O with 28 GPIO pins (vs. 8), 8 analog channels (vs. 4), and hardware I2C and SPI interfaces. Same 8KB Flash and 512B SRAM, but note the ATtiny88 has only 64 bytes of EEPROM (vs. 512 bytes on the ATtiny85).
- 28 GPIO Pins — Including 8 analog input channels, I2C (TWI), and SPI interfaces
- Micro-USB Programming — No external programmer needed; uses the Micronucleus bootloader for direct USB uploads
- Arduino IDE Compatible — Program using familiar Arduino sketches and libraries
- Compact Nano-Like Form Factor — Breadboard-friendly with dual inline header pins
- Onboard LED — Connected to Pin 0 (PD0) for quick testing
- Low Power — Microchip picoPower technology for battery-powered projects
- Voltage Regulator Onboard — Accepts 7–12V on the VIN pin
📋 Specifications
| Parameter | Details |
|---|---|
| Microcontroller | Microchip ATtiny88 |
| Architecture | 8-bit AVR RISC |
| Clock Speed | 16 MHz (external crystal) |
| Flash Memory | 8 KB (approx. 6 KB available after bootloader) |
| SRAM | 512 Bytes |
| EEPROM | 64 Bytes |
| Digital I/O Pins | 28 (active-high/low configurable) |
| Analog Input Channels | 8 (10-bit ADC) — A0 through A7 |
| PWM Outputs | 2 (Pin 9 / OC1A, Pin 10 / OC1B) |
| Communication Interfaces | I2C (TWI), SPI (no hardware UART) |
| USB Interface | Micro-USB (via Micronucleus bootloader, software USB) |
| Bootloader | Micronucleus v2.x (Digispark-compatible) |
| Operating Voltage | 5V |
| Input Voltage (VIN) | 7–12V DC |
| I/O Pin Voltage | 5V logic level |
| Max Current per I/O Pin | 40 mA |
| Onboard LED | Pin 0 (PD0) |
| Timer/Counters | 1 × 8-bit (Timer0), 1 × 16-bit (Timer1) |
| Board Dimensions | Approx. 44.5 × 18.3 × 3 mm (1.75 × 0.72 × 0.12 inches) L × W × H |
📌 Pin Map
The ATTINY88 board uses an Arduino-style pin numbering system. Here's a breakdown of the pin functions:
| Arduino Pin | ATtiny88 Port | Function(s) |
|---|---|---|
| D0 | PD0 | Digital I/O, Onboard LED |
| D1 | PD1 | Digital I/O |
| D2 | PD2 | Digital I/O, INT0 (External Interrupt) |
| D3 | PD3 | Digital I/O, INT1 (External Interrupt) |
| D4 | PD4 | Digital I/O |
| D5 | PD5 | Digital I/O |
| D6 | PD6 | Digital I/O |
| D7 | PD7 | Digital I/O |
| D8 | PB0 | Digital I/O |
| D9 | PB1 | Digital I/O, PWM (OC1A) |
| D10 | PB2 | Digital I/O, PWM (OC1B), SPI SS |
| D11 | PB3 | Digital I/O, SPI MOSI |
| D12 | PB4 | Digital I/O, SPI MISO |
| D13 | PB5 | Digital I/O, SPI SCK |
| A0 (D14) | PC0 | Analog Input / Digital I/O |
| A1 (D15) | PC1 | Analog Input / Digital I/O |
| A2 (D16) | PC2 | Analog Input / Digital I/O |
| A3 (D17) | PC3 | Analog Input / Digital I/O |
| A4 (D18) | PC4 | Analog Input / Digital I/O, I2C SDA |
| A5 (D19) | PC5 | Analog Input / Digital I/O, I2C SCL |
| A6 (D20) | PC6 | Analog Input / Digital I/O |
| A7 (D21) | PC7 | Analog Input / Digital I/O |
Important Pin Notes:
-
PWM: Only pins D9 and D10 support hardware PWM output via
analogWrite(). This is fewer than a standard Arduino Uno (which has 6 PWM pins). -
Analog Inputs: Use
A0throughA7constants withanalogRead(). These map to digital pins D14–D21. -
I2C: SDA is on A4 (pin 18), SCL is on A5 (pin 19). Use the
Wirelibrary (TinyWireM for some board packages). - SPI: MOSI (D11), MISO (D12), SCK (D13), SS (D10).
-
No Hardware UART: The ATtiny88 does not have a built-in hardware serial port. Use
SoftwareSerialif you need serial communication. - USB Pins: D1 and D2 are used by the Micronucleus USB bootloader during programming. Avoid using these pins for circuits that might interfere with USB communication.
💻 Setting Up the Arduino IDE
The ATTINY88 board uses the Micronucleus bootloader (the same family used by Digispark boards), so setup is a bit different from a standard Arduino. Follow these steps carefully:
Step 1: Install the Digispark USB Driver
Before the Arduino IDE can communicate with your board, your computer needs the correct USB driver.
Windows:
- Download the Digispark driver package from: https://github.com/digistump/DigistumpArduino/releases
- Extract the ZIP file and run
Install Drivers.exe(orDPinst64.exefor 64-bit systems). - Follow the on-screen prompts to complete installation.
- Important: Do NOT plug in the board until the driver installation is complete.
macOS: No driver installation is typically required. The board should be recognized automatically.
Linux: You may need to add a udev rule. Create a file /etc/udev/rules.d/49-micronucleus.rules with the following content:
SUBSYSTEMS=="usb", ATTR{idVendor}=="16d0", ATTR{idProduct}=="0753", MODE:="0666"
Then reload udev rules: sudo udevadm control --reload-rules
Step 2: Add the Board Manager URL
- Open the Arduino IDE.
- Go to File → Preferences (or Arduino IDE → Settings on macOS).
- In the "Additional Boards Manager URLs" field, add the following URL:
https://raw.githubusercontent.com/MHEtLive/arduino-boards-index/master/package_mhetlive_index.json
- Click OK to save.
Step 3: Install the Board Package
- Go to Tools → Board → Boards Manager.
- Search for "MH-ET" in the search box.
- Find "MH-ET LIVE Boards" and click Install.
- Wait for the installation to complete.
Step 4: Select the Board
- Go to Tools → Board.
- Under the MH-ET LIVE Boards section, select "MH-ET LIVE Tiny88 (16.0MHz)".
- Under Tools → Programmer, select "Micronucleus".
🚀 Uploading Your First Sketch
Programming the ATtiny88 is a little different from programming a standard Arduino board. The most important thing to understand is the upload sequence:
Key Difference:With a regular Arduino, you plug the board in first, then upload. With the ATtiny88, you click Upload first, then plug the board in when prompted. This is because the Micronucleus bootloader only listens for new code for about 5 seconds after the board is powered on.
The ATtiny88 Upload Sequence
- Do NOT plug in the board yet.
- Write or open your sketch in the Arduino IDE.
- Click the Upload button (or press Ctrl+U / Cmd+U).
- The IDE will compile the sketch and then display a message: "Please plug in the device..." (or similar, depending on the version).
- Now plug in the board via the Micro-USB cable.
- The upload will begin automatically. You'll see progress in the console.
- Once complete, the sketch will start running immediately.
Tip: If the upload fails, unplug the board, click Upload again, and re-plug when prompted. The bootloader has a short 5-second window to accept uploads after being plugged in.
🔧 Example: Blink the Onboard LED
The classic "Hello World" of microcontrollers. The onboard LED is connected to Pin 0 on this board.
// Blink - ATTINY88 Onboard LED
// The onboard LED is on Pin 0
void setup() {
pinMode(0, OUTPUT); // Set Pin 0 as output
}
void loop() {
digitalWrite(0, HIGH); // LED ON
delay(1000); // Wait 1 second
digitalWrite(0, LOW); // LED OFF
delay(1000); // Wait 1 second
}
Upload this sketch using the plug-in method described above. If the onboard LED blinks on and off every second, your board and IDE setup are working correctly.
🔧 Example: Reading an Analog Sensor
This example reads a potentiometer (or any analog sensor) on pin A0 and blinks the LED at a rate proportional to the reading.
// Analog Read - ATTINY88
// Reads A0 and adjusts LED blink rate
int sensorValue = 0;
void setup() {
pinMode(0, OUTPUT); // Onboard LED
}
void loop() {
sensorValue = analogRead(A0); // Read analog pin A0
digitalWrite(0, HIGH);
delay(sensorValue); // Delay based on reading (0-1023 ms)
digitalWrite(0, LOW);
delay(sensorValue);
}
🔧 Example: I2C Scanner
This sketch scans the I2C bus and reports the addresses of any connected devices. Useful for verifying I2C sensors and displays are wired correctly.
// I2C Scanner - ATTINY88
// Scans for I2C devices on SDA (A4) and SCL (A5)
#include <Wire.h>
void setup() {
Wire.begin();
pinMode(0, OUTPUT); // Use onboard LED for feedback
}
void loop() {
byte deviceCount = 0;
for (byte address = 1; address < 127; address++) {
Wire.beginTransmission(address);
byte error = Wire.endTransmission();
if (error == 0) {
deviceCount++;
}
}
// Blink LED once for each device found
for (byte i = 0; i < deviceCount; i++) {
digitalWrite(0, HIGH);
delay(200);
digitalWrite(0, LOW);
delay(200);
}
delay(2000); // Wait before scanning again
}
Note: Since the ATtiny88 has no hardware UART, you can't use Serial.print() to output I2C addresses to a serial monitor in the traditional way. The LED blink count method above is a simple workaround. For full serial output, you would need to use SoftwareSerial on available pins.
🔌 Compatible With
- Arduino IDE — Version 1.6.x and later (including Arduino IDE 2.x)
- I2C Devices — OLED displays (SSD1306), temperature sensors (BMP280, DHT series via digital pin), real-time clocks (DS3231), and more
- SPI Devices — SD card modules, shift registers, LED drivers
- Sensors — Analog sensors (potentiometers, photoresistors, thermistors), digital sensors (PIR, ultrasonic via digital pins)
- LEDs and Displays — Individual LEDs, LED strips (with appropriate drivers), I2C LCD/OLED displays
- Breadboards — Standard solderless breadboards (dual inline pin headers)
- Operating Systems — Windows 7/8/10/11, macOS, Linux
🎯 Typical Applications
- Learning and prototyping with Arduino-compatible code
- Compact sensor nodes for IoT projects
- Wearable electronics and small embedded systems
- LED controllers and lighting effects
- Environmental monitoring (temperature, humidity, light)
- USB-connected input devices and controllers
- Battery-powered data loggers
- Robotics sub-controllers
- Replacement/upgrade for Digispark ATtiny85 projects needing more I/O
🛠️ Troubleshooting
| Problem | Possible Cause | Solution |
|---|---|---|
| Board not recognized by computer | Missing USB driver | Install the Digispark/Micronucleus USB driver (see setup section above) |
| "Please plug in device" never completes | Board plugged in too early or too late | Click Upload first, wait for the prompt, then plug in the board within 5 seconds |
| Upload fails with timeout error | Bootloader timing issue | Unplug the board, click Upload again, and re-plug when prompted. Try a different USB port or cable. |
| Board not listed in Arduino IDE | Board package not installed | Add the MH-ET LIVE board manager URL and install the package (see setup steps) |
| Sketch compiles but doesn't work | Wrong board selected in IDE | Verify "MH-ET LIVE Tiny88 (16.0MHz)" is selected under Tools → Board |
analogWrite() not working on a pin |
Pin doesn't support PWM | Only pins D9 and D10 support hardware PWM on the ATtiny88 |
Serial.print() not working |
No hardware UART | The ATtiny88 has no hardware serial. Use SoftwareSerial library instead. |
| I2C device not detected | Wrong pins or missing pull-ups | Connect SDA to A4 (pin 18) and SCL to A5 (pin 19). Add 4.7kΩ pull-up resistors if not on the device module. |
| Sketch too large | Limited flash memory | Only ~6KB is available for sketches (bootloader uses ~2KB). Optimize code or remove unused libraries. |
⚠️ Important Notes
-
No Hardware UART: The ATtiny88 does not include a hardware serial port (USART). If your project requires serial communication, use the
SoftwareSeriallibrary. - Limited PWM: Only 2 PWM-capable pins (D9 and D10) are available, compared to 6 on an Arduino Uno.
- Limited Flash: With 8KB total Flash and ~2KB used by the Micronucleus bootloader, you have approximately 6KB for your sketch. Keep code lean and avoid large libraries.
- Small EEPROM: Only 64 bytes of EEPROM are available — significantly less than the ATtiny85's 512 bytes or the ATmega328P's 1KB. Plan data storage accordingly.
- USB Pin Conflict: Pins D1 and D2 are shared with the USB interface. Avoid connecting components to these pins that could interfere with programming.
- 5V Logic Only: All I/O pins operate at 5V logic levels. Use a level shifter when connecting to 3.3V devices to avoid damage.
- Upload Sequence: Always click Upload in the IDE first, then plug in the board when prompted. This is the opposite of how most Arduino boards work.
- Not a Full Arduino Replacement: While Arduino-compatible, the ATtiny88 has fewer peripherals and less memory than an ATmega328P (Arduino Uno/Nano). It's ideal for simpler, space-constrained projects.
- Header Pins: The header pins are typically shipped unsoldered. You'll need a soldering iron to attach them before using the board with a breadboard.
🏪 Where to Buy the ATtiny88
The ATtiny88 Development Board is available at Envistia Mall.
Buy the ATtiny88 Development Board →
- 📦 Fast Free US Shipping
- 🔄 Hassle-Free Returns
- 📧 Responsive Customer Support
📚 Additional Resources
- Microchip ATtiny88 Product Page & Datasheet
- MH-ET LIVE Board Manager JSON (for Arduino IDE)
- Digispark USB Driver Downloads
- Micronucleus Bootloader GitHub Repository
- Getting Started With MH-ET LIVE Tiny88 (Instructables)
This user guide is provided by Envistia Mall for informational and educational purposes. While we strive for accuracy, specifications and procedures may change over time. Always refer to the latest manufacturer documentation for critical applications. Envistia Mall is not responsible for any damages resulting from the use or misuse of this information.