Przewodnik instalacji Linuxa na platformie embedded

Komputery SBC Elvis

W pierwszej części artykułu opisałem możliwość użycia taniego netbooka w roli sterownika robota. Zgodnie z zapowiedzią w kolejnym wpisie przedstawiam instrukcję instalacji Linuxa na wybranej wcześniejszej platformie.

Do dalszej pracy niezbędne są: bootloader, jądro linuxa, system plików oraz kompilator (toolchain).

Udostępnij

« Poprzedni artykuł z seriiNastępny artykuł z serii »

W przypadku Raspberry Pi moglibyśmy pobrać całość jako gotową dystrybucję (np. Raspbian). Wykorzystując netbooka musimy przygotować wszystko od początku.  Zaczniemy od końca, czyli od kompilatora i systemu plików.

Przygotowania

Na początek potrzebny będzie komputer (PC, laptop) z zainstalowanym linuxem. Można co prawda używać innego systemu (np. Windows lub Mac OS), ale wszystko będzie wtedy dużo trudniejsze.

Warto więc postarać się o szybki komputer i dużo wolnego miejsca na dysku (20GB to minimum, lepiej zarezerwować nawet większą przestrzeń). Ja używam dystrybucji Ubuntu 14.04 LTS, jednak można wykorzystać właściwie każdą popularną wersję. Potrzebny będzie jeszcze dostęp do internetu, najlepiej szybkiego.

Pierwsza kompilacja

Pierwszy cross-compilator mamy dostępny w systemie. Wystarczy, że go zainstalujemy:

sudo apt-get install gcc-arm-linux-gnueabi

Możemy sprawdzić, czy działa:

arm-linux-gnueabi-gcc –version

Otrzymamy komunikat:

arm-linux-gnueabi-gcc (Ubuntu/Linaro 4.7.3-12ubuntu1) 4.7.3
Copyright © 2012 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.

Jeśli jesteśmy leniwi, moglibyśmy na tym poprzestać. Kompilator działa jak zwykły gcc, jedyna różnica to przedrostek “arm-linux-gnueabi-”. Jest nieco długi, ale tak przyjęło się nazywać cross-compilatory. Później okaże się to całkiem przydatne, ponieważ na jednym komputerze możemy mieć jednocześnie wiele różnych wersji gcc. Wybrana wersja kompiluje program w C do postaci przeznaczonej dla procesorów ARM.

Możemy ją wykorzystać do skompilowania jądra. Jednak zaczniemy od systemu plików.

Linux składa się z dwóch głównych części:

• jądra,
• systemu plików.

Każdy kto miał do czynienia z linuxem zna charakterystyczny układ katalogów:

• /bin,
• /etc,
• /home,
• /usr.

Zawartość tych katalogów musimy przygotować i wyposażyć w pliki zgodne z wykorzystywanym procesorem. Na szczęście są gotowe narzędzia, które nam w tym pomogą. Wykorzystamy Buildroota -  proste w użyciu, ale całkiem potężne narzędzie, które “zbuduje” naszego linuxa. Kod pobieramy ze strony projektu: http://buildroot.uclibc.org/

Najłatwiej użyć git-a (oczywiście trzeba go zainstalować: sudo apt-get install git). Poniższym poleceniem pobieramy całość na nasz komputer.

git clone git://git.buildroot.net/buildroot

Sam buildroot jest stosunkowo niewielki, dopiero później się rozrośnie (u mnie zajmuje 10GB). Wchodzimy do katalogu buildroota i wydajemy polecenie:

make menuconfig

Jeśli nie zainstalowaliśmy wcześniej biblioteki ncurses, należy ją szybko doinstalować:

sudo apt-get libncurses5-dev

Powinniśmy zobaczyć menu programu:

Jeśli ktoś bardzo nie lubi trybu tekstowego, może wydać polecenie:

make xconfig lub make gconfig

O ile zostaną zainstalowane wszystkie wymagane biblioteki (qt lub gtk), zobaczymy środowisko graficzne. Jednak ich zawartość jest dokładnie taka sama. Którą opcję wybierzemy, zależy od naszych upodobań.

Za pomocą menu wybieramy, jakie parametry będzie miał nasz linux, a następnie wychodząc zapisujemy konfigurację. Zostanie ona zachowana w pliku (ukrytym) o nazwie ”.config”.

Kolejnym krokiem będzie polecenie:

make

 i dłuuuuga przerwa na kawę.

Pierwsze próby mogą zakończyć się niepowodzeniem. Trzeba wtedy przeczytać komunikaty z informacja o błędach. Najczęściej błędy wynikają one z braku zainstalowania odpowiednich bibliotek. Trzeba te biblioteki doinstalować i zacząć jeszcze raz.

Co warto wybrać:

• Target options → Target Architecture – wybieramy ARM (little endian)
• Target options → Target Architecture Variant – cortex-A9, czyli nasz procesor
• Target options → Target ABI → EABIhf – jeśli procesor ma sprzętową obsługę liczb zmiennopozycyjnych, hf pozwoli na wykorzytywanie koprocesora
• Toolchain → C library → eglibc – wersja bibliteki standardowej C. Dostępna jest uClibc – bardzo mała wersja, glibc – wersja dla PC, pełna oraz eglibc – nieco okrojona, ale całkiem wystarczająca dla naszych potrzeb
• Toolchain → Build cross gdb for the host – zaznaczenie tej opcji automatycznie przygotuje debugger dla naszego toolchain-a
• Toolchain → Register toolchain within Eclipse Buildroot plug-in – pozwoli na łatwe zintegrowanie naszego toolchaina ze środowiskiem Eclipse

Target packages – w tym menu wybieramy, jakie pakiety będą w naszej wersji Linuxa. Polecam:

• Games → PrBoom – nie ma to jak pograć w Doom-a na robocie ;-)
• Audio and video applications → alsa-utils – jeśli chcemy uruchomić dźwięk
• Audio and video applications → madplay – odtwarzacz mp3 zawsze się przyda
• Debugging, profiling and benchmarking → gdb, gdbserver – będzie potrzebny później do pracy debuggera
• Libraries → Graphics → opencv – chyba najważniejsze jeśli chcemy wykorzystać płytkę do robotyki

Jak łatwo zauważyć, jest jeszcze sporo pakietów, którymi możemy się (później) pobawić. Po skonfigurowaniu systemu, budujemy obraz poleceniem make. Buildroot sam pobierze odpowiednie pakiety, wykona kompilację, skopiuje pliki w odpowiednie miejsce.

Trochę to potrwa za pierwszym razem, ale możemy zobaczyć rezultat. W katalogu output pojawią się podkatalogi, z których nas będą interesowały:

• host – tutaj znajdziemy narzędzia wykorzystywane na komputerze PC, w szczególności “nasz” cross-compilator
• images – plik rootfs.tar zawiera obraz gotowego do wgrania linuxa

Kompilacja jądra

W moim netbooku zainstalowany jest procesor firmy WonderMedia. Teoretycznie, każdy producent jest zobowiązany do udostępnienia kodu źródłowego linuxa lub androida – licencja GPL do tego obliguje. Nie zawsze jest z tym łatwo, na szczęście do tego procesora możemy uzyskać odpowiedni kod.

Pobieramy go z repozytorium git-a:

git clone https://github.com/wondermedia/wm8850

Kompilacja jest prosta. Wchodzimy do katalogu i kompilujemy:

make clean
make Android_defconfig
make
make modules
make modules_install

Jeśli nie zadziała (!), zgłaszając komunikat o braku arm-linux-gcc, edytujemy plik Makefile i zmieniamy przedrostek na nasz, pobrany wcześniej:

CROSS_COMPILE ?= arm-linux-gnueabi-

Teraz powinno działać poprawnie. Kompilacja znowu trochę potrwa, powinniśmy otrzymać obraz jądra – jest to plik: uzImage.bin (w katalogu ANDROID_3.0.8). Moduły jądra zostaną skopiowane do katalogu out.

Teraz mamy już właściwie wszystko: jądro linuxa, system plików, toolchain. Bootloaderem nie musimy się martwić – jest już zainstalowany, a że nie mamy jego kodu, pozostaje wykorzystać gotowca.

Kolejny krok to przeniesienie plików na płytkę z netbooka. Linux można wgrać do pamięci Flash, można wykorzystać sieć ethernet (bardzo wygodne podczas tworzenia oprogramowania) albo wykorzystać kartę SD. Pierwsza opcja wymagałaby skasowania Androida, a szkoda go zupełnie wyrzucać (najpierw należałoby zrobić backup!).  Druga opcja jest nieco skomplikowana, zostaje nam karta SD.

Karta SD

Do pracy z linuxem będziemy potrzebowali karty z dwoma partycjami (tak jak dla RaspberryPi):

• pierwsza partycja typu FAT, na niej znajdzie się obraz jądra (plik uzImage.bin)
• druga partycja typu ext3 z systemem plików naszego linuxa

Na moim komputerze, kartę SD podłączyłem przez zewnętrzny czytnik. Jest widoczna jako urządzenie /dev/sde – należy to dostosować do własnej konfiguracji.

Uruchamiamy program fdisk poleceniem:

sudo fdisk /dev/sde

Interfejs nie jest zbytnio przyjazny, ale narzędzie jest bardzo funkcjonalne. Najpierw sprawdzamy, jakie partycje są już na karcie poleceniem „p” i usuwamy je „d”. Karta powinna być pusta:

Tworzymy pierwszą partycję:

Command (m for help): n
Select (default p): p
Partition number (1-4, default 1): 1
First sector (2048-x, default 2048): 
Using default value 2048
Last sector, +sectors or +size{K,M,G}: +512M

I następną:

Command (m for help): n
Select (default p): p
Partition number (1-4, default 1): 2
First sector (1050624-x, default 1050624): 
Using default value 1050624
Last sector, +sectors or +size{K,M,G}:

Dwie partycje powinny zostać utworzone, możemy się o tym upewnić wydając polecenie „p”. Widzimy również, że obie partycje są typu Linux, musimy zmienić pierwszą na FAT.

Command (m for help): t
Partition number (1-4): 1
Hex code (type L to list codes): 6

Partycje są przygotowane, pozostaje wyjść z programu zapisując wyniki. Służy do tego polecenie „w”. Czas sformatować partycje. Najpierw pierwszą formatujemy systemem FAT:

sudo mkfs.fat /dev/sde1 -n KERNEL

Następnie drugą systemem ext3:

sudo mkfs.ext3 /dev/sde2 -L linuxfs

Teraz możemy skopiować potrzebne pliki. Na pierwszą partycję po prostu kopiujemy plik uzImage.bin. Na drugą musimy rozpakować plik rootfs.gz. Wchodzimy do katalogu buildroot/output/images i wydajemy polecenie:

sudo tar -C <ścieżka_do_partycji_na_karcie_sd> -xf rootfs.tar

u mnie byłoby to polecenie:

cd buildroot/output/images
sudo tar -C /media/elvis/linuxfs/ -xf rootfs.tar

Podczas kompilacji jądra, w katalogu out przygotowane zostały moduły – je też kopiujemy na kartę.  Po prostu katalog lib z zawartością kopiujemy do obrazu plików.

Pamiętajmy, żeby „grzecznie” odmontować kartę (zapisy mogą być odroczone, więc to trochę zajmuje), ja na wszelki wypadek zawsze wykonuję polecenie „sync”, które wymusza fizyczny zapis na nośniku. Mamy już wszystko gotowe do uruchomienia linuxa na płytce.

Bootloader

Wkładamy kartę sd do złącza na płytce i podłączmy zasilanie (jeśli już było podłączone, to naciskamy reset – jak to miło że producent umieścił przycisk na płytce). Jeśli nic nie zrobimy, wystartuje Android zapisany w pamięci Flash. To dobrze, zawsze będziemy mogli chcieć go jeszcze używać.

Powinniśmy uzyskać następujący efekt:

Na ekranie netbooka pojawi się ikonka androida, ale bootowanie zostanie przerwane. To co widzimy to uboot, jeden ze standardowych bootloaderów. Jeśli potrzebujemy pomocy, możemy wydać komendę help lub ?.

Pojawią się wszystkie dostępne komendy z krótkim opisem, uboot to całkiem potężne narzędzie, temat na kolejny artykuł. W tej chwili po prostu chcemy uruchomić linuxa. Kopiujemy poniższe polecenie i wklejamy w okno terminala:

setenv bootargs 'mem=447M root=/dev/mmcblk0p2 rw console=ttyS0,115200n8'; mmc init; fatload mmc 0 0x00E00000 uzImage.bin; bootm 0x00E00000

Kilka sekund później linux jest gotowy do działania:

Logujemy się jako root, hasło jest domyślnie puste. Możemy zobaczyć nasze ciężko przygotowane pliki, poszperać w systemie. A w wolnej chwili wpisać:

/usr/games/prboom -width 800

Miłej zabawy!

Czas na przerwe!

« Poprzedni artykuł z seriiNastępny artykuł z serii »

Załączniki

• Plik .config

To nie koniec, sprawdź również

Przeczytaj powiązane artykuły oraz aktualnie popularne wpisy lub losuj inny artykuł »

Stacja lutownicza z akumulatorami? Pomysł z Kickstartera

Artykuły i poradniki o elektronice od czytelników Forbota #2

Tarcza sterowana przez Arduino – zostań mistrzem gry!

Co ciekawego w DIY? 10 projektów naszych czytelników #32

Czym są moduły SOM? Przykład na bazie VisionSOM-6ULL

Odroid C2 – nowy 64-bitowiec, pierwsze uruchomienie

Jetson TK1 okiem robotyka – #1 – Słowo wstępne

Odroid C2 – pierwszy program w C, obsługa GPIO

android, embedded, linux, netbook