Besturingssystemen (2014-2015)

Opleidingsonderdeel laatst gegeven in 2014-2015. Inhoud is enkel indicatief.

Laurent Segers - lasegers@vub.ac.be

Niek Blondeel - nblondee@vub.ac.be

Introductie en doelstellingen WPO's

Introductie slides

Downloads

Communication stack: Deze stack laat toe om de Beaglebone met verschillende te laten communiceren. Het aantal devices in het netwerk is beperkt tot 254 (255- 1 broadcast adres). De communicatiestack is platform onafhankelijk, en kan gebruikt worden met eender welk onderliggende communicatiemiddel (dus ook de seriële poort). De nodige documentatie zit vervat binnen de headerfile.

Altium project PIC18F2455 demo bord: Dit is het Altium Designer project van het demo bordje dat in de lessen gebruikt wordt.

Demo applicatie BeagleBone Black met IP stack: Hier kan een demo gevonden worden dat toelaat om de seriële poort uit te lezen op een BeagleBone Black. Ter demo is hier ook de IP stack al inbegrepen als sniffer (zie IP.h om dat te veranderen). Zie ook het laatste WPO om de gepaste functies aan te roepen om BBB tot een meewerkende node om te vormen (zenden + ontvangen).

Inleiding tot Embedded Linux met de BeagleBone Black

Vandaag worden er steeds meer bordjes geproduceerd waarop een variant van (embedded) Linux draait. Tijdens de werkcolleges zullen we daarom de BeagleBone configureren. Dit bordje bevat o.a. een krachtige ARMv7 microprocessor, en kan daarom aanzien worden als een (kleine) computer. De BeagleBone heeft een slot voor een SD-kaart waarop firmware zich bevindt. Vaak wordt er voor commerciële bordjes zoals de BeagleBone een kant en klare (Linux) image voorzien. Soms wordt deze image niet voorzien. In dat geval kan men zich beroepen op bestaande elementen, zoals een filesystem en de kernel voor de bedoelde microprocessor. Tijdens de eerste 3 WPO's zullen we a.d.h.v. bestaande elementen de SD-kaart conditioneren zodat de BeagleBone hiervan kan 'booten'.

Bronnen:

Building BeagleBone Black Linux kernel
Building BeagleBone Black Linux kernel
BeagleBone Black pagina

Voorbereidende stappen

Het is belangrijk om deze stappen goed uit te voeren. Het niet volledig lezen of doorgronden van de documentatie kan achteraf leiden tot frustraties! Tijdens de WPO's zullen we gebruik maken van een Linux virtueel machine om de SD-kaart van de BeagleBone gebruiksklaar te maken. Voorzie een Linux virtueel machine (Linux Mint, Linux Ubuntu 12.04 LTS, of ander Debian based Linux naar keuze) waarmee rechtreeks toegang tot de SD-kaart mogelijk is (gelieve dit ook na te gaan). De keuze van de virtualisatietechnologie (VMWare, VirtualBox, enz.) wordt aan de lezer overgelaten. De virtuele machine beschikt idealieter over een schijfruimte van 20GB en een werkgeheugen van 1024MB tot 2048MB RAM.

Eenmaal de virtuele machine gebruiksklaar is, moeten er een aantal packages geïnstalleerd worden, tesamen met de nodige bestanden voor de BeagleBone. De nodige packages worden hieronder opgesomd. Het volstaat om de commando's in een terminal uit te voeren. 

# Installeer de GCC compiler
sudo apt-get install build-essential
# Installeer 'ncurses' -> belangrijk om het menu van de kernel te kunnen tonen
sudo apt-get install libncurses5-dev
# Installeer de kernel compressie tool
sudo apt-get install lzop
# Installeer git: zo kan men de kernelbestanden downloaden
sudo apt-get install git
# Configureer git zodat deze alle info kan ophalen (verplicht, vervang tussen de aanhalingstekens)
sudo git config --global user.mail "your.email@example.com"
# Installeer de compiler voor ARMv7 (BeagleBone)
# Met de compiler is het ook mogelijk programma's op de host te 
# compileren voor het bordje
sudo apt-get install gcc-arm-linux-gnueabi
# Installeer u-boot mkimage
# als de host Ubuntu 12.04 LTS is, anders ga naar Mint hieronder
sudo apt-get install uboot-mkimage
# als de host Mint is 
sudo apt-get install u-boot-tools

Na de installatie wordt een ontwikkelmap aangemaakt. Dit kan onder onder de homedirectory (~/). Een voorbeeldmap is ~/Devel. Ga nadien via de terminal in deze map. 

mkdir ~/Devel
# zet de rechten op 'alles toegelaten'
sudo chmod 777 -R ~/Devel
# ga in de map
cd ~/Devel

In deze map worden de verschillende onderdelen gedownload: de u-boot bestanden, de kernel en het bestandssysteem (root filesystem). De u-boot bestanden zijn enkel nodig indien men de bootlaoder van het bordje wenst aan te passen. Standaard is de al aanwezige bootloader al voldoende. Hieronder volgt de download ter informatie. 

# Download de map
wget ftp://ftp.denx.de/pub/u-boot/u-boot-latest.tar.bz2
# Extraheer de map
tar -xjf u-boot-latest.tar.bz2
# Ga in de map en compileer 
cd into u-boot directory
make tools-only

De Linux kernel download wordt hieronder weergegeven. 

# Download de kernel via git
git clone git://github.com/beagleboard/kernel.git	
# Ga in de submap van de kernel
cd kernel
# Haal de branch 3.8 op via git
git checkout 3.8
# Voer de nodige patches uit. Deze patch duurt even (alles downloaden via git)
./patch.sh
# Kopieer de config bestanden voor de BeagleBone naar de juiste plaats
cp configs/beaglebone kernel/arch/arm/configs/beaglebone_defconfig
# Download nog een nodige bin-bestand
wget http://arago-project.org/git/projects/?p=am33x-cm3.git\;a=blob_plain\;f=bin/am335x-pm-firmware.bin\;hb=HEAD -O kernel/firmware/am335x-pm-firmware.bin
# Keer terug naar de hoofdmap
cd ..

Als bestandssysteem (filesystem) zullen we Arch-Linux gebruiken. Arch-Linux is een relatief klein en robuust Linux distributie voor o.a. ingebedde platformen. Het bestandssysteem kan via deze pagina gedownload worden. Kopieer de tarball naar ~/Devel. Uitpakken is hier niet wenselijk, omdat de bestandsrechten onherroepelijk gewijzigd zouden worden. Hierdoor zou de BeagleBone achteraf niet degelijk kunnen opstarten.

WPO 1

Tijdens dit WPO zullen we de BeagleBone Black configureren. In de voorbereidende fase hebben we de nodige bestanden (kernel + filesystem) hiervoor gedownload. Om ervoor te zorgen dat we de juiste kernel hebben, moeten we onderstaande stappen ondernemen. Ga hiervoor via de terminal eerst naar de submap kernel van de kernel. 

# Eerst voeren we een clean uit (enkel de eerste keer!)
make distclean							
# Zorg ervoor dat we de kernel kunnen compileren met de juiste settings (beagle definitions)
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- beaglebone_defconfig
# Met dit menu kan je de kernel verder configureren, welke drivers en welke niet 
# meegecompileerd worden.
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- menuconfig
# Compileer de kernel
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j4 uImage dtbs	
# Compileer de modules voor de kernel, dit is nodig als je de drivers als
# module laat compileren. De modules moeten achteraf wel apart op de SD kaart komen.
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- -j4 modules
# Compileer de kernel voor de BeagleBone
make ARCH=arm CROSS_COMPILE=arm-linux-gnueabi- uImage-dtb.am335x-boneblack

Sommige configuraties zijn niet zichtbaar met het menuconfig commando. Wel is het mogelijk om settings manueel te configureren. Hiervoor wordt onderstaande commando gebruikt. Let wel op: doe dit enkel als je weet welke opties je aanpast! 

# Open het configuratiebestand (van de beaglebone)
nano .config

Via de zoekfunctie van de editor kan volgende tekst opgezocht worden: CONFIG_FHANDLE. Deze configurator zorgt ervoor dat de kernel tekst al dan niet via seriële communicatie naar buiten toe kan communiceren. Zolang deze optie in commentaar staat zal dit niet lukken. Ook moet deze optie op "=y" staan. Om deze optie geldig te maken dient de kernel opnieuw gecompileerd te worden. Merk op dat we de speciale gnueabi compiler hiervoor gebruiken. Wat is er zo speciaal aan deze compiler?

De gecompileerde kernel is terug te vinden als (vanuit kernel/kernel): arch/arm/boot/uImage-dtb.am335x-boneblack

Eenmaal we beschikken over kernel, wordt het tijd om de SD kaart te partitioneren. Neem hiervoor best een SD-kaart van minimaal 4GB. Volgende partities worden hierop aangemaakt: een FAT16 partitie van 100MB, en een ext3 partitie die de resterende ruimte inneemt. Deze partities kunnen (onder Linux) aangemaakt worden met Gparted (te installeren). De FAT16 partitie moet als bootable gevalgd worden.

De kernel wordt gekopieerd naar de FAT16 partitie, en wordt daar naar uImage hernoemd. Naast de kernel wordt er een klein configuratiebestandje (uEnv.txt) aangemaakt. Dit bestandje zorgt ervoor dat de bootloader van de BeagleBone weet waar de nodige bestanden staan om Linux te kunnen opstarten. De inhoud van dit bestandje wordt hieronder weergegeven. 

mmcargs=setenv bootargs console=ttyO0,115200n8 root=/dev/mmcblk0p2 rw ext3 rootwait
loadaddr=0x82000000
loadimageFAT=fatload mmc 0 ${loadaddr} uImage;bootm ${loadaddr};
uenvcmd=run mmcargs; run loadimageFAT;

Het 2de gedeelte omvat het filesystem. Deze wordt op de ext3 partitie van de SD-kaart gezet. Ga hiervoor met de terminal naar de plaats waar de tarball van de rootfilesystem staat. Met volgende commando wordt deze naar de juiste partitie geëxtraheerd (met behoud van bestandsrechten). 

# Pak de file tarball uit naar de ext3 partitie. Pas hiervoor wel de paden aan.
sudo tar xvf file.tar.gz -C /media/partitie2

Plaats de SD-kaart in de BeagleBone en laat deze opstarten. Enkele hints zijn hier van toepassing:

  • Het is gemakkelijker om het opstartproces van de BeagleBone te monitoren via een seriële verbinding (ttyO0). Waar bevindt zich ttyO0 (op het bordje) en hoe verbindt men deze met een USB naar serieel converter?
  • Ga na welke de gebruikersnaam en wachtwoord zijn voor de BeagleBone
  • Ga na (indien je ingelogd bent) of internet toegang hebt (ifconfig). Indien ja, dan kan je inloggen via ssh.

Opgave: zorg ervoor dat de BeagleBone degelijk opstart. Zorg ervoor dat toegang via internet mogelijk is. Achteraf (volgende WPO's) zullen bijkomende drivers geïnstalleerd moeten worden. Ga na de welke en compileer ze mee in de kernel.

WPO 2

Tijdens dit WPO zullen we nagaan op welke wijze applicaties voor de BeagleBone gecompileerd kunnen worden. Enerzijds zullen we eerst nagaan hoe men met de klassieke gcc (GNU C Compiler) compiler applicaties voor de gebruikte host kunnen compileren. Anderzijds zal men met de cross-compiler voor de BeagleBone dezelfde applicatie voor de BeagleBone compileren. Het compileren van 1 enkel c-bestand (code) wordt als volgt uitgevoerd: 

# Compileer main.c tot main (-o staat voor output)
gcc main.c -o main

Hoewel men met 1 enkel c-bestand al ver kan geraken, worden projecten vakk opgedeeld tot subprojecten (verschillende c-bestanden). Al deze c-bestanden worden compileerd tot 1 uitvoerbaar bestand (executable). Echter moet de compilatie nu in 2 fasen verlopen: het compileren naar een object bestand van elk c-bestand, en het linken van alle object-bestanden tot 1 executable (zie fragment hieronder). Merk op dat object-bestanden de extensie *.o meekrijgen. 

# Compileer main.c tot main (-c staat voor compile)
gcc main.c -c main.o
# Doe hetzelfde voor include.c
gcc include.c -c include.o
# Alle objectbestanden linken gebeurt als volgt (-o nu om te compilen):
gcc -c main main.o include.o

Deze laatste methode kan zeer omslachtig worden voor grotere projecten. Zeker als deze nog eens afhankelijk zijn van diverse libraries. Om het manueel hercompileren te vermijden, worden Makefiles aangemaakt. Makefiles (bestandsnaam is altijd "Makefile") zijn als het ware een recept welke bestanden op welke wijze te compileren tesamen met welke libraries. Een voorbeeld van zo'n Makefile wordt hieronder weergegeven. 

CC=gcc
CFLAGS=-c -Wall -pthread
LDFLAGS=-pthread
SOURCES=main.c include1.c include2.c
EXECUTABLE=main
#################################################################
OBJECTS=$(SOURCES:.c=.o)

all: $(SOURCES) $(EXECUTABLE)
	
$(EXECUTABLE): $(OBJECTS) 
	$(CC) $(LDFLAGS) $(OBJECTS) -o $@

.c.o:
	$(CC) $(CFLAGS) $< -o $@

In bovenstaand fragment volstaat het om enkel de C-bestanden op te geven, en de libraries achter de LDFLAGS bij te zetten (elke library wordt door een "-" voorafgegeaan. Door welke compiler moet men gcc vervangen om te kunnen cross-compilen voor de BeagleBone? Is dit ook van toepassing op de BeagleBone zelf?

WPO 3

In dit laatste WPO zullen we een applicatie schrijven dat enerzijds toelaat om vanuit de seriële poort van de BeagleBone data in te lezen, als er naar te schrijven. Hiervoor hebben we twee belangrijke componenten nodig: een seriële poort interface en threading. De eerste component is duidelijk. Via deze link kan de startcode voor de seriële poort communicatie gedownload worden. De namen de functies zou voor zich moeten spreken. De code van de seriële poort heeft echter een probleem: het lezen vanuit de poort voorzaakt een "blocking read". M.a.w. het programma wacht totdat er data binnenkomt. Dit zorgt ervoor dat het programma dus in die tijdspanne geen data mee kan verzenden. Om dit probleem te verhelpen worden er threads ingevoerd. Een thread is een onafhankelijk stuk code dat in parallel uitgeoverd wordt t.o.v. een andere thread binnenin een proces. In C kunnen threads aangemaakt d.m.v. de posixthreads. De procedure om threads aan te maken wordt hieronder weergegeven. 

// include de posixthreads (p-thread)
#include 
//...
//...
// initialiseer de struct om de threads the kunnen aanmaken.
pthread_t thread1;
// schrijf een functie volgens het gepaste prototype
void* function(void* data) {}
// maak de thread aan, en start deze onmiddelijk
pthread_create(&thread1, 0, function, 0);
// wanneer de thread afgesloten mag worden, wordt er een join operatie uitgevoerd met de startende thread
pthread_join(thread1, 0);
Gebruik threads in het volgende programma om een seriële poort te benaderen.

Inleiding tot de PIC18F2455 en ingebedde besturingssystemen WPO4-WPO9

Aan de hand van een demo-bordje worden de labo's met de PIC18F2455 gegeven. De labo's worden als volgt ingedeeld:

  • In het eerste labo (WPO4) zal men leren werken met de PIC18F2455. Zo zal er aangeleerd worden hoe men een datasheet doorgrondt en hoe de PIC initieel wordt ingesteld. Na dit eerste labo zullen de studenten hebben aangeleerd hoe een "hello-world"programma geschreven wordt. Aan het einde van dit labo zullen we in staat zijn zijn om een hardware-programma te schrijven.
  • Het tweede labo legt de begrippen UART en interrupts uit. Hiermee wordt het mogelijk data te communiceren met een host-computer.
  • In het derde labo zal een schakeling ontworpen worden om een sensor via de ADC in te lezen. Via UART is het dan mogelijk deze waarde de verzenden.
  • Het vierde labo heeft als doel via de timer functies van de microcontroller een real-time klok (RTC) te maken. Hiermee dient dan in het vijfde labo een scheduler gemaakt te worden dat de basis vormt van een besturingssysteem.
  • Zoals reeds aangehaald zal in het vijfde labo een scheduler worden gemaakt. Deze scheduler kan individuele taken zoals het inlezen van een sensor, versturen van informatie apart en periodiek plannen.
  • In het laatste labo wordt dit samengebundeld met een wireless systeem dat werkt via UART. Zo kan de waarde van de ADC draadloos en periodiek verstuurd worden. Het ingebed draadloos ontwikkeld systeem verstuurt zijn informatie volgens een bepaald vooropgesteld protocol. Door de aangeboden conventie te hanteren kan er gestructureerd gecommuniceerd worden met de Beaglebone van de vorige labo's.

WPO4 - WPO9: PIC18F2455

De documenten van de WPO's worden publiek gemaakt op deze website gedurende de periode van de lessen.