Arduino Gemma: Your Tiny Wearable Computing Companion
The Arduino Gemma is a small, sewable microcontroller board designed for wearable projects and rapid prototyping.
The Arduino Gemma is a compact microcontroller board designed by Adafruit and the Arduino team, specifically for wearable technology and small-scale projects. Released around 2014, it was one of the first boards to focus on integrating electronics into fabric and fashion. Its small size and ease of use make it ideal for beginners looking to experiment with interactive textiles and embedded systems without the complexity of larger boards.
At the heart of the Arduino Gemma is the ATtiny85 microcontroller, a popular choice for low-power, small-form-factor applications. The ATtiny85 is an 8-bit AVR microcontroller that, while less powerful than the ATmega328P found on boards like the Arduino Uno, offers sufficient processing power and peripherals for many embedded tasks. It features 8KB of Flash memory for program storage and 512 bytes of SRAM for data, making it suitable for simple programs and sensor readings.
The Gemma occupies a niche in the Arduino family as a specialized, low-cost, and extremely small board. It shares the Arduino programming environment and libraries, making it accessible to users familiar with the Arduino IDE. Unlike many other Arduino boards that use USB for programming directly, the Gemma relies on an external programmer (like an Arduino Uno or FTDI adapter) via its ICSP header, as it lacks a built-in USB-to-serial converter. This design choice contributes to its minimal size and cost.
This board is particularly well-suited for makers, students, and designers who want to embed intelligence into clothing, accessories, or small interactive devices. Its sewable headers allow for direct integration with conductive thread, simplifying the creation of electronic circuits within textiles. Projects can range from simple LED blinkers and color changers to more complex interactive installations that respond to touch, light, or motion.
Watch
Related video, embedded from YouTube.
Specifications
| Microcontroller / SoC | ATtiny85 |
| Architecture | AVR 8-bit |
| Clock speed | 8 MHz |
| Flash / Storage | 8 KB (5 KB available for user code) |
| RAM / SRAM | 512 Bytes |
| Operating voltage | 3.3V |
| Digital I/O pins | 5 (shared with other functions) |
| Analog / ADC | 4 (on PB0, PB1, PB2, PB3) |
| PWM | 3 (on PB0, PB1, PB2) |
| Connectivity | — |
| USB | — (requires external programmer for uploading) |
| Power input | 3.3V to 5V (via VIN pin or USB via programmer) |
| Dimensions | 0.7 x 0.3 inches (17.8 x 7.6 mm) |
Pinout & pin functions
| Pin | Function |
|---|---|
| GND | Ground |
| 3.3V | 3.3V power output |
| VIN | Input voltage (3.3V to 5V) |
| SCK | Digital I/O, SPI Clock (also ADC0, physical pin 5) |
| MISO | Digital I/O, SPI Master In, Slave Out (also ADC1, physical pin 6) |
| MOSI | Digital I/O, SPI Master Out, Slave In (also ADC2, physical pin 7) |
| RX | Digital I/O, UART Receive (also PWM, physical pin 1) |
| TX | Digital I/O, UART Transmit (also PWM, physical pin 0) |
| SDA | Digital I/O, I2C Data (also ADC3, physical pin 2) |
| SCL | Digital I/O, I2C Clock (also ADC4, physical pin 3) |
| RESET | Reset pin (active low) |
| ICSP Header | (MOSI, MISO, SCK, RESET, VCC, GND) for programming |
Wiring & circuit basics
Powering the Arduino Gemma requires careful consideration due to its 3.3V operating voltage. You can power it via the VIN pin, which accepts a range of 3.3V to 5V. The onboard regulator will step this down to the 3.3V required by the ATtiny85. Alternatively, if powering through the ICSP header, ensure you provide a stable 3.3V or 5V supply to the VCC pin. Avoid exceeding 5V on the VIN pin to prevent damage. Current draw will depend on the components you connect, but the Gemma itself is very low power.
It is crucial to remember that the Gemma operates at a 3.3V logic level. Connecting 5V components directly to its I/O pins can cause damage. If you need to interface with 5V devices, use a logic level shifter. For example, to light an LED, connect an LED's anode to a digital pin (like D0/TX) through a current-limiting resistor (typically 220-330 ohms) and connect the LED's cathode to GND. The ATtiny85 can source or sink a limited amount of current per pin, so check its datasheet for precise limits.
For a more complex example, consider wiring an I2C sensor like the BMP180. Connect the sensor's VCC to the Gemma's 3.3V pin, GND to GND, SDA to the Gemma's SDA pin, and SCL to the Gemma's SCL pin. Ensure the sensor also operates at 3.3V or uses a level shifter if it's a 5V device. The ATtiny85 has hardware support for I2C, making it straightforward to communicate with such sensors using the appropriate libraries within the Arduino IDE.
Programming & getting started
The primary toolchain for programming the Arduino Gemma is the Arduino IDE. Due to the ATtiny85's lack of a native USB interface, you cannot directly upload code via USB. Instead, you'll need an external programmer, such as an Arduino Uno, an FTDI adapter, or another compatible device. Connect the programmer to the Gemma's ICSP header (MOSI, MISO, SCK, RESET, VCC, GND). In the Arduino IDE, select the 'ATtiny25/45/85' board and the appropriate '8MHz (internal)' clock speed, then choose 'Burn Bootloader' if necessary, and finally upload your sketch. Libraries like TinyWireM (for I2C) are often needed for ATtiny microcontrollers.
For a first program, you can upload a simple sketch to blink an LED. Connect an LED (with a resistor) between a digital pin (e.g., D0/TX) and GND. In the Arduino IDE, write a basic sketch: `pinMode(0, OUTPUT); digitalWrite(0, HIGH); delay(500); digitalWrite(0, LOW); delay(500);`. Ensure your board and clock settings are correct, connect your programmer, and upload. This process will familiarize you with the necessary setup for programming the Gemma.