Jens Vandenreyt blogt

Meer bestuursmogelijkheden

2011-04-28T16:29:00.000+02:00

Omdat het onder de knie krijgen van het werken met mijn bachelorproef lang kan duren, heb ik een alternatief ingebouwd dat toelaat om makkelijker gebruik te kunnen maken van de EPOC headset.

Voorheen was er enkel de mogelijkheid om de Cognitiv Suite van Emotiv te gebruiken. Dit zorgde ervoor dat ik steeds véél moest oefenen of trainen met de applicatie en de EPOC op het hoofd vooraleer ik nog maar kon beginnen echt te testen. Dit leidde natuurlijk af en toe tot grote frustratie en werd na een tijdje erg vervelend en herhalend.

Onderaan kan er worden gekozen

In overleg met de begeleider heb ik dan deze week de mogelijkheid ingebouwd waardoor er kan gekozen worden tussen twee verschillende suites. Enerzijds blijft de Cognitiv Suite gewoon klaar voor gebruik. Hierbij worden dus enkel de hersenen gebruikt en moet je je dus concentreren op bepaalde gedachten. Anderzijds heb ik nu ook de Expressiv Suite ingebouwd. Door deze suite te gebruiken moet men niet steeds het moeilijke en verveelde trainingsproces doorlopen. De Expressiv Suite detecteert de (verandering in) gezichtsuitdrukkingen. Dit maakt het dus mogelijk door via simpele bewegingen in het gezicht (links of rechts 'lachen' met de mond en het opheffen of fronsen van de wenkbrauwen) de applicatie aan te sturen.

Of dit goed werkt blijft afwachten tot morgen. Dan ga ik op het EDM nog eens testen met de headset op het hoofd. Wanneer dit goed meevalt kan er ook eens rond gekeken worden voor andere testpersonen (hint C7 ;-) ) die dan de applicatie eens komen testen.

Voor de rest heb ik in het begin van de week ook de code voor het ontvangen van de UDP-pakketten doorgestuurd die momenteel in de revalidatie-applicatie wordt geïmplementeerd. Wanneer dit klaar is kan ik mijn applicatie eens gaan testen in samenwerking met de revalidatie-applicatie.

Pegs - het vervolg

2011-04-03T23:51:00.001+02:00

Op de vraag of Pegs nog een vervolg zou krijgen is het antwoord dus duidelijk ja geworden. Ik heb me vorige week eens bezig gehouden met het implementeren van meerdere levels in het spelletje. De nieuwe versie van spelletje, inclusief de 13 levels, kan hier gedownload worden. Ik zou het echter meer appreciëren als je Pegs download via onderstaande knop. Gewoon de zip uitpakken en Pegs.exe openen.

Het hele systeem achter de levels is echter nog niet zo geweldig gemaakt. In deze versie zijn de levels compleet hard-coded in het spel, wat het natuurlijk niet bepaald uitbreidbaar maakt. Wat ik misschien later - wederom als ik nog eens zin heb - kan doen is een file-handler maken die effectief levels kan inlezen, zodat ik niet de enige ben die effectief levels kan maken voor het spel.

Véél testen

2011-04-03T23:35:00.000+02:00

Nadat het toch weer voor een tijdje stil heeft gelegen, heb ik vrijdag nog eens even tijd tussen alle andere practica door gevonden om op het EDM te gaan werken aan mijn bachelorproef. Daar is het echter niet veel anders geworden dan testen, debuggen en tweaken. Een grote update zal je dus ook niet krijgen in deze post.

Ten eerste heb ik de code die ik heb geschreven om met threads te werken wat verbeterd en geoptimaliseerd. Het afsluiten van de thread heb ik bijvoorbeeld wat verschoond, zodat er nu niet op willekeurige momenten een crash kan optreden als ik mijn headset-listener of programma afsluit - wat overigens tot zéér vervelend dataverlies en het onvermijdelijke gevolg van opnieuw te moeten trainen leidt.

Verder heb ik het mogelijk gemaakt om nog een extra acties, neutraal denken (voor zover dat een acties kan worden genoemd), te trainen. De Emotiv engine vereist dat deze neutrale staat is getraind zodat hij ook kan bepalen wanneer je effectief niet de interface wilt aansturen.

Ten derde heb ik mijn cognitieve vaardigheden wat verder getraind en mijn profiel in de applicatie verder uitgebreid. Ik heb nu ook een kleine documentatie aan mezelf aangelegd zodat ik de volgende keer als ik ga trainen en testen rechtstreeks verder kan gaan met de acties die ik reeds had getraind.

Nadat ik het cognitieve denken terug een beetje onder de knie had ben ik begonnen met het effectief testen, hetgeen waarvoor ik in de eerste plaats ben gekomen. Zoals in een van mijn vorige posts ik al had gezegd heb ik in de applicatie Pegs (dat simpele spelletje...) een UDP-listener ingebouwd die kan luisteren naar iedereen en alles die iets heeft te zeggen, maar toch vooral naar mijn EmotivHandler. Door beide applicaties op te starten en de headset-listener te activeren, kon ik controleren of mijn project nu ook effectief al een praktisch nut begon te krijgen. Wat blijkt: het werkte! En goed zelfs! Nooit verwacht eigenlijk, wel op gehoopt. Het enige probleem was dat ik soms - redelijk veel nog - dacht: "Ga naar rechts!", wat hij dan natuurlijk niet deed... Dit lag gelukkig niet aan mijn code, want in de logs kan je perfect zien wat je ook effectief denkt. Het lag dus eerder aan mijn kunde. Conclusie: Ik heb dus nog veel trainingswerk voor de boeg.

Het trainen op 4 verschillende acties plus een neutrale staat is overigens absoluut niet simpel. Na wat research weet je ook waarom... Een actie plus het neutrale (welke ik nu niet meer steeds opnieuw ga vermelden) is een simpele opdracht. De engine kan dan makkelijk het verschil merken tussen "ik denk niks of toch niks specifiek" en "ik denk aan iets of ik doe alleszins moeite om niet aan niks te denken". Wanneer je er dan een tweede actie bijneemt, ga je merken dat je gedachten al minder goed worden gehoorzaamd en opgevolgd door een actie. Je kan je ondertussen waarschijnlijk wel al inbeelden wat voor effect dit heeft als je opgezadeld zit met vier acties.

Het grote probleem hierbij is dat de engine het moeilijker heeft om je gedachten te onderscheiden van elkaar omdat een groot deel van de gedachten elkaar overlappen. Als dit zo is heeft dat meestal één grote reden: je doet het niet goed... Dit komt meestal omdat je in de eerste plaats - als nieuweling dus - vanzelfsprekend het volgende denkt: "een cognitieve gedachte kan ik het makkelijkst oproepen door me een beeld voor de geest te halen." Dit is echter niet waar. Het tegendeel zelfs. Denken aan beelden heeft helemaal geen effect. Wat voor mij min of meer werkt is het proberen te verleggen van je bewustzijn. Om naar beneden te gaan kan je bijvoorbeeld proberen heel aandachtig je bewustzijn in je tenen te stoppen. Het zelfs zo doen dat je echt de minste aanraking of bewegen of weet ik veel wat waarneemt. De instructies waar ik het juist over had zijn voor mij de volgende:

Links:  denk aan en concentreer op linkerhand
Rechts: denk aan en concentreer op rechterhand 
        (over textuur van tafel wrijven)
Omlaag: denk aan en concentreer HARD op de tenen
Omhoog: denk aan omhoog en aan de neus

Het leuke aan vrijdag was dus dat ik effectief een spelletje - dat ik dan ook nog eens zelf had gemaakt, wat het nog leuker maakt - met mijn hersenen heb bediend, zonder dat ik aan mijn toetsenbord of muis moest komen. Ik zal proberen de volgende keer een filmpje ervan te maken en dat erbij te posten.

Milestone 2

2011-03-20T22:44:00.000+01:00

Als methode om met de externe (EDM-)applicatie te communiceren had ik tot aan mijn vorige post nog niet beslist - en volledig onderzocht - wat ik ging gebruiken. Zoals gezegd heb ik wat opgezocht en gelezen en dit is het resultaat:

Berichten naar het venster met focus
Een van de manieren om de ene applicatie iets te laten weten vanuit een andere applicatie is gebruik maken van de ingebouwde functies van Windows om berichten te sturen. Deze berichten zijn meestal venster-gerelateerde acties - zoals minimaliseren of sluiten - maar kunnen ook acties zijn zoals het zenden van een toetsaanslag (keystrokes). Hoewel de msdn van Microsoft altijd wel uitgebreid is, is de documentatie over dit deel van de functies zeer beperkt. Artikels over het topic zijn maar zeer schaars en als je dan ook nog eens moet gaan snoeien in de resultaten omdat de meeste artikels voor C# of .NET zijn, schiet er bijna niets meer over. Het gebruik van de *Message-functie is daarbij ook nog eens tegen intuïtief.
Berichten via een socket
Het andere alternatief is het gebruiken van een socket om berichten van de ene applicatie (poort eigenlijk) naar de andere te krijgen. Hiervoor opteer ik om een UDP-socket te gebruiken. De keuze voor UDP valt te verantwoorden door het feit dat de communicatie snel moet gaan. Dit kan het beste met UDP waarbij er niet zoveel tijd verloren gaat aan het garanderen van de betrouwbaarheid. Dat laatste is overigens niet nodig aangezien er op de lijn tussen IP 127.0.0.1 en 127.0.0.1 nu niet zo veel kan gebeuren ;-).

Na wat testen wat het makkelijkste was voor mij en een mailtje te sturen met de vraag welk van de twee alternatieven ze het liefst op het EDM zullen implementeren is de knoop doorgehakt en is het het UPD alternatief geworden. Met een half uurtje programmeren en wat testen is dit uiteindelijk klaar geraakt.

Het testen van de besturing van een applicatie via de socket heb ik gedaan met het spelletje Pegs waarover ik het in mijn vorige post had. Door daarin met een QUdpSocket te werken was het zelfs niet nodig om een extra listener-thread aan te maken. Via de simpele signal-slot-constructie van Qt heb ik een slot gemaakt dat de informatie die werd verstuurd over de socket ontvangt en analyseert en daarna de juiste toetsaanslag simuleert. Hierdoor was het zeer simpel om de socket te koppelen aan de uiteindelijke acties van het spel.

Door beide applicaties op te starten en de Emotiv Handler te verbinden met de EmoComposer kon ik de hersenactiviteit simuleren en op die manier zien dat het - tot nu toe - allemaal feiloos werkt. :-) Eens kijken hoe dit gaat wanneer ik nog eens ga testen met de EPOC headset op mijn hoofd.

Pegs - het meest simpele spel

2011-03-17T22:22:00.001+01:00

Tijdens het studeren voor een fysica examen wat waarschijnlijk toch niet zo goed gaat geweest zijn, is de nodige ontspanning zeker niet te vergeten. En wat gaat er (tijdens het werken met een grafisch rekentoestel) boven het spelen van spelletjes op dat rekentoestel? Niets... (anti-climax eh?;-))

Zo is het dan ook gekomen dat ik een spelletje (Pegs) dat ik 5 jaar geleden - jawel, in het 5de middelbaar - op mijn rekentoestel had gezet nu terug heb gevonden en opnieuw heb uitgespeeld. Ik vond het zelfs zo leuk dat ik dacht: "hoe moeilijk kan het zijn om dit spel zelf te maken?" Ik met mijn idiote ideeën altijd ben dus de dag voor het examen, 's avond in de zetel, begonnen met het programmeren aan een kleine Qt-applicatie.

Test scene

Na een paar regels code en wat prullen in Qt-creator kwam de basis interface er al uit en een uurtje later was het spelletje een feit. De bedoeling van het spel is dat je alle beweegbare blokken (buiten de 'cursor') wegwerkt. Dit kan door blokken van hetzelfde type tegen elkaar te duwen zodat ze verdwijnen of transformeren tot een vaste onbeweegbare blok. De transformatie regels zijn als volgt:

Driehoek + driehoek = vaste blok,
Cirkel + cirkel = verdwijnen,
Wit vierkant + wit vierkant = verdwijnen,
Plus + plus geeft een nieuwe blok waarvan je het type kan kiezen,
Zwart vierkant + wit vierkant = verdwijnen,
Zwart vierkant + eender welk ander type = zwart vierkant

De bijgevoegde afbeelding is een test scene waarbij ik alle soorten blokken heb geplaatst in de scene. Omdat ik geen zin meer had heb ik echter nooit de moeite gedaan om echte scene's voor het spel te maken waardoor dit project eigenlijk niet meer is dan een hoopje mogelijkheden om jezelf en de verschillende blokken door de scene te verplaatsen en te transformeren. Misschien dat het project nog een vervolg krijgt, wie weet krijg ik daar wel nog eens zin in. Dat blijft echter de grote vraag nu...

Eerste EPOC ervaring

2011-03-01T15:33:00.000+01:00

Zoals reeds gezegd had ik woensdag een afspraak op het EDM om mijn applicatie te testen met de EPOC headset. Na het installeren van mijn laptop en het aansluiten van de EPOC begon ik met de lastige taak van het op mijn hoofd zetten van de headset. Hier alleen al ben je - in het begin, na verloop van tijd werd het makkelijker - een half uur aan kwijt, en dat allemaal te danken aan mijn toch nog niet zó gigantisch duivennest als haardos hierboven... Maar goed, eens alles klaar kon ik beginnen met testen.

Ik ben begonnen met het zoeken naar een alternatieve methode om te verbinden met de EmoEngine, aangezien het rechtstreeks verbinden om de een of andere reden - qua code is het min of meer dezelfde opbouw als in de voorbeelden waarin het overigens wel werkt - niet werkt. Nu goed, na wat prullen en zoeken kwam ik erop uit dat via het Control Panel van Emotiv zelf ik wel een connectie kon leggen met de engine. Op die manier was ik vertrokken!

Het Emotiv blokje

Nu dat connectie maken lukt, begon ik aan de training in het Control Panel (CP) van Emotiv. Dit had dus even niks meer te maken met mijn eigen applicatie. In dat Control Panel zit er bij de Cognitiv suite een trainingsprogramma waarbij je met je gedachte een blokje dat zweeft moet proberen te manipuleren. Deze manipulaties zijn de standaard acties die kunnen worden geïmplementeerd. Ik ben dus direct aan het trainen geslagen voor zo snel mogelijk wat resultaat te hebben. De eerste actie die ik trainde was (neutraal en daarna pas) bewegen naar links. Na een of twee keer de trainingssessie van 10 seconden te volgen ging dat redelijk vlot.

Vervolgens pak je daar na een paar sessies telkens een nieuwe actie bij. Iedere keer dat je er een nieuwe actie bij neemt, merk je dat het uitvoeren van de andere acties ook beduidend moeilijker wordt. Na wat meer lezen heb ik gevonden dat dit komt omdat een ongeoefend EPOC-gebruiker nog teveel dubbelzinnige signalen uitzendt wanneer er wordt getraind. Op die manier hebben meerdere acties bepaalde delen van signalen die overlappen en weet de Engine soms niet meer wat te doen.

Na uiteindelijk bijna een uur bezig te zijn met dat trainen en een beetje ervaring op te doen met zo een EEG headset - uiteindelijk ben ik nog steeds de grootste n00b die er bestaat hierin - kon ik beginnen met het toepassen van het gebruik van de EPOC op mijn eigen tot nu toe gemaakte applicatie. Ik was zo slim geweest om bij het trainen van de acties met het blokje, de acties te nemen die overeenstemmen met de acties die ik gebruik in de EmotivHandler. Op die manier moest ik maar gewoon mijn applicatie openen en terug sluiten om al mijn data die ik net had getraind op te slaan in een eigen profiel in het formaat dat de applicatie verstaat.

Al snel kwam het eerste probleem aan het licht. Nee, eigenlijk niet het eerste... Het eerste probleem was dat wanneer je die EPOC al een uur op je hoofd hebt, je serieus hoofdpijn begint te krijgen. Dat ding spant langs alle kanten en duwt blijkbaar op gevoelige plaatsen op het hoofd. Met andere woorden: memo aan mezelf. Neem de volgende keer een pijnstiller mee... Terug serieus, het eerste (tweede dus ;-) ) probleem dat ik tegenkwam was dat wanneer ik mooi getraind had en ik eens wou gaan testen of mijn applicatie mooi reageerde op de input die hij kreeg vanuit mijn hersenen, de Emotivhandler bijna overspoeld werd door de signalen die hij - laten we aannemen dat de applicatie mannelijk is - binnen kreeg. Dat deed al snel een belletje rinkelen dat er een dubbele filter op de input - voor de EPOC is dit de output - signalen moest komen. Enerzijds heb ik toen een filter gemaakt die ervoor zorgt dat enkel de signalen met een sterke boven 40% worden geïnterpreteerd. Anderzijds heb ik die filter dan nog eens uitgebreid zodat enkel om de volledige seconde een signaal van het zelfde type kan worden uitgevoerd.

Op het einde van de dag is het resultaat toch al niet niks, vind ik zelf. Wat mijn EmotivHandler nu kan is het volgende:

Verbinden met de EmoEngine, weliswaar via het Control Panel,
Profiel inlezen en opslaan,
Acties trainen en wissen (neutraal trainen moet ik nog een knopje voor maken),
Headset listener aan- en uitschakelen,
Signalen filteren en de daaruit volgende acties aanroepen (deze acties hebben nog geen gevolg).

De volgende vraag diende zich nu op: Hoe moeten deze acties worden afgehandeld? Via een socket? Via signalen naar het venster met focus? Zelf de interface implementeren (zal wel...)? Kortom, vooraleer de volgende grote milestone er komt moet er nog wel wat worden opgezocht en gelezen...

De groeten en tot de volgende!

Milestone 1: check!

2011-02-21T21:48:00.000+01:00

Mijn doel voor het einde van de week was het volgende: heb een volledig werkende applicatie. Dat is natuurlijk niet gelukt. Het maken van een applicatie met een kleine interface met de benodigde functionaliteit was een meer realistisch doel. Dat is dus ook wat ik heb gedaan.

Na het onder de knie krijgen van de API ben ik rechtstreeks in gang geschoten met coderen. Hierbij ben ik begonnen met in Qt een kleine interface te maken zodat ik een houvast had om rond te kunnen werken. Deze 'houvast-interface', het mainwindow, is niet meer dan een menubalk, een log-venstertje en een knop om het luisteren en verzenden naar de EPOC aan en uit te zetten. Het grootste deel van de acties van de applicatie vertrekt dus hier en de feedback daarop wordt ook zichtbaar gemaakt in dit venster. De 'Enable headset'- of 'Disable headset'-knop doet eigenlijk niet veel meer dan een extra thread opstarten of afsluiten die een while-loopje heeft om events op te vangen.

Dialoog: Connect to

Om de applicatie te laten communiceren met de EmoEngine, moet er natuurlijk eerst een connectie worden opgezet. Om zo een connectie op te zetten moet er in het menu - niet verschieten - op 'Connect' worden geklikt. Hetgeen wat er dan opent is een simpel en klein dialoogvenstertje dat de keuze biedt om te verbinden met enerzijds de EmoEngine direct of anderzijds via de EmoComposer of het Emotiv Control Panel met de EmoEngine.

Eens de verbinding tot stand is gebracht is het verstandig om te beginnen met een training van de acties. Dit kan worden gedaan in het dialoogvenster 'Training'. Om een training voor een bepaalde actie te starten wordt er simpelweg op de gewenste actie en vervolgens op de knop 'Start training' geklikt. Op het moment dat de training start kan er voor tien seconden lang niet anders worden gedaan dan de training en op het einde van die training wordt er nog eens voor een bevestiging gevraagd.

Wanneer de acties zijn getraind, kan men beginnen met het uitdenken en verzenden van acties. Door in het hoofdvenster simpelweg op 'Enable headset' te klikken, wordt het hierboven reeds uitgelegde thread opgestart. Wanneer er dan aan een van de acties wordt gedacht, zal in het logvenster hiervan de juiste feedback en sterkte van de gedachte worden gegeven.

Allemaal goed en wel, alle code tot nu toe is helemaal thuis geschreven. Het nadeel aan thuis werken wanneer er extra - relatief dure - hardware nodig is, is dat je die niet hebt. Met het testen heb ik het volledig moeten doen met de EmoComposer. Die bijgeleverde applicatie is een simulator voor het zenden van brainwaves. Dit allemaal verloopt in theorie wel vlotjes, maar in samenwerking met de nieuwe applicatie verloopt dit toch maar wat houterig. Zo zendt de EmoComposer steeds op eenzelfde frequentie (vb. f = 4 Hz) uit met sterktes die maar variëren tot in de honderdsten. Een echt probleem vormt dit niet, maar the real thing is natuurlijk leuker! The real thing zal dan ook voor woensdag zijn, wanneer ik het ga testen op het EDM met de EPOC op mijn hoofd!

Emotiv Development Kit

2011-02-19T00:00:00.000+01:00

Na het installeren van de SDK van Emotiv - genaamde EDK -, het verkennen van de magere documentatie en het bekijken van de voorbeelden ben ik begonnen met een ontwerp te maken voor de basisgedachte van de applicatie en de werking ervan.

De hele API van Emotiv werkt met drie zo genaamde suites, de Expressiv, de Affectiv en de Cognitiv suite. De Expressiv suite gebruikt de hersengolven die instaan voor het creëren van de spiersamentrekkingen om gezichtsuitdrukkingen te maken. De Affectiv suite focust zich op de gemoedstoestand van de gebruiker en de Cognitiv suite, de suite die ik zal gaan gebruiken, werkt met het reproduceren van bepaalde gedachten.

Waar de twee eerste suites elk kunnen werken zonder enige training of configuratie, moet er voor de Cognitiv suite een profiel worden bijgehouden. In zo een profiel worden bepaalde gedachten gekoppeld aan het uitsturen van bepaalde 'signalen'. Aan zo een signaal kan de ontwikkelaar dan bepaalde acties koppelen die kunnen worden gereproduceerd door diezelfde gedachte terug op te halen.

De idee achter de applicatie is een tussenliggende applicatie die alle in- en output van de EmoEngine afhandelt. Het gedeelte waarbij de EmotivHandler communiceert met de EmoEngine, en dus ook met de EPOC headset, is allemaal redelijk voor de hand liggend met een extra thread die steeds staat te luisteren. Het tweede gedeelte van de applicatie, de koppeling met de reeds ontwikkelde hoofdapplicatie kan op meerdere manieren gebeuren:

Via een socket kan de EmotivHandler communiceren met de revalidatie-applicatie en zo zijn ding doen daar. Het voordeel aan deze benadering is dat ze rechtstreeks is en speciaal toegespitst is op de hoofdapplicatie. Dit voordeel is eveneens het nadeel ervan. Omdat ze zo een specifiek doel heeft, kan zo alleen maar gebruikt worden voor dat doel.
Via signalen naar het venster met focus kan de EmotivHandler niet alleen de navigatie in de doelapplicatie verzorgen maar ook die van andere vensters. Op die manier is het domein waarin de applicatie kan worden gebruikt niet zo eng.

Welke keuze ik ga maken weet ik nog niet. Dat hangt af van nog wat opzoekingswerk dat gaat volgen.

Let my brain show you how

2011-02-17T10:35:00.000+01:00

Na een tijdje lezen en denken over een naam voor mijn bachelorproef, is het EmotivHandler geworden. Dit project wordt uiteindelijk een applicatie die via een API hersengolven om kan zetten naar acties in een bepaalde applicatie. Deze API is geschreven door Emotiv en gebruikt de Emotiv EPOC headset om alles op te vangen.

Emotiv EPOC

Het doel van het project is zo een applicatie te schrijven die met behulp van de EPOC headset het mogelijk maakt om door een grafische menu te navigeren, zonder daarvoor enig gebruik te maken van de spieren. Deze grafische menu is deel van een revalidatie-applicatie ontwikkeld door het EDM voor MS en CVA patiënten. Bij deze revalidatie geraken de patiënten al snel fysiek vermoeid. Om het dan eenvoudiger te maken om te selecteren welke training men wilt uitvoeren, is het nodig om een alternatieve methode van navigatie aan te bieden die de fysieke vermoeidheid van de patiënt niet verder verhoogt.

In het vervolg zullen hier updates worden bij gehouden omtrent de verdere ontwikkeling van het project.

myCMS CMS Framework

2011-01-23T15:36:00.001+01:00

Om me tussenin het leren wat bezig te houden ben ik begonnen met een Content Management System Framework te bouwen in PHP. Dit framework ben ik aan het maken in combinatie met de Smarty Template Parser.

Waar het bouwen van een website van begin tot einde toch elke weken tot maanden kan duren, gaat het bouwen van websites met myCMS zich beperken tot wat configuratiewerk en het ontwerpen van een tempate. Op deze manier bespaar ik serieus wat tijd uit.

Een opsomming van de huidige mogelijkheden van het systeem:

Paginabeheer
Het aanmaken, bewerken en verwijderen van pagina's die al dan niet in een menu worden geplaatst. In het control panel kunnen aan deze pagina's zoveel verschillende modules worden toegevoegd als gewenst.

Modules
De modules die op pagina's worden geplaatst kunnen worden beheerd met een simpele moderatie-pagina. De verschillende soorten modules die momenteel klaar voor gebruik zijn zijn Catalogus, Contactformulier, Gastenboek, Google Maps, Nieuws, Stemming en Tekst.

Gebruikers-, groepen- en rechtenbeheer
Het is mogelijk om gebruikers aan te maken, groepen aan te maken en hierin gebruikers te steken en groepen bepaalde zie-, lees- of moderatierechten te geven. Groepen kunnen ook administratierechten krijgen.

Configuratie
Het control panel voorziet een simpel formulier waarin standaardwaarden van de globale website kunnen worden aangepast. Deze waarden gaan het die website-titel tot het aantal posts per pagina.

Prullenbak
Verwijderde modules en pagina's worden natuurlijk niet direct definitief verwijderd. Ze belanden eerst in een soort van prullenbak waar ze op een later tijdstip terug kunnen worden uitgevist. Ongelukje kunnen altijd gebeuren!

IRClient

2010-11-05T20:43:00.000+01:00

Als een opdracht voor het vak Computernetwerken op school moeten we een IRC-client schrijven die volledig aan het standaard IRC-protocol (RFC1459) moet voldoen. Ik ben deze applicatie aan het schrijven in C++ en gebruik als extra toolkit Qt voor de GUI.

Voor het moment zijn de volgende items al functioneel:

Verbinden met een server,
Het maken, ingaan en verlaten van kanalen (channels),
Basis administratie- en moderatiefunctionaliteiten en
De hulp-module.

Dit project is nog niet voltooid. Wanneer het klaar is zal de client ook bestanden moeten kunnen verzenden via het peer-to-peer DCC protocol.

Eerste post

2010-11-04T19:48:00.000+01:00

Welkom op mijn blog!

Zoals je kan zien ben ik vandaag begonnen met bloggen, waar toe ik trouwens compleet nieuw ben. Op mijn blog ga ik proberen alle projecten die ik maak of moet maken bij te houden. Van deze projecten geef ik dan een kleine voorstelling of wat specificaties.