ATtiny85-Mikro-Minimum

AVR-Programmierung und Minimalismus - IDE-Tools/AVR-SIM

ATtiny85-Mikro-Minimum
8 Bytes in Assembler für ein Blink mit der Arduino IDE

Die Verwendung der natürlichen Sprache einer Maschine gestattet es mit ganzen 8 Bytes eine LED blinken zu lassen. Das funktioniert unter anderem mit dem vom Arduino verwendeten Mikrocontroller, aber auch mit dem kleinen ATtiny85.

Die 70 Bytes des Blinkers in der Sprache C bestehen nur im Kern aus den Blink-Anweisungen. Ein C-Compiler legt zusätzlich eine Programm-Struktur an, die weitere Dinge berücksichtigt, die jedoch nicht immer notwendig sind. Durch schrittweises Reduzieren soll der Zugang zur Maschinensprache verdeutlicht werden. Die benötigten Werkzeuge liegen der Arduino-IDE bei, so dass alles quellofffen und kostenfrei bleibt. Zusätzlich kommt avr-sim zum Einsatz, der AVR-Mikrocontroller simulieren kann, aber auch Dateien erzeugt, die einem realen Prozessor hochgeladen werden können.

Software Arduino IDE und AVR-Sim

Display mit 48x30 Zeichen

Über den Link Software | Arduino findet man etwas weiter unten den Download für die verschiedenen Betriebssysteme. Verwendet wird hier die ZIP-Version, damit eine möglichst überschaubare Installation entsteht. Das Archiv wird hier unter Windows im Wurzelverzeichnis von Laufwerk C entpackt. Eine Verknüpfung von arduino.exe in diesem Verzeichnis landet auf dem Desktop oder im Startmenü.

Ist bereits eine IDE installiert, so kann das Installations-Verzeichnis über die Verknüpfungs-Eigenschaften (rechte Maustaste) und Dateipfad öffnen festgestellt werden.

Die Hilfsprogramme für die IDE liegen in einem Unterverzeichnis bin mit den ausführbaren Dateien wie C-Compiler, Assembler, Disassembler und dem Programm zum Lesen und Schreiben des Flash-Speichers, also für das Hochladen von Programmen. Falls die Installation so erfolgt ist wie oben beschrieben, ist der absolute Pfad zu diesem Verzeichnis: C:\arduino-1.8.19-windows\arduino-1.8.19\hardware\tools\avr\bin.

Ein Klick in der Adresszeile des Explorers schaltet die Darstellung um, damit das Ergebnis kopiert werden kann. Diese Werkzeuge können auch direkt von der sogenannten Kommandozeile zur Ausführung kommen. Dazu startet man die Powershell von Windows mit der rechten Maustaste über Start/Windows Powershell.

Der Benutzer Q kann nun über den Pfad auf die Werkzeuge der IDE zugreifen.

Die bereits für die 70 Bytes-Version Verwendete IDE ist die letzte der 1.8 Reihe und bleibt aus Kompatibilitätsgründen als Legacy-Version verfügbar.

Disassembler Maschinen-Code des C-Compilers

In der Arduino-IDE kann die kompilierte Binärdatei ohne sie hochzuladen über Sketch/ Kompilierte Binärdatei exportieren gespeichert werden. Das Ergebnis ist eine HEX-Datei in einem Format, welches auch zum Hochladen verwendet wird. Das Format enthält nur hexadezimale Zahlen als Text mit zusätzlichen Prüfsummen und Adressen. Der Export der 70 Bytes des Blinkers in C hat das folgende Aussehen.

85blinkNEO.ino

int main(void) {DDRB = B00000010 ; TCCR1 = B10011111 ; OCR1C = 100 ; }

85blinkNEO.ino.tiny8.hex (70 Bytes)

:100000000EC015C014C013C012C011C010C00FC064 :100010000EC00DC00CC00BC00AC009C008C011241E :100020001FBECFE5D2E0DEBFCDBF02D00AC0E8CF11 :1000300082E087BB8FE980BF84E68DBD90E080E0E1 :060040000895F894FFCFC3 :00000001FF

Diese 70 blau dargestellten Bytes sind das Maschinenprogramm, welches in den Flash-Speicher des Controllers hochgeladen werden kann. Das dazu erforderliche Werkzeug der IDE nennt sich avrdude und kommt später zum Einsatz. Die für die Maschine gut lesbaren Bytes lassen sich mit Hilfe eines Disassemblers in besser lesbare Assembler-Mnemonics umwandeln. Die kursiv dargestellten Bytes entsprechen den drei Zeilen C, der Rest sind vom Compiler erzeugte Sprünge zur eventuellen Behandlung von Interrupts usw. welche hier jedoch nicht erforderlich sind.

Diese HEX-Datei 85blinkNEO.ino.tiny8.hex liegt nach dem Export vom Benutzer Q im Sketch-Verzeichnis: C:\Users\Q\Documents\Arduino\85blinkNEO

Der Disassembler avr-objdump liegt im bin-Verzeichnis der IDE-Werkzeuge:
C:\arduino-1.8.19-windows\arduino-1.8.19\hardware\tools\avr\bin

Die Powershell - oder wie Microsoft meint - das Powershell orientiert sich origineller Weise an Linux und ruft ausführbare Dateien jetzt mit ./ auf, was zu einer gewissen Kompatibilität führen soll. Um also an avr-objdump die HEX-Datei zu übergeben und mit avr5-Code zu disassemblieren, ist folgende Kommandozeile erforderlich (Copy/Paste/Enter):

C:\Users\Q> C:\arduino-1.8.19-windows\arduino-1.8.19\hardware\tools\avr\bin./avr-objdump -j .sec1 -d -m avr5 C:\Users\Q\Documents\Arduino\85blinkNEO\85blinkNEO.ino.tiny8.hex

   0:   0e c0           rjmp    .+28            ;  0x1e
   2:   15 c0           rjmp    .+42            ;  0x2e
   4:   14 c0           rjmp    .+40            ;  0x2e
   6:   13 c0           rjmp    .+38            ;  0x2e
   8:   12 c0           rjmp    .+36            ;  0x2e
   a:   11 c0           rjmp    .+34            ;  0x2e
   c:   10 c0           rjmp    .+32            ;  0x2e
   e:   0f c0           rjmp    .+30            ;  0x2e
  10:   0e c0           rjmp    .+28            ;  0x2e
  12:   0d c0           rjmp    .+26            ;  0x2e
  14:   0c c0           rjmp    .+24            ;  0x2e
  16:   0b c0           rjmp    .+22            ;  0x2e
  18:   0a c0           rjmp    .+20            ;  0x2e
  1a:   09 c0           rjmp    .+18            ;  0x2e
  1c:   08 c0           rjmp    .+16            ;  0x2e
  1e:   11 24           eor     r1, r1
  20:   1f be           out     0x3f, r1        ; 63
  22:   cf e5           ldi     r28, 0x5F       ; 95
  24:   d2 e0           ldi     r29, 0x02       ; 2
  26:   de bf           out     0x3e, r29       ; 62
  28:   cd bf           out     0x3d, r28       ; 61
  2a:   02 d0           rcall   .+4             ;  0x30
  2c:   0a c0           rjmp    .+20            ;  0x42
  2e:   e8 cf           rjmp    .-48            ;  0x0
  30:   82 e0           ldi     r24, 0x02       ; 2
  32:   87 bb           out     0x17, r24       ; 23
  34:   8f e9           ldi     r24, 0x9F       ; 159
  36:   80 bf           out     0x30, r24       ; 48
  38:   84 e6           ldi     r24, 0x64       ; 100
  3a:   8d bd           out     0x2d, r24       ; 45
  3c:   90 e0           ldi     r25, 0x00       ; 0
  3e:   80 e0           ldi     r24, 0x00       ; 0
  40:   08 95           ret
  42:   f8 94           cli
  44:   ff cf           rjmp    .-2             ;  0x44

In der ersten Spalte ist die Adresse des Flash-Speichers aufsteigend notiert. Die beiden nächsten Spalten zeigen die Bytes, die darunter abgespeichert sind und die der Prozessor als Anweisungen ausführt. Danach folgen die Übersetzungen der Bytes in mnemotechnischer Schreibweise - quasi das was gewöhnlich kurz Assembler genannt wird. Nach dem Semikolon folgen numeriische Hinweise und Umrechnungen.

Der Controller setzt nach einem Reset den Adresszähler auf die Adresse 0x00 und arbeitet die Befehle in Byteform ab. Ein Sprung nach 0x1E initialisiert Dinge und ruft dann das Unterprogramm (main) an der Adresse 0x30. Anschließend folgt der Sprung nach 0x42 wo eine Endlosschleife bei 0x44 den Prozessor gefangen hält. Die hexadezimale Schreiweise 0xnn ist der Sprache C entliehen.

Assembler Maschinen-Code von Menschenhand

Zwar kann die Arduino-IDE auch direkt Assembler entgegennehmen, der durch den Compiler erzeugte geringe Overhead bleibt jedoch bestehen. Da der direkte Aufruf des avr-as bisher nicht klar ist, findet der Assembler im AVR-SIM Verwendung. Diese Software ist frei und mit offenem Quelltext. Er verwendet eine eigene Oberfläche, die sehr schnell beherrscht wird. Von den vielen Möglichkeiten soll hier nur die zielführende Assembler-Abteilung zum Einsatz kommen.

Die Datei avr_sim.exe liegt beim Benutzer Q im Verzeichnis C:\Users\Q\Downloads\avr_sim_28_win64. Mit einem neuen ATtiny85-Projekt mit dem Namen 85 erzeugt die Software einen Assembler Quelltext 85.asm, der ein ausführliches Skelett darstellt. Erkennbar sind auch hier die Initialisierungen der Sprünge im Code-Abschnitt, das Hauptprogramm Main und die Endlosschleife. Mit Menu/Assemble wird eine HEX-Datei erzeugt und eine Simulation ohne Hardware ist die eigentliche Absicht des Programmierers von AVR-SIM. Hier soll jedoch der IDE-Code eingesetzt werden, um dann die kürzere Hex-Datei dem realen Controller durch hochladen zu übergeben. Mit Strg+A und Entf wird der Quelltext komplett gelöscht und mit den folgenden Zeilen in dieser Datei 85.asm ersetzt, da das Kopieren aus dem Browser nicht ohne Fehlermeldungen klappt. Nach Assemble zeigt die erzeugte 85.lst-Datei u.a.:

Path: C:\Users\Q\Downloads\avr_sim_28_win64\ Source file: 85.asm Hex file: 85.hex Eeprom file: 85.eep Compiled: 14.12.2022, 12:24:06 Pass: 2

1: .cseg 2: .org 000000 3: 000000 E082 ldi r24,0x02 4: 000001 BB87 out 0x17,r24 5: 000002 E98F ldi r24,0x9F 6: 000003 BF80 out 0x30,r24 7: 000004 E684 ldi r24,0x64 8: 000005 BD8D out 0x2d,r24 9: loop: 10: 000006 CFFF rjmp loop 11:

und die ebenfalls erzeugte HEX-Datei 85.hex:

:020000020000FC :0E00000082E087BB8FE980BF84E68DBDFFCF15 :00000001FF

Das sind netto 14 Bytes oder 7 Worte!

Hochladen upload mit avrdude

Der vom Ballast befreite Maschinencode soll nun im realen ATtiny85 überprüft werden. Um zu sehen, wie die IDE selber einen Sketch hochlädt, kann unter Datei/Voreinstellungen der Haken bei ausführliche Ausgaben bei Hochladen gesetzt werden. Den 70-Byte-Sketch lädt die IDE mit folgendem Aufruf hoch, wobei die Hex-Datei in einem von der IDE benutzten temporären Verzeichnis erzeugt wurde:

C:\arduino-1.8.19-windows\arduino-1.8.19\hardware\tools\avr/bin/avrdude -CC:\arduino-1.8.19-windows\arduino-1.8.19\hardware\tools\avr/etc/avrdude.conf -v -pattiny85 -cstk500v1 -PCOM3 -b19200 -Uflash:w:C:\Users\Q\AppData\Local\Temp\arduino_build_774864/85blinkNEO.ino.hex:i

Mit den selben Parametern, aber anderer Hex-Datei sieht der Einzeiler der Powersshell dann aus wie folgt (Copy/Paste/Enter):

Das freundliche Hochladeprogramm endet mit der Ausgabe

avrdude.exe: verifying ... avrdude.exe: 14 bytes of flash verified

avrdude.exe: safemode: lfuse reads as E2 avrdude.exe: safemode: hfuse reads as DF avrdude.exe: safemode: efuse reads as FF avrdude.exe: safemode: Fuses OK (E:FF, H:DF, L:E2)

avrdude.exe done. Thank you.

und der ATtiny85 blinkt hektisch vor sich hin.

Es geht auch ohne rjump…

avrdude.exe: verifying ... avrdude.exe: 12 bytes of flash verified

Es geht auch ohne OCR1C = 0..255

17: 000000 E082 ldi r24, 0x02 18: 000001 BB87 out 0x17, r24 19: 000002 E98F ldi r24, 0x9F 20: 000003 BF80 out 0x30, r24

avrdude.exe: verifying ... avrdude.exe: 8 bytes of flash verified

Und damit blinkt die LED am ATtiny etwa einmal pro Sekunde mittels 8 Byte.

ATtiny85 als Compact-Interface
ATtiny88 als Compact-Interface
ATtiny85 ISP-Programmer - 70 Bytes Blink
Mehr Software