Maak (opnieuw) kennis met de Atmel ATtiny85 microcontroller

Recentelijk maakte ik voor het Cursusburo een cursus Praktische analoge en digitale elektronica waarin ik ook de beginselen van het werken met microcontrollers uit de doeken doe. Niet het programmeren zelf, maar het toepassen van een (voorgeprogrammeerde) microcontroller als onderdeel in een elektronische schakeling was hier het onderwerp. De toegepaste microcontroller, de Atmel ATtiny85, is een oude bekende van me en de inleidende tekst past goed in mijn eigen projectbeschrijvingen. Ik heb als voorbeeld gebruikgemaakt van een eerder gemaakte toepassing: het automatisch fietsachterlicht.

Toepassingsgebied

De ATtiny85 is een microcontroller in de trand van Arduino, maar met veel minder besturingspennen, minder werkgeheugen en een kleinere verpakking. Als onderdeel van de Atmel AVR family heeft de ATtiny85 een mooie combinatie van verpakking (DIP-8) en eigenschappen zoals voldoende flashgeheugen. De ATtiny85 kan als los IC op een breadboard worden gebruikt, zolang de juiste voedingsspanning wordt toegevoerd.

Ondanks zijn kleine formaat kan er met de ATtiny85 op veel verschillende manieren worden gecommuniceerd. Op het meest basale niveau hebben we zes 5 V logische digitale in- en uitgangspinnen ter beschikking, waarvan er vier ook kunnen worden gebruikt als analoge ingangspinnen (ADC) voor gebruik met componenten zoals een lichtgevoelige weerstand. Vier van de beschikbare pinnen kunnen worden gebruikt als digitale uitgang met pulsbreedtemodulatie (PWM). Ook zijn zijn er twee seriële bussen SPI en I²C beschikbaar voor gebruik met slimme sensoren en andere apparaten. van de 8 aansluitpennen 3 speciale functies hebben, moet er voor de overige 5 zorgvuldig worden gekozen, welke functie er gebruikt gaat worden op welke pen.

Over het algemeen geldt, dat alles wat met Arduino kan, ook met de ATtiny85 kan. Van het aansturen van een enkele led, het besturen van individueel adresseerbare WS2812 leds, het besturen van een servo, het bedienen van een grafisch display tot het inlezen van schakelaars, draaipotentiometers of sensoren: de ATtiny85 kan het.

ATtiny85 technische specificaties

De nummering van de ATtiny85 pinnen in de Arduino programmeeromgeving wijkt af van de nummering van de fysieke behuizing van de microcontroller. Het is daarom een goed idee om de voor de ATtiny85 gebruikte pin-nummering in de broncode op te nemen.

1
2
3
4
5
6
7
8

/*
  ATtiny85 pinbeschrijving
                   _______
  RESET ADC0 PB5 x|1  ^  8|x VCC (+)
    PWM ADC3 PB3 x|2     7|x PB2 ADC1 
    PWM ADC2 PB4 x|3     6|x PB1 PWM
         (-) GND x|4_____5|x PB0 PWM
*/

Digitale signalen inlezen

Het inlezen van digitale (logisch 0 of 1) signalen gaat in de Arduino programmeertaal met digitalRead(pinnummer). Het pinnummer is hier de logische nummering van de PBn poorten en niet de fysieke pin van de ATtiny85.

1
2
3
4

int digitaleIngangPin = 4; // Digitale ingang PB4, ATtiny85 pin 3
int digitaleWaarde; // Variabele die de ingelezen waarde gaat bevatten 
pinMode(digitaleIngangPin, INPUT); // Configureer poort als ingang 
digitaleWaarde = digitalRead(digitaleIngangPin); // Lees digitale waarde in

Bij gebruik van de digitale in- en uitgangen PBn moet met pinMode(pinnummer, INPUT) de signaalrichting geconfigureerd worden om aan te geven dat de poort als ingang gebruikt gaat worden.

Analoge signalen inlezen

Het inlezen van analoge (0 V tot V_CC V) signalen gaat in de Arduino programmeertaal met de instructie analogRead(pinnummer). Het pinnummer is hier de logische nummering van de ADCn poorten en niet de fysieke pin van de ATtiny85.

1
2
3

int analogeIngangPin = 3; // Analoge ingang ADC3, ATtiny85 pin 2
int analogeWaarde; // Variabele die de ingelezen waarde gaat bevatten 
analogeWaarde = analogRead(analogeIngangPin); // Lees analoge waarde in

Bij gebruik van de analoge ingangen ADCn is configuratie van de signaalrichting niet nodig.

Digitale signalen uitsturen

Het uitsturen van digitale (logisch 0 of 1) signalen gaat in de Arduino programmeertaal met digitalWrite(pinnummer). Het pinnummer is hier de logische nummering van de PBn poorten en niet de fysieke pin van de ATtiny85.

1
2

int digitaleUitgangPin = 0; // Digitale uitgang PB0, ATtiny85 pin 5 
pinMode(digitaleUitgangPin, OUTPUT); // Configureer de digitale poort als uitgang digitalWrite(digitaleUitgangPin, HIGH); // Maak de digitale uitgang HOOG digitalWrite(digitaleUitgangPin, LOW); // Maak de digitale uitgang LAAG

Bij gebruik van de digitale in- en uitgangen PBn moet met pinMode(pinnummer, OUTPUT) de signaalrichting geconfigureerd worden om aan te geven dat de poort als uitgang gebruikt gaat worden.

Pulsbreedtemodulatiesignalen uitsturen

Met pulsbreedtemodulatie wordt de spanning van de uitgang gedurende een instelbaar percentage van de tijd hoog- en laaggemaakt. De uitgang wordt hiertoe voorzien van een wisselspanning die tussen (0 V tot V_CC V) wisselt in een frequentie van ongeveer 500 Hz. De verhouding tussen hoog en laag zorgt ervoor dat een aangesloten belasting zoals een led, slechts een deel van de stroom ontvangt. Deze verhouding wordt arbeidsduurverhouding of duty cycle genoemd en wordt uitgedrukt in een percentage 0% (altijd 0 V) tot 100% (altijd V_CC V).

Het uitsturen van een PWM signaal gaat in de Arduino programmeertaal met analogWrite(pinnummer, arbeidsduurverhouding), wat technisch overigens niets te maken heeft met de analoge poorten. De arbeidsduurverhouding wordt opgegeven in een getal 0 (0%) tot 255 (100%).

1
2
3
4

int pwmUitgangPin = 1; // Digitale uitgang PB1, ATtiny85 pin 6 
digitalWrite(pwmUitgangPin, 0); // Lever een signaal met 0% arbeidsduur 
digitalWrite(pwmUitgangPin, 128); // Lever een signaal met 50% arbeidsduur
digitalWrite(pwmUitgangPin, 255); // Lever een signaal met 100% arbeidsduur

Bij gebruik van PWM is configuratie van de signaalrichting niet nodig.

Toepassingsvoorbeeld

Een typische elektronische toepassing van de ATtiny85 is in een eenvoudig circuit waarbij de ATtiny85 de functie overneemt van wat normaliter met meerdere digitale logica- en interfaceelektronica opgelost zou worden. In het voorbeeld hieronder een schakeling waarmee een led wordt ingeschakeld bij duisternis:

In het afgebeelde schema zijn verschillende circuits te onderscheiden. Het circuit dat bestaat uit weerstand R1, de led, transistor T1 en weerstand R2 wordt door de ATtiny85 aangestuurd via pen 5 (PB0). Het circuit dat bestaat uit de LDR en weerstand R3 vormt een spanningsdeler waarvan de spanning door de ATtiny85 wordt ingelezen via pen 2 (ADC3). De ATtiny85 wordt gevoed vanuit de batterij via pennen 4 (-) en 8 (+).

Het programma dat in de ATtiny85 is vastgelegd leest de waarde van ADC3 en bepaalt of de ingelezen waarde kleiner is dan een proefondervindelijk bepaalde drempelwaarde en schakelt dan de led via PB0 in door de pen hoog te maken (gelijk te maken aan de batterijspanning). Als de ingelezen waarde niet kleiner is, dan wordt de led uitgeschakeld door PB0 laag te maken.

Programmeren van de ATtiny85 met een Arduino programmeerinrichting

Om een ATtiny85 (of andere variant van Atmel) te programmeren is een programmeerinrichting nodig. Dat kan heel goed een Arduino zijn, waarvoor specifiek voor dit doel specifieke configuraties en een codebibliotheek vanuit de Arduino-IDE beschikbaar zijn. Het bedraden van de Arduino en ATtiny85 is nog wel een klusje:

Een speciale opzetprint voor de Arduino maakt het allemaal een stuk eenvoudiger en handiger voor als er met regelmaat meerdere ATtiny’s moeten worden geprogrammeerd:

Over het algemeen is het handig om een Arduino controllerboard te gebruiken als Dev Board voor een toekomstige ATtiny85 toepassing. Dit heeft enkele voordelen:

• Een Arduino controllerboard wordt via een USB aansluiting geprogrammeerd, waarbij de I/O pennen in een circuit aangesloten kunnen blijven (een ATtiny85 wordt via dezelfde pennen geprogrammeerd als die ook met een toekomstig circuit verbonden worden)
• Een Arduino controllerboard heeft een ingebouwde stroomvoorziening, die aangesloten randapparaten van 5 of 3.3 volt voorziet. Handig om even snel een schakeling mee op te bouwen
• Een Arduino controllerboard heeft verschillende leds en een seriële poort waarover loginformatie kan worden betrokken. Het maakt debuggen van programma’s veel gemakkelijker

Omdat een Arduino ook gebruikt wordt als programmeerapparaat voor de ATtiny85 is het handig om twéé Arduino controllerboards te gebruiken: eentje als experimenteer Dev Board voor de toekomstige ATtiny85 toepassing, en eentje als programmeerapparaat. Maar met eentje lukt het ook prima: eerst de toepassing maken en debuggen met een Arduino, daarna dezelfde Arduino als programmeerapparaat gebruiken.

Om de ATtiny85 te programmeren met een Arduino controllerboard volg je deze stappen:

• Kies voor een Arduino Uno of Duecimila (andere versies zullen vast geschikt zijn) en verbind deze met de computer en de Arduino programmeeromgeving op de gebruikelijke manier. Kies in de Arduino programmeeromgeving als board de gekozen Arduino controllerboard
• Laad op de Arduino controllerboard een sketch om deze als programmeerapparaat te gebruiken. Kies in de Arduino programmeeromgeving het volgende:
  File > Voorbeelden > 11.ArduinoISP > ArduinoISP
• Upload de ArduinoISP sketch naar de aangesloten Arduino Uno of Duecimila controllerboard
• Maak de Arduino controllerboard los van de computer
• Bedraad de Arduino controllerboard met een ATtiny85 zoals in bovenstaand bedradingsschema, of plaats een geschikt opzetprintje met dezelfde functie zoals in de foto hierboven getoond
• Plaats een ATtiny85 microcontroller in het circuit of op het opzetprintje en verbind de Arduino controllerboard opnieuw met de computer
• Kies in de Arduino programmeeromgeving in de Bordbeheerder de attiny package van David A. Mellis:
  Hulpmiddelen > Bord > Bordbeheerder… > attiny
• Kies in de Arduino programmeeromgeving als Bord een ATtiny25/45/85:
  Hulpmiddelen > Bord > attiny > ATtiny25/45/85
• Stel in de Arduino programmeeromgeving het gebruik van een ATtiny85 en de juiste kloksnelheid in:
  Hulpmiddelen > Processor: “ATtinynn“ > ATtiny85
  Hulpmiddelen > Clock: “Internal n MHz” > Internal 1 MHz
• Instrueer de Arduino programmeeromgeving om de aangesloten Arduino Uno of Duecimila als programmeerapparaat te gebruiken wanneer er een programma moet worden geupload, zodat een programma via het programmeerapparaat in de ATtiny85 wordt geprogrammeerd, in plaats van naar de aangesloten Arduino:
  Hulpmiddelen > Programmeerapparaat > Arduino as ISP
• Laad of schrijf het programma voor de ATtiny85 in de Arduino programmeeromgeving
• Upload het programma naar de ATtiny85 via de upload-knop
• Test de ATtiny85 in een circuit los van de Arduino Uno of Duecimila zodat de aangesloten pennen van de ATtiny85 vrij zijn voor het beoogde doel