Das erste C-Programm, das man zu sehen bekommt, ist für die meisten das "Hallo Welt". Bei "Hallo Welt" geht es weniger um die Funktionalität an sich, sondern darum zu lernen, wie man überhaupt ein Programm übersetzt und einen Compiler verwendet.
Was für den PC das "Hallo Welt" ist für einen kleinen Microcontroller der "Hallo Blinky", der einfch nur eine Leuchtdiode (LED) blinken lässt.
Im Vergleich zu "Hallo Welt" sieht der Blinky viel komplizierter aus, aber eigentlich ist er einfacher, dann es werden keine umfangreichen Funktionen oder Black-Boxen benutzt wie etwa printf(). Ausser dem eingegebenen Quellcode kommt also kein andere Code zur Ausführung!
Inhaltsverzeichnis
Von der C-Quelle zum hex-File
Das Beispiel besteht ganz bewusst aus zwei getrennten Quelldateien (Modulen) um zu zeigen, wie man Code auf mehrere Dateien aufteilen kann um die Übersichtlichkeit bei grösseren Projekten zu wahren.
Ausserdem wird das Übersetzen über Kommandozeilen-Eingaben erlegigt und nicht über Werkzeuge wie make, dessen inkorrekte Anwendung eine häufige Fehlerquelle ist.
Nach Speichern der Quelldatein in ein eigenes Verzeichnis ehtält dieses
blinky.c timer1.c timer1.h
Compilieren
Zunächst werden die C-Dateien übersetzt. Der Übersetzungsvorgang wird gesteuert durch Kommandozeilen-Parameter (siehe avr-gcc). Die Option -c tegt fest, daß nur compiliert wird (und nicht gelinkt), -o name gibt den Name der Ausgabedatei an, -mmcu=xxxx legt den Controllertyp fest, -g erzeugt Debug-Infos und -Os optimiert auf Codegröße.
avr-gcc blinky.c -c -o blinky.o -Os -g -mmcu=atmega8 avr-gcc timer1.c -c -o timer1.o -Os -g -mmcu=atmega8
Danach sind zwei neue Dateien entstanden (*.o)
blinky.c blinky.o timer1.c timer1.h timer1.o
Linken
Die beiden erzteugten Objekte werden nun zusammengebunden, um die Ausgabedatei (*.elf) zu erhalten.
avr-gcc blinky.o timer1.o -o blinky.elf -mmcu=atmega8
Erzeugt die ausführbare Datei (*.elf), die noch zusätzliche Informationen wie Debug-Infos etc. beinhaltet.
blinky.c blinky.elf blinky.o timer1.c timer1.h timer1.o
Umwandeln nach hex
Viele Progger wollen die zu ladende Datei im Intel-hex-Format (*.hex bzw. *.ihex). Dazu gibt man an
avr-objcopy -j .text -j .data -O ihex blinky.elf blinky.hex
Damit enthält die hex-Datei die Sections .text (Programm) und .data (Daten). Das Verzeichnis beinhaltet jetzt
blinky.c blinky.elf blinky.hex blinky.o timer1.c timer1.h timer1.o
Listfile erstellen
Falls man ein Listfile haben möchte, dann geht das mit
avr-objdump -h -S -j .text -j .data blinky.elf > blinky.lst
Das Listfile ist eine Textdatei, die alle Assembler-Befehle auflistet, wie sie letztendlich auf den Controller geladen werden.
Die Größe ermitteln
Die Größe der erhaltenen Objekte/Files können mit avr-size ausgegeben werden.
avr-size -x blinky.o timer1.o
druckt aus:
text data bss dec hex filename 0x42 0x0 0x2 68 44 blinky.o 0x70 0x0 0x2 114 72 timer1.o
Das ist die Größe der einzelnen Objekte. Für das Flash relevant ist die Größe von .text (Code) + .data (initialisierte Daten), für das SRAM relevent ist .data (initialisierte Daten) + .bss (null-initialisierte Daten.
avr-size -x -A blinky.elf
druckt aus:
blinky.elf : section size addr .text 0x110 0x0 .data 0x0 0x800060 .bss 0x4 0x800060 .noinit 0x0 0x800064 .eeprom 0x0 0x810000 .stab 0x798 0x0 .stabstr 0x6b0 0x0 Total 0xf5c
Die Größe einzelner Funktionen lässt man anzeigen mit
avr-nm --size-sort -S blinky.elf
was druckt
00800060 00000002 b irq_count 00800062 00000002 b timer1a_job 00000086 00000018 T main 0000009e 00000022 T timer1_init 0000005c 0000002a t job_timer1 000000c0 0000004e T SIG_OUTPUT_COMPARE_1A
Quellcode
blinky.c
#include <avr/io.h>
#include <avr/interrupt.h>
#include "timer1.h"
/* PortB.1 blinkt jede Sekunde */
/* also mit einer Frequenz von 1/2 Hz */
#define DDR_LED DDRB
#define PORT_LED PORTB
#define PAD_LED 1
static void ioinit();
static void job_timer1();
/* Zählt in jedem aufgetretenem IRQ eins hoch */
static volatile uint16_t irq_count = 0;
/* Diese Funktion ist ein 'Callback' */
/* Sie wird an timer1_init() übergeben */
/* und von dort aus aufgerufen, und zwar */
/* INTERRUPTS_PER_SECOND mal pro Sekunde. */
/* Sie wird also auf IRQ-Ebene ausgeführt */
void job_timer1()
{
uint16_t count;
/* irq_count um 1 erhöhen und */
/* gegebenenfalls die LED blinken */
count = 1+irq_count;
if (count >= INTERRUPTS_PER_SECOND)
{
count = 0;
PORT_LED ^= (1 << PAD_LED);
}
irq_count = count;
}
void ioinit()
{
/* Port als Ausgang */
DDR_LED |= (1 << PAD_LED);
/* Initialisiert Timer1, um jede Sekunde */
/* INTERRUPTS_PER_SECOND mal die Funktion job_timer1 */
/* aufzurufen */
timer1_init (job_timer1);
}
int main (void)
{
/* Peripherie initialisieren */
ioinit();
/* Interrupts aktivieren */
sei();
/* Nach main landen wir in exit(), */
/* das nur aus einer Endlosschleife besteht (avr-gcc) */
/* Der Interrupt lässt die LED weiterhin */
/* im Sekundentakt blinken */
return 0;
}
timer1.h
#ifndef _TIMER1_H_ #define _TIMER1_H_ #include <inttypes.h> #ifndef INTERRUPTS_PER_SECOND #define INTERRUPTS_PER_SECOND 1000 #endif /* INTERRUPTS_PER_SECOND */ extern void timer1_init (void (*) (void)); #endif /* _TIMER1_H_ */
timer1.c
#include <avr/io.h>
#include <avr/signal.h>
#include "timer1.h"
#ifndef F_CPU
#define F_CPU 1000000
#endif /* F_CPU */
/* Test von F_CPU und INTERRUPTS_PER_SECOND */
/* auf Gültigkeitsbereich */
#if (F_CPU / INTERRUPTS_PER_SECOND -1 < 0) \
|| (F_CPU / INTERRUPTS_PER_SECOND -1 >= 0x10000)
#error Werte für F_CPU bzw. INTERRUPTS_PER_SECOND ungeeignet
#error evtl. muss der Prescaler verwendet werden
#endif
/* Callback-Funktion */
static void (*timer1a_job) (void);
void timer1_init (void (*job) (void))
{
timer1a_job = job;
#if defined (__AVR_AT90S2313__)
/* AVR Classic: */
/* Timer1 läuft mit vollem Takt */
/* CTC: Clear Timer on CompareMatch */
/* Timer1 ist Zähler */
TCCR1A = 0;
TCCR1B = _BV (CS10) | _BV (CTC1);
#elif defined (__AVR_ARCH__) && ((__AVR_ARCH__==4) || (__AVR_ARCH__==5))
/* AVR Mega: */
/* Mode #4 für Timer1 (ATMega8 Manual S. 97) */
/* und voller MCU Takt (Prescale=1) */
TCCR1A = 0;
TCCR1B = _BV (WGM12) | _BV (CS10);
#else
#error Dont know how to setup timer1
#endif
/* OutputCompare1A Register setzen */
OCR1A = (uint16_t) ((uint32_t) F_CPU / INTERRUPTS_PER_SECOND -1);
/* evtl. gesetztes OC1A-Flag zurücksetzen */
TIFR = (1 << OCF1A);
/* OutputCompare1A Interrupt aktivieren */
TIMSK |= (1 << OCIE1A);
}
/* Die Interrupt Service Routine ruft lediglich */
/* timer1a_job auf (callback) */
SIGNAL(SIG_OUTPUT_COMPARE_1A)
{
timer1a_job();
}
