HomeProjekteMicrocontroller unter Linux 

Microcontroller unter Linux

Weitersagen:

Was ist eigentlich ein Microcontroller?

Kurz gesagt — ein programmierbarer IC. Man entwickelt am Computer ein Programm und spielt es über ein Kabel auf den Microcontroller (kurz: µC), der dieses dann bei 5V Spannung ausführt. Somit kann man zum Beispiel komplizierte Ansteuerungen von LCD-Displays realisieren, die ohne µC oder passenden IC fast unmöglich wären. Außerdem lässt sich bei geänderten Anforderungen leicht eine neue Version aufspielen, ohne dass an der Hardware etwas modifiziert werden muss.

Grundlagen

Ein Microcontroller hat immer drei festgelegte Anschlüsse: Betriebsspannung (VCC), Masse (GND) und Reset. Alle restlichen Pins (die „Beinchen” des µCs) sind immer maximal zu acht in Ports organisiert. Die Ports werden mit Buchstaben benannt, die Pins mit Zahlen; beispielsweise wird der zweite Pin im PortD mit PORTD1 angesprochen (weil das Zählen in den meisten Programmiersprachen mit Null anfängt).
Wenn an einem Pin die Betriebsspannung anliegt, ist er high, ansonsten low. Für Microcontroller gibt es nichts dazwischen, da im Binärsystem nur mit Nullen und Einsen gerechnet wird.

Benötigte Programme

Die folgenden Pakete werden (zusätzlich zu einem Texteditor) benötigt:

avrdude
zum Übertragen einer hex-Datei über die serielle Schnittstelle
avr-libc
Bibliotheken und Header-Dateien für C
gcc-avr
für AVR-Zwecke angepasster C-Compiler
avra
Assembler für die Atmel-Familie

Für Debian und dessen deutsch Derivate (z.B. Ubuntu, Kubuntu und Xubuntu) gilt somit folgender Code:

Terminal:

$ sudo apt-get install avrdude avr-libc gcc-avr avra

Danach müssen noch die Berechtigungen angepasst werden:

Terminal:

$ sudo chmod a+rw /dev/ttyS0

Atmels AVR-Familie

Wir werden hauptsächlich den ATtiny13, den ATtiny2313 den ATmega8 und den ATmega16 verwenden, von Atmel gibt es aber eine ganze Reihe von Microcontrollern:

(Die Bedeutung der hervorgehobenen Teile wird im nächsten Abschnitt beschrieben.)

AT90S1200
avrdude -p 1200
AT90S2313
avrdude -p 2313
AT90S2333
avrdude -p 2333
AT90S2343
avrdude -p 2343
AT90S4414
avrdude -p 4414
AT90S4433
avrdude -p 4433
AT90S4434
avrdude -p 4434
AT90S8515
avrdude -p 8515
AT90S8535
avrdude -p 8535
AT90CAN128
avrdude -p c128
AT90CAN32
avrdude -p c32
AT90CAN64
avrdude -p c64
ATmega103
avrdude -p m103
ATmega128
avrdude -p m128
ATmega1280
avrdude -p m1280
ATmega1281
avrdude -p m1281
ATmega1284P
avrdude -p m1284p
ATmega128RFA1
avrdude -p m128rfa1
ATmega16
avrdude -p m16
ATmega161
avrdude -p m161
ATmega162
avrdude -p m162
ATmega163
avrdude -p m163
ATmega164
avrdude -p m164
ATmega164P
avrdude -p m164p
ATmega168
avrdude -p m168
ATmega169
avrdude -p m169
ATmega2560
avrdude -p m2560
ATmega2561
avrdude -p m2561
ATmega32
avrdude -p m32
ATmega324P
avrdude -p m324p
ATmega325
avrdude -p m325
ATmega3250
avrdude -p m3250
ATmega328P
avrdude -p m328p
ATmega329
avrdude -p m329
ATmega3290
avrdude -p m3290
ATmega329P
avrdude -p m329p
ATmega3290P
avrdude -p m3290p
ATmega32U4
avrdude -p m32u4
ATmega48
avrdude -p m48
ATmega64
avrdude -p m64
ATmega640
avrdude -p m640
ATmega644P
avrdude -p m644p
ATmega644
avrdude -p m644
ATmega645
avrdude -p m645
ATmega6450
avrdude -p m6450
ATmega649
avrdude -p m649
ATmega6490
avrdude -p m6490
ATmega8
avrdude -p m8
ATmega8515
avrdude -p m8515
ATmega8535
avrdude -p m8535
ATmega88
avrdude -p m88
AT90PWM2
avrdude -p pwm2
AT90PWM2B
avrdude -p pwm2b
AT90PWM3
avrdude -p pwm3
AT90PWM3B
avrdude -p pwm3b
ATtiny10
avrdude -p t10
ATtiny12
avrdude -p t12
ATtiny13
avrdude -p t13
ATtiny15
avrdude -p t15
ATtiny2313
avrdude -p t2313
ATtiny25
avrdude -p t25
ATtiny26
avrdude -p t26
ATtiny261
avrdude -p t261
ATtiny4
avrdude -p t4
ATtiny44
avrdude -p t44
ATtiny45
avrdude -p t45
ATtiny461
avrdude -p t461
ATtiny5
avrdude -p t5
ATtiny84
avrdude -p t84
ATtiny85
avrdude -p t85
ATtiny861
avrdude -p t861
ATtiny88
avrdude -p t88
ATtiny9
avrdude -p t9
AT32uca0512
avrdude -p ucr2
ATmega1286
avrdude -p usb1286
ATmega1287
avrdude -p usb1287
ATmega162
avrdude -p usb162
ATmega647
avrdude -p usb646
ATmega647
avrdude -p usb647
ATmega82
avrdude -p usb82
ATxmega128A1
avrdude -p x128a1
ATxmega128A1revD
avrdude -p x128a1d
ATxmega128A3
avrdude -p x128a3
ATxmega128A4
avrdude -p x128a4
ATxmega16A4
avrdude -p x16a4
ATxmega192A1
avrdude -p x192a1
ATxmega192A3
avrdude -p x192a3
ATxmega256A1
avrdude -p x256a1
ATxmega256A3
avrdude -p x256a3
ATxmega256A3B
avrdude -p x256a3b
ATxmega32A4
avrdude -p x32a4
ATxmega64A1
avrdude -p x64a1
ATxmega64A3
avrdude -p x64a3
ATxmega64A4
avrdude -p x64a4

Programmierplatinen

Um vom Computer aus Dateien auf den µC spielen zu können, benötigt man eine Programmierplatine. Dabei gibt es Einsteigerboards wie das Pollinboard (Bausatz oder fertige Schaltung), das bereits einige Hardware zum Üben mitbringt. Eine andere Möglichkeit sind sogenannte ISP-Adapter, die über ein entsprechendes Kabel mit der Zielschaltung verbunden werden, ohne dort den µC aus dem Sockel nehmen zu müssen. Diese haben den Vorteil, dass man sie für mehrere Zielschaltungen verwenden kann. Beispiele sind der AVR-ISP-Adapter (Selbstbau) oder USBasp (Bausatz).

Übertragen

Das Programm, das die gewünschte Funktionalität bereitstellt, wird natürlich auf dem Computer mit einem beliebigen Texteditor geschrieben. Um es zu übertragen, wird eine hex-Datei benötigt, die erst durch das Kompilieren (bei C) oder Assemblieren (bei Assembler) entsteht. Diese generierte Datei kann dann über eine Programmierplatine auf den µC programmiert werden. Dazu ist das Programm avrdude da:

Terminal:

$ avrdude -p m8 -c ponyser -P /dev/ttyS0 -v -U flash:w:datei.hex
avrdude: AVR device initialized and ready to accept instructions

Reading | ################################################## | 100% 0.00s

avrdude: Device signature = 0x1e9309
avrdude: NOTE: FLASH memory has been specified, an erase cycle will be performed
To disable this feature, specify the -D option.
avrdude: erasing chip
avrdude: reading input file "datei.hex"
avrdude: writing flash (5462 bytes):

Writing | ################################################## | 100% 3.18s



avrdude: 5462 bytes of flash written
avrdude: verifying flash memory against datei.hex:
avrdude: load data flash data from input file datei.hex:
avrdude: input file datei.hex contains 5462 bytes
avrdude: reading on-chip flash data:

Reading | ################################################## | 100% 2.08s

avrdude: verifying ...
avrdude: 5462 bytes of flash verified

avrdude: safemode: Fuses OK

avrdude done. Thank you.
 

bzw. für den EEPROM, der erst später gebraucht wird:

$ avrdude -p m8 -c ponyser -P /dev/ttyS0 -v -U eeprom:w:datei.eep.hex

Dieser Befehl überträgt die Datei datei.hex (-U) über die serielle Schnittstelle (-P) auf einen ATmega8 (-p m8). Der Parameter -c gibt das Interface an, -v schaltet mehr Ausgabeinformationen ein. Eine Übersicht aller verwendbaren Parameter und möglicher Interfaces gibt es im english Manual.

Vor allem später, wenn man Fuses setzen will, wird einem aber die Kommandozeile doch zu umständlich. Torsten Brischalle hat eine GUI geschrieben, die intuitiv zu bedienen ist: deutsch AVR8 Burn-O-Mat

Zahlendarstellungen

Für die Programmierung ist es evtl. wichtig oder praktischer, eine Zahl in einem speziellen Format darzustellen. Wichtig ist dabei, dass alle Darstellungen dieselbe Zahl bedeuten.

Bit Nr.76543210
dezimaler Wert1286432168421
hexadezimaler Wert84218421
Beispiele:
dezimalhexadezimalbinär
170x110b0001000100010001
600x3c0b0011110000111100
1030x670b0110011101100111
410x290b0010100100101001
2380xf30b1111001111110011
1650xa50b1010010110100101

Um aus einer binären Zahl eine (hexa)dezimale Zahl zu errechnen, addiert man nun die dezimalen bzw. hexadezimalen Werte aller Bits, die auf high gesetzt sind, also den Wert 1 haben. Bei der hexadezimalen Darstellung stehen die Buchstaben A bis F (Groß- / Kleinschreibung egal) für die Zahlen 10 bis 15.

Jetzt aber los!

Nach der ganzen Theorie kommen wir natürlich endlich zu den Projekten: Als erstes beschäftigen wir uns mit dem Pollinboard.
Allen, die schon etwas Erfahrung haben, empfehle ich die eigene Würfelplatine.
Wer nach einer Programmieralternative für den USB-Port sucht, wird mit USBasp sicher glücklich.

makefiles

Bei jedem Microcontroller-Projekt müssen mehrere Befehle vom Kompilieren / Assemblieren zum Übertragen ausgeführt werden. Das wird natürlich sehr schnell sehr lästig. Deshalb gibt es eine schöne kleine Programmiersprache namens english make. In dem entsprechenden makefile wird bei einem Aufruf von make für jede Zieldatei geprüft, ob sich etwas an den zugehörigen Quelldateien geändert hat. Dann werden die Befehle ausgeführt, die zum Erstellen der Zieldatei nötig sind.

Für C-Dateien:

Makefile-Code:
# Datei, die übertragen werden soll
file = mein-projekt.hex

all: $(file)
avrdude -p m8 -c ponyser -P /dev/ttyS0 -v -U flash:w:$(file)
# Befehl wird jedes Mal ausgeführt

%.hex: %.c
avr-gcc -mmcu=atmega8 -I. -Wall -Wstrict-prototypes -Wundef -std=gnu99 $*.c -o $*.o
# -mmcu muss natürlich an den jeweiligen µC angepasst werden
avr-objcopy -O ihex -R .eeprom $*.o $*.hex
# $* wird durch Dateinamen ohne Endung (mein-projekt) ersetzt

Für Assembler-Dateien:

Makefile-Code:
# Datei, die übertragen werden soll
file = mein-projekt.hex

all: $(file)
avrdude -p m8 -c ponyser -P /dev/ttyS0 -v -U flash:w:$(file)
# Befehl wird jedes Mal ausgeführt

%.hex: %.asm
avra -I "/usr/share/avra" $*.asm
Terminal:

$ make

Teile diese Seite!    RSS-Feed abonnieren:
RSS