Was braucht man um einen Mikrocontroller wie den ATtiny 13A zu programmieren? Zumindest mal zwei Dinge: Einen Programmer und eine dazu passende Software. Letzteres ist einfach, denn dafür bietet sich die Arduino IDE an, die ich bereits für mein Feinstaubprojekt benutzt hatte um den µC zu flashen. Bei der Programmierhardware wird es schon schwieriger, denn der ATtiny 13A ist ein blanker 8-Füßler ohne Bootloader und ohne USB-Anschluss. Es braucht also ein extra Programmiergerät um einen Sketch (ein Mikrocontroller-Programm) dort drauf flashen zu können. Beides, Programmer und Programmierumgebung bereiten wir in diesem Artikel vor, so dass wir uns danach an die eigentliche Programmierung machen können.
Arduino Nano als Programmiergerät
Ein einfaches und kostengünstiges Programmiergerät für Mikrocontroller kann ein anderer Mikrocontroller sein in Form eines Arduino-Boards. Ich verwende hier einen Fernost-Arduino-Nano-Clone in der 7€-Klasse. Damit lässt sich auf einem Steckbrett zusammen mit einem Kondensator schnell ein Programmer zusammenstecken und danach kann man den Nano auch wieder für was anderes verwenden. Mit einer solchen Schaltung lassen sich neben dem ATtiny 13A natürlich auch andere Mikrocontroller flashen, ein ATtiny 85 zum Beispiel, der die gleich Pinbelegung hat, wie der 13A. Für µCs mit anderer Gehäuseform müsste natürlich die Verdrahtung angepasst werden.
Schaltung
Viel braucht man nicht für so eine Programmierschaltung: Ein Steckbrett, einen Arduino Nano (oder Clone), einen Kondensator, den zu programmierende ATtiny 13A und ein paar Steckbrücken. Die LED und der Widerstand sind optional – sie dienen nur dem Blink-Programm, das wir als erstes flashen und ausprobieren wollen.
Die Verdrahtung ist einfach: Der ATtiny bekommt +5V und GND über die Plus- und Minus-Schienen vom Nano (rot und blau). Die vier weiteren Drähte (orange, grün, gelb und violett) sind die Programmiersignale MISO, MOSI, RST und SCK. Die LED hängt an Pin 2 des ATtiny 13A (Anschluss PB3).
Kondensator
Und dann ist da noch dieser Elektrolytkondensator. Der hat folgenden Zweck: Der Arduino Nano bekommt bei der Programmierung über die PC-Leitung (genauer vom Schnittstellensignal DTR) einen Resetimpuls auf seinen RST-Pin. Das ist gut, wenn der Nano selbst programmiert werden soll, führt aber zu Problemen, bei der Programmierung des ATtiny. Zumindest ist das bei meinem Nano 3.0 Clone und der aktuellen ArduinoISP-Software so. Dem lässt sich abhelfen durch besagten Elko zwischen den GND- und RST-Beinchen des Nano. Dadurch werden kurze Resetimpulse geschluckt. Der Minuspol des Elektrolykondensators gehört natürlich an GND. Die Kapazität des Kondensators ist unkritisch, ich verwende 10µF, es geht aber auch mit 1µF oder mit 47µF. Mit Kondensator lässt sich jetzt der ATtiny programmieren, aber nicht mehr der Nano selbst. Es gilt also folgende Regel:
- Nano programmieren – Kondensator raus
- ATtiny programmieren – Kondensator rein
Mit dem Anschluss an den USB-Port des PC ist die Schaltung auch mit Spannung versorgt und bereit für die Programmierung. Nun kümmern wir uns um die Software.
Arduino IDE als Programmiersoftware
Die Arduino IDE (Integrated Development Environment) ist Editor, Compiler und Programmiersoftware in einem und damit gut geeignet, den ATtiny Mikrocontroller mit einem Programm zu beschicken. Wie man die Arduino IDE auf dem PC installiert, habe ich schon mal im Rahmen des Feinstaubprojekts erklärt. Aber da wir es hier mit einem anderen Mikrocontroller zu tun haben, zeige ich die Installation hier noch einmal komplett Schritt für Schritt für ein Linux-Desktop-System. Die IDE gibts auch für Windows und Mac, aber dazu sollte man sich die jeweilige Installationsanleitung auf der Arduino-Webseite ansehen
Arduino IDE Installation
Zuerst laden wir die Arduino IDE aus dem Internet herunter. Der Link lautet: https://www.arduino.cc/en/Main/Software. Dort holen wir uns die 64bit Linux Version zum Download. Im Fall der Softwareversion 1.8.5 erhalten wir eine Archivdatei arduino-1.8.5-linux64.tar.xz, die typischerweise im Verzeichnis Downloads liegt. Für andere Softwareversionen lautet der Dateiname natürlich entsprechend anders. Die Archivdatei öffnen wir mit der Archivverwaltung (rechte Maustaste) und entpacken sie in den persönlichen Ordner. Das ergibt dort ein Verzeichnis arduino-1.8.5.
Jetzt öffnen wir ein Terminalfenster und geben den fettgedruckten Teil ein:
ich@rechner:~$ ~/arduino-1.8.5/install.sh
Adding desktop shortcut, menu item and file associations for Arduino IDE... done!
ich@rechner:~$
Damit erhalten wir ein Icon auf dem Desktop, mit dem wir die Arduino IDE jetzt starten können. Der erste Start erzeugt die Verzeichnisse Arduino und .arduino15 im persönlichen Ordner, wobei letzteres versteckt ist (Punkt vor dem Verzeichnisnamen). Und so sieht die Programmoberfläche der Arduino IDE aus.
Boardmanager
Die Arduino IDE kennt bereits zahlreiche Mikrocontroller – vor allem natürlich die Arduino Boards selbst, den ATttiny 13A allerdings nicht. Dem können wir abhelfen, in dem wir für den ATtiny 13A einen so genannten Boardmanager installieren. Das geht folgendermaßen:
Wir öffnen die Arduini IDE und gehen auf Datei – Voreinstellungen. Im Einstellungsfenster suchen wir nach Zusätzliche Boardverwalter-URLs: und tragen dort folgende URL ein:
https://mcudude.github.io/MicroCore/package_MCUdude_MicroCore_index.json
Dann das Fenster mit OK schließen. Dann gehen wir auf Werkzeuge – Board – Boardverwalter… und suchen in der Liste nach dem Eintrag MicroCore by MCUdude, klicken drauf und dann auf Installieren.
Danach können wir den Boardverwalter schließen.
Arduino Nano per Software zum Programmiergerät machen
In diesem Arbeitsschritt bekommt das Arduino Nano Board eine Software geflasht, die das Board zum Programmiergerät macht. Dazu müssen wir den Kondensator (siehe oben bei der Hardwarebeschreibung) herausnehmen, das Nano-Board per USB an den Computer anschließen und in der Arduino IDE unter Werkzeuge – Port den entsprechenden Anschluss auswählen. Typischerweise lautet der unter Linux /dev/ttyUSB0. Sollte hier ein Zweifel bestehen, kann man das Nano-Board auch nochmal abstecken – der Port, der jetzt aus der Auswahl verschwindet, wäre der richtige gewesen.
Gleichzeitig stellen wir unter Werkzeuge – Board und Werkzeuge – Prozessor den Arduino Nano mit seinem ATmega328P Chip ein, so wie im nebenstehenden Bild. Möglicherweise gibt es mehrere passende Auswahlmöglichkeiten beim Prozessor, zum Beispiel ATmega328P (Old Bootloader), dann müssen wir später ausprobieren welche Einstellung funktioniert. (bei mir ist es der „Old Bootloader“.)
Jetzt brauchen wir noch die Software, die aus dem Arduino Nano einen Mikrocontroller-Programmierer macht. Die wird mit der Arduino IDE bereits mitgeliefert und wir finden sie unter Datei – Beispiele – ArduinoISP – ArduinoISP.
Die Software (der Sketch) öffnet sich in einem neuen Arduino ISP Fenster und kann durch Klick auf den Pfeil nach rechts in der Iconleiste direkt auf den Nano geflasht werden. Eventuelle Fehler würden unten im schwarzen Feld angezeigt werden. Wenn das nicht der Fall ist und darüber Hochladen abgeschlossen erscheint, ist der Flash-Vorgang erfolgreich beendet.
Damit haben wir den Arduino Nano zu einem Programmiergerät für Mikrocontroller-Chips gemacht. Nähere Informationen zur Programmierfunktion findet man in den einleitenden Kommentaren zu Sketch. Dort sind auch drei Pins des Nano beschrieben, an die man drei LEDs (mit Vorwiderstand versteht sich) anschließen könnte. Die LEDs geben dann beim Programmieren eines angeschlossenen Mikrocontrollers Statussignale aus wie Heartbeat, Error und Programming. Ich habe diese LEDs in meiner Schaltung weggelassen, den Programmiervorgang kann man auch gut über die eingebauten LEDs des Nano-Boards verfolgen, speziell Rx, Tx und L.
Bevor wir einen ATtiny Mikrocontroller programmieren können, müssen wir aber noch zwei Dinge umstellen: Zum einen muss der Kondensator wieder zwischen RST und GND eingesetzt werden (Polarität beachten!). Und zum zweiten müssen wir in der Arduino IDE vom Nano auf den ATtiny 13 zurückschalten und zusätzlich unter Werkzeuge – Programmer den Eintrag Arduino as ISP oder Arduino as ISP (slow) auswählen. Auch hier müssen wir testen, welche Einstellung besser funktioniert. Die slow Variante wird vom Hersteller des Boardmanagers empfohlen, bei mir funktioniert hingegen nur die normale Einstellung „Arduino as ISP“. Die Einstellungen unter Werkzeuge sehen dann in etwa so aus, wie nebenstehend abgebildet.
Bootloader auf den ATtiny 13A brennen – nicht wirklich
Dazu muss ich wohl vorausschicken, was ein Bootloader eigentlich ist: Ein Bootloader ist ein Stück Software auf einem Mikrocontroller, das es ermöglicht ein Programm (einen Sketch) von außen über die serielle Schnittstelle (bzw. USB) auf den Mikrocontroller zu laden, ohne dafür ein Programmiergerät zu brauchen. So haben wir zum Beispiel oben den Arduino Nano über USB mit Software beschicken können. Dass das ohne ein Programmiergerät funktioniert hat, verdanken wir dem Bootloader, der auf allen Arduino-Boards, deren Nachbauten und zahlreichen anderen Controllern bereits werksseitig vorhanden ist. Auf den kleinen Mikrocontrollern, wie den ATtinys, verzichtet man aber in der Regel auf einen Bootloader um Speicherplatz zu sparen.
Wollen wir also jetzt auf dem ATtiny 13A einen Bootloader installieren? Nicht wirklich, wir verwenden nur die Funktion Bootloader brennen der Arduino IDE, um sogenannte Fuses zu brennen. Das sind Einstellungs-Bits bezüglich Taktrate oder Brown-Out-Detection (BOD) und solchen Kram, über den wir uns hier keine Gedanken machen wollen. Der Hersteller des Boardmanagers für den ATtiny 13 (MCUdude) nimmt darüber ein paar Grundeinstellungen an den Fuses passend zu seiner Software vor. Wir brennen also Fuses und keinen realen Bootloader.
Dazu gehen wir nun auf Werkzeuge – Bootloader brennen und beobachten den Vorgang im Statusfenster. Hier ein stark gekürzter Auszug:
avrdude: Version 6.3, compiled on Jan 17 2017 at 11:00:16
Copyright (c) 2000-2005 Brian Dean, http://www.bdmicro.com/
Copyright (c) 2007-2014 Joerg Wunsch
avrdude: load data hfuse data from input file 0xfb:
avrdude: input file 0xfb contains 1 bytes
avrdude: reading on-chip hfuse data:
.
.
.
Reading | ################################################## | 100% 0.02s
avrdude: verifying ...
avrdude: 1 bytes of hfuse verified
avrdude: reading input file "0x3A"
avrdude: writing lfuse (1 bytes):
Writing | ################################################## | 100% 0.01s
avrdude: 1 bytes of lfuse written
avrdude: verifying lfuse memory against 0x3A:
avrdude: load data lfuse data from input file 0x3A:
avrdude: input file 0x3A contains 1 bytes
avrdude: reading on-chip lfuse data:
Reading | ################################################## | 100% 0.01s
avrdude: verifying ...
avrdude: 1 bytes of lfuse verified
avrdude done. Thank you.
avrdude: ser_open(): can't open device "unknown": No such file or directory
Fehler beim Brennen des Bootloaders.Von Interesse ist hier die Fehlermeldung am Ende, das Programm kann eine Datei nicht finden. Das wäre die Bootloaderdatei gewesen, wir hatten aber gar keine bereitgestellt. Den Fehler können wir also ignorieren, die Fuses wurden trotzdem gebrannt, wie man der Statusausgabe entnehmen kann.
Der erste Sketch
Jetzt wollen wir die Programmierung gleich mal ausprobieren. Dazu verwendet man im Arduino-Umfeld gerne ein Blink-Programm. Das ist eine einfache Schleife, in der eine LED ein- und ausgeschaltet wird. Ich hab hier mal einen entsprechenden Sketch für den ATtiny 13A:
#define LED_PIN 3
void setup() {
pinMode(LED_PIN, OUTPUT); // digital pin is output
}
void loop() {
digitalWrite(LED_PIN, HIGH); // turn the LED on
delay(100); // wait for 100ms
digitalWrite(LED_PIN, LOW); // turn the LED off
delay(100); // wait for 100ms
}Den Sketch in ein neues Fenster der Arduino IDE kopieren und dann auf den ATtiny flashen mit Sketch – Hochladen mit Programmer. Es geht auch mit Shift-Taste und Klick auf das Icon mit dem Pfeil nach rechts. Nach einem kurzen Moment für den Flashvorgang sollte das Programm automatisch ausgeführt werden und die LED anfangen zu blinken.