Kompilatory od podszewki - #4 - Programowanie mikrokontrolerów AVR z terminala

[Matthew11]

Ten artykuł jest częścią serii "Kompilatory od podszewki"

• #1 - Wprowadzenie
• #2 - Linker i biblioteki
• #3 - Automatyzacja procesu kompilacji, kompilatory a mikrokontrolery
• #4 - Programowanie mikrokontrolerów AVR z terminala (właśnie to czytasz)

W tej części

Zobaczysz jak bardzo proste jest programowanie mikrokontrolerów AVR bezpośrednio z terminala - bez żadnego IDE. Napiszemy program, który będzie sterował diodą. Następnie skompilujemy ten program pod mikrokontroler ATmega328p a wygenerowany plik wsadowy wgramy na płytkę Arduino Uno.

Logo mikrokontrolerów serii AVR.

Programowanie mikrokontrolerów AVR z terminala

Jak wspomnieliśmy w porzedniej części, programy dla mikrokontrolerów AVR możemy skompilować za pomocą kompilatora AVR GCC Toolchain - avr-gcc. Zasada korzystania jest taka sama jak dla kompilatorów których używaliśmy. Tym razem zamiast clang++ czy g++ używamy avr-gcc lub avr-g++ w przypadku programu napisanego w C++. Podajemy odpowiednie argumenty dla dostosowania pracy kompilatora i gotowe. 

W przypadku popularnej ATmegi 328P znanej np. z płytki Arduino Uno, najprostsze wywołanie będzie miało formę:

$ avr-g++ -mmcu=atmega328p -o main.bin main.cpp

W przypadku kompilacji programów na układy wbudowane musimy podać kompilatorowi typ mikrokontrolera - w tym przypadku za pomocą argumentu -mmcu. Czasami będziemy musieli podać więcej informacji - zależy to już od układu jaki wykorzystujemy - co mogliśmy zaobserwować w poprzedniej części mówiąc o tym co w tle wykonuje STM32CubeIDE. Więcej o parametrze -mmcu możemy przeczytać w dokumentacji.

Logo projektu WinAVR.

Instalacja kompilatora avr-gcc - Ubuntu

W przypadku Ubuntu instalacja wszystkich potrzebnych narzędzi zamyka się w poniższym wywołaniu:

$ sudo apt-get install binutils gcc-avr avr-libc

Instalacja kompilatora avr-gcc - Windows

W przypadku Windowsa w celu instalacji kompilatora należy pobrać i zainstalować zestaw narzędzi pod nazwą WinAVR. Instalację wykonujemy z domyślnymi opcjami. Standardowo WinAVR zostanie zainstalowany w folderze C:\WinAVR-20100110. Uwaga, numer wersji - 20100110 - może się zmienić. Instalator powinien automatycznie dodać wszystkie potrzebne ścieżki do zmiennej środowiskowej Path. W celu sprawdzenia czy instalacja się powiodła musimy wywołać w terminalu:

avr-gcc --version

Efektem powinno być wydrukowane następujących informacji:

avr-gcc.exe (WinAVR 20100110) 4.3.3
Copyright (C) 2008 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

W przypadku problemów sprawdź czy w zmiennej środowiskowej Path znajdują się te poniższe ścieżki:

C:\WinAVR-20100110\bin
C:\WinAVR-20100110\utils\bin

ATmega328PB. Źródło grafiki.

“Blink” dla mikrokontrolera ATmega328P

Zawsze kiedy poznajemy nowy język programowania pierwszym krokiem w jego nauce jest napisanie programu który wypisze tekst "Hello World!". W świecie mikrokontrolerów jest to napisanie programu, który miga diodą.

Uwaga: Przykład nie korzysta z żadnej formy wyższej abstrakcji - jak w przypadku pisania programów w frameworku Arduino - zamiast tego program napisany jest na rejestrach i wykorzystuje funkcje biblioteczne dostarczone przez producenta układu.

Założyłem, że dioda podłączona jest do pinu 5 na porcie PORTA - tak jak w oryginalnej płytce Arduino Uno. Stwórzmy zatem plik o nazwie main.cpp i przepiszmy do niego zawartość poniższego programu korzystając z dowolnego edytora tekstu. Program inicjalizuje rzeczony port i realizuje sterowanie diodą LED z użyciem funkcji opóźniających w nieskończonej pętli:

// main.cpp

#define F_CPU 16000000UL
#include <avr/io.h>
#include <util/delay.h>

int main(void)
{
    DDRB |= (1 << DDB5);

    while (1)
    {
        PORTB |= (1 << PORTB5);
        _delay_ms(1000);
        PORTB &= ~(1 << PORTB5);
        _delay_ms(1000);
    }
}

Ważniejsze fragmenty kodu to ustawienie pinu o numerze 5 w rejestrze DDRB (rejestr definiujący kierunek) jako wyjście:

DDRB |= (1 << DDB5);

Ustawienie stanu wysokiego na pinie 5 w rejestrze PORTB (rejestr definiujący stan wyjścia):

PORTB |= (1 << PORTB5);

Ustawienie stanu niskiego (lub wyzerowanie stanu) na pinie 5 w rejestrze PORTB (rejestr definiujący stan wyjścia):

PORTB &= ~(1 << PORTB5);

Memory-Mapped Input/Output

Czym są te wszystkie symbole: DDRB, DDB5, PORTB itp? Są to makra zdefiniowane w bibliotekach dostarczonych przez producenta, które uzyskują w wygodny dla nas sposób dostęp do rejestrów mikrokontrolera. Definicje tych makr możemy znaleźć w katalogu:

C:\WinAVR-20100110\avr\include\avr

A dla naszego przypadku - ATmegi 328p - w pliku iom328p.h. Dla przykładu weźmy rejestr DDRB, we wspomnianym pliku możemy znaleźć następujące definicje:

// ...
#define DDRB _SFR_IO8(0x04)
#define DDB0 0
#define DDB1 1
#define DDB2 2
#define DDB3 3
#define DDB4 4
#define DDB5 5
#define DDB6 6
#define DDB7 7
// ...

Są to definicje rejestru DDR dla portu B (DDRB) i definicje pinów 0-7 (DDB0-7). Makro _SFR_IO8 w swojej definicji korzysta z kolejnego makra:

#define _SFR_IO8(io_addr) _MMIO_BYTE((io_addr) + __SFR_OFFSET)

Natomiast makro _MMIO_BYTE odpowiedzialne jest za uzyskanie dostępu do danych znajdujących się pod podanym adresem pamięci mikrokontrolera - przez castowanie adresu (mem_addr) na wskaźnik (volatile uint8_t*) i dereferencję (*) tego wskaźnika:

#define _MMIO_BYTE(mem_addr) (*(volatile uint8_t *)(mem_addr))

Taki koncept nosi nazwę Memory-Mapped Input/Output. My na tym zakończymy, ale jeśli chciałbyś przeczytać więcej o tym zagadnieniu to polecam świetną serię na blogu Feabhas.

Kompilacja

Kompilacji dokonujemy za pomocą wywołania:

$ avr-g++ -Os -Wall -Wextra -mmcu=atmega328p -o main.bin main.cpp

Aby funkcje opóźniające mogły działać prawidłowo musieliśmy włączyć odpowiedni poziom opytymalizacji czyli podać flagę -Os. Przy braku optymalizacji kompilator ostrzega:

/usr/lib/avr/include/util/delay.h:112:3: warning: #warning "Compiler optimizations disabled; functions from <util/delay.h> won't work as designed" [-Wcpp]

# warning "Compiler optimizations disabled; functions from <util/delay.h> won't work as designed"

Generowanie programu wsadowego

Otrzymaliśmy plik binarny o nazwie main.bin. Jeszcze nie możemy go w takiej postaci wgrać do mikrokontrolera musimy go przetworzyć do odpowiedniego formatu (.hex), do tego celu służy narzędzie avr-objcopy - które opisaliśmy w poprzednij części. Taki plik otrzymamy wywołując dla naszego przykładu:

$ avr-objcopy -j .text -j .data -O ihex main.bin main.hex

Wgrywanie programu do mikrokontrolera

Ostatnim krokiem jest wgranie programu do mikrokontrolera. Dla mikrokontrolerów AVR specjalnym narzędziem do tego celu jest AVRDUDE. Instalacja na Ubuntu:

$ sudo apt-get install avrdude

W przypadku Windowsa wykorzystamy z AVRDUDE dostarczonego wraz z WinAVR. AVRDUDE przyjmuje szereg argumentów, zakładając że korzystamy z płytki Arduino Uno, wgranie programu do pamięci wykonamy przez wywołanie:

$ avrdude -C<path/to/avrdude.conf> -patmega328p -carduino -P<port> -b115200 -D -Uflash:w:<program_name.hex>:i

gdzie za miejsca <...> podajemy konkretne wartości. W moim przypadku płytka podpięta jest pod port /dev/ttyUSB0 (Ubuntu) lub COM7 (Windows), a program ma nazwę main.hex, więc właściwe wywołanie na Ubuntu ma postać:

$ avrdude -patmega328p -carduino -P/dev/ttyUSB0 -b115200 -D -Uflash:w:main.hex:i

a na Windows:

$ avrdude -patmega328p -carduino -PCOM7 -b115200 -D -Uflash:w:main.hex:i

W trakcie wgrywania AVRDUDE wydrukuje takie informacje:

avrdude: AVR device initialized and ready to accept instructions

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

avrdude: Device signature = 0x1e950f (probably m328p)
avrdude: reading input file "main.hex"
avrdude: writing flash (176 bytes):

Writing | ################################################## | 100% 0.04s

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

Reading | ################################################## | 100% 0.03s

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

avrdude: safemode: Fuses OK (E:00, H:00, L:00)

avrdude done.  Thank you.

A po wszystkim dioda na płytce będzie świecić i gasnąć co jedną sekundę. 

To już koniec tej serii - podsumowanie

Jak mogliśmy zauważyć zbudowanie programu, wygenerowanie pliku wsadowego i wgranie programu na mikrokontroler posługując się jedynie terminalem to bardzo prosta czynność, która zamyka się w trzech poleceniach:

$ avr-g++ -Os -Wall -Wextra -mmcu=atmega328p -o main.bin main.cpp
$ avr-objcopy -j .text -j .data -O ihex main.bin main.hex
$ avrdude -patmega328p -carduino -P/dev/ttyUSB0 -b115200 -D -Uflash:w:main.hex:i

Zaglądnięcie "pod maskę" daje większe zrozumienie tego co się dzieje jak również pełną kontrolę nad tym co w danym momencie się wykonuje. Możemy dodawać dodatkowe opcje lub je zmieniać, możemy wygenerować listing assemblera, podejrzeć rozmiar wynikowego programu i wiele więcej - wszystko co w danym momencie potrzebujemy.

Dobrym sposobem na poszerzenie wiedzy o tym co dzieje się za kurtyną, jest przeglądanie zakładek dotyczących konfiguracji kompilatora przez IDE i przeczytanie w dokumentacji kompilatora co każda z tym opcja oznacza. Dużo informacji może również dostarczyć podejrzenie czynności wykonywanych przez Wasze IDE, gdy klikniecie przycisk “Buduj” i “Wgraj” i przeanalizowanie jakie narzędzia w tych czynnościach są wykorzystywane i z jakimi parametrami są wywoływane.

[Treker (Damian Szymański)]

@Matthew11 artykuł został właśnie zaakceptowany i jest już dostępny publicznie

[jargraw]

Dzięki, ciekawe artykuły. Nie próbowałem "ręcznie" ładować swoich wypocin do Arduino, bo podejrzewałem, że nadpiszę bootloader. Rzeczywiście, avrdude korzysta z pliku konfiguracyjnego dostarczonego z Arduino, i dodatkowych opcji. W Geany są odpowiednie opcje budowania do zdefiniowania, to sobie zdefiniuję.

 

[Gieneq]

@Matthew11 bardzo ciekawe artykuły. Przyznam że kiedyś je tylko przejrzałem, ale to dobrze, bo teraz jak chciałem coś doczytać o linkerze to wiedziałem, gdzie szukać.  Szczególnie 2 pierwsze części mi się przydały, dobra robota