izgradnja ugradbenih sustava korištenjem yocto projecta
TRANSCRIPT
SVEUČILIŠTE U ZAGREBU FAKULTET ELEKTROTEHNIKE I RAČUNARSTVA
ZAVRŠNI RAD br. 4053
Izgradnja ugradbenih sustava korištenjem Yocto Projecta
Petar Kuštro
Zagreb, lipanj 2015.
SADRŽAJ
1. Uvod ............................................................................................................................. 1
2. Yocto Project .............................................................................................................. 2
2.1. Uvod u Yocto Project ............................................................................................. 2
2.2. Poky sustav za izgradnju ......................................................................................... 2
2.2.1. Ideja Poky sustava za izgradnju ................................................................................. 3
2.2.2. BitBake ....................................................................................................................... 3
3. Izgdradnja vlastite Yocto distribucije Linux-a ....................................................... 7
3.1. Razvojno okruženje ................................................................................................ 7
3.1.1. Osnovni alati .............................................................................................................. 7
3.1.2. Grafički alati ............................................................................................................... 8
3.1.3. Alati za izradu dokumentacije .................................................................................... 8
3.1.4. Dodaci za instalaciju razvojnog programskog paketa ................................................ 8
3.1.5. Instalacija Yocto-a ...................................................................................................... 9
3.2. Izgradnja predefinirane Yocto distribucije Linux-a ................................................ 9
3.2.1. Izgradnja i pokretanje Yocto distribucije za QEMU ................................................ 10
3.2.2. Izgradnja i pokretanje Yocto distribucije za Raspberry Pi2 ..................................... 11
3.3. Razvoj jednostavne aplikacije unutar Yocto Linux-a ........................................... 13
3.3.1. Priprema razvojnog okruženja.................................................................................. 13
3.3.2. Postavljanje i podešavanje Eclipse razvojnog okruženja ......................................... 14
3.3.3. Izrada jednostavne aplikacije ................................................................................... 16
3.4. Izrada vlastitog sloja ............................................................................................. 17
4. Zaključak .................................................................................................................. 20
Literatura ........................................................................................................................... 21
Sažetak ................................................................................................................................ 22
Summary ............................................................................................................................ 22
PRIVITAK A: IZVORNI KOD IZRAĐENE APLIKACIJE ....................................... 23
i
1. UVOD
Ugradbeni sustavi nalaze se svuda oko nas i dolaze u raznim inačicama. Ugradbeni sustav je računalni sustav s namjenskim funkcijama unutar većeg električnog ili mehaničkog sustava. Uglavnom se radi o uređajima s vrlo ograničenim sklopovskim mogućnostima. Procesorska jedinica, radna memorija, memorija za pohranu i ostalo sklopovlje su prilagođeni tako da imaju dovoljan kapacitet za obavljanje predefiniranih zadataka. No s dolaskom novih tehnologija te pojeftinjenjem istih došlo je i do značajnog unapređenja ugradbenih računala. Tako danas imamo vrlo mala ugradbena računala sa ne tako ograničenim mogućnostima i učinkovitosti. Dolazimo do pitanja kako iskoristiti ugradbena računala da ne služe samo za predodređene funkcije, odnosno kako unaprijediti njihove funkcije. Jedno od mogućih rješenja je izgradnja prilagođenog operacijskog sustava za ugradbena računala. Potrebno je izgraditi operacijski sustav za koji je moguće izraditi dodatne aplikacije koje bi omogućile potpuno iskorištavanje ugradbenih računala. Kao jedno od mogućih rješenja navedenog problema nudi se Yocto Project.
Yocto Project nudi sve potrebno kako bi se izgradila prilagođena distribucija Linux-a za ugradbeno računalo. Yocto ne nudi samo okruženje za izgradnju operacijskog sustava, on nudi i okruženje za razvoj aplikacija za izgrađeni operacijski sustav. Nudi podršku za mnoge sklopovske arhitekture te je otvoren za nova proširenja. Također već posjeduje veliku bazu proširenja, kako podršku za razne tipove ugradbenih računala tako i za programska proširenja i podršku. Posjeduje jako opširnu dokumentaciju o svakom aspektu izgradnje. Yocto zajedno sa svime navedenim se nameće kao jedno od logičnih rješenja za izgradnju prilagođenih operacijskih sustava i aplikacija za ugradbena računala.
Ovaj rad je podijeljen na četiri poglavlja. U drugom poglavlju opisana je ideja i osnovne informacije o Yocto Project-u, njegovi osnovni alati i arhitektura. U trećem poglavlju opisan je način instalacije i pokretanje Yocto Project-a. Također je opisan proces izgradnje Linux operacijskog sustava za virtualno i realno okruženje te njegovo pokretanje. Nakon navedenog opisan je i princip izrade aplikacije unutar Yocto Project-a. Privitak A: donosi izvorni kod građene aplikacije. Na kraju trećeg poglavlja je opisan način na koji se izrađena aplikacija postavlja kao jedan od slojeva građenog operacijskog sustava.
1
2. YOCTO PROJECT
U ovom poglavlju je opisan Yocto Project, osnovni alati te osnovne mogućnosti.
2.1. Uvod u Yocto Project
Yocto Project je projekt otvorenog koda koji pruža zajedničku polaznu točku, programerima ugrađenih Linux sustava, za stvaranje prilagođene Linux distribucije za ugradbena računala bez znanja o sklopovskoj arhitekturi računala. Yocto Project je više od sustava za izgradnju(engl. build system), on nudi alate, procese, predloške i metode kako bi omogućio programerima da brzo stvore i ostvare proizvod za tržište ugradbenih sustava. Jedna od glavnih komponenti Yocto Project-a je Poky sustav za izgradnju, kojeg je stvorio Richard Purdie koji je danas glavni upravitelj i arhitekt Yocto Project-a. Godine 2001. Sharp Corporation je predstavila SL-5000 PDA(skraćenica od Personal Digital Assistant) još zvan i Zaurus. Zaurus je pokretao Linux operacijski sustav za ugradbena računala, Lineo distribucija. Ubrzo nakon toga gospodin Chris Larson osnovao je projekt OpenZaurus kao zamjensku Linux distribuciju za SharpROM. Nakon toga korisnici su počeli ubrzano razvijati programske pakete za OpenZaurus te je započeo razvoj i za druge uređaje. Nakon početka projekta on je pokazao svoju krhkost i nestabilnost. Zatim su gospoda Chris Larson, Michael Lauer i Holger Schurig započeli rad na novom projektu: OpenEmbedded te prenijeli stotine paketa s OpenZaurus sustava za izgradnju na novi sustav za izgradnju. Iz ovog polako nastaje Yocto Project, on je stabilna grana OpenEmbedded projekta te koristi tisuće njegovih recepata. Ova dva projekta s vremenom su srasli u nešto puno veće od sustava za izgradnju. Zajedno s Eclipse dodatkom, mrežnim datotečnim sustavom i QEMU emulatorom su postali kompletna programska platforma za razvoj na ugradbenim računalima. 2010. godine je odlučeno da će Yocto Project biti sponzoriran od strane Linux zaklade(engl. Linux Foundation). Također je odlučeno da će se Yocto Project i OpenEmbedded koordinirati u daljnjem razvoju temeljnog skupa paketa meta-podataka jezgre ovih dvaju projekata pod nazivom OE-Core te kako će se kombinirati najbolje iz Poky i OpenEmbedded sustava s povećanim raslojavanjem za dodatne komponente.
2.2. Poky sustav za izgradnju
Poky sustav za izgradnju je jezgra Yocto Projecta. Dakle Yocto je uz pomoć Poky-a sposoban izgraditi kompletnu sliku, spremnu za pokretanje na ugradbenom računalu, koristeći izvore navedene u meta-podacima slojeva. Zadane postavke Poky-a pružaju dvije inačice slika, a to su:
• minimalna - distribucija čiji se rad odvija isključivo kroz ljusku • potpuna - Linux standardna bazna slika kompatibilna s "GNOME Mobile and
Embedded" bazirana na korisničkom sučelju zvanom "Sato".
Na ove bazne slike moguće je dodati nove slojeve(engl. layer) kako bi se proširila funkcionalnost. Slojevi mogu dodati novi programski stog(engl. software stack) slici, dodati podršku za sklopovlje(engl. Board Support Package layer; skraćeno BSP layer) ili predstavljati novi tip slike. Kako je Poky jako velik i vrlo složen alat za izgradnju unutar ovog rada biti će opisana samo njegova glavna komponenta: BitBake.
2
2.2.1. Ideja Poky sustava za izgradnju Jedan od najmoćnijih značajki Poky sustava za izgradnju je u tome da je svaki aspekt izgradnje upravljan meta-podacima. Meta-pdaci mogu se slobodno grupirati u datoteke s postavkama ili pakete recepata. Recepti su kolekcija ne-izvršivih meta-podataka koje BitBake koristi za postavljanje varijabli ili za postavljanje zadataka u toku izgradnje. Recepti sadrže polja kao što su verzija recepta, licenca paketa, izvor izvornog koda na internetu. Također, mogu sadržavati podatak o tome koji proces izgradnje koristi paket koji opisuju(autotools, make, distutils i sl.), a u tom slučaju osnovna funkcionalnost može biti nasljeđena iz klase OE-Core sloja. U receptima mogu biti definirani i dodatni zadaci kao i njihovi preduvjeti.
Datoteke s postavkama mogu se podijeliti u dvije skupine: ona koja podešava BitBake i kompletnu izgradnju te ona koja podešava pojedini sloj koji Poky koristi za stvaranje različitih postavki slika. Sloj je bilo koja grupa meta-podataka koja nudi neku dodatnu funkcionalnost, a to može biti: BSP sloj, sloj dodatne vrste slike ili programski sloj. Zapravo je i jezgra meta-podataka Yocto Project-a(meta-yocto) sloj, koji se nalazi na sloju meta-podataka OE-Core sloja(meta) i dodaje mu vrste slika i programe. Na Sl. 2.1. vidimo prikaz slojeva Yocto Project-a.
Sl. 2.1. Prikaz slojeva Yocto Project-a
Slojevi i njihov poredak se definiraju u varijabli BBLAYERS, a ona se nalazi u datoteci "bblayers.conf" Primjer slojeva koji će se koristi u drugom dijelu ovog rada: BBLAYERS ?= " \ /home/user/poky/meta \ /home/user/poky/meta-yocto \ /home/user/poky/meta-yocto-bsp \ /home/user/poky/meta-raspberrypi \"
2.2.2. BitBake BitBake je alat za izgradnju koji koristi meta-podatke za stvaranje Linux slike iz izvora(engl. source). U početku izgradnje BitBake pokreće klasu BBCooker tzv. kuhalo(engl. cooker), ona upravlja izvođenjem zadataka izgradnje, tzv. "pečenjem"(engl. baking) recepata. Jedna od prvih stvari koju kuhalo napravi je učitavanje i obrada(parsiranje) datoteka s postavkama. Prva datoteka s postavkama koju kuhalo traži je "bblayers.conf", nakon što ju pročita, kuhalo pregledava "local.conf" datoteku svakog sloja
3
navedenog u BBLAYERS varijabli. Nakon obrade datoteka s postavkama slojeva, kuhalo učitava i obrađuje "bitbake.conf" datoteku čiji je glavni zadatak postaviti globalne varijable koje se koriste tijekom izgradnje.
Tijekom izgradnje slike, BitBake obrađuje datoteke s postavkama, uključuje definirane dodatne slojeve, klase ili recepte te stvara težinski lanac ovisnosti. Ovaj proces daje slijedni plan izvođenja zadataka posloženih po težini i važnosti. Bitbake zatim koristi taj plan kako bi procijenio po kojem redu paketi moraju biti izgrađeni kako bi se najučinkovitije ispunila kompilacija ovisnosti(zadaci koji su potrebni za izvođenje drugih zadataka ili paketa moraju biti pokrenuti ranije). Bitbake sprema sažetke meta-podataka te ako je došlo do promjena meta-podataka on ponovno obrađuje samo promijenjeni dio.
Nakon obrade BitBake prolazi kroz red zadataka. Zadaci tijekom izgradnje paketa mogu biti izmijenjeni ili nadodani kroz recept. Osnovni predefinirani red zadataka kod izgradnje paketa je prikazan na Sl. 2.2. Prevedeni izvori se dijele u pakete, koji se zatim pakiraju u podržanje formate: RPM, ipk ili deb, zatim BitBake te pakete koristi za izgradnju korijenskog datotečnog sustava(engl. root file system).
Sl. 2.2. Predefinirani red zadataka kod izgradnje paketa
2.2.2.1. Arhitektura BitBake-a Bitbake koristi klijent-poslužitelj arhitekturu, sukladno tome jedna od njegovih komponenti je međuprocesna komunikacija(engl. interprocess Communications - IPC). Ova komponenta je prvotno ugrađena kako bi omogućila pokretanje više procesa tijekom izgradnje sustava, no sada se koristi za komunikaciju između različitih komponenti BitBake-a. Svaka izgradnja započinje pokretanjem korisničkog sučelja, ono pruža mehanizme za zapisivanje procesa izgradnje, praćenje statusa i napredovanje izgradnje. Također prima događaje koje dolaze iz zadataka izgradnje te ih prikazuje korisniku. Zadano korisničko sučelje je "knotty", to je sučelje koje koristi Linux ljusku za rad. Hob je grafičko korisničko sučelje, nudi mogućnost uređivanja datoteka s postavkama, dodavanje slojeva i paketa te potpuno prilagođavanje izgradnje. Korisničko sučelje šalje naredbe
4
sljedećoj BitBake komponenti, a to je BitBake poslužitelj. BitBake podržava više tipova poslužitelja kao što su XMLRPC i procesni poslužitelj koji je zadani tip poslužitelja. Kuhalo obavlja gore navedene zadatke obrađivanja, iniciranja stvaranja težinskog lanca ovisnosti te upravlja izgradnjom. Kuhalo inicijalizira i BitBake spremište podataka(engl. datastore), zatim obrađuje sve Poky datoteke s postavkama te pokreće izgradnju. Na Sl. 2.3 je prikazana BitBake arhitektura.
Sl. 2.3. BitBake arhitektura
Kao spremište podataka BitBake koristi kopiraj-na-pisanje rječnik(engl. Copy-on-Write dictionary). BitBake pohranjuje podatke iz početnih postavki u rječnik kao podatkovne objekte, svaki od tih objekata može sadržavati drugi podatkovni objekt ili samo razliku podataka dvaju objekata. Dakle, ako recept promjeni nešto iz inicijalnih podatkovnih postavki umjesto kopiranja cijelog objekta sprema se samo razlika između dva objekta i to u sljedeći donji sloj rječničkog stoga. Kada se zatraži neka varijabla, rječnik pretražuje prvo gornji sloj, ukoliko ne nađe varijablu prelazi na niži sloj i tako sve dok ne nađe traženu varijablu.
2.2.2.2. Ovisnosti Unutar sustava postoje dvije vrste ovisnosti(engl. dependencies): ovisnost izgradnje(engl. build dependency ili još "RDEPENDS") i ovisnost("DEPENDS"). Ovisnost je nešto što je potrebno da bi BitBake mogao izgraditi pojedini paket. Ovisnost izgradnje označava što još treba biti ugrađeno u sliku da bi paket koji gradimo mogao raditi. Uz pakete, zadaci također mogu imati svoje ovisnosti, a to su: interna ovisnost, "DEPENDS" ovisnost, "RDEPENDS" ovisnost i ovisnost među zadacima. Interna ovisnost je ovisnost zadataka postavljena unutar recepta, dodaje pojedini zadatak prije ili poslije određenog zadatka. "DEPENDS" i "RDEPENDS" označavaju zadatke koji se pokreću nakon odabranog
5
zadatka. Ovisnost među zadacima označava da je neki zadatak ovisan o nekom zadatku u drugom paketu.
2.2.2.3. Red pokretanja Kako za izgradnju jedne slike BitBake može koristiti stotine recepata, a svaki od njih ima svoje ovisnosti, potrebno je posložiti red pokretanja(engl. run queue) zadataka. Nakon što kuhalo odredi koje sve pakete treba izgraditi složit će težinski lanac ovisnosti te iz njega stvoriti posloženu listu zadataka koje BitBake treba pokrenuti. Tu listu još zovemo red pokretanja. Red pokretanja ima lanac ovisnosti i listu svih paketa koje treba izgraditi. Kako bi započeo izvođenje izgradnje potrebno je stvoriti objekt s podacima o zadatku(engl. taskdata object) kako bi mogao početi izdvajati zadatke iz težinske mape zadataka. Započinje uzimanjem svakog izgradivog paketa kojeg nađe, podijeli zadatke za izgradnju paketa te procjeni težinu zadatka na temelju broja paketa koji su potrebni za njegovu izgradnju. Teži zadaci koji imaju više ovisnosti počinju ranije s izgradnjom. Nakon što je red izvođenja stvoren BitBake može početi s izvođenjem reda raspoređujući zadatke u dretve(engl. threads). Ovisno o računalnim resursima računala domaćina(engl. host) i o tipu slike cijela izgradnja može trajati od pola sata pa do nekoliko sati. Valja napomenuti da sve procedure prije početka izvođenjem zadataka traju do jedne minute.
6
3. IZGDRADNJA VLASTITE YOCTO DISTRIBUCIJE LINUX-A
Kako se radi o izgradnji Linux distribucija operacijskog sustava nužno je da računalo domaćin(engl. host) bude jedna od distribucija Linux-a. Projekt trenutno službeno podržava nekoliko distribucija Linux-a, a to su: Ubuntu(14.04 LTS i 14.10), Fedora release 21, CentOS(release 6.x i 7.x), Debian GNU/Linux(7.x Wheezy i 8.x Jessie) te openSUSE 13.2. Razvoj okruženja za navedene distribucije se konstantno provodi te postoji platforma za prijavu grešaka i komentara vezanih za projekt. Yocto project trenutno nema namjeru službeno podržavati druge distribucije, ali podržava zakrpe i prijavu grešaka na drugim distribucijama. Za potrebe izrade ovog rada korišten je 32-bitna verzija "Ubuntu 14.04.2 LTS" distribucija Linux-a koja je pokrenuta u "VMware Workstation" virtualnom okruženju s 2GB radne memorije i 100GB prostora na čvrstom disku. U daljnjem tekstu postupci podrazumijevaju korištenje navedene distribucije Linux-a te se za računalo domaćin smatra Ubuntu operacijski sustav.
3.1. Razvojno okruženje
U ovom poglavlju će biti opisano kako postaviti razvojno okruženje na računalu domaćinu. Kako Yocto pokriva sva potrebna područja za izgradnju Linux operacijskog sustava lista alata potrebnih na računalu domaćinu može biti jako velika.
3.1.1. Osnovni alati Alati potrebni kod izgradnje slika za bezglave sustave(engl. headless system), odnosno kod pokretanja na računalima koja nemaju grafičko sučelje, ekran ni perifernih uređaja. To su obično ugradbeni sustavi u različitim oblicima, npr.: industrijski strojevi, automobili, medicinska oprema, kućanski aparati, avioni, razni aparati, igračke, itd. Potrebni alati su:
• gawk: snažan alat za pronalaženje uzoraka i rad s tekstom, baziran na jeziku AWK • wget - alat za dohvat datoteka s interneta, podržava HTTP, HTTPS i FTP
protokole • git-core - alat za rad s Git-om. Git je distributivni sustav za kontolu revizija
programa, a Yocto ga koristi u razvoju • diffstat - alat za izradu histograma(umetanja, dodavanja, brisanja po datotekama) • unzip - alat za dekompresiju skinutih datoteka • texinfo - službeni format za dokumentaciju GNU projekta • gcc-multilib - GNU prevoditelj programskog jezika C • build-essential - paket sadrži informacije o svim potrebnim alatima za prevođenje i
dodatnim paketima za C i C++ programski jezik • chrpath - alat za uređivanje putanja kodiranih u izvršnu datoteku, koristi se tijekom
dinamičkog povezivanja za povezivanje izvršnih knjižica(engl. libraries) ili knjižničnih zahtijeva(engl. library requires)
• socat - alat za uspostavu dvosmjernog toka bajtova i prijenos među njima. Naredba za instalaciju alata iz ljuske je: $ sudo apt-get install gawk wget git-core diffstat unzip\ texinfo gcc-multilib build-essential chrpath socat
7
3.1.2. Grafički alati Alati potrebni kod izgradnje sustava na ugradbenim računalima s ekranom i perifernim uređajima poput zvučnika, tipkovnice i miša. Alati:
• libsdl1.2-dev - SDL knjižica(engl. Simple DirectMedia Layer library) omogućuje pristup grafičkom izlazu, audio izlazu, mišu i tipkovnici
• xterm - standardni konzolni emulator za X Window sustave. Koristi se kod pokretanja okruženja za otklanjanje grešaka u Eclipse programskom alatu
Naredba za instalaciju je: $ sudo apt-get install libsdl1.2-dev xterm
3.1.3. Alati za izradu dokumentacije Ukoliko je potrebno napraviti dokumentirane upute uz svoj rad u Yocto-u bit će potrebni sljedeći alati:
• make - alat za izgradnju pokretljivih programa(engl. executables programs) i knjižica iz izvornog koda uz pomoć "makefile" datoteka koje specificiraju kako izvesti ciljani program
• xsltproc - alat za primjenu XSLT stila na XML dokumentima • docbook-utils - kolekcija alatnih skripti koji se koriste za pretvaranje i analizu
SGML dokumenata i DocBook dokumenata. DocBook je semantički označni jezik(engl. semantic markup language) za tehničku dokumentaciju
• fop - paket koji sadrži ispisni uređivač za XSL • dblatex - alat za korištenje latex-a • xmlto - alat koji koristi skripte kroz ljusku(engl. shell-script) za pretvaranje XML
dokumenata u razne druge formate
Instalacijska naredba: $ sudo apt-get install make xsltproc docbook-utils fop\ dblatex xmlto
3.1.4. Dodaci za instalaciju razvojnog programskog paketa Za razvoj programa koji će se pokretati na Linux distribuciji dobivenoj pomoću Yocto-a potreban je razvojni programski paket(engl. ADT - Application Development Toolkit) o čemu ćemo govoriti u nastavku ovog rada. Za instalaciju razvojnog programskog paketa potrebni su sljedeći alati:
• autoconf - proširivi paket M4 makro-naredbi koje proizvode skripte za ljusku koje automatski postavljaju pakete izvornog koda programa
• automake - alat za automatsko generiranje "Makefile.in" datoteka koje se koriste za izgradnju pokretljivih programa
• libtool - alat koji stvara prenosive prevedene knjižice(engl. portable compiled libraries)
• libglib2.0-dev - paket s GLib knjižicama koje sadrže mnogo korisnih mogućnosti za programski jezik C, kao što su stabla(engl. trees), hash-ovi, liste, nizovi(engl. strings)
Naredba za instalaciju navedenih paketa je: $ sudo apt-get install autoconf automake libtool\ libglib2.0-dev
8
3.1.5. Instalacija Yocto-a Instalacija samog Yocto Project-a je vrlo jednostavna te se provodi s nekoliko kratkih naredbi: $ git clone http://git.yoctoproject.org/git/poky $ cd poky $ git checkout -b fido origin/fido
Naredbom "git clone" kopira se direktorij s dobivene adrese u lokalni /poky direktorij. Drugom naredbom se pozicioniramo u novonastali direktorij. Naredba "git checkout -b" kreira novu granu razvoja projekta, drugi parametar naredbe označava naziv lokalne verzije, dok treći parametar označava gdje se na poslužitelju, koji je zadan prvom naredbom, nalazi verzija na kojoj zasnivamo novu granu projekta.
3.2. Izgradnja predefinirane Yocto distribucije Linux-a
U ovom poglavlju opisat ćemo kako izgraditi jednostavnu Yocto sliku koju je moguće pokrenuti u QEMU virtualnom okruženju unutar Linux operacijskog sustava. U ljusci se pozicioniramo u direktorij "poky" te pokrenemo naredbu: $ source oe-init-build-env
Ovom naredbom pokreće se skripta "oe-init-built-env" koja postavlja okruženje(engl. environment setup). Pokretanjem ove skripte definiraju se OpenEmbedded postavke okruženja za izgradnju, također kreira i direktorij za izgradnju koji je u ovom slučaju nazvan /build. Ukliko se naredbi kao parametar preda niz znakova direktorij za izgradnju će se zvati po tom nizu(npr. source oe-init-build-env direktorijIzgradnje ). Na kraju izvođenja skripte ona će pozicionirati ljusku u direktorij izgradnje. Sve datoteke koje se koriste tijekom izgradnje će se nalaziti u direktoriju izgradnje. Nakon što se skripta uspješno izvrši ona će o tome ispisati poruku.
U direktoriju izgradnje se pojavljuje nekoliko novih direktorija, među kojima je i "conf" direktorij, u njemu se nalaze datoteke s postavkama. U njemu se nalazi datoteka "local.conf" u kojoj se nalaze neke varijable bitne za izgradnju. Iako su i zadane varijable zadovoljavajuće valjalo bi obratiti pažnju na neke od njih, a one su:
• BB_NUMBER_THREADS - maksimalni broj zadataka(engl. tasks) koje BitBake može pokenuti paralelno u istom trenutku.
• PARALLEL_MAKE - dodatna opcija koja se predaje "make" alatu za vrijeme "do_compile" zadataka kako bi se odredilo koliko se paralelnih izrada smije dozvoliti. Ova varijabla se dodaje u obliku: "-j x"(s navodnicima) gdje x određuje koliko se maksimalno paralelnih niti smije izvoditi.
• BB_NUMBER_PARSE_THREADS - označava koliko se paralelnih dretvi smije pokrenuti tijekom obrade. Sve tri varijable potrebno je podesiti na broj jezgri procesora računala domaćina, a ako procesor podržava tehnologije poput Hyper Threading-a varijablu je potrebno pomnožiti sa brojem dva.
• INHERIT += "rm_work" - ova varijabla se ne nalazi u postavkama, ali ukoliko računalo domaćin raspolaže s ograničenim prostorom na čvrstom disku, trebalo bi ju dodati kako bi se smanjilo zauzeće prostora na čvrstom disku. Dakle, ona briše radne direktorije korištene tijekom izgradnje kada je paket izgrađen.
• DL_DIR - označava u koji direktorij će se vršiti spremanje datoteka dohvaćenih s interneta.
9
• SSTATE_DIR - direktorij za spremanje datoteka zajedničkog stanja. BitBake koristi datoteke zajedničkog stanja za bržu izgradnju sustava.
• TMPDIR - direktorij u koji se spremaju privremene datoteke i izlaz izgradnje. Ovo su osnovne varijable koje vrijede za sve vrste arhitektura za koje će se graditi prilagođeni operacijski sustavi. U sljedeća dva poglavlja biti će opisana izgradnja Yocto distribucije Linuxa za QEMU emulator x86 arhitekture te za Raspberry Pi2 ugradbeno računalo koje je građeno na ARM arhitekturi.
3.2.1. Izgradnja i pokretanje Yocto distribucije za QEMU Kako bi se odabrala ciljanu arhitekturu odnosno tip računala koje će pokretati prilagođenu distribuciju Linux-a izgrađenu pomoću Yocto project-a potrebno je urediti "local.conf" datoteku koja se nalazi unutar conf direktorija. U njoj se nalazi sljedeći popis:
#MACHINE ?= "qemuarm" #MACHINE ?= "qemuarm64" #MACHINE ?= "qemumips" #MACHINE ?= "qemuppc" #MACHINE ?= "qemux86" #MACHINE ?= "qemux86-64" #MACHINE ?= "beaglebone" #MACHINE ?= "genericx86" #MACHINE ?= "genericx86-64" #MACHINE ?= "mpc8315e-rdb" #MACHINE ?= "edgerouter" MACHINE ??= "qemux86"
Radi se o popisu uređaja za koje Yocto ima predefinirane postavke. Prvih nekoliko s prefiksom "qemu" su postavke namijenjene pokretanju u QEMU emulatoru, ostatak naziva označava emuliranu arhitekturu. Sljedećih nekoliko označava ostale uređaje/arhitekture. Svaka od navedenih postavki, osim posljednje, ima hash simbol "#" koji označava komentar, odnosno kod čitanja datoteke Yocto će zanemariti tu liniju. Posljednja postavka, osim što ju ne predvodi oznaka za komentar, u sebi sadrži dva upitna znaka, što znači da su to pretpostavljene postavke za izgradnju. Ukoliko prilikom učitavanja datoteke s postavkama nije pročitana ni jedna postavka " MACHINE ?=" Yocto će izgraditi sustav za pretpostavljeni uređaj/arhitekturu. Kako želimo izgraditi Yocto distribuciju za QEMU x86 arhitekture datoteku s postavkama nije potrebno mijenjati.
Kako je u prijašnjem poglavlju već pozvana skripta za postavljanje Yocto razvojnog okruženja, sada je dovoljno samo pokrenuti BitBake kako bi izgradio sliku za pokretanje. Prije izgradnje slike potrebno je odabrati koju inačicu slike želimo, s pretpostavljenim postavkama ponuđene su nam dvije opcije:
• core-image-minimal - minimalna inačica koja se pokreće samo u obliku ljuske, bez drugog korisničkog sučelja
• core-image-sato - inačica s grafičkim sučeljem i osnovnim programima(npr. uređivač teksta, ljuska, upravitelj datotekama, itd)
Izgradnja slike pokreće se naredbom: $ bitbake core-image-sato
Tijekom izgradnje računalo treba imati pristup internetu te dovoljno slobodnog prostora na čvrstom disku kako bi Yocto mogao izgraditi sliku. Ova izgradnja, na računalu koje je korišteno tijekom izrade ovog rada, je trajala sedam sati s četiri paralelne niti. Tijekom
10
izgradnje Yocto je s interneta dohvatio dva gigabajta podataka koje je koristio tijekom izgradnje. Također je dobro napomenuti da je zauzeće na tvrdom disku, uz uključenu opciju za štednju prostora, poraslo s inicijalnih 45 megabajta poraslo na 10 gigabajta, broj datoteka je porastao sa 6400 na 318.000 datoteka. No bitno je napomenuti da je nakon ove izgradnje započeta i izgradnja slike "core-image-minimal" te je ona zahvaljujući opciji za spremanje zajedničkog stanja imala puno bolje rezultate. Ona je trajala samo osam minuta, nije skidala dodatne podatke s interneta, zauzela je neznatno više prostora na čvrstom disku te povećala broj datoteka na 323.000, što se u odnosu na prvu izgradnju čini minimalnim. Tijekom prve izgradnje u konzoli se ispisalo samo jedno upozorenje o nemogućnosti dohvaćanja izvornog koda s izvora na internetu te poruka da će sustav pokušati sa zrcalnim izvorima(engl. mirror source).
Nakon završetka izgradnje slika se pokreće unutar QEMU emulatora sljedećom naredbom: $ runqemu qemux86
Rezultat pokretanja QEMU emulatora vidimo na Sl. 3.1.
Sl. 3.1. Početni zaslon Linux sustava izgrađenog pomoću Yocto Projecta
3.2.2. Izgradnja i pokretanje Yocto distribucije za Raspberry Pi2 Izgradnja za Raspberry Pi2 također započinje pokretanjem skripte "oe-init-built-env" koja postavlja okruženje za izgradnju. Ukoliko nakon prethodne izgradnje neke slike niste zatvarali ljusku, skriptu nije potrebno pokretati, jer je okruženje za izgradnju još uvijek postavljeno. Kod izgradnje slike za Raspberry Pi2 potrebno je koristiti poseban sloj za prilagodbu sustava sklopovlju(engl. BSP layer - Board Support Package layer). On se koristi kako bi Yocto mogao iskoristiti sve mogućnosti sklopovlja na kojem se pokreće. Dohvaća se tako da se u ljuski pozicionira u direktorij "poky" te pokrene sljedeća naredba:
11
$ git clone git://git.yoctoproject.org/meta-raspberrypi
Nakon što smo dohvatili paket sloja za prilagodbu sklopovlja, potrebno ga je dodati u BBLAYERS varijablu unutar "bblayers.conf" datoteke. Navedena datoteka nalazi se u "conf" direktoriju unutar direktorija za izgradnju(pretpostavljeni direktorij je "build"). BBLAYERS varijablu je potrebno definirati na sljedeći način: BBLAYERS ?= " \ /{DIR}/poky/meta \ /{DIR}/poky/meta-yocto \ /{DIR}/poky/meta-yocto-bsp \ /{DIR}/poky/meta-raspberrypi \"
Oznaka {DIR} označava direktorij u kojem je Yocto project, odnosno tamo gdje se nalazi "poky" direktorij. Prva tri retka varijable, odnosno prva tri sloja u varijabli su pretpostavljena i koriste se u pravilu kod svake izgradnje. Četvrti sloj je dodan kako bi omogućio pokretanje Yocto distribucije Linuxa na Raspberry Pi2 uređaju. Još je potrebno urediti "local.conf" datoteku kako bi se kao ciljani sustav postavio Raspberry Pi2. Unutar navedene datoteke potrebno je dodati sljedeće varijable: MACHINE ?= "raspberrypi2" GPU_MEM = "16"
Prva naredba označava kako je ciljano sklopovlje za izgradnju Raspberry Pi2, druga varijabla pokazuje koliko memorije u megabajtima je potrebno odvojiti za grafički čip na ciljanom sklopovlju. Također unutar ove datoteke se mogu dodati još neke varijable vezane za specifičnosti sklopovlja kao što je varijabla za omogućavanje korištenja kamere ili varijable za povećanje učinkovitosti sklopovlja(engl. overclock).
Nakon podešavanja potrebnih varijabli može se pokrenuti izgradnju slike. Uz već navedene dvije vrste slike kod Raspberry Pi2 uređaja je moguće i izgraditi sljedeće slike:
• rpi-hwup-image - slika koja pokreće minimalne postavke dovoljne samo za pokretanje sklopovlja i ljuske.
• rpi-basic-image - kao i prethodna slika uz podršku za ssh poslužitelj(ssh-server-dropbear) te s početnim zaslonom kod pokretanja(engl. splash screen).
Kao i u prethodnom primjeru izgradit ćemo sliku "core-image-sato", izgradnja se pokreće istom naredbom kao i u prethodnom primjeru("bitbake core-image-sato").
Kako smo već izgradili jednu sliku te imamo postavljene direktorije zajedničkog stanja te direktorije za skidanje ova izgradnja nešto kraće traje. Po završetku izgradnje slike, sliku za Raspberry Pi2 možemo pronaći unutar direktorija: "../{direktorij_izgradnje}/tmp/deploy/ images/raspberrypi2/" s nazivom "core-image-sato-raspberrypi2-20150524005602.rootfs.rpi-sdimg". Zbog sklopovskih nedostataka računala na kojem se odvijao cijeli proces izgradnje slika je premještena na Windows 7 operacijski sustav, kako bi se zatim presnimila na SD memorijsku karticu s koje se pokreće Raspberry Pi2. Za snimanje slike na SD memorijsku karticu korišten je program "Win32DiskImager". Navedeni program je potrebno pokrenuti s administratorskim ovlastima te u njemu samo odabrati gore navedenu sliku i uređaj na koji ju želimo presnimiti te odabrati "Write". Nakon nekoliko trenutaka slika je presnimljena i spremna za pokretanje na Raspberry Pi2.
Pokretanje Linux-a izgrađenog pomoću Yocto projecta na Raspberry-u se odvija u svega jedanaest sekundi nakon uključenja napajanja. U toku isprobavanja izgrađenog Linux operacijskog sustava na Raspberry Pi2 uređaj su spajani sljedeći periferni uređaji: miš i tipkovnica, 7" LCD zaslon osjetljiv na dodir(engl. LCD touchscreen) te memorijski
12
štapić(engl. memory stick). Svi uređaji su spajani na Raspberry Pi2 uređaj putem USB vrata, osim zaslona koji se spaja na HDMI vrata, osjetljivost na dodir zaslona spaja se nezavisno od zaslona također preko USB vrata. Valja napomenuti da je operacijski sustav sve navedene uređaje prepoznao te je uredno vršio komunikaciju s njima. Uz periferne uređaje je spojen i mrežni kabel koji je spojen na mrežu sa sustavom za automatsko dodjeljivanje IP adresa(DHCP). Yocto je uredno preuzeo dobivenu adresu te je mogao komunicirati lokalnom i Internet mrežom.
3.3. Razvoj jednostavne aplikacije unutar Yocto Linux-a
Sva jednostavnost pri izgradnji prilagođenog sustava ne bi imala smisla da nije moguće jednostavno izraditi i aplikaciju koja se pokreće unutar tog sustava. U ovom poglavlju biti će opisano kako izraditi jednostavnu aplikaciju koja će se pokretati na Linux-u izrađenom pomoću Yocto projecta. Izradi aplikacije će biti pristupljeno pomoću Eclipse razvojnog okuženja.
3.3.1. Priprema razvojnog okruženja Postoji nekoliko načina pripreme razvojnog okruženja, no unutar ovog rada će biti opisan samo jedan način. Potrebno je izgraditi instalacijski paket skupine alata za razvoj aplikacija(engl. adt-installer, ADT je skraćenica od Application Development Toolkit). Navedeni paket gradi se tako da, nakon što se unutar ljuske pokrene skripta za postavljanje okruženja za izgradnju, pokrene naredba: $ bitbake adt-installer
Kao rezultat operacije dobit će se "tar" arhivska datoteka(engl. tarball) s nazivom "adt_installer.tar.bz2" unutar direktorija "../{dirktorij_izgradnje}/tmp/deploy/sdk/". Nakon toga potrebno je da se, unutar ljuske, pozicioniramo u početni direktorij te tamo kopirati dobivenu arhivsku datoteku te ju raspakirati. To sve se obavlja sa sljedeće tri naredbe: $ cd ~ $ cp poky/build/tmp/deploy/sdk/adt_installer.tar.bz2 $HOME $ tar -xjf adt_installer.tar.bz2
Nakon ovih operacija, u početnom direktoriju ljuske, nastat će novi direktorij "adt-installer" unutar kojeg se nalazi datoteka s postavkama "adt_installer.conf". U datoteci s postavkama se nalazi više predefiniranih varijabli koje označuju: da li je potrebna instalacija QEMU emulatora, koje postavke slika je potrebno koristiti kod određenih arhitektura, adresa repozitorija s kojeg će se dohvaćati potrebni materijali, i sl. Od svih predpodešenih varijabli trenutno je potrebno obratiti pažnju samo na sljedeće varijable:
• YOCTOADT_TARGETS - ova varijabla označava za koje će se arhitekture graditi aplikacija te je bitno da željena arhitektura bude navedena u popisu, ostale po želji ukloniti ili ostaviti.
• YOCTOADT_NFS_UTIL - varijabla označava da se instaliraju alati za mrežni datotečni sustav(engl. Network File System) kako bi se za izradu i ispitivanje aplikacije zajedno mogli koristiti Eclipse programsko okruženje i QEMU emulator. Varijabla se postavlja na vrijednost "Y".
Nakon uređenja datoteke s postavkama potrebno je ljusku pozicionirati u direktorij "adt-installer" te pokrenuti skriptu za instalaciju. To je moguće napraviti koristeći sljedeće naredbe: $ cd adt-installer
13
$ ./adt_installer
Nakon početka instalacije ljuska će zatražiti putanju direktorija u koji će izvršiti instalaciju, pretpostavljeni direktorij je "/opt/poky/{verzija_Yocto-a}/". Nakon toga instalacijska skripta postavlja pitanje da li želite nastaviti rad u interaktivnom ili tihom načinu rada te da odabire "I" za interaktivni mod ili "S" za tihi mod. U interaktivnom načinu rada je lakše pratiti trenutni rad skripte. Ovom skriptom postavlja se skup alata za rad na aplikacijama koje se pokreću na arhitekturi različitoj od one na kojoj se razvijaju(engl. cross toolchain).
Valja napomenuti kako je s navedenom instalacijom u Yocto verziji 1.7.1 bilo problema s automatskim dohvaćanjem slika datotečnog sustava(engl. file system image) i jezgri(engl. kernel) s Internet-a. Problem je nastajao zbog toga što su u skriptama bili navedeni skraćeni nazivi, a na izvorima na internetu(engl. sources) se pod tim nazivima nalazio prečac koji je vodio do pravih datoteka s drugačijim nazivom. Nakon što bi skripta skinula prečac, iza tog prečaca se nije nalazilo ništa te instalacija nije obavljena uspješno. Rješenje je da se te slike i jezgre dohvate koristeći internet preglednik te im se promjeni naziv u naziv iz skripte(ili naziv prečaca), zatim je ih potrebno premjesti u direktorij u koji skripta skida izvore s Interneta("/adt-installer/download_image/"). U novijoj verziji(1.8) Yocto Project-a, koja je izašla tijekom pisanja ovog rada, problem je uklonjen te se instalacija odvija bez ikakvih drugih problema.
Također je potrebno podesiti i okruženje za razvoj na drugim arhitekturama, ovo također obavlja skripta te je potrebno pozicionirat se s ljuskom u direktorij instalacije "adt-installer" skripte(pretpostavljeni direktorij je: "/opt/poky/{verzija_Yocto-a}/") te pokrenuti naredbu: source /opt/poky/1.8/environment-setup-i586-poky-linux
Pokretanjem ove skripte podešavaju se varijable okruženja u kojima su definirane postavke i zastavice okruženja i programskih jezika, prevoditelja, veznika(engl. linker), itd.
Za potrebe pokretanja i testiranja aplikacije potrebno je pripremiti jezgru i datotečni sustav za koji se razvija aplikacija. Kako ćemo u ovom poglavlju razvijati jednostavnu aplikaciju, za Yocto distribuciju Linuxa pokrenutu unutar QEMU emulatora, preporuka je jezgru i datotečni sustav dohvatiti sa sljedeće poveznice http://downloads.yoctoproject.org/releases/yocto/yocto-1.8/machines/qemu/qemux86/, jezgra se nalazi pod nazivom "bzImage-qemux86.bin" a datotečni sustav je "core-image-sato-sdk-qemux86-20150403003610.rootfs.tar.bz2". Kako je potrebno, tijekom razvoja, pokrenuti i ispitati aplikaciju potrebno je i otpakirati dohvaćeni datotečni sustav. To je moguće napraviti sa sljedećim nizom naredbi: $ cd ~ $ source /opt/poky/1.8/environment-setup-i586-poky-linux $ runqemu-extract-sdk ~/Downloads/core-image-sato-sdk- qemux86-20150403003610.rootfs.tar.bz2\ $HOME/qemux86-sato
3.3.2. Postavljanje i podešavanje Eclipse razvojnog okruženja Podešavanju Eclipse razvojnog okruženja pristupit će se uz pretpostavku da je ono već instalirano na računalu. Kako je za instalaciju dovoljno skinuti arhivu s Interneta i raspakirati je na računalu postupak neće biti detaljnije opisivan. Također kao pretpostavku se uzima da je instalirana inačica Eclipse razvojnog okruženja "Kepler".
14
3.3.2.1. Postavljanje Eclipse razvojnog okruženja Nakon pokretanja Eclipse-a potrebno je uključiti odnosno instalirati neke dodatke za razvoj aplikacija za Linux okruženje. Unutar izbornika za instalaciju programskih dodataka Eclipse razvojnog okruženja(izbornik "Help", pa zatim "Install New Software") potrebno je odabrati odgovarajući repozitorij za Eclipse verziju koja je pokrenuta te zatim unutar navedenih izbornika označiti sljedeće opcije:
• "Linux tools" označiti: • "LTTng - Linux Tracing Toolkit boxes"
• "Mobile and Device Development" označiti: • "C/C++ Remote Launch" • "Remote System Explorer End-user Runtime" • "Remote System Explorer User Actions" • "Target Managment Terminal" • "TCF Remote System Explorer add-in" • "TCF Target Explorer"
• "Programming Languages" označiti: • "C/C++ Autotools Support" • "C/C++ Development Tools boxes"
Nakon odabira svih navedenih dodataka potrebno je završiti instalaciju istih. Zatim je potrebno unutar istog izbornika za instalaciju dodatak dodati novi repozitorij koji se nalazi na adresi "http://downloads.yoctoproject.org/releases/eclipse-plugin/1.8/kepler/". Ukoliko se radi s nekom drugom verzijom Yocto Project-a moguće je zamijeniti predzadnje polje poveznice na verziju koja se koristi(npr. iz 1.8 na 1.7). Isto vrijedi i za inačicu Eclipse razvojnog okruženja, ali u zadnjem polju(npr. kepler u juno). Nakon dodavanja i odabira novog repozitorija potrebno je odabrati koje je sve dodatke potrebno instalirati i završiti instalaciju. Potrebni dodaci su:
• "Yocto Project ADT Plug-in" • "Yocto Project Bitbake Commander Plug-in" • "Yocto Project Documentation Plug-in"
3.3.2.2. Podešavanje Eclipse razvojnog okruženja Unutar Eclipse-a potrebno je postaviti postavke vezane za razvoj aplikacija za platformu različitu od one na kojoj se razvija(engl. cross compiler options) te postavke vezane za ciljani uređaj. Odabirom izbornika "Window" te zatim "Preferences" pa "Yocto Project ADT" prikazuje se popis postavki bitnih za razvoj aplikacije. Kako je odabrano korištenje već izgrađenog sustava potrebno je obarati "Standalone pre-built toolchain" te pod "Toolchain Root Location" odabrati putanju gdje je instaliran "ADT toolchain" pomoću skripte "adt-installer", pretpostavljeni direktorij u ovom slučaju je "/opt/poky/1.8". Zatim je potrebno odabrati putanju do datotečnog sustava("Sysroot Location"), to je lokacija na koju je raspakiran dohvaćeni datotečni sustav(trenutno je to "$HOME/qemux86-sato"). Zatim je potrebno odabrati postavke ciljanog uređaja("Target Options"), kako se radi aplikacija pokretana unutar QEMU emulatora potrebno je odabrati opciju "QEMU". Na kraju je potrebno odabrati putanju do jezgre sustava kojeg se pokreće, u ovom slučaju je to datoteka "bzImage-qemux86.bin", koja je također dohvaćena s interneta. Ovime je završeno podešavanje Eclipse razvojnog okruženja. Sada se može krenuti u izradu aplikacije koja će se pokretati unutar Linuxa izgrađenog pomoću Yocto Project-a.
15
3.3.3. Izrada jednostavne aplikacije U ovom poglavlju je opisano kako izraditi jednostavnu aplikaciju od stvaranja projekta do pokretanja aplikacije unutar QEMU emulatora.
3.3.3.1. Stvaranje projekta i postavljanje aplikacije Projekt se stvara tako da se odabere izbornik "File" pa zatim "New" te onda "Project". Nakon toga otvara se izbornik u kojem je potrebno izabrati vrstu projekta, unutar podizbornika "C/C++" potrebno je izabrati "C Project" te odabrati "Next". Potom je potrebno upisati ime projekta te odabrati tip projekta. Tip projekta se nalazi u podizborniku "Yocto Project ADT Autotools Project" te zatim "Empty C Autotools Project". Zatim je dovoljno odabrati završetak kako bi se stvorio željeni projekt.
Nakon stvaranja projekta potrebno ga je podesiti. Kako se ciljana aplikacija zasniva na "GTK+" knjižicama(engl. libraries) potrebno je u projekt uključiti sve ostale knjižice o kojima zavisi izvođenje "GTK+" knjižice. To je potrebno napraviti na sljedeći način: desnim klikom na stvoreni projekt odabire se "Propertiese" izbornik te zatim "C/C++ General" podizbornik te zatim opcija "Paths and Symbols". Unutar navedene opcije postoji prozor "Includes" gdje se dodaju sve potrebne knjižice, odnosno putanje do njih. Koje su sve potrebne knjižice odnosno putanje za neku knjižicu doznaje se izvođenjem naredbe: pkg-config --cflags gtk+-2.0
3.3.3.2. Razvoj aplikacije Daljnji razvoj aplikacije teče kao i razvoj svake druge aplikacije u C programskom jeziku te ovdje neće biti opisivano. Izvorni kod primjera aplikacije nalazi se u privitku A.
3.3.3.3. Pokretanje aplikacije Kako bi se aplikacija pokrenula potrebno je pokrenuti QEMU tako da koristi mrežno-datotečni-sustav za rad(engl. Network File System mode). Iz izbornika "Run" unutar Eclipse-a je potrebno otići na pod-izbornik "External Tools" gdje se nalazi stavka "qemu_i586-poky-linux", koju je potrebno odabrati. Nakon toga će se otvoriti ljuska koja će tražiti da lozinku administratorskog korisničkog računa. Nakon nekoliko trenutaka pokreće se QEMU emulator i u njemu se podiže Linux distribucija izgrađena pomoću Yocto Project-a. U ljusci će se ispisati poruka o pokretanju te će u njoj pisati IP adresa koju koristi za mrežni datotečni sustav.
Nakon što je pokrenut QEMU, može se pokrenuti i izrađena aplikacija. Prvo je potrebno izgraditi aplikaciju tako da se na rađenom projektu odabere opcija "Build Project". Nakon toga potrebno je odabrati "Debug Configurations..." iz izbornika "Run" te se otvara novi prozor koji s lijeve strane ima ponuđeno nekoliko postavki. Jedna od njih je "C/C++ Remote Application", njenim proširenjem pojavljuje izgrađeni projekt te ga je potrebno odabrati. Pod "C/C++ Application" potrebno je upisati putanju unutar projekta gdje se nalazi građena aplikacija, također u polje"Remote Absolute File Path for C/C++ Application" upisati u koji direktorij na mrežnom datotečnom sustavu će izgrađena aplikacija biti spremljena. Nakon toga potrebno je definirati vezu na već pokrenuti QEMU emulator. Za to je u retku "Connection" potrebno odabrati "New..." te u novootvorenom prozoru odabrati "Next". Zatim je potrebno upisati "Host name:" koji je zapravo gore spominjana IP adresa koju koristi mrežni datotečni sustav te upisati željeni naziv veze pod "Connection name" te završiti postavljanje. Zatim je potrebno odabrati novostvorenu vezu u izborniku "Connection" te je time sve spremno za pokretanje odnosno odabrati "Run".
16
Kako u ovom radu nije razmatra izrada ikona i prečaca za aplikacije, ovu aplikaciju je potrebno pokrenuti iz ljuske. Unutar pokrenutog QEMU emulatora potrebno je odabrati "Terminal" te u njemu upisati naziv aplikacije i pritisnuti tipku "Enter". Nakon toga na zaslonu će se otvoriti aplikacija, rezultat je vidljiv na Sl. 3.2.
Sl. 3.2. Jednostavna aplikacija unutar Yocto Project-a
3.4. Izrada vlastitog sloja
U ovom poglavlju će biti pokazano kako izraditi vlastiti sloj unutar Yocto Project-a. Unutar sloja će se nalaziti paket s novonastalom aplikacijom. Za izradu sloja koristit će se skripta "yocto-layer" koja automatizira izradu sloja. Uz pretpostavku da je već pokrenuta skripta za postavljanje okruženja za izgradnju u ljusci, pozicioniranoj u "poky" direktoriju potrebno je izvršiti naredbu: $ yocto-layer create mojsloj
Skripta će zatim upitati koji je prioritet novog sloja, dovoljno je ostaviti zadani prioritet. Sljedeće pitanje koje postavlja skripta je da li želite stvoriti primjer recepta te da li želite stvoriti "bbappend" datoteku(dodatak receptu), na oba pitanja dovoljno je odgovoriti sa "n" što označava ne. Nakon završetka skripte ona je stvorila novi direktorij pod nazivom "meta-mojsloj", unutar njega se nalaze datoteke "README" koji sadrži osnovne podatke o sloju i "COPYING.MIT" koja sadrži podatke o licenci. Stvoren je i direktorij "conf" unutar kojeg se nalazi datoteka "layer.conf". U datoteci s postavkama sloja se nalaze podaci o sloju te podaci o receptima. Izmjene ove datoteke nisu potrebne. Kako bi stvorili recepte, unutar direktorija sloja, je potrebno stvoriti novi direktorij s nazivom "recipes-{naziv_skupine_recepata}". Kako je u "layer.conf" datoteci označeno da se recepti nalaze u direktorijima sloja s "recipes-" prefiksom u nazivu, naziv direktorija je ograničen na danu formu. Unutar direktorija koji predstavlja skupinu recepata stvaramo datoteku, odnosno
17
recept, s nazivom "{naziv_recepta}_{verzija_recepta}.bb" te jedan direktorij s nazivom "{naziv_recepta}_{verzija_recepta}". Unutar novonastalog direktorija potrebno je stvoriti datoteku "{ naziv_izvornog_koda}.c " i u nju upisati izvorni kod aplikacije pisan u C programskom jeziku. Recept, {naziv_recepta}_{verzija_recepta}.bb, je potrebno urediti na sljedeći način: DESCRIPTION = "Prva Yocto aplikacija" SECTION = "{naziv_skupine_recepata}" LICENSE = "MIT" LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT; md5=0835ade698e0bcf8506ecda2f7b4f302" PR = "r0" SRC_URI = "file://{naziv_izvornog_koda}.c" S = "${WORKDIR}" RDEPENDS = "freetype cairo atk glib-2.0 gdk-pixbuf gtk+ pango fontconfig" do_compile() { ${CC} $(pkg-config gtk+-2.0 --cflags) $(pkg-config gtk+-2.0 --libs) {naziv_izvornog_koda}.c -o {naziv_izvornog_koda} } do_install() { install -d ${D}${bindir} install -m 0755 {naziv_izvornog_koda} ${D}${bindir} }
Kratak opis nekih varijabli:
• PR - broj revizije recepta. • SRC_URI - lokacija na kojoj se nalazi izvorni kod, može biti i lokacija s interneta
ili mreže. • S - "radni" direktorij(u njemu se nalaze privremene datoteke u vrijeme izgradnje). • RDEPENDS - ovdje je potrebno navesti sve pakete koji su potrebni kako bi izvorni
kod mogao raditi kao izvršiva datoteka, kako je za primjer uzeta aplikacija koja je izgrađena u poglavlju 3.3.3. potrebno je dodati sve pakete koje koristi GTK+ knjižica.
Zadaci unutar recepta:
• do_compile - govori BitBake-u kako treba prevesti dani izvorni kod. • do_install - zadaje kako i gdje treba instalirati izvorni kod, odnosno aplikaciju.
Nakon postavljanja recepta, potrebno je izgraditi paket. Ukoliko je već postavljeno okruženje za izgradnju, dovoljno je se pozicionirati u direktorij izgradnje i pokrenuti naredbu: $ bitbake {naziv_recepta}
Te pustiti da BitBake izgradi paket. Ukoliko primijeti da postoje paketi o kojima ovisi dani izvorni kod, a ti paketi nisu navedeni kao ovisnost izgradnje("RDEPENDS"), BitBake će o tome ispisati upozorenje. Nakon izgradnje paketa, potrebno je novostvoreni sloj dodati u BBLAYERS varijablu kao posljednji sloj. Ovaj postupak je opisan već pa se neće detaljnije opisivati. Kako bi Bitbake znao da treba uključiti novonastali paket u sliku koju gradimo, potrebno je u datoteku "local.conf" dodati varijablu IMAGE_INSTALL_append = "{naziv_recepta}". Sada je sve spremno za izgradnju slike s novonastalim slojem, potrebno je samo izvršiti naredbu:
18
$ bitbake core-image-sato
Nakon izgradnje dovoljno je pokrenuti QEMU s izgrađenom slikom te u ljusci upisati naziv aplikacije koji je naveden u do_install dijelu recepta, u primjeru je to "{naziv_izvornog_koda}". Kako je korišten izvorni kod iz poglavlja 3.3.3. rezultat je jednak kao na Sl. 3.2.
19
4. ZAKLJUČAK
Unutar rada su opisane i isprobane samo osnovne mogućnosti Yocto Project-a. Izgradnja slike operacijskog sustava za ugradbena računala, izgradnja aplikacija za taj operacijski sustav te izrada aplikacijskog sloja za izgrađeni operacijski sustav su osnovne, a ujedno i glavne, mogućnosti Yocto Project-a. Izrada osnovnih slika je vrlo jednostavna, lako se izvodi praćenjem uputa na web stranicama projekta. Za izradu aplikacije također postoje uputstva, ali ako se želi izraditi nešto više od ispisivanja u ljusci potrebno je nešto više znanja o izgradnji aplikacija za Linux platformu. Slična situacija je i s izradom sloja i recepata. Recepti npr. podržavaju korištenje "autotools" alata za postavljanje aplikacije, korišten je u Eclipse razvojnom okruženju, ali kod izrade recepta nije uspješno iskorišten te je bilo potrebno upotrijebiti znanje o izradi Linux aplikacija kako bi se uspješno preveo i instalirao("do_compile" i "do_install" zadaci). Za pomoć i upite korisnika Yocto Project koristi tzv. "mailing list" koje se dosta teško pretražuju te su nepregledne za čitanje. Da je projekt u razvoju i da se redovno rješavaju problemi koji postoje dokazuje rješavanje problema s dohvatom materijala s interneta. Projekt već posjeduje pozamašnu skupinu slojeva raznih primjena koji nude još bolju iskoristivost. Neki od njih su: "meta-security" za uređaje spojene na internet, "meta-java" nudi podršku za Java-u, "meta-baryon" omogućuje korištenje Yocto distribucije Linux-a kao mrežni čvrsti disk(engl. Network-attached storage - NAS), i mnogi drugi.
Prije izrade ovog rada koristio sam nekoliko vrsta ugradbenih računala s Linux-om, ali radilo se o gotovim distribucijama koje su namijenjene baš za određeni uređaj ili baš za određenu platformu(npr. MikroTik, OpenWRT, DD-WRT, i sl.). Njihova instalacija i pokretanje je teklo vrlo jednostavno, rad je bio besprijekoran, ali ograničen na njihovu opću namjenu. Susretanjem i upoznavanjem s Yocto Project-om spoznao sam jednu, za mene potpuno novu, stranu korištenja ugradbenih računala. Kako sam do sada imao samo osnovno znanje o Linux platformi, iznenadila me jednostavnost izrade prilagođenog operacijskog sustava pomoću Yocto-a, aplikacija za isti te njegova prilagodljivost. Teorija Yocto Project-a me toliko zainteresirala da sam se odlučio za nabavku jednog ugradbenog računala(gore spomenuti Raspberry Pi2) te odlučio isprobati kako Yocto radi u stvarnom okruženju. Pokazalo se da je izgradnja za pravo ugradbeno računalo jednaka kao i za virtualno te je na taj način Yocto privukao još više pažnje.
Sada kada su osnovne funkcije Yocto Project-a obrađene u ovom radu, i pokazale su se kao jako jednostavne i korisne, nameće se pitanje kako opisani projekt još iskoristiti u stvarnom svijetu i gdje iskoristiti sve njegove mogućnosti. No to će ostati kao tema za neki drugi, opširniji rad.
20
LITERATURA
1. Yocto Project Quick Start, Linux Foundation, http://www.yoctoproject.org/docs/1.8/yocto-project-qs/yocto-project-qs.html
2. The Yocto Project Development Manual, Scott Rifenbark, http://www.yoctoproject.org/docs/1.8/dev-manual/dev-manual.html
3. Elizabeth Flanagan, The Yocto Project, http://www.aosabook.org/en/yocto.html
21
SAŽETAK
Izgradnja ugradbenih sustava korištenjem Yocto Projecta Ovaj rad opisuje alate i predloške za izgradnju prilagođenog Linux operacijskog sustava, za ugradbena računala, uz pomoć Yocto Project-a. Ujedno je na jednom primjeru prikazan način izgradnje aplikacije za izgrađeni prilagođeni operacijski sustav. Izradi rada pristupilo se prateći službenu dokumentaciju i testiranjem navedenih postupaka u stvarnom okruženju. Kao rezultat je dobiveno potpuno pokretljiv operacijski sustav na ugradbenom računalu.
Ključne riječi: Yocto Project, ugradbena računala, izgradnja prilagođenog Linuxa za ugradbena računala, izrada aplikacije za ugradbeno računalo
SUMMARY
Title: Creating custom Linux-based embedded systems with Yocto Project Summary This thesis describes the tools and templates to build a custom Linux-based operating system for embedded system, with Yocto Project. It also shows how to build applications for custom made operating system. While writing this document official documentation was followed and testing was done in real environment. Result is obtained as a fully agile operating system for embedded system.
Keywords: Yocto Project, embedded system, building custom Linux for embedded system, creating custom application for embedded system
22
PRIVITAK A: IZVORNI KOD IZRAĐENE APLIKACIJE
#include <gtk/gtk.h> static void exitBtn (GtkWidget * widget, gpointer data){ g_print ("Exit\n"); } static void destroy (GtkWidget * widget, gpointer data){ gtk_main_quit (); } void show_about(GtkWidget *widget, gpointer data){ GtkWidget *dialog = gtk_about_dialog_new(); gtk_about_dialog_set_name(GTK_ABOUT_DIALOG(dialog), "Yocto test"); gtk_about_dialog_set_version(GTK_ABOUT_DIALOG(dialog), "0.1a"); gtk_about_dialog_set_copyright(GTK_ABOUT_DIALOG(dialog), "Petar Kuštro"); gtk_about_dialog_set_comments(GTK_ABOUT_DIALOG(dialog), "Jednostavni test Yocto aplikacije."); gtk_dialog_run(GTK_DIALOG (dialog)); gtk_widget_destroy(dialog); } int main (int argc, char *argv[]){ GtkWidget *winMain; GtkWidget *btnQuit; GtkWidget *btnAbout; GtkWidget *frmText; GtkWidget *label; GtkWidget *diaAbout; gtk_init (&argc, &argv); winMain = gtk_window_new (GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(winMain), "YOCTO prva aplikacija"); gtk_container_set_border_width (GTK_CONTAINER (winMain), 10); g_signal_connect (G_OBJECT (winMain), "destroy", G_CALLBACK (destroy), NULL); frmText = gtk_fixed_new(); gtk_container_add(GTK_CONTAINER(winMain), frmText); label = gtk_label_new("Ovo je probna aplikacija unutar Yocto Project-a."); gtk_fixed_put(GTK_FIXED(frmText), label, 15,15); btnQuit = gtk_button_new_with_label("Izlaz"); gtk_widget_set_size_request(btnQuit, 150, 30); gtk_fixed_put(GTK_FIXED(frmText), btnQuit, 350, 380); btnAbout = gtk_button_new_with_label("O programu"); gtk_widget_set_size_request(btnAbout, 150, 30); gtk_fixed_put(GTK_FIXED(frmText), btnAbout, 190, 380); gtk_widget_add_events(winMain, GDK_BUTTON_PRESS_MASK); g_signal_connect(G_OBJECT(btnAbout), "button-press-event", G_CALLBACK(show_about), (gpointer) winMain);
23
g_signal_connect (G_OBJECT (btnQuit), "clicked", G_CALLBACK (exitBtn), NULL); g_signal_connect_swapped (G_OBJECT (btnQuit), "clicked", G_CALLBACK (gtk_widget_destroy), G_OBJECT (winMain)); gtk_widget_show_all(winMain); gtk_main (); return 0; }
24