How to Test and Program an ATtiny Controller Using a Custom PCB

In the previous article, we have already covered the differences in specifications between the Arduino and ATtiny series AVR microcontrollers. However, another major difference between the two is the way the microcontrollers are programmed.

The Arduino board can be programmed simply by plugging it into a computer via a USB cable. In addition to the bootloader, these boards also integrate a number of peripheral components that allow them to be programmed without any special connections or software.

However, this is not the case with the ATtiny series of microcontrollers. The ATtiny series of microcontrollers can be programmed in a few different ways, depending on the size of your project.

Methods for Programming ATtiny Microcontrollers

One method of programming the ATtiny that has been covered in this article is to use an Arduino Uno as an ISP programmer. Using an Arduino as an AVR programmer is a good option for prototyping a single unit, but is impractical for a business producing a product. This is especially true for designs using SMD microcontrollers, as they cannot be plugged into an Arduino or a breadboard.

In this article we will look at three different methods of programming ATtiny microcontrollers that allow programming of SMD packages and can be used to scale up from small prototype runs of no more than 100 units to mass production runs of several hundred:

● Programming using IC test clip and ISP programmer

● PCB plug connector or test point, use the plug connector or pogo pins to connect the ISP programmer to the PCB;

● The microcontroller can be programmed directly using SMT test clips before being soldered to the board, or the chip can be factory programmed.

Custom Design Test PCB

In order to test various methods of programming the ATtiny range of microcontrollers I designed a simple test PCB.

The PCB is a thermometer with a DHT22 temperature and humidity sensor on the back. In this case, this sensor only reads the temperature.

Back view of the custom PCB using the DHT22 sensor.

The test board also features a row of LEDs on the front, similar to the mercury/alcohol tubes on an analog thermometer. At higher temperatures more LEDs light up, and in addition the LEDs change color from blue to red between low and high temperatures.

In cold temperatures (like outside in the winter), the LEDs glow blue and fewer LEDs light up.

Under high temperatures (such as in front of a heat gun), the LED will light up red and more LEDs will light up.

The main part of the test board contains a variety of packages for mounting one of the following ATtiny series microcontrollers: ATtiny84, ATtiny85, ATtiny2313, and ATmega328. Each microcontroller also has some passive components to make everything work properly.

The PCB also contains footprints for mounting an ATtiny 84, ATtiny 85, ATtiny2313, or ATmega328.

Finally, the system is powered by the Micro USB port on the bottom of the board.

The produced PCB is red, matching the color of the alcohol thermometer. Except for the DHT22, all other components are SMD parts, so the board can be assembled by reflow soldering.

Run the code to test the PCB

The code to run the test PCB is not too complex.

At the beginning of each loop, the microcontroller takes the temperature reading from the DHT22. The temperature reading is then converted into the color of the LEDs and the number of LEDs to light using two different map() statements.

1. /*
   

2.    Project:  ATtiny Microcontroller Test Platform
   

3.    Published on Maker Pro
   

4.    Author:  Scott Hatfield (Toglefritz)  
   

5. */
   

6. 
   

7. // CONFIGURATION  //
   

8. 
   

9. // If you are using an ATint84, the LEDs are connected to pin 2. For any of the other
   

10. // microcontrollers, the LEDs are connected to pin 4.
    

11. 
    

12. // ATtiny84
    

13. // #define PIN 2
    

14. 
    

15. // ATtiny85 or ATTiny2313 or ATmega328
    

16. #define PIN 4
    

17. 
    

18. // NEOPIXEL SETUP //
    

19. 
    

20. // Include the Adafruit NeoPixel library
    

21. #include
    

22. 
    

23. #define NUMPIXELS 7   // There are seven LEDs on the board
    

24. 
    

25. // Set up the NeoPixel library
    

26. Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
    

27. 
    

28. // DHT22 SETUP  //
    

29. #include "TinyDHT.h"
    

30. 
    

31. // The temperature sensor is connected to pin 3 for all microcontrollers
    

32. #define DHTPIN 3
    

33. 
    

34. #define DHTTYPE DHT22   // DHT 22  (AM2302)
    

35. DHT dht(DHTPIN, DHTTYPE); //// Initialize DHT sensor
    

36. 
    

37. // SKETCH VARIABLES  //
    

38. float temp;  // Stores temperature value
    

39. int color;   // The color of the LEDs, for use with the Wheel() function
    

40. int number;  // The number of LEDs to illuminate
    

41. 
    

42. 
    

43. void setup() {
    

44.   // Set up the LEDs
    

45.   pixels.begin();   // Initialize NeoPixel object
    

46.   pixels.clear();   // Set all pixel colors to 'off' to start
    

47.   pixels.setBrightness(50);   // The LEDs do not need to be super bright
    

48. 
    

49.   dht.begin();    // Initialize the DHT22 object
    

50. }
    

51. 
    

52. void loop() {
    

53.   // Read the temperature
    

54.   int16_t temp = 30;//dht.readTemperature();
    

55.   // Reading temperature or humidity takes about 250 milliseconds!
    

56.   delay(250);
    

57.   /*
    

58.      The DHT22 is capable of measuring temperatures between -40C and 125C. But, because this is supposed to
    

59.      be hand-held device, we will map the temperatures only to between -25C and  40C.
    

60.   */
    

61. 
    

62.   // Map the temperature reading to a color number used for the LEDs. At the coldest temperatures, the light will be blue,
    

63.   // at the hottest, the light will be red.
    

64.   color = map(temp, -18, 30, 75, 1);
    

65. 
    

66.   // Then, map the temperature reading to a number of LEDs to illuminate. At the lowest temperatures, only the bottom LED will
    

67.   // illuminate, at the hightest temperatures, all LEDs will illuminate.
    

68.   number = map(temp, -18, 30, 0, 6);
    

69. 
    

70.   // Set the LEDs to the color corresponding to the current temperature reading
    

71.   for(int i = 0; i <= number; i++) {
    

72.     pixels.setPixelColor(i, Wheel(color));
    

73.   }
    

74.   pixels.show();
    

75. }
    

76. 
    

77. // Wheel() is a helper function to get colors from single values between 0 and 255  
    

78. // Input a value 0 to 255 to get a color value.
    

79. // The colours are a transition r - g - b - back to r.
    

80. // For a visual representation of the values, see https://docs.google.com/spreadsheets/d/1vYsRDL4QzcZtP30jqQByM2pK3_Xq2RPOyVwkcxQOnPI/edit?usp=sharing
    

81. uint32_t Wheel(byte WheelPos) {
    

82.     if(WheelPos < 85) {
    

83.         return pixels.Color(255 - WheelPos * 3, 0, WheelPos * 3);
    

84.     }
    

85.     else if(WheelPos < 170) {
    

86.         WheelPos -= 85;
    

87.         return pixels.Color(0, WheelPos * 3, 255 - WheelPos * 3);
    

88.     }
    

89.     else {
    

90.         WheelPos -= 170;
    

91.         return pixels.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
    

92.     }
    

93. }

Trying out ATtiny programming methods using a test PCB

As mentioned earlier, there are three main methods of programming the ATtiny series of microcontrollers. The PCB board is a thermometer with a DHT22 temperature sensor and a row of LEDs to indicate the current temperature based on the color and number of illuminated LEDs. Subsequent parts of this series will all use the same test board to illustrate how to use the above programming methods.