Halverwege Google Summer of Code

Door Sh4wn op maandag 18 juli 2011 21:40 - Reacties (6)
CategorieŽn: Elektronica, Linux, Programming, Views: 4.740

Het lijkt alweer een tijdje geleden dat ik een mailtje in mijn inbox zag waarin stond dat ik mee mocht doen met de Google Summer of Code, en nu zijn we alweer halverwege. In deze blog een verslag van de eerste helft :)

Het project

Ik studeer elektrotechniek, en heb vakken gehad als C, C++ en microcontroller (AVR) programmeren. Voor C en C++ gebruikte ik altijd de IDE Anjuta, op dit moment denk ik de beste IDE voor GNOME. Voor AVR development vond ik het toch makkelijker om de voorgeÔnstalleerde opstellingen op school te gebruiken, en dat moest op een Windows PC.

Atmel (de bedenker van de AVR microcontrollers) heeft een best aardige IDE voor AVR development. Helaas werkt die alleen op Windows, dus thuis heb ik daar weinig aan. Voor Linux heb je gelukkig wel een heleboel tools voor AVR development, maar niet allemaal mooi geÔntegreerd in 1 pakket.

Dus ik dacht, dat lijkt mij wel een mooi project om voor de Google Summer of Code te doen. Van te voren een beetje besproken met de Anjuta developers, mijn inzending voor de GSoC gefinetuned, en uiteindelijk ontving ik het mailtje met melding dat ik geaccepteerd was. :)

Ik ga dus voor GNOME deze zomer werken, iets specifieker de C/C++/Javascript/Python/Vala IDE genaamd Anjuta.
Wat ik nou precies ga doen
Je hebt voor Linux (en ook windows overigens) een port van GCC (de GNU C compiler) voor AVR. Anjuta moet dus de goede compiler aanroepen, als je op compile klikt. Ook wil je wat extra configuratie opties voor bijvoorbeeld het type AVR wat je hebt, en het is gebruikelijk om de CPU frequentie te definiŽren tijdens het compilen.

Er is ook een port van GDB (de GNU debugger) om AVR code te debuggen. Hiervoor heb je nog wel extra tools voor nodig, namelijk een koppeling tussen de AVR code en GDB zelf, want de code draait hoogstwaarschijnlijk niet op jouw PC zelf. Hiervoor kan je AVaRICE gebruiken, dat GDB commando's vertaalt naar JTAG commando's en dus zorgt dat jij op je chip kan debuggen via GDB.

Je hebt ook een open source AVR simulator genaamd simulavr, dat ook met GDB kan communiceren, en dan jouw AVR code uitvoert op een gesimuleerde AVR CPU.

AVaRICE en simulavr zijn voorbeelden van GDB servers, een GDB client stuurt de juiste commando's door die een gebruiker wilt. Een voorbeeld van een GDB client is het GDB terminal programma zelf en Anjuta is er ook een. Voordat we in Anjuta dus moeten debuggen, moeten we dus zorgen dat de GDB server beschikbaar is, en het ligt aan de gebruiker welke hij wil (simuleren of debuggen op de chip).

Ook wil ik een frontend maken voor avrdude, een tool voor het programmeren van je AVR (dat wil zeggen, de code echt op je AVR zetten). Een mooie interface met welke fusebits je wilt, etc. :)

De afgelopen weken

Goed, ik heb dus wel enig ervaring met C en C++, en heb ook veel Python en PHP gedaan. In C++, Python en zelfs ook in PHP heb ik wel eens met de grafische toolkit GTK+ gewerkt, maar nooit echt hele grote programma's geschreven, het is dus redelijk nieuw voor mij, vooral in C.

In het begin was het dus behoorlijk onderzoeken hoe Anjuta intern werkt, hoe het plugin systeem in elkaar zit, etc. Ook moest ik even wennen aan de manier van denken van C (Ook al probeert GTK+ een object oriented API te hebben in C, het is toch net anders denken dan echte object oriented talen).

Ik heb die eerste paar weken wel begin gemaakt met de project wizard, en ook een beetje gediscussieerd over hoe ik het beste avr-gcc en wat extra UI elementen daarvoor kon integreren.

Daarna begonnen mijn tentamens, dus een paar weken iets minder kunnen doen, wel een beetje door gediscussieerd over hoe we het allemaal een beetje gingen aanpakken.

Na de tentamens begon het echte programmeren, en om je een iets beter beeld te geven wat ik precies allemaal heb gedaan even een simpele uitleg hoe Anjuta een beetje in elkaar zit.

De 'Anjuta Shell' zoals ze het noemen, is zeg maar de core van Anjuta, eigenlijk niets meer dan een window met een menu en toolbar. Voor de rest wordt bijna alles gedaan met plugins. Zo is er een project manager plugin, een plugin die het compilen van een bestand/project regelt, een debugger plugin, version control en nog heeel veel meer. Al die plugin implementeren bepaalde interfaces die in de Anjuta core zijn gedefinieerd, zodat de core niet hoeft te weten welke plugin er is geladen voor een bepaalde taak.

Anjuta kan ook erg goed overweg met het GNU build system (bekend van ./configure en make install), en er is dus een plugin die zorgt dat als jij in een menu op 'Configure Project' klikt, er een dialoog komt met want configuratie mogelijkheden, en als jij op 'OK' klikt './configure' wordt aangeroepen met de juiste argumenten (die plugin doet nog een boel meer, dit is 1 voorbeeld).

Voor mijn AVR plugin die ik ga maken, heb ik ook besloten om het GNU build system te gebruiken als basis. Is waarschijnlijk nogal een overkill voor de meeste AVR projecten (zo groot zijn die programma's vaak niet), maar goed het kan ook weinig kwaad. :)

Het mooie is dat de plugin die zorgt dat './configure' wordt aangeroepen (hierna 'build plugin'), eerst zoekt naar andere plugins die de interface IAnjutaEnvironment implementeren, een interface bedoeld voor plugins die helpen met cross-compiling (iets wat ik dus ook aan het maken ben). Plugins die deze interface implementeren kunnen nog last minute iets aan het uiteindelijke './configure' command wijzigen (bijvoorbeeld extra argumenten, of compiler flags).

Ik heb de IAnjutaEnvironment interface en de build plugin een beetje aangepast, zodat het nu ook mogelijk is om wat UI elementen toe te voegen aan het 'Configure Project' schermpje. In mijn geval is het dus de bedoeling dat je daar je type microcontroller kan selecteren, en kan invoeren welke CPU frequentie je gebruikt.

Goed, mijn AVR plugin implementeerd dus ook de IAnjutaEnvironment interface zodat ik ook aan de hand van de UI die ik heb toegevoegd, het type microcontroller en de CPU frequentie aan de compiler kan doorgeven.

Na een './configure' komt een 'make', en dan wordt je programma gecompileerd, en kan je hem als het goed is op je AVR programmeren.

Tot slot

Ik vind het erg leuk om mee te doen aan een behoorlijk bekend project als GNOME, en ook leuk om eens een kijkje te hebben in de 'IDE technologie'. :P Het is ook erg fijn om je C skills een beetje op te schroeven want in de embedded wereld is dat nog altijd de standaard taal. En dan krijg je er ook nog een boel kennis bij over de GTK+ toolkit, en dat vind ik ook erg relaxt, want ik heb al een tijdje de neiging om iets meer betrokken te raken bij het GNOME project, en dit is wel een mooie mogelijkheid. :)

Volgende: Nieuwe website en admin panels 07-'12 Nieuwe website en admin panels
Volgende: Pylons > Django 10-'10 Pylons > Django

Reacties


Door Tweakers user CT, maandag 18 juli 2011 22:19

toen ik zelf een tijdje met avr's bezig was (atmel op de arduino) week je al snel van de arduino ide uit naar (in mijn geval als java'er) netbeans met c/c++ zodat je ook bijv. processing direct kon gebruiken etc. en uiteindelijk loop je tegen de limitaties van de arduino libs en ga je direct verder met de atmel libs maar dan merk je vooral op linux dat er nogal een gebrek is aan goeie ide's - ja genoeg highlight editors - maar dan mag je al je scripts nogsteeds zelf maken - dus ik ben zeker benieuwd naar het resultaat :) dan haal ik me strip atmels weer's uit de kast ;)

Door Tweakers user Sh4wn, maandag 18 juli 2011 22:31

@CT Deze makefile maakt het al een stuk makkelijker :)

Door Tweakers user -DarkShadow-, maandag 18 juli 2011 23:33

Wordt het ook mogelijk om te debuggen met de AVR Dragon en JTAG of DebugWire? AVR Studio 5 is een vervelend gedrocht, dus dit is goed werk! :) Waar studeer je?

[Reactie gewijzigd op maandag 18 juli 2011 23:36]


Door Tweakers user Steffannnn, dinsdag 19 juli 2011 01:17

-DarkShadow- schreef op maandag 18 juli 2011 @ 23:33:
Wordt het ook mogelijk om te debuggen met de AVR Dragon en JTAG of DebugWire? AVR Studio 5 is een vervelend gedrocht, dus dit is goed werk! :) Waar studeer je?
Daar is AVaRICE dus voor.

Trouwens, een simpele en tegelijk gevanceerde AVR simulator en alternatief voor simulavr is Simavr. Deze simulator is relatief nieuw, maar werkt goed.

[Reactie gewijzigd op dinsdag 19 juli 2011 01:20]


Door Tweakers user Sh4wn, dinsdag 19 juli 2011 14:54

Ik zit momenteel op de Haagse Hogeschool in Delft, vorig jaar beetje gefaald op de TU (iets met studentenvereniging enzo), goed volgend jaar al wel de schakelminor voor Embedded Systems, dus dan ben ik weer een halfjaartje op de TU. :)

@Steffan, die ziet er idd leuk uit, binnenkort eens proberen.

Door Tweakers user Skinkie, dinsdag 19 juli 2011 20:28

Afgelopen twee jaar mentor geweest. Vind het weer leuk om te lezen hoe sommige studenten wel vertellen waar ze aan bezig zijn, terwijl anderen alleen wat opleveren op het einde (of bij de midterm die net is geweest). Succes, klinkt als een leuk project!

Reageren is niet meer mogelijk