1e Tussentijds Verslag, 5-12-'94

Structuur v/ computerprogramma's

Dennis

De artificieel levende robot,

in een gesimuleerde wereld.

Werner Van Belle

2e Kandidatuur Computerwetenschappen

e-mail : we47091@vub.ac.be

---

Wel er werd een tussentijds verslag gevraagd. Hier heb je er een. Persoonlijk vind ik het een moeilijk project, in die zin dat ik me de algoritmes niet onmiddellijk kan inbeelden. Vandaar dat ik denk dat deze tussentijdse evaluatie wel degelijk nuttig zal zijn. Onderstaande tekst is gewoon geschreven alsof ik de wijsheid in pacht heb. Dit is om lange tussenwerpselen zoals 'ik denk...', 'volgens mij'... te vermijden.

Het programma bestaat uit een aantal lagen.

User-interface : De user-interface zal zorgen dat het testen van het programma op een eenvoudige en doeltreffende wijze kan gebeuren. In feite is dit het meest eenvoudige aan dit programma. De userinterface beheert de robotten en de wereld waarin deze bewegen. Nochthans kan hij deze niet onmiddelijk veranderen, daarvoor zal hij alles moeten laten gebeuren door een 'programma'. (imperatief & functioneel geprogrammeerd)

Programma : Het ADT programma is diegene die de robotten zegt wat ze moeten doen. Het programma moet STAP per STAP kunnen uitgevoerd worden. (Zo heeft de user-interface toch nog wat in de pap te brokken). Een programma verandert niets rechtstreeks aan de wereld, noch aan de robotten. (message-passing) (samen met de user-interface : 5 uur)

Een error-message is een string die de 'error-text' bevat.

function(parameters)->result is de algemne vorm van de interface

self is de dispatch die wordt weergegeven

?? indien ik het zelf nog niet goed weet

Create-program()->self Maakt een leeg programma.

Execute-step(robot)->errormessage Voert de volgende stap uit op robot <robot>

Load(fromport)->self Laad een programma van input-file

Save(outport)->self Saved een programma naar outport

Print(printfunc)->self Print het programma in een leesbare vorm

User-input(??)->self Laat de gebruiker een programma invoeren

Robot : Een robot kent al zijn interne componenten. De robot, Dennis genaamd, zorgt dat de commando's die hem gegeven worden naar de juiste component worden doorgestuurd. (door hem een naam te geven denk je gemakkelijker 'message-passing-gericht). Dennis zal ook zorgen dat interne & externe conflicten niet kunnen voorkomen. Dit kan hij doen door aan de juiste component te vragen welk 'bewegingspad' dat component zou willen volgen. Dan controleert hij of dit bewegingspad iets anders kruist en besluit hij eventueel dit commando niet uit te voeren. (message-passing). De robot wordt bijgehouden als een tree, die als knopen componenten heeft. (5 uur)

Create-robot(unieke-name)->self Creëert een robot

Draw()->self Tekent de robot door de componenten te tekenen

User-input(??)->self Laat de gebruiker een robot invoeren

Command(bericht)->error-message De robot probeert commando <bericht> uit te voeren

Load, save & print

Componenten : Componenten zorgen ervoor dat de beperkingen die een component zijn opgelegd zonder meer worden uitgevoerd. Door het object-gericht te programmeren worden al de verschillen (die irritant zijn voor Dennis) in één klap opgelost. Elke component moet op zijn specifieke commando's kunnen reageren. Als resultaat wordt dan weergegeven of het commando MAG uitgevoerd worden. (Bijvoorbeeld : een scharnier mag geen hoek <10° toelaten). Als het commando mag uitgevoerd worden, wordt als resultaat het bewegingspad weergegeven. (zodat de Dennis kan controleren of er interne of externe snijdingen plaatsgrijpen). Om de component vlot te laten werken zal hij kennis bezitten over wie zijn vader is en wie hij als kind heeft. Voor de rest moet hij zichzelf kunnen tekenen op het scherm (door gebruik te maken van de nuggets).(20 uur)

Create-component(name, parent)->self Maakt een component met als vader <parent>

Draw()->self Tekent de component op het scherm.

Command(bericht)->graph-set Probeert de component te bewegen

Load, save & print

De nuggets : dit zijn de grafische basis-routines waarover het systeem beschikt. Bij deze valt of staat heel het systeem (lopen zal het wel nooit). Deze worden functioneel geprogrammeerd zodat er geen 'acces'-problemen zijn. De term 'grafische routines' is misschien ietwat misleidend. Zij zullen niet enkel gebruikt worden om iets af te drukken op het scherm, maar ook om lijnen te snijden. Om een circle met een lijn te snijden. Om te controleren of een punt in een gesloten verzameling valt enz... (30 uur)

Legende
og open of gesloten?
go grafisch object

Points
constructor Make-point
fields X, Y
methods Draw-point, Point?, Save-point, Load-point
intersect Intersect-p-p

Lines
constructor Make-line
fields From, To, X1, X2, Y1, Y2, fromc, toc, from-og, to-og
methods Save-line, load-line, Draw-Line, Line?
intersect Intersect-p-l, intersect-l-l

Circles
constructor Make-circle
fields from-angle, to-angle, from-of, to-og, radius, center
methods Circle?, Draw-circle, Save-Circle, Load-circle
intersect Intersect-p-c, intersect-l-c, intersect-c-c

Graph-set
constructor Make-graph-set,
methods foreach, delete, add, draw-set, save, load, print
intersect intersect-p-s, intersect-l-s, intersect-c-s, intersect-s-s, go-in-set?

Algemene ongetypeerde procs
Draw, Save, Load, Print, Intersect

World : De bedoeling van deze is bij te houden wat waar staat. Welke robots er in de wereld leven. Dit is voornamelijk bedoelt om rap op te zoeken of een beweginspad snijd met iets. Indien het snijdt moet ik als resultaat iets krijgen dat mij zegt welke robot en welke component.

Rationale getallen : Om exact te werken voer ik ze opnieuw eens in. De interne representatie zorgt dat de exactheid perfect is en dat er met oneindig gewerkt kan worden. (3 uur)

Even een run van het programma schetsen (nee het is geen filmscenario):

- User-interface zorgt dat de gebruiker 2 programma's laadt.

- De user-interface werkt deze twee programma's stap per stap af.

- Het Programma zorgt dat bij elke stap de robot wordt verplaatst, indien mogelijk.

- De robot probeert zichzelf te verplaatsen door aan de juiste component het juiste bericht te sturen

- De component geeft een bewegins-pad weer. (zie figuur)

- De robot controleert nu of dit sleeppad nergens tegenaan botst.

- Indien dit het geval is wordt er gewoon niets verplaatst. Indien dit niet het geval is wordt de robot verplaatst en wordt de wereld aangepast.

- Hop, controle weer naar de user-interface.