Opisz swój projekt na forum i odbierz 50 zł rabatu do sklepu Botland! Sprawdź szczegóły akcji »

Przewodnik instalacji Linuxa na platformie embedded

Przewodnik instalacji Linuxa na platformie embedded

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).

« 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:

Możemy sprawdzić, czy działa:

Otrzymamy komunikat:

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.

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

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

Powinniśmy zobaczyć menu programu:

Linux01

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

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:

 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:

Kompilacja jest prosta. Wchodzimy do katalogu i kompilujemy:

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:

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:

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:

Linux02

Tworzymy pierwszą partycję:

I następną:

Linux03

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.

Linux04

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:

Następnie drugą systemem ext3:

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:

u mnie byłoby to polecenie:

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:

Linux05

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:

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

Linux06

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ć:

Miłej zabawy!

Linux07.png

Czas na przerwe!

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

Załączniki

Plik .config (zip, 10 KB)

android, embedded, linux, netbook

Trwa ładowanie komentarzy...