ATtiny85 is a small form factor microcontroller from Microchip (originally developed by ATMEL). It has 8k of flash and 512 bytes of RAM, 6 I/O pins with various functionality. Due to its small form factor is ideal for small projects and learning.
The advantage is that it is quite simple and due to this it makes for a good starting point if someone starts learning programming of microcontrollers. As starting point the my recommendation is to get the Digispark USB Development Board as it allows to program the uC directly via USB without the need of extra HW. It is inexpensive and SW for development is already available.
For development the Arduino board can be installed in the Arduino IDE. A tutorial is available here: http://digistump.com/wiki/digispark/tutorials/connecting
Datasheet for the ATtiny can be downloaded from the Microchip site.
A little care needs to be taken when connecting directly to the PC USB port since it does not have proper protection and can damage the USB port.
First program - Blink
The first thing to do is to flash the first program on the tiny. This is achieved using the already programmed bootloader. To program the device unplug-it from the USB, start the command line flashing utility (usually performed by the Arduino IDE), and then plug in the digispark into the USB.
#define __AVR_ATtiny85__
#include <avr/io.h>
#include <util/delay.h>
void setup()
{
DDRB |= _BV(DDB1); // set PB1 as output
}
void loop()
{
PORTB |= _BV(PB1);
_delay_ms(1000);
PORTB &= ~_BV(PB1);
_delay_ms(1000);
}
A simple LED controller
After the very simple example is time to test the input of the tiny. This is achieved by checking the PORTB for the bit corresponding to the input pin. As a quick debouching the sleep mechanism is used. Here is the pin change interrupt is used to wake the microcontroller.
#define __AVR_ATtiny85__
#include <avr/io.h>
#include <avr/sleep.h>
void setup()
{
DDRB |= _BV(DDB1);
DDRB &= ~_BV(DDB2);
PORTB &= ~_BV(PB1);
}
void loop()
{
if (bit_is_set(PINB, PINB2)) {
PORTB |= _BV(PB1);
}
else {
PORTB &= ~_BV(PB1);
}
system_sleep();
}
void system_sleep()
{
cli(); // Disable interrupts
GIMSK |= _BV(PCIE); // Enable Pin Change Interrupts
PCMSK |= _BV(PCINT2); // Turn ON interrupt pins
sei(); // Enable interrupts
ADCSRA &= ~_BV(ADEN); // ADC off
set_sleep_mode(SLEEP_MODE_PWR_DOWN);
sleep_enable(); // Sets the Sleep Enable bit in the MCUCR Register (SE BIT)
sleep_cpu(); // sleep
sleep_disable(); // Clear SE bit
ADCSRA |= _BV(ADEN); // ADC on
cli(); // Disable interrupts
PCMSK &= ~_BV(PCINT2); // Turn OFF interrupt pins
sei(); // Enable interrupts
}
ISR(PCINT0_vect)
{
}
PWM Control
There are a maximum of 3 PWM pins on the attiny (some tricks are needed to get 4...but it is possible). 2 of them are very easy to use and conveniently placed on PB0 and PB1. Here is a very basic example:
#define __AVR_ATtiny85__
#define F_CPU 16500000
#include <avr/io.h>
#include <avr/sleep.h>
#include <util/delay.h>
void setup()
{
// set the pin as output
DDRB = _BV(DDB1);
// set the fast PWM output on OC0B, Inverting Mode
TCCR0A = (3 << COM0B0) | (3 << WGM00);
// clkI/O/64 prescaler and Fast PWM to 0xFF from BOTTOM
TCCR0B = (3 << CS00);
// comparator value
OCR0B = 255;
}
void loop()
{
for (uint8_t i=255; i>0; i--) {
OCR0B = i;
_delay_ms(10);
}
for (uint8_t i=0; i<255; i++) {
OCR0B = i;
_delay_ms(10);
}
}
The output on pin 1 looks like this:
Inputs - rotary encoder
The ATtiny inputs can be mapped to interrupts and monitored. Here, a classic example is the monitoring of the rotary encoder using interrupts. The rotary encoder has pull-up resistors on both outputs.
The two plots plots are generated based on the 2 output pins that are toggled when the interrupt is executed and according to the input pins state.
#define __AVR_ATtiny85__
#include <avr/io.h>
void setup()
{
// PB0 and PB1 outputs
DDRB |= _BV(DDB0) | _BV(DDB1);
// PB2 and PB3 inputs
DDRB &= ~(_BV(DDB2) | _BV(DDB3));
// set default high
PORTB |= (_BV(DDB0) | _BV(DDB1));
cli(); // Disable interrupts
GIMSK |= _BV(PCIE); // Enable Pin Change Interrupts
PCMSK |= _BV(PCINT2) | _BV(PCINT3); // Turn ON interrupt pins
sei(); // Enable interrupts
}
void loop()
{
}
ISR(PCINT0_vect)
{
if (bit_is_set(PINB, PINB2)) {
PORTB |= _BV(PB0);
} else {
PORTB &= ~_BV(PB0);
}
if (bit_is_set(PINB, PINB3)) {
PORTB |= _BV(PB1);
} else {
PORTB &= ~_BV(PB1);
}
}
ADC measurements
Using a potentiometer is another possibility to input data into the controller. Based on the read value the PWM can be adjusted in order to control the luminosity of a LED.
#define __AVR_ATtiny85__
#include <avr/io.h>
void setup()
{
// set the pin as output
DDRB = _BV(DDB1);
// set the fast PWM output on OC0B, Inverting Mode
TCCR0A = (3 << COM0B0) | (3 << WGM00);
// clkI/O/64 prescaler and Fast PWM to 0xFF from BOTTOM
TCCR0B = (3 << CS00);
// comparator value
OCR0B = 255;
// VCC used as Voltage Reference, disconnected from PB0 (AREF).
ADMUX = _BV(ADLAR) | // left shift result
0B0010; // use ADC2 for input (PB4), MUX bit 1
ADCSRA = _BV(ADEN) | // Enable ADC
_BV(ADPS2) | // set prescaler to 128, bit 2
_BV(ADPS1) | // set prescaler to 128, bit 1
_BV(ADPS0); // set prescaler to 128, bit 0
}
void loop()
{
ADCSRA |= _BV(ADSC);
loop_until_bit_is_clear(ADCSRA, _BV(ADSC));
// get the sample value from ADCH and store-it in the comparator
OCR0B = ADCH;
}
Programing using ICSP
Using the USBTinyISP programmer the uC can be flashed. In this way the bootloader will be overwritten and the full flash can be used.
The bootloader can be afterwards reflashed. It can be downloaded from https://github.com/micronucleus/micronucleus.
