AVR Microcontrollers

To learn about AVR microcontrollers in general we direct you to our AVR Microcontrollers tutorial. You will need to follow the sections for ATtinys since we will be using an ATtiny variant in this project. We will be using the Arduino UNO as an ISP as our bootloading device, you may skip any mentions of the Sparkfun Pocket AVR Programmer.

After reviewing the AVR microcontrollers tutorial, you should have the ATtinyCore bootloaders installed, and be familiar with the board settings for ATtinys.

Next, we will introduce each of the ATtiny variants and how we will be using it in this project!

ATtinyX5 Microcontroller

Now we will cover the ATtinyX5 series in general. The ATtiny Programmer's role is only to program the ATtinyX5. To learn about the ATTinyX5, we direct you to our ATtinyX5 Microcontroller tutorial. Since we will be using the Arduino UNO as an In-System Programmer, you need only pay attention to the sections pertaining to the Arduino as an ISP explicitly to bootload and program the ATtiny85.

Here we show a reference of the ATtiny85 pinout:

This pinout describes the physical and logical layout of the ATtiny85. The physical layout are the physical pins - pins one through eight in a counter-clockwise fashion. The logical layout of the ATtiny85 are the numerous labels tied to each physical pin.

We have the ATtiny85 device in our EAGLE libraries and it is represented as follows:

Observe the similarities and differences. The numbers represent the physical layout of the ATtiny85. However, the order of these numbers do not match the physical layout of the ATtiny85. The reason is because they are organized logically. On the left, the power connections are shown (i.e. VCC and GND). On the right, the GPIO (general purpose input and output) pins are labeled and ordered by port (e.g. PB = port B).

Each of the GPIO pins have one or more functions. The pins that you can program using the ATtinyCore in the Arduino IDE are labeled on the far right inside the parentheses (e.g. D# for a digital input or output pin, A# for an analog input pin, PWM# for a digital PWM or analog output pin). You would use these pins like you would in any typical Arduino sketch.

Challenge: Programming the ATtiny85

In this challenge, we will explicitly program the ATtiny85. Follow the ATtinyX5 Microcontroller tutorial closely and program the ATtiny85 to simply blink an LED. We will be using the Arduino UNO as an ISP as our bootloading device, you may skip any mentions of the Sparkfun Pocket AVR Programmer.

Here is the behavior of the challenge simplying blinking an LED:

Challenge Solution

Note that this solution is NOT the only solution. This is just how we realized it.

The schematic should be similar to the following:

As for the code, we took the Blink example from the Arduino UNO library of examples and modified the pin number to one appropriate on the Attiny85:

// Trivial program to test the ATtinyX5.
//
// Toggles LED on and off for a fixed period of time.
//  Typical blink sketch.


#define led 0

void setup() {
  // Initialize ATtinyX5 digital physical pin 5 
  //	(programming pin 0) as an output.
  pinMode(led, OUTPUT);
}

void loop() {
  // Toggle LED on
  digitalWrite(led, HIGH);
  delay(1000);

  // Toggle LED off
  digitalWrite(led, LOW);
  delay(1000);
}

Again, the results are as follows:

And that is it! Your ATtiny85 should be blinking an LED. This was a trivial example, but it is the first stepping stone to making more interesting functionality.

ATtinyX4 Microcontroller

Now we will cover the ATtinyX4 series in general. The ATtiny Programmer's role is only to program the ATtinyX4. To learn about the ATTinyX4, we direct you to our ATtinyX4 Microcontroller tutorial. Since we will be using the Arduino UNO as an In-System Programmer, you need only pay attention to the sections pertaining to the Arduino as an ISP explicitly to bootload and program the ATtiny84.

Here we show a reference of the ATtiny84 pinout:

This pinout describes the physical and logical layout of the ATtiny84. The physical layout are the physical pins - pins one through 14 in a counter-clockwise fashion. The logical layout of the ATtiny84 are the numerous labels tied to each physical pin.

We have the ATtiny84 device in our EAGLE libraries and it is represented as follows:

Observe the similarities and differences. The numbers represent the physical layout of the ATtiny84. However, the order of these numbers do not match the physical layout of the ATtiny84. The reason is because they are organized logically. On the left, the power connections are shown (i.e. VCC and GND). On the right, the GPIO (general purpose input and output) pins are labeled and ordered by port (e.g. PB = port B).

Each of the GPIO pins have one or more functions. The pins that you can program using the ATtinyCore in the Arduino IDE are labeled on the far right inside the parentheses (e.g. D# for a digital input or output pin, A# for an analog input pin, PWM# for a digital PWM or analog output pin). You would use these pins like you would in any typical Arduino sketch.

Challenge: Programming the ATtiny84

In this challenge, we will explicitly program the ATtiny84. Follow the ATtinyX4 Microcontroller tutorial closely and program the ATtiny84 to simply blink an LED. We will be using the Arduino UNO as an ISP as our bootloading device, you may skip any mentions of the Sparkfun Pocket AVR Programmer.

Here is the behavior of the challenge simplying blinking an LED:

Challenge Solution

Note that this solution is NOT the only solution. This is just how we realized it.

The schematic should be similar to the following:

As for the code, we took the Blink example from the Arduino UNO library of examples and modified the pin number to one appropriate on the Attiny84:

// Trivial program to test the ATtinyX4.
//
// Toggles LED on and off for a fixed period of time.
//  Typical blink sketch.


#define led 5

void setup() {
  // Initialize ATtinyX4 digital physical pin 8
  //	(programming pin 5) as an output.
  pinMode(led, OUTPUT);
}

void loop() {
  // Toggle LED on
  digitalWrite(led, HIGH);
  delay(1000);

  // Toggle LED off
  digitalWrite(led, LOW);
  delay(1000);
}

Again, the results are as follows:

And that is it! Your ATtiny84 should be blinking an LED. This was a trivial example, but it is the first stepping stone to making more interesting functionality.

ATtinyX313 Microcontroller

Now we will cover the ATtinyX313 series in general. The ATtiny Programmer's role is only to program the ATtinyX313. To learn about the ATTinyX313, we direct you to our ATtinyX313 Microcontroller tutorial. Since we will be using the Arduino UNO as an In-System Programmer, you need only pay attention to the sections pertaining to the Arduino as an ISP explicitly to bootload and program the ATtiny4313.

Here we show a reference of the ATtiny4313 pinout:

This pinout describes the physical and logical layout of the ATtiny4313. The physical layout are the physical pins - pins one through 20 in a counter-clockwise fashion. The logical layout of the ATtiny4313 are the numerous labels tied to each physical pin.

We have the ATtiny4313 device in our EAGLE libraries and it is represented as follows:

Observe the similarities and differences. The numbers represent the physical layout of the ATtiny4313. However, the order of these numbers do not match the physical layout of the ATtiny4313. The reason is because they are organized logically. On the left, the power connections are shown (i.e. VCC and GND). On the right, the GPIO (general purpose input and output) pins are labeled and ordered by port (e.g. PB = port B).

Each of the GPIO pins have one or more functions. The pins that you can program using the ATtinyCore in the Arduino IDE are labeled on the far right inside the parentheses (e.g. D# for a digital input or output pin, A# for an analog input pin, PWM# for a digital PWM or analog output pin). You would use these pins like you would in any typical Arduino sketch.

Challenge: Programming the ATtiny4313

In this challenge, we will explicitly program the ATtiny4313. Follow the ATtinyX313 Microcontroller tutorial closely and program the ATtiny4313 to simply blink an LED. We will be using the Arduino UNO as an ISP as our bootloading device, you may skip any mentions of the Sparkfun Pocket AVR Programmer.

Here is the behavior of the challenge simplying blinking an LED:

Challenge Solution

Note that this solution is NOT the only solution. This is just how we realized it.

The schematic should be similar to the following:

As for the code, we took the Blink example from the Arduino UNO library of examples and modified the pin number to one appropriate on the ATtiny4313:

// Trivial program to test the ATtinyX313.
//
// Toggles LED on and off for a fixed period of time.
//  Typical blink sketch.


#define led 8

void setup() {
  // Initialize ATtinyX313 digital physical pin 11
  //	(programming pin 8) as an output.
  pinMode(led, OUTPUT);
}

void loop() {
  // Toggle LED on
  digitalWrite(led, HIGH);
  delay(1000);

  // Toggle LED off
  digitalWrite(led, LOW);
  delay(1000);
}

Again, the results are as follows:

And that is it! Your ATtiny4313 should be blinking an LED. This was a trivial example, but it is the first stepping stone to making more interesting functionality.

The ATtiny Programmer

Hopefully at this point you are feeling two things:

Enter the ATtiny Programmer. An opportunity to create an Arduino UNO shield that programs 3 of the most popular ATtiny variants: ATtinyX5, ATtinyX4, and ATtinyX313. Also a device that is extremely convenient as you will never have to think about the circuits to bootload and program our ATtiny variants ever again!

So if we take what we learned earlier and combine the circuits to program each ATtiny variants individually into one combined circuit we obtain the following:

This is the ATtiny Programmer circuit that we will design and solder! Everything here should look familiar with exception that we removed the Arduino UNO schematic symbol and replaced it with four header pins. However, these header pins should resemble the layout of the Arduino UNO to some degree (it is a little smaller to be efficient on space).

Now that we are familiar with the circuit we need to build, lets design it in EAGLE!

PCB Design with EAGLE

If you have never used EAGLE or need a refresher, we have an Introduction to EAGLE PCB Design tutorial that we encourage you to follow. This tutorial will also get you started downloading and installing EAGLE. Furthermore, this will get you equipped with the basics so that you can keep up with the pace of the EAGLE content in this project. In these modules, we proceed slowly, however we are not going to go over the basic tools of EAGLE and assume you have the EAGLE Libraries integrated into the EAGLE environment.

PCB Design: ATtiny Programmer

First, we will design the ATtiny Programmer schematic.

Then, we shape our board and carefully place our Arduino UNO shield header pins so that it can perfectly fit into an Arduino UNO. This is crucial or else our efforts will be for naught. We layout the rest of the board and place labels along our device for a potential future user and for ourselves.

Finally, we route our PCB and then place some miscellaneous labels to complete the ATtiny Programmer PCB.

This video is optional, but recommended. Here we show you what the ATtiny Programmer looks like in Fusion360 and realize a 3D render of our PCB designed in EAGLE. Then we import our design into OSH Park to get another perspective on our completed board and order our board, if desired.

This completes the ATtiny Programmer PCB design. Next up, we will solder the ATtiny Programmer.

Soldering: ATtiny Programmer

First, we start by filing down the artifacts may contain from panelization in the manufacturing process. Then we solder the SMD components, followed by the header pins. We take advantage of using the Arduino UNO to make sure our header pins are perfectly aligned.

We wrap up the soldering portion by soldering the dual-inline package (DIP) connectors for the ATtinys and then the 10uF capacitor.

This completes the ATtiny Programmer PCB design. Now, let us test our ATtiny Programmer PCB!

AVR Microcontrollers

From the AVR Microcontrollers tutorial make sure you have your Arduino UNO configured as an In-System Programmer. The process is exactly the same for each ATtiny, except now we no longer need to construct the circuit to bootload and program the ATtinys on a breadboard anymore. Our ATtiny Programmer PCB takes care of this!

Next, we will review each of the ATtiny variants, but now we will program them using the ATtiny Programmer!

ATtinyX5 Microcontroller

Follow the ATtinyX5 Microcontroller tutorial. Except now we will be using the ATtiny Programmer to program the ATtinyX5. Remember, we still need the Arduino UNO configured as an In-System Programmer, but the work of the circuit is now abstracted away into our ATtiny Programmer PCB.

ATtinyX4 Microcontroller

Follow the ATtinyX4 Microcontroller tutorial. Except now we will be using the ATtiny Programmer to program the ATtinyX4. Remember, we still need the Arduino UNO configured as an In-System Programmer, but the work of the circuit is now abstracted away into our ATtiny Programmer PCB.

ATtinyX313 Microcontroller

Follow the ATtinyX313 Microcontroller tutorial. Except now we will be using the ATtiny Programmer to program the ATtinyX313. Remember, we still need the Arduino UNO configured as an In-System Programmer, but the work of the circuit is now abstracted away into our ATtiny Programmer PCB.