View source for Förberedelse programmering STM32

Här samlas information om hur man sätter upp toolchains, IDE, programmeringsmjukvara o.s.v. för STM32.

Vilse började skriva denna.
Jag som gjort denna guide vill inte påstå mig ha en överlägset bra koll på allt det jag skriver om, utan snarare är jag en nybörjare själv som nyligen fått igång det jag skriver om. Men min förhoppning är att jag, till skillnad från mer erfarna medlemmar i föreningen, har just på grund av detta möjlighet att skriva en guide som riktar sig till den totala nybörjaren och jag kommer inte utgå från att du har erfarenhet av linux, mikrokontrollers eller C programmering. Guiden är tänkt att läsas från början till slut, och hoppa över de delar som inte berör dig.

Det är lätt att drunkna i information, samtidigt som man inte hittar svar på de allra mest basala frågor, när man vill lära sig något nytt. min erfarenhet är att man fastnar på ett litet problem, som t.ex. ett felmeddelande under en installation, och i letan om vad meddelandet säger så hittar man en uppsjö bra guider och forum som berör ämnet, men det slutar allt som oftast med att man länkas vidare i många steg, så att i slutet av kvällen har man 100 flikar öppna med halvlästa guider i webbläsaren. för att spara Din tid så kommer jag försöka att lägga in "allt" material du behöver på denna sida (exkl. saker du behöver ladda hem), så att minimalt antal avstickningar från denna guide behövs under hela förloppet. när länkar till annat material presenteras så är det dels en källhänvisning (cred till den person som skrev orginalguiden) eller en möjlighet att läsa mer om ämnet.

Har du frågor, fastnar du, får du problem, eller vill du bara tacka för hjälpen; '''hör av dig till en [http://chalmersrobotics.se/?page_id=80 styrelse-medlem]!''' 

Jag har också varit här och härjat /Sternå

=Komma igång snabbt=
För dig som inte orkar sätta upp allt ordentligt finns här en snabbguide på hur du gör. Nackdelen (men också möjligen en fördel) med detta är att du måste köra i en virtuell maskin och inte på din egen installation på ditt huvud-OS.

Föruppsatt VM av Ubuntu 12.04 för Virtualbox med byggkedja förinstallerad finns tillgänglig via torrent:
[[File:IntroARM.vdi.torrent.zip]]<br>
Användaren i VMen är '''introarm''' och lösenordet är '''crf'''. Notera även att det är upp till användaren att sätta upp guest-extension för att få USB-delning fungerande. Detta eftersom att det är i stor del beroende på version av Virtualbox och vilket operativsystem som används.
Mer utförlig information på hur du sätter upp det själv samt annan information finns i resten av artikeln.

==Använda GNU ARM Eclipse-pluginet==
''ST har övergivit sitt gamla stdperiph-lib som IntroARM är byggt på. Pluginet använder därför det nyare HAL-libbet som IntroaARM-koden inte är kompatibel med. För att använda pluginet med det gamla libbet finns en guide här: http://eraycanli.com/2015/08/19/using-standard-peripheral-library-instead-of-hal-with-stm32f4/''

Någonting som fungerar ganska smidigt och är helt cross platform är att använda sig av [http://gnuarmeclipse.livius.net/blog/ GNU ARM Eclipse-pluginet]. Det är i korta drag ett plugin till Eclipse som kopplas till en toolchain. Det har inbyggt stöd för att skapa projekt för STM32 också, vilket är smidigt. Utförliga installationsinstruktionerna finns [http://gnuarmeclipse.livius.net/blog/install/ här]. I korta drag behöver man:
*Ladda hem och installera [https://www.eclipse.org/downloads/packages/eclipse-ide-cc-developers/lunasr2 Eclipse för C/C++]
*Installera [http://gnuarmeclipse.livius.net/blog/plugins-install/ GNU ARM Eclipse-pluginet] genom att i Eclipse köra Help->Install new software och skriva in "http://gnuarmeclipse.sourceforge.net/updates" som URL och "GNU ARM Eclipse Plug-ins" som namn (du kan välja vilket namn som helst, men detta är smidigt). De plugins du behöver som minst är "GNU ARM C/C++ Cross Compiler" och "GNU ARM C/C++ STM32Fx Project Templates", även om en del andra kan vara bra att ha (som debugging med OpenOCD).
*Ladda hem och installera [http://gnuarmeclipse.livius.net/blog/toolchain-install/ GNU ARM-toolchainen]. Filen att ladda ner finns [https://launchpad.net/gcc-arm-embedded/+download här] och installationen beror på vilket OS du har (se första länken för närmare instruktioner).
*När du installerat allt kan du skapa ditt först projekt. Där är det lite att tänka på, för dom har dummat sig med pluginet.
**Först skapar du ditt projekt med File->New->C Project. Välj Executable->Den processor du använder dig av (IntroARM har STM32F10x). Se till att toolchainen är Cross ARM GCC.
**Härnäst ställer du in vilken processor du har, klockfrekvens etc. Denna info finns i databladet. För IntroARM gäller Medium Density Value Line, 128k Flash, 8k RAM, 8MHz extern klocka. Vidare bör du välja Empty content, Freestanding (No system calls), No trace output. Stäng även av Check Most warning, annars är den så sjukt grinig. Ta också bort -Werror. Alla de andra kan vara som de är.
**Ställ in namn för mappar. Standard funkar bra.
**Ifall du ska debugga kan du ha kvar debug. Annars kan du ta bort den konfigurationen.
**Ställ in sökvägen till toolchainen. Den bör hittas automatiskt, annars får du peka ut den själv (du kommer väl ihåg vart du la den?)
**Tryck Finish och du kan börja koda. Ifall du har färdig kod (t.ex. [[Program IntroARM | IntroARM-programmet]]) kan du kopiera in koden och ta bort de existerande filerna (_write.c, för den kommer bråka).
*Nu är det ett par saker kvar att göra för att det ska kompilera. De som gjort pluginet har gjort fel så du får gå in och åtgärda följande saker:
**Ställ in rätt processorfamilj. IntroARM använder sig av stmf10x_md_vl (medium density, value line). Högerklicka på projektet du skapat och välj "Properties" (du kan även markera projektet och trycka alt+enter). Där går du till C/C++ Build->Settings. Expandera Assembler samt C och C++ Compiler. Under var och en av dessa går du in på fliken Preprocessor och dubbelklickar där det står STM32F10X_MD. Byt ut detta mot STM32F10X_MD_VL.
**Av någon outgrundlig anledning har dom gjort så att alla filer inte kompilerar. I projektet, gå in i mappen system/src/stm32f1-stdperiph. Där finns det ett antal filer som ser utgråade och överstrykna ut. Detta innebär att de inte kompileras med projektet, vilket dom definitivt behöver göras. Markera alla utgråade filerna, högerklicka och välj Resource Configuration->Exclude from build. Se till att ingen av checkboxarna är markerade (filen ska INTE exkluderas från bygget). Tryck F5 för refresha.

==Kod till IntroARM==
Koden samt förklaringar av programmet till IntroARM finns på [[Program IntroARM | kod-sidan.]]

==STM32Flash under Linux==
Vi använder två modifierade versioner av [[Stm32flash]]:

Den till v2.1 och senare är här: [[File:Stm32flash-master.zip]] finns även på Devilholks githubsida. Den Reset och Boot (RTS/CTS) separat.

Den till v2 är här: [[File:Stm32flash with RTS-toggle.zip]]. Den förlitar sig på en krets som använder en pinne för att styra både boot och reset med samma signal. Kretsen är slopad efter V2.

===Bygg och installera===
1. Zippa upp<br>
2. Ställ dig i den upzippade mappen i terminalen<br>
3. Skriv "make" i terminalen<br>
4. Skriv "sudo make install" i terminalen<br>
5. Ange lösenord<br>

===Använda V2.1+===
Kortslut DTR-kondensatorn på USB UART-kretsen genom att löda bort den och löda över den, ifall du har en sådan på din USB-UART.
Anslut RTS till pinne 5, kolla noga vilken som är RTS på USB-UART kretarna, vissa är dåligt märkta.
Anslut DTR till pinne 4
Kör sedan följande kommando i terminalen:

sudo stm32flash -b115200 -Rcs.rts -Bcs.dtr -w'''introarm.bin''' /dev/ttyUSB0

Notera att introarm.bin kan variera beroende på vad filen som du vill ladda över heter och var du står i terminalen.
<br>STM32Flash klarar även andra fil-typer, såsom .hex.

===Använda V2===
Anslut RTS till pinne 4, kolla noga vilken som är RTS på USB-UART kretarna, vissa är dåligt märkta.
Kör sedan följande kommando i ternminalen:

sudo stm32flashv2 -tw '''introarm.bin''' /dev/ttyUSB0

Notera att introarm.bin kan variera beroende på vad filen som du vill ladda över heter och var du står i terminalen.
<br>STM32Flash klarar även andra fil-typer, såsom .hex.

=Mer utförlig guide: Innan du börjar=
Detta behöver du:
*Tid
*Passion och nyfikenhet
*Förmåga att läsa engelska 
*En dator med ~10GB ledigt på hårddisken
*Ett usb-minne (enklast för installation av Ubuntu) ( fungerar även med t.ex. CD/DVD skiva)

=Operativsystem=
Vi rekommenderar att du programmerar i [[Ubuntu]] då det finns en bra så kallad tool-chain i Ubuntu som är gratis och inte har några inbyggda begränsningar. Det finns även alternativ för windows, så som [http://www.keil.com/ Kiel] eller [http://www.iar.com/ewarm/ IAR] men det är ingen i föreningen som använt denna och kan hjälpa dig ifall du fastnar. Både Kiel och IAR är begränsade till att bara kunna använda 32kb flashminne i gratisversionen, så det kan vara bra att testa om du vill komma igång direkt, men det är ingen hållbar lösning.
En lite mer hållbar lösning som är ganska vettig för windows är att använda sig av [http://www.coocox.org/ Coocox IDE]. Det är byggt på Eclipse, och specialanpassat för ARM-microcontrollers, men kraftigt stympat. Dock är det rätt efterblivet på många sätt, men du slipper sätta upp toolchains och sånt.
==Om du har [[Ubuntu]] installerat==
Då är allt som det ska och du kan hoppa ner till [[Förberedelse programmering STM32#Kompilera kod för ARM | Kompilera kod för ARM]]

==Om du har Mac OS X==
Kort version (tills det kommer en riktig variant):
Du kan köra nästan samma guide som för Ubuntu till OSX. Du behöver ha XCode installerat för att få lite kompilatorer, samt att du behöver ha [http://www.macports.org/ Macports] eller [http://www.finkproject.org/ Fink] (kan även fungera med [http://brew.sh/ homebrew]).
Du kan även utan problem köra Ubuntu i Virtual Box. Annars är det bara att googla på ''Setting up STM32 for OS X Eclipse'' eller nåt och följa instruktioner.
TODO: Fixa en genomtänkt guide.

==Om du har Windows==
Det finns 3 sätt att fixa Ubuntu på din dator:
*[[Ubuntu#Installera Ubuntu vid sidan av Windows|Installera Ubuntu vid sidan av Windows]]
*[[Ubuntu#Installera Ubuntu istället för Windows|Installera Ubuntu istället för Windows]]
*[[Ubuntu#Installera en Virtuell Maskin med Ubuntu i Windows|Installera en Virtuell Maskin med Ubuntu i Windows]]

OM du verkligen inte vill ha Ubuntu så kan du alltid googla på ''Setting up Eclipse and STM32 for Windows'' eller liknande.

=Kompilera kod för ARM=
Denna del går igenom hur du sätter upp kompilatorer och liknande för ARM. För att kunna göra detta behöver du primärt GCC (vilket bör finnas på din dator). Vid slutet av denna del kommer du att kunna bygga enkel exempelkod och ta fram en körbar fil.
Denna del går igenom:
*Sätta upp ARM-gcc (och andra verktyg)
*Makefil
*Lite om bibliotek

Denna guide är skriven av Benjamin Vedder på [http://vedder.se/2012/07/get-started-with-stm32f4-on-ubuntu-linux/ hans hemsida]. Modifierad av Mikael Tulldahl.

Man kan även kolla på [http://gnuarmeclipse.livius.net/blog/ GNU ARM-Eclipse] hemsida. Där finns det info om Eclipse-plugin och tollchains.

==Download and build GCC, GDB, OpenOcd and newlib==

To set up the toolchain, a modified version of the summon-arm-toolchain script will be used. Firstly, a few packages have to be installed. Open a terminal(Ctrl + t) and paste the following command:
<pre style="white-space:-moz-pre-wrap; white-space:-pre-wrap; white-space:-o-pre-wrap; white-space:pre-wrap; word-wrap:break-word;">
sudo apt-get install build-essential git flex bison libgmp3-dev libmpfr-dev libncurses5-dev libmpc-dev autoconf texinfo libtool libftdi-dev libusb-1.0-0-dev zlib1g zlib1g-dev python-yaml
</pre>

Execute by pressing enter.
This will build all the required tools, for which the summon-arm script can be used. For me it didn’t work right out of the box, so I modified the script a bit. You can download the modified version [https://github.com/vedderb/summon-arm-toolchain/archive/master.zip here]

Unzip the files to some directory and make the file runnable with this command (make sure to replace '''PATH_TO_DOWNLOADED FILE''' with the actuall path, probably this works:"~/Downloads"):

<source lang="bash">
cd PATH_TO_DOWNLOADED FILE
unzip summon-arm-toolchain.zip
cd summon-arm-toolchain
chmod +x summon-arm-toolchain
</source>

Build the toolchain with this command ('''Note this will take about 1 hour or so'''):
<source lang="bash">
./summon-arm-toolchain
</source>

While this is building, you can make sure that the tools are in you path by opening another terminal(Ctrl + t) and typing (make sure to replace '''YOU_USER''' with your actuall user name):

<source lang="bash">
sudo su
echo 'export PATH=/home/YOUR_USER/sat/bin:$PATH' > /etc/profile.d/arm_tools.sh
exit
</source>

This should make sure that you can run the tools from any directory without the need to specify the full path. For the path update to take effect you have to log out and log in again.

When the summon-arm script finishes, you should be able to build programs for the STM32F4 (and many other) microcontrollers and use hardware floating point support.

==Byggprocessen och makefil==
''Huvudartikel: [[Byggprocess_ARM | Byggprocess ARM]]''<br>
För att kunna bygga din kod behöver du en [http://en.wikipedia.org/wiki/Makefile makefil]. Den skriver du antingen själv (baserat på en existerande såklart) eller låter en IDE generera den. Makefilen berättar hur kompilatorn ska arbeta, d.v.s. vilka filer och bibliotek som ska med, hur det ska optimeras, vilken processor man arbetar mot o.s.v.
Byggandet går igenom ett antal steg som grovt kan delas upp i kompilering, länkning, flash-dumpning, listdumpning och storleksdumpning. Kompileringssteget tar dina C- och H-filer och gör om dom till maskinkod (till objektfiler, .o). Länkaren tar sedan dessa filer och sätter ihop dom till en [http://en.wikipedia.org/wiki/Executable_and_Linkable_Format .elf-fil]. Elf-filen omvandlas sedan till en flash-dump i antingen .hex eller .bin (eller något annat format, men det är dom vanligaste). Listdumpning ger gör en läsbar fil av elf-filen som kan vara bra att ha vid felsökning eller optimering och storleksdumpning skriver ut hur mycket data som går till vilket minne.

=Flytta programmet från dator till STM32=
Detta kan göras på flera sätt. Antingen använder man en [[Förberedelse_programmering_STM32#ST-LINK | STM32-programmerare]] eller så använder man [[Förberedelse_programmering_STM32#Bootloader | den inbyggda bootloadern]]. (Det finns säkert fler sätt, såsom att använda 2 strömbrytare och mycket tid)
==ST-LINK==
[http://www.st.com/web/catalog/tools/FM146/CL1984/SC724/SS1677/PF251168 ST-LINK] är STs officiella programmerare. Den finns i två versioner, V1 och V2. Primärt använder vi V2, eftersom den är bättre och enklare att prata med. Dessutom finns det en sådan inbyggt på nästan alla STs utvecklingskort, såsom [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/LN1199/PF252419?s_searchtype=partnumber STM32F4Discovery] som finns att köpa på t.ex. [https://www.elfa.se/elfa3~se_sv/elfa/init.do?item=73-872-87&toc=0&q=discovery+board Elfa], men det spelar nästan ingen roll vilken version (F0,F1, ... ,F4). Det finns även i [[Main_Page#Lokal | Lokalen]] att använda (ej låna med hem!). Det enda kortet man bör undvika är [http://www.st.com/web/catalog/tools/FM116/SC959/SS1532/PF250863 STM32VLDiscovery] eftersom den innehåller ST-LINK/V1, som är svårare att prata med, men fortfarande möjligt.
På Discovery-kortet sitter det dels en så kallad "programmerare" (ST-LINK/V2) och dels en STM32. vi ska använda programmeraren för att programmera om vår stm32'a. Ta bort de två jumpers som är markerade "ST-LINK DISCOVERY" för att programmera genom SWD porten. Annars kommer stm32'an på discovery-kortet att programmeras.

För att ladda över programmet behöver man ett program på datorn för att prata med programmeraren. Det finns ett flertal olika program.

===QSTLink2===

Denna guide är skriven av Benjamin Vedder på [http://vedder.se/2012/07/get-started-with-stm32f4-on-ubuntu-linux/ hans hemsida]. Modifierad av Mikael Tulldahl.

In order to upload the binary files to the STM32F4 Discovery board I have been using a program called QSTLink2. I have modified the program a bit and added a button to upload the last uploaded file (which is pretty convenient) and fixed a few bugs in the cli interface. You can download the modified version [http://vedder.se/wp-content/uploads/2012/07/qstlink2.zip here].

You have to build QSTLink2 from source in order to use it. First, install some dependencies:

<source lang="bash">
sudo apt-get install qt4-qmake libqt4-dev libqt4-gui libqt4-xml qt4-designer qtcreator libusb-0.1-4 libusb-1.0-0-dev
</source>

Now unzip QSTLink2 to some directory and cd to it from a terminal. Then type:

<source lang="bash">
qmake-qt4
make
sudo make install
sudo reload udev
</source>

Plug in your Discovery board. You should now be able to start QSTLink2 by entering in a terminal:

<source lang="bash">
./qstlink2
</source>

Connect the Discovery board with the mini usb and upload the binary file which is generated in the build directory of the sample project when running make (you're looking for a .bin file).

===OpenOCD===
[http://openocd.sourceforge.net/ OpenOCD] (Open On-chip debugger, OOCD) är ett open-source-projekt som är en generell programmerar-mjukvara för allt möjligt, såsom ARM-processorer, flash-minnen, FPGA osv. Det ska finnas versioner för alla OS.
Det är möjligt att OpenOCD kommer med i summon-arm-scriptet, men det kan vara en gammal version. Kolla [http://sourceforge.net/projects/openocd/files/openocd/ här] ifall du har den senaste versionen (du kollar vilken version du har installerad genom att köra "openocd -v" i terminalen). Om så inte är fallet, ladda hem och bygg den. Innan du bygger bör du köra följande kommando från mappen dit du unzippat OpenOCD:
<source lang="bash">
./configure --enable-maintainer-mode \
	    --disable-option-checking \
	    --disable-werror \
	    --enable-dummy \
	    --enable-ft2232_libftdi \
	    --enable-usb_blaster_libftdi \
	    --enable-ep93xx \
	    --enable-at91rm9200 \
	    --enable-presto_libftdi \
	    --enable-usbprog \
	    --enable-jlink \
	    --enable-vsllink \
	    --enable-rlink \
	    --enable-arm-jtag-ew\
	    --enable-stlink
</source>
Primärt är det maintainer-mode och stlink du vill ha, men det är lika bra att installera allt. Sedan bygger du programmet som vanligt (från samma mapp):
<source lang="bash">
make
sudo make install
sudo reload udev
</source>
Du kan kontrollera att det är korrekt version du har installerad genom att skriva "openocd -v" i en terminal.<br>
För att ladda över ditt program kopplar in din programmerare och kör följande kommando (fungerar från OpenOCD 0.7.0):
<pre style="white-space:-moz-pre-wrap; white-space:-pre-wrap; white-space:-o-pre-wrap; white-space:pre-wrap; word-wrap:break-word;">
openocd -f interface/stlink-v2.cfg -c "set WORKAREASIZE 0x2000" -f target/stm32f1x_stlink.cfg -c "program <path_to_your_.elf-file> verify reset"
</pre>
där interface anger vilken programmerare du har, target säger vilken processor som ska programmeras (stm32f1x_stlink.cfg för STM32F1, stm32f4x_stlink.cfg för STM32F4 osv), och <path_to_your_.elf-file> pekar ut den .elf-fil som genereras när du kompilerar ditt program (borde ligga i release-mappen). Det är möjligt att man inte behöver sätta WORKAREASIZE längre efter att undertecknad (sternå) gnällde på det. Ifall den är för stor (i förhållande till RAM-storleken på din krets) så går det inte att programmera program som är för stora.

När du laddar över programmet bör det se ut någonting såhär:
<pre style="white-space:-moz-pre-wrap; white-space:-pre-wrap; white-space:-o-pre-wrap; white-space:pre-wrap; word-wrap:break-word;">
openocd -f interface/stlink-v2.cfg -c "set WORKAREASIZE 0x2000" -f target/stm32f1x_stlink.cfg -c "program /Users/Sterna/Dropbox/eclipse/ARM/IntroArm/Release/IntroARM.elf verify reset"
Open On-Chip Debugger 0.7.0-rc1 (2013-04-25-15:10)
Licensed under GNU GPL v2
For bug reports, read
	http://openocd.sourceforge.net/doc/doxygen/bugs.html
0x2000
Info : This adapter doesn't support configurable speed
Info : STLINK v2 JTAG v14 API v2 SWIM v0 VID 0x0483 PID 0x3748
Info : Target voltage: 2.893868
Info : stm32f1x.cpu: hardware has 6 breakpoints, 4 watchpoints
target state: halted
target halted due to debug-request, current mode: Thread 
xPSR: 0x01000000 pc: 0x080014b8 msp: 0x20001000
** Programming Started **
auto erase enabled
Info : device id = 0x10016420
Info : flash size = 128kbytes
Info : Padding image section 0 with 2404 bytes
wrote 8192 bytes from file /Users/Sterna/Dropbox/eclipse/ARM/IntroArm/Release/IntroARM.elf in 0.587122s (13.626 KiB/s)
** Programming Finished **
** Verify Started **
verified 5408 bytes in 0.123319s (42.826 KiB/s)
** Verified OK **
** Resetting Target **
shutdown command invoked
</pre>

Du kan även använda OpenOCD för att debugga din microcontroller också. Mer information om detta finns i [http://vedder.se/2012/12/debugging-the-stm32f4-using-openocd-gdb-and-eclipse/ benjamins guide]. Vidare kan du även programmera andra microcontrollers med OpenOCD och ST-LINK. Har du tur finns det inbyggt stöd, annars får du lägga in en egen .cfg-fil för det.

==Bootloader==
Detta metod används på [[introARM]]. Inbyggt i alla STM32-processorer finns en [http://www.st.com/st-web-ui/static/active/en/resource/technical/document/application_note/CD00167594.pdf bootloader] (ett litet program som tillåter att processorn programmerar in sitt program själv) som kan prata över en del olika kommunikationskanaler (t.ex. USB, UART eller CAN). Den processor som sitter på [[IntroARM]] stödjer endast UART. Detta kräver ett program på datorn samt en USB-UART-brygga (för det är väl ingen som fortfarande har serieport på datorn?). Ett exempel är en [http://www.silabs.com/products/interface/usbtouart/Pages/usb-to-uart-bridge.aspx CP2102 eller CP2104] som ingår i IntroARM men även finns att köpa på föreningen. 
Ett simpelt program som man kan använda är [[Stm32flash]]. Det ska fungera till alla OS, men har primärt testats på Linux och OSX. Vi använder en modifierad variant som tillåter styrning av flödeskontrollpinnarna.

=Debugga=
Det är sällan man skriver en kod som fungerar på direkten. Då är det oftast bättre att använda ett debugging-verktyg än att slumpmässigt börja ändra i sin kod.
För att fixa igång detta följer du [http://vedder.se/2012/12/debugging-the-stm32f4-using-openocd-gdb-and-eclipse/ Benjamin Vedders Guide].

=IDE är trevligt=
Man kan tröttna snabbt på att knacka ihop kod i en ordbehandlar, skriva make i terminalen för att sedan använda st-link eller boot-loader för att skicka över programmet. då kan man kolla på en Integrated Developement Environment, IDE.
[http://eclipse.org/ Eclipse] är en sådan IDE, den hjälper dig väldigt mycket när du skriver kod, och den kan även integrera kompilatorn, så att du trycker på en knapp i GUIn för att kompilera istället för att skriva make i en terminal. Till Eclipse finns även ett ARM-plugin som är rekommenderat.