DES WPU-KURSES Scribus - Wernher von Braun Schule

PROJEKTABSCHLUSSBERICHT 

DES WPU-KURSES 

„ROBOTER PLANEN, KONSTRUIEREN UND PROGRAMMIEREN“ 

an der Wernher-von-Braun-Schule (Neuhof) 

Scribus 

Team 7 

Neuhof, 13.06.2009

1 INHALTSVERZEICHNIS 

1 INHALTSVERZEICHNIS .......................................................................................................... 1 

2 DAS TEAM ............................................................................................................................... 2 

3 EINLEITUNG ............................................................................................................................ 3 

4 PROJEKTPLANUNG ............................................................................................................... 3 

5 PROJEKTABLAUF .................................................................................................................. 4 

6 PROJEKTERGEBNIS ............................................................................................................ 10 

7 REFLEXION ........................................................................................................................... 12 

8 AUSBLICK ............................................................................................................................. 14 

9 BEWERTUNG DER PROJEKTARBEIT ................................................................................ 14 

10 BILDER ............................................................................................................................... 15 

11 QUELLENVERZEICHNIS .................................................................................................... 18 

12 ENTLASTUNG DES PROJEKTTEAMS .............................................................................. 19 

13 ANHÄNGE ........................................................................................................................... 20 

Seite 1 von 19

Wernher-von-Braun-Schule (Neuhof) Roboter-Projekt 2008/09 (Team 7) 

2 DAS TEAM 

Benjamin Hosenfeld 

Benjamin ist 16 Jahre alt und nun seit drei Jahren in der Robotik aktiv. Er hat 

bei diesem Projekt die Gruppenleitung übernommen und organisiert die Arbeit 

in unserer Gruppe. Neben seinen Leitungsaufgaben unterstützt er Marc Leinweber 

bei der Programmierung und bei der Planung des Programmaufbaus. 

Außerdem hat er den Bau des Roboters zusammen mit Marius Ruppel übernommen. 

Marc Leinweber 

Marc Leinweber ist 16 Jahre alt und wie Benjamin Hosenfeld seit drei Jahren 

im Bereich der Robotik tätig. In Gruppe 7 ist er hauptsächlich für die Programmierung 

verantwortlich. Der größte Schwerpunkt lag im Programm der 

interaktiven Bildschirmeingabe. Außerdem war Marc ursprünglich noch für die 

Stundenprotokolle eingeteilt. Dieser Job wurde jedoch im Laufe des Halbjahres 

von den anderen Gruppenmitgliedern übernommen, da Marc sich vier 

Wochen in Amerika befand. 

Marius Ruppel 

Marius Ruppel ist 17 Jahre alt und seit 2 Jahren in unserem Roboterteam. Bei 

dieser Projektarbeit hat er verschiedene Aufgaben übernommen. Er hat in der 

visuellen Protokollierung, dem Bau und der Protokollierung mitgewirkt. Wo Not 

am Mann war, hat die Gruppe unterstützt. 

Patrick Kimpel 

Patrick Kimpel ist 16 Jahre alt und seit der achten Klasse in der Roboterarbeit 

tätig. Seine aktuelle Aufgabe liegt in der Anfertigung einer visuellen Bauanleitung 

unseres Roboters. Zwischenzeitlich hat er auch in anderen Aufgabengebieten 

mitgewirkt. So hat er zum Beispiel Marc und Benjamin bei der Programmierung 

oder auch andere Gruppen mit seinem Wissen unterstützt. 



3 EINLEITUNG 

Unser Roboterteam hat sich dafür entschieden, einen Roboter zu konstruieren, der schreiben kann. Wir haben 

uns dafür entschieden, weil wir schon viele fahrende Roboter gebaut und programmiert hatten und ein neues 

Gebiet der Robotik für uns erschließen wollten. 

Zu Beginn des Projektes hatten wir schon einige Erfahrung im Themenbereich der Robotik, haben jedoch 

durch unser Projekt neue Wege der Programmierung kennen gelernt. Das Projekt gab uns die Möglichkeit, mit 

Programmdatenbanken zu arbeiten. Des Weiteren haben wir die Variablenstruktur „array“ kennen gelernt. Die 

Informationen haben wir aus verschieden Guides und Foren gewonnen (http://mindstorms-forum.de, 

http://nxtasy.org, NXC Guide von John Hansen und ein Guide von Daniele Benedettelli). Außerdem konnte 

uns Herr Dietrich durch seine Programmierkenntnisse tatkräftig zur Seite stehen. 

Unser Maximalziel war neben der Darstellung von Buchstaben nach einer Bildschimeingabe die Umsetzung 

komplexer mathematischer Funktionen in graphischer Form. Dies beinhaltet lineare und quadratische Funktionen. 

Die Zielsetzung wurde vom Auftraggeber so übernommen. 

4 PROJEKTPLANUNG 

Die Planung unseres Projektes teilte sich in folgende Schritte: Erstellung 

• eines Projektauftrags (genaue Zielsetzung), 

• einer Umfeldanalyse (Sammeln von Informationen über ähnliche Projekte und die Umsetzung unseres 

Projektes), 

• eines Projektstrukturplanes (schematische Darstellung aller zu beachtenden Dinge in logischer Reihenfolge 

geteilt in Planungs- und Realisierungsphase), 

• eines Projektablaufplanes (zeitliche Planung des Projektes) 

• und eines Aktionsplan (vorher geplante Aktionen werden einem Gruppenmitglied zugewiesen). 

In unserer Gruppe waren Benjamin Hosenfeld, Marc Leinweber, Patrick Kimpel und Marius Ruppel aktiv. Benjamin 

Hosenfeld übernahm die Gruppenleitung. Er hat bei der Programmierung und bei der Konstruktion mitgewirkt. 

Marc Leinweber war für die Erstellung des Programms und der Berichte zuständig. Er übernahm hierbei 

den Hauptteil. Marius Ruppel konstruierte unseren Roboter. Er sammelte Informationen über eine mögliche 

Konstruktion. Des Weiteren half er dort, wo er gebraucht wurde. Patrick Kimpel erstellte mit dem Programm 

„MLCad“ eine visuelle Baueinleitung unseres Roboters. Außerdem war Frau Jungk in unserer Projektgruppe. 

Sie übernahm zusammen mit Marc den Hauptteil der Programmierung. Leider war sie im zweiten 

Halbjahr aufgrund ihres Examens vermehrt nicht anwesend. 

Als externer Beteiligter wirkten Herr Dietrich und Herr Müller mit. Herr Müller lieferte uns Papier zum Beschreiben, 

Herr Dietrich unterstützte uns bei Programmierfragen. 



Unsere Zwischenziele als Hinführung zum Endziel: 

• gerade Linie zeichnen 

• 90° Winkel zeichnen 

• Rechteck zeichnen 

• Quadrat zeichnen 

• Schräge zeichnen 

• Stern zeichnen 

• Schreiben 

• Komplexe mathematische Funktionen umsetzen 

Zur Programmierung benutzten wir die Programmentwicklungsumgebung „BrixCC Command Center“. Diese 

unterstützt die Programmiersprache „Not eXactly C“ (NXC). Bei der Erstellung unserer Protokolle, Berichte 

und Planungsdokumente nutzten wir verschiedene Officeprodukte, wie zum Beispiel Microsoft Word. 

5 PROJEKTABLAUF 

01.12.2008 Da wir in der letzten Novemberwoche das Heron-Verfahren, ein Näherungsverfahren zum 

Ziehen einer Quadratwurzel, auf dem Fuldaer Medientag vorgeführt und somit beendet hatten, 

suchten wir uns ein neues Projekt. Im Internet hatten wir während unserer Arbeit schon 

oft von sog. 'Plottern' gelesen und uns diverse Videos auf 'Youtube.com' angeschaut. Unser 

Interesse daran war geweckt und so beschlossen wir, dies umzusetzen. 

Auf der Seite http://www.norgesgade14.dk/ fanden wir eine brauchbare Anleitung und Projektvorstellung. 

Somit beschlossen wir, diesen Roboter ungefähr nachzubauen, um einen 

Einstieg in das Ganze zu bekommen. Bis zum Ende der Stunde bauten wir den ersten Teil 

des Plotters. 

02.12.2008 In dieser Doppelstunde hatten wir zu Beginn mit Fr. Jungk und Hr. Dietrich unser Konzept 

besprochen und 'verabschiedet'. Es war beschlossene Sache, dass wir von nun an einen 

Plotter bauen, den wir zum Ende hin immer komplexer gestalten wollten. Es war daran gedacht, 

zwischendurch mathematische Algorithmen als auch Darstellungen von quadratischen 

oder auch Sinus- und Kosinusfunktionen auszuprobieren. Nach diesem einführenden Gespräch 

begannen wir wiederum am Plotter zu bauen. 

04.12.2008 - Entfiel wegen SV-Stunde - 

08.12.2008 Noch während der Mittagspause begannen wir mit einem Brainstorming, indem wir die Blattgröße 

beschlossen und über die genauere Umsetzung sprachen. Während der Doppelstunde 

hatten wir unsere neuen Ideen gleich umgesetzt, was bedeutete, dass wir unsere erste Konstruktion 

wieder abbauten und das Ganze auf das kleinere Format „A5“ umbauten. Zuerst hatten 

wir als Blattgröße A4 im Sinn, jedoch stellten unsere beiden Baukästen nicht genug Teile 

bereit. Zum Ende der Stunde hatten wir unseren Stifthalter zu Ende gebaut und die ersten 

Einträge in diesem Blog erstellt. 

09.12.2008 In dieser Stunde hatten wir intensiv an unserem Roboter gebaut. Des Weiteren wurde uns ein 

Zugang und ein Bereich auf der Schulhomepage http://www.wvbneuhof.de zur Verfügung 

gestellt. 

11.12.2008 In dieser Stunde stellte sich uns ein Problem. In der letzten Stunde wurde unser Roboter so- 



weit fertig gestellt, dass das Fahrgestell, die Schienen, der Stifthalter und das Stiftfahrgestell 

fertig waren. Für die Fahrschienen wurden zwei Motoren benötigt. Dadurch waren aber alle 

Motorenports belegt, da wir bereits einen Motor zum Bewegen des Schlittens und einen zum 

Heben und Senken des Stiftes benötigten. Wir suchten nach einer Lösung mit dem Ziel, den 

Stifthalter mit einem zweiten Brick zu steuern. Dafür würden wir die Bluetooth-Kommunikation 

benötigen. 

Nachdem wir diese Entscheidung gefällt hatten, befestigten wir unsere Fahrschiene, damit 

das Fahrgestell nicht aus der Spur springt. 

15.12.2008 In dieser Stunde lernten wir die Bluetooth-Kommunikation zwischen zwei Robotern kennen. 

Hierbei stießen wir auf leichte Verständnisschwierigkeiten, konnten sie aber durch "Learning 

by doing" schnell aus dem Weg räumen. Nachdem wir das Grundprinzip verstanden hatten, 

führten wir die ersten Tests durch. Der Pumpbrick sollte mit dem Brick, der das Gestell 

steuert, angesteuert werden. Dieser ist dafür da, den Stift auf Befehl zu heben und zu senken. 

16.12.2008 Im ersten Teil der Doppelstunde schrieben wir die Lernkontrolle für das erste Halbjahr. 

Im zweiten Teil wollten wir ein Programm testen, das Benjamin und Marc zu Hause geschrieben 

hatten. Das Ganze funktionierte nicht. Wir stellten fest, dass unser Slaveprogramm, d.h. 

das Programm für den Pumpbrick, einwandfrei funktionierte. Es wurde durch uns eine switch- 

Verzweigung in eine while (true)-Endlosschleife so eingebaut, dass wir bei dem Übermitteln 

des Wertes "3" den Pumpbrick zum Beenden des Programms bringen. Beim Wert "1" hob er 

seinen Stift, bei "2" senkte er diesen. 

Jedoch konnten wir innerhalb der 45 Minuten, die uns nur zur Verfügung standen, das Problem, 

das Gestell so zu bewegen, wie wir es uns vorstellten, nicht lösen. 

12.01.2009 Heute konnten wir erfolgreich einen "Rechteck-Algorithmus" entwickeln und programmieren. 

Er wurde erfolgreich umgesetzt. Dabei stießen wir auf ein paar Konstruktions- und Programmierfehler, 

die wir beseitigten. 

13.01.2009 In dieser Stunde bekamen wir den Auftrag, Formulare für unser kommendes Projekt auszufüllen. 

Dies betraf primär die anderen Gruppen der Klasse, da wir schon mit unserem Plotter- 

Projekt, das wir Scribus nannten, begonnen hatten. Des Weiteren mussten wir eine genaue 

Zielsetzung festlegen und Forschungen anstellen, wo Vorbilder für unser Projekt im Netz 

bereits zu finden waren. Bei dieser Projektumfeldanalyse hatten wir einige anderen Projekte 

gefunden und unseres genau beschrieben und davon abgehoben. 

15.01.2009 Zu Beginn der Stunde führten wir die Notenbesprechung durch. Danach begannen wir, die 

Konstruktion noch ein wenig zu verfeinern. Patrick wurde von Benjamin in das 3D- 

Konstruktionsprogramm MLCad eingewiesen. Mit diesem sollte Patrick eine Anleitung für 

unsere "Druckmaschine" oder auch Plotter entwickeln. 

19.01.2009 In dieser Stunde trennten sich die einzelnen Wege der Gruppenmitglieder. Frau Jungk war 

leider verhindert und konnte nicht teilnehmen, Patrick ging seiner Aufgabe, eine Bauanleitung 

für unseren Plotter zu erstellen, nach und Benjamin und Marius verfeinerten die Konstruktion. 

Sie setzten die Stiftführungsschiene herunter. 

Bei der anfänglichen Konstruktion mit den zu langen Trägern bot die Stiftführungsschiene 

keinen Halt. Die Steckverbindungen aus Lego-Teilen, aus denen der Rahmen zusammengesetzt 

war, konnten bei der zu hohen Länge den Stift nicht halten. Er blieb auf dem Papier 

hängen und konnte keine gerade Linie zeichnen. 



Mit dem Heruntersetzen der Führung und dem Verkürzen der Träger erreichten sie einen 

tieferen Schwerpunkt und so einen stabileren, weniger fehleranfälligen Rahmen. 

Anschließend mussten sie die Stifthalterung mit der Vorrichtung zum Anheben und Absenken 

des Stiftes an die Seite versetzen, weil unter dem herabgesenkten Rahmen kein Platz mehr 

war. 

20.01.2009 Benjamin und Frau Jungk waren aufgrund einer Erkrankung leider nicht anwesend. Patrick 

beschäftigte sich wieder mit dem Kennenlernen des Programms MLCad, um die Anleitung 

erstellen zu können. Marc besprach mit Hr. Dietrich weitere Details für unser Homepageprojekt 

www.wvb-interaktiv.de, welches spätestens im Februar online gehen sollte. Des Weiteren 

kümmerte er sich um die Publizierung unseres neuen Projektes im Netz und fertige Protokolle 

und Analysen an. Marius verfeinerte die in der letzten Stunde begonnene Arbeit an der Konstruktion. 

22.01.2009 Nachdem Benjamin und Marius die Führungsschiene nach unten gesetzt hatten, begannen 

die beiden nun, die Stifthalterung zu stabilisieren. Marc durchforstete das Internet nach verschieden 

NXT-Projekten und Lösungen, um Ideen für das eigene Projekt zu sammeln. Patrick 

war immer noch mit seiner Einführung in das Programm MLCad beschäftigt. 

26.01.2009 An diesem Montag führte Benjamin den Umbau der Stifthalterung fort und beendete dies 

erfolgreich. 

Marc begann damit, das erste interaktive Programm zu schreiben, bei dem der NXT auf die 

drei Buttons reagieren sollte. Hierfür hatte er in der letzten Stunde Ideen gefunden und versuchte 

diese umzusetzen. Dies war allerdings noch nicht geglückt. 

27.01.2009 Die einzelnen Gruppen sollten in der ersten Stunde ihre verschiedenen Projekte vorstellen. 

Auch wir stellten unser Projekt und zusätzlich das Mindstormsforum, mit dem Gruppen arbeiten 

sollen, vor. 

In der zweiten Stunde erstellten wir einen Projektstrukturplan, in dem wir alle uns in den Sinn 

gekommenen Probleme und Aufgaben aufschrieben und diese strukturierten. Fortsetzung 

dieses Plans sollte der Projektablaufplan sein, welcher einen genauen Zeitplan vorschreibt. 

Marc konnte das interaktive Programm mit Buttoneingabe beenden und erfolgreich testen. 

29.01.2009 

- 16.02.2009 

In diesen 5 Stunden (am 12.02.2009 entfiel der Unterricht) war die Gruppe damit beschäftigt, 

den Projektauftrag, die Projektumfeldanalyse, den Projektstrukturplan, den Projektablaufplan 

und den Aktionsplan zu erstellen. Hierbei sollte das Projekt genau beschrieben (Projektauftrag 

und Projektumfeldanalyse), bei einem Brainstorming alle Tätigkeitsbereiche gesammelt 

und danach sortiert (Projektstrukturplan), ein fester Terminplan entwickelt (Projektablaufplan) 

und im Aktionsplan die Aufgaben bis ins kleinste Detail festgelegt werden. Hierbei hatten wir 

viel Spaß! 

17.02.2009 In der ersten Stunde hielt Herr Dietrich einen Vortrag über Dokumentation der Projekte in den 

Gruppen und die Gruppenordner, die jede Gruppe einzeln anlegen sollte. Unsere einzelnen 

Gruppenmitglieder befassten sich mit der Anleitung in MLCad, der Programmierung einer 

Diagonale, die unser Roboter schreiben sollte. 

In der zweiten Stunde erstellten wir ein Programm, um eine Diagonale zu zeichnen. Außerdem 

stellte ein Gruppenmitglied den Aktionsplan fertig. 

Am Ende testeten wir das Diagonalprogramm mit den einfachen Befehlen "OnFwd" und „On- 

Rev“. 



19.02.2009 Heute hatte Patrick etwas größere Probleme mit der Stifthalterung voranzukommen. Der Rest 

der Gruppe befasste sich mit der Programmierung eines simplen Umrisses für das „Haus vom 

Nikolaus“. Es traten einige Probleme mit der Nutzung des "Wait-Befehls" auf. 

23.02.2009 In dieser Doppelstunde Roboter-AG stellten wir uns wieder dem Problem des "Hauses vom 

Nikolaus". Es entstanden erste Versuche, die Innenlinien des Hauses zu zeichnen, was leider 

fehlschlug. Zunächst verbesserten wir noch den Grundriss. Wieder stellte sich der "Wait- 

Befehl" als eher ungeeignet dar. Die Werte sind schwer zu ändern und absolut unpräzise. 

Patrick kam in dieser Stunde weit voran, er stellte die Stifthalterung fast fertig. 

24.02.2009 In der ersten Stunde referierte Herr Dietrich. Er machte uns klar, wie wichtig Projektmanagement 

und Dokumentation seien. Ab dieser Stunde hatte jedes Mitglied jeder Gruppe unserer 

Klasse die Aufgabe, Stundenprotokolle nach einem vorgegebenen Raster anzufertigen. 

Unsere Gruppe hatte in der zweiten Stunde viel nachzuarbeiten. Alle Gruppenmitglieder, außer 

Patrick, hingen dem Zeitplan hinterher. Es gab somit viel aufzuholen. Das Außengerüst 

des „Hauses vom Nikolaus“ wurde in dieser Stunde fast fertig. Jedoch wurden wir durch den 

Schulgong bei unserem großen geistigen Gedankenfluss gestört. Wir konnten unsere Ideen 

erst am darauf folgenden Montag wieder ins Projekt einfließen lassen. 

Patrick stellte heute die Stifthalterung fertig. 

26.02.2009 An diesem Donnerstag war nur ein Gruppenmitglied unseres Teams anwesend. Marc, Marius 

und Benjamin waren zu einem Schnuppertag an der Ferdinand-Braun-Schule eingeladen. 

In dieser Infostunde überlegte Patrick, mit welchem Roboterteil er fortfahren sollte. Er begann 

bereits mit der Planung des Schlittens unseres Roboters. 

02.03.2009 Patrick begann mit der Anleitung des Schlittens in MLCad. Marius baute für Herrn Dietrich 

sämtliche Sensoren und Arme für einen anderen Roboter. Marc und Benjamin perfektionierten 

das Programm des „Hauses vom Nikolaus“. 

All diese Aufgaben mussten an diesem Montag bewältig werden. Dies gelang nur mit perfekter 

Aufgabenteilung und Planung des Projekts. Die Ergebnisse dieser Stunde waren grundlegend 

für alle weiteren Projekte und Aufgaben. Außerdem fiel Benjamin auf, dass der "Wait- 

Befehl" absolut ungeeignet für dieses Projekt ist. An Ungenauigkeit ist er nicht zu übertreffen. 

Das „Haus vom Nikolaus“ ist durch viel ausprobieren entstanden. Die Verwendung der Prozessorzeiten 

wäre um einiges genauer. Um eine Lösung zu finden, war eine Teamsitzung am 

darauf folgenden Dienstag (03.03.2009) nötig. 

03.03.2009 An diesem Dienstag wurde eine erste Gruppensitzung gehalten. Der "Wait-Befehl" muss ersetzt 

werden und anstehende Aufgaben wurden besprochen. 

Danach widmeten wir uns den spezifischen Aufgaben. Marius befasste sich mit der Sortierung 

unserer gemischten Kästen. Marc und Benjamin begannen ein Programm zum Schreiben 

eines Sterns zu entwickeln. Dieser Stern stellte uns vor neue Herausforderung. Die Genauigkeit 

spielt bei einem Stern eine äußerst wichtige Rolle. Es musste somit eine Strategie 

entwickelt werden, womit wir bestimmte Winkel präziser aufs Papier bringen können. 

05.03.2009 Heute stellte Patrick den Schlitten unseres Roboters fertig. Ein bestimmtes Teil fehlte, doch 

Patrick konnte es leider nicht finden. 

Der Rest unserer Gruppe begann weitere Buchstaben zu programmieren. Zunächst versuchten 

wir uns an einem großen "A". Ein weiteres Hindernis stellten Buchstaben dar, die schräge 

Linien enthalten, wie beispielsweise ein B. 



10.03.2009 Es wurden mehrere Buchstaben programmiert. Mithilfe von Unterfunktionen gestaltetem wir 

unser Programm übersichtlicher. 

Da Patrick seinem Zeitplan um einiges voraus war (3 Wochen), half er heute den anderen 

Gruppen(mitgliedern). 

12.03.2009 Heute mussten Marius und Benjamin einer anderen Gruppe helfen. Somit war leider kaum 

Zeit, um die anderen Aufgaben zu erfüllen. Marc und Patrick führten das Programm weiter, 

konnten aber nichts ausprobieren, da unsere Anlage zu diesem Zeitpunkt leicht auseinander 

gebaut war. 

16.03.2009 Wir begannen mit der Programmierung eines interaktiven Programms. Der Roboter sollte 

durch eine Bildschirmeingabe entweder nach links oder nach rechts fahren. Marius assistierte 

Patrick beim Anfertigen der Bauanleitung unseres Roboters. Es mussten bestimmte Teile des 

Roboters auseinander gebaut werden. 

17.03.2009 An diesem Dienstag war unser Hauptprogrammierer krank. Benjamin übernahm daher die 

Aufgabe der Programmierung. Patrick und Marius arbeiteten weiter an der Anleitung in 

MLCad. Heute wurde das ABC bis zum Buchstaben "I" programmiert. Somit konnte auch ein 

einfaches Wort geschrieben werden. 

19.03.2009 An diesem Donnerstag hatten wir geplant, was wir die nächsten Stunden ohne unseren Programmierer 

tun sollten. Wir kamen zum Entschluss, unseren Zeitplan einzuhalten und uns am 

Aktionsplan entlang zu hangeln. 

23.03.2009 Heute optimierten wir Buchstaben. 

Patrick half bei der Verbesserung der Programme, da er seinem Zeitplan wieder weit voraus 

war. Wir programmierten erfolgreich die Buchstaben A, B, C und D, wobei uns aber die Halterung 

des Stiftes einige kleine Probleme bereitete. 

24.03.2009 Ein Großteil unserer Gruppe half der Gabelstaplergruppe. Dies nahm einige Zeit in Anspruch. 

Außerdem versuchte Marius einen der beiden Touchsensoren besser zu platzieren, was jedoch 

misslang. 

Letztendlich hatten wir unsere Konstruktion nicht verändert. 

30.03.2009 Heute haben Benjamin und Marius die Buchstaben H-O programmiert. Patrick verbrachte die 

Doppelstunde weiterhin mit der Baukonstruktion in MLCad. 

31.03.2009 Heute versuchten wir, einen Zeilenumbruch zu programmieren, was jedoch fehlschlug. 

02.04.2009 In dieser Stunde feilten wir an den einzelnen Buchstaben. Der Buchstabe F stellte dabei das 

größte Problem dar; wir konnten den Fehler nicht beheben. 

20.04.2009 An diesem Montag nach den Ferien testete Marius alle bisher programmierten Buchstaben. 

Benjamin programmierte weiter an unserer Buchstabendatenbank und Patrick fuhr mit der 

Anleitung in MLCad fort. Ansonsten war die Stimmung im Team laut Fr. Jungk furchtbar, der 

Rest war anderer Meinung. 

21.04.2009 Wir arbeiteten weiter an der Fehlerbehebung im Buchstaben F. Patrick fuhr mit seiner Anleitung 

in MLCad fort. 

23.04.2009 Heute beschäftigten wir uns weiter mit dem F. Das Programm funktionierte immer noch nicht 

richtig. Patrick war weiterhin mit der Anleitung beschäftigt. 



27.04.2009 Der Fehler im F wurde durch Marc behoben. Danach begannen wir mit den schwierigen 

Buchstaben X und Q. 

28.04.2009 Diesen Dienstag haben wir die restlichen Buchstaben überprüft und ggf. verbessert. Danach 

haben wir neue Worte mit Erfolg getestet. 

30.04.2009 Der Roboter sollte heute zum ersten Mal die Worte "Marc", "Affe" und den kleineren Satz "Ich 

bin Tom" schreiben, wobei ein weiterer Fehler beim Buchstaben "F" auftauchte und der Zeilenumbruch 

Schwierigkeiten bereitete. Die Fehler beim Zeilenumbruch konnten wir noch nicht 

beheben, dafür aber die Fehler beim Buchstaben "F". 

Patrick arbeitete weiter an der Bauanleitung. 

11.05.2009 Heute waren wir damit beschäftigt Marcs USB-Stick zu retten. Dieser hatte technische Macken 

und funktionierte nicht mehr richtig. Einige Dateien waren beschädigt. 

Nachdem wir die kaputten Dateien ersetzt hatten, konnten wir weiter daran arbeiten, ICH BIN 

TOM zu schreiben. 

12.05.2009 Heute haben wir uns mit dem Schreiben des Satzes ICH BIN TOM beschäftigt. Beim Buchstaben 

B war der mittlere Balken zu lang und der Zeilenabstand zwischen den Wörtern zu 

groß. 

Die Probleme beim Schreiben, die ohne ersichtlichen Grund auf einmal in Erscheinung traten, 

haben wir gelöst. Marius stellte fest, dass der Stift bei den Versuchen von Woche zu Woche 

in seiner Halterung immer ein Stück weiter nach unten gezogen wurde. Der Stift drückte so 

stark auf das Papier, dass er beim Schreiben den Schlitten aus seiner Führung gehoben hatte. 

14.05.2009 An diesem Donnerstag schritt unser Projekt kaum voran. Alle von uns halfen anderen Gruppen. 

18.05.2009 Mithilfe eines "Arrays" tasteten wir uns allmählich an die interaktive Benutzereingabe heran. 

Herr Dietrich führte uns hierbei in das neue Gebiet ein. 

19.05.2009 Heute probierten wir uns weiter an der Bildschirmeingabe. 

25.05.2009 Heute arbeitete die Gruppe an der interaktiven Bildschirmeingabe. Patrick arbeitete weiter an 

der Bauanleitung. 

26.05.2009 In der ersten Stunde arbeiteten wir noch einmal an der interaktiven Bildschirmeingabe. Nachdem 

der Fehler im Programm behoben war, der uns die letzten beiden Stunden bereits beschäftigt 

hatte, kümmerten sich Marc und Benjamin um die anderen Gruppen. Patrick war 

weiterhin mit der Bauanleitung beschäftigt. 

28.05.2009 Heute hatten wir Besucher. Wir sollten einigen Schülern, die interessiert sind, einige leichte 

und kleine Programme erklären. Die Begeisterung schlug Wellen (Ironie). Einige sahen leider 

nur uninteressiert und auf die nächste Pause wartend zu. 

Die Meisten interessierten sich mehr für unser kompliziertes Schreib-Programm. 

02.06.2009 Wir beschäftigten uns heute mit dem Projektabschlussbericht. Zunächst fotografierten wir die 

Gruppenmitglieder, dann fassten wir deren Aufgabenbereich in Textform zusammen. 

Patrick beschäftigte sich weiter mit dem Bauplan des Roboters. Dieser stellte die Prognose, 

dass er aufgrund des Verlustes des bereits zu 3/4 fertigen Bauplans nicht mehr mit dem er- 



neut begonnenen Projekt fertig wird. 

08.06.2009 Heute arbeitete die Gruppe am Projektordner. 

Patrick hatte Probleme mit der Bauanleitung, die aber Benjamin lösen konnte. Patrick hatte 

ein Teil nicht gefunden. 

Marc und Marius tippen mit Benjamins Hilfe die Texte für die Mappe ein. 

6 PROJEKTERGEBNIS 

Insgesamt stellte sich unser Team die Arbeit und Programmierung mit dem Plotter leichter vor. Die Konstruktion 

stellte zu Anfang ein großes Problem dar. Programme waren bereits angefertigt und zum ersten Testlauf 

bereit, jedoch musste die Konstruktion aufgrund anhaltender schwerwiegender Mängel oft umgeändert werden. 

Im späteren Verlauf des Projektes änderten sich die Probleme. Die Konstruktion stand, nur die Programme 

stellten immer und immer wieder große Probleme dar. Kleinigkeiten, wie beispielsweise das Fehlen eines 

Leerzeichens kosteten wertvolle Zeit und Nerven. Diese Erfahrungen brachten uns insgesamt trotz der 

manchmal endlos scheinenden Fehlersuche weiter. Später konnten wir Probleme schneller und effizienter 

finden und beheben, da wir nun wussten, wie ein Problem einzugrenzen ist. 

Trotz dieser Probleme haben wir unser erstes Maximalziel, den schreibenden Roboter mit Eingabefunktion, 

erreicht. Wir konnten ein Programm entwickeln, das den Roboter Buchstaben, nach Eingabe durch den Benutzer, 

schreiben lässt: Zu Beginn des Programms erläutert der Roboter über den Bildschirm (als Textausgabe) 

seine Möglichkeiten. Der Benutzer wird gefragt, was der Roboter machen soll. Er kann nun zwischen allen 

Buchstaben aus dem Alphabet (außer Umlaute) oder einem Zeilenumbruch wählen. Des Weiteren besteht die 

Möglichkeit, dass Programm über sich selbst zu beenden (nicht die graue Abbrech-Taste). Nach der Wahll 

eines Buchstabens gibt der Hauptbrick über Bluetooth dem Pumpbrick den Befehl, den Stift zu senken. Nun 

beginnt der Hauptbrick die einzelnen Motoren anzusteuern und die Buchstaben zu zeichnen. Der Roboter 

stellt nach dem Zeichnen automatisch einen vordefinierten Zeichenabstand her und fragt auf dem Bildschirm 

nach dem nächsten Schritt. Der Benutzer sollte, bevor er mit dem Schreiben beginnt, seinen Satz bzw. seine 

Aussage planen, da in eine Zeile nur vier oder fünf Zeichen passen und die Zeilenumbrüche nach oben ausgeführt 

werden. 

Als Nebenprodukt unserer Programmierarbeit entstand eine digitale Uhr, die einstellbar ist. Diese Uhr entstand 

zur Erlernung der Programmierung einer Eingabeabfrage und eine erweiterte Arbeit mit Variablen und Arrays. 

Roboterkonstruktion 

Bei der Konstruktion des Roboters mussten einige Schwierigkeiten gemeistert werden. Wir mussten einen 

Roboter konstruieren, der stabil und robust ist und vor allem natürlich schöne Buchstaben auf das Papier bringen 

kann. Im Internet suchten wir nach Denkanstößen, bis wir auf die Seite http://www.norgesgade14.dk/ stießen. 

Sofort begannen wir eifrig einen Roboter nach den Vorgaben auf dieser Seite nachzubauen, doch schon 

nach kurzer Zeit mussten wir unterbrechen, da Teile fehlten. Nach einer langen Suchaktion stand fest: Wir 



müssen einen eigenen Roboter mit unseren Möglichkeiten in der Schule konstruieren. Wir übernahmen lediglich 

die Stifthalterung und die Idee für die Pumpstation von der Website. Der Rest unserer Anlage musste somit 

selbst in irgendeiner Art und Weise zusammengebastelt werden. Dies fiel uns entgegen unseren Erwartungen 

extrem leicht. Die Konstruktion stand innerhalb einer Woche. Wie fast alle Anlagen, musste sie noch 

verfeinert werden. Vor allem an der unbelastbaren Brücke musste etwas verbessert werden. Leichter gesagt 

als getan: Wir benötigten vier Versuche, um unsere jetzige Brücke fertig zu stellen. Letztendlich stecken circa 

drei Wochen Arbeit, Talent und etwas Glück in der momentanen Konstruktion. 

Unser Roboter unterteilt sich in fünf Elemente: 

• Rahmen: 

Der Rahmen unseres Roboters ist der wohl simpelste Teil des Gesamten. Er bildet die Grundlage und 

Stütze für alle anderen Elemente des Roboters. Außerdem sind an ihm die zwei Motoren befestigt, die 

unsere Brücke bewegen. 

• Brücke: 

Der große bewegbare Teil über dem Blatt wird von uns als Brücke bezeichnet. Sie besteht aus zwei 

im Rahmen verankerten Zahnstangen, die es ihr erlauben, sich horizontal über die Schreibfläche zu 

bewegen. Auf der Brücke befindet sich eine weitere Zahnstange. Auf ihr fährt der „Schlitten“ in vertikaler 

Richtung über dem Papier. 

• Schlitten: 

Mithilfe des Schlittens ist es möglich, wie schon im oberen Teil erwähnt, horizontal über dem Papier 

hin und her zu fahren. An ihm ist als weiteres Teil der Stifthalter befestigt. 

• Stifthalter: 

Wie der Name preisgibt, ist am Stifthalter der Stift befestigt. Der Stifthalter kann in zwei verschiedenen 

Positionen sein: Stift gehoben oder Stift gesenkt. 

• Pumpstation: 

Die Pumpstation ist das Element an unserem Roboter, das den Stift in seiner Halterung nach oben 

oder unten bewegt. Durch einen Motor wird Druck auf einen Schlauch gegeben, der die Pumpstation 

mit der Stifthalterung verbindet. Entsprechend dem programmierten Befehl bewegt sich nun der Stift 

entweder auf das Blatt oder vom Zettel weg. Das Prinzip kann man mit dem Antrieb einer Dampflokomotive 

vergleichen, bei der der Druck in Bewegung umgewandelt wird. Unser System funktioniert genau 

andersherum. Wir bauen durch Bewegung Druck auf. 

Ein Brick hat nur drei Outputs für Motoren. Wie bei der Beschreibung der Elemente unseres Roboters bereits 

festzustellen ist, arbeitet unsere Anlage mit vier Motoren: Die zwei Antriebe an den Seiten der Brücke, der 

Motor im Schlitten auf der Brücke und der der Pumpstation. Die Lösung für dieses Problem fanden wir in der 

Nutzung eines zweiten Brick. Das stellte bei der Konstruktion nur eine untergeordnete Rolle dar. Es musste 

ein guter und freier Platz für den zweiten Brick gefunden und die Pumpstation an die richtige Stelle angebracht 



werden. An den Seiten war unseres Erachtens nach der beste Platz, um den zweiten Kopf des Roboters unter 

zu bringen. Demnach setzten wir unsere Pumpstation einfach auf einen der beiden seitlichen Antriebe für die 

Brücke. Die andere Schwierigkeit bestand in der Programmierung. 

Zusammenfassend kann unser Projekt als Erfolg angesehen werden. Wir konnten im Bereich der Pneumatik 

und in der effizienten Ausnutzung der zur Verfügung stehenden Bauteile Erfahrungen sammeln. 

Programmierung 

Unser Quellcode besteht aus einem Hauptprogramm (Scribus.nxc) und einer Programmdatenbank, die die 

einzelnen Quellcodes für die Buchstaben und den Zeilenumbruch in sog. Headerdateien bereithält. Zu Beginn 

des Programms werden diese Dateien mit der Preprozessoranweisung „include“ eingebunden. Danach wird 

das Alphabet in den String eingelesen. Nun wird der Benutzer nach dem Buchstaben gefragt. Mit der rechten 

Pfeiltaste kann der Benutzer zum nächsten Buchstaben springen, mit der orangefarbenen Taste kann er einen 

Buchstaben bzw. einen der weiteren Befehle (Zeilenumbruch, Programm beenden) bestätigen. Wenn der 

Stringzähler bei 27 angekommen ist, d.h. am Bildschirm „Fertig“ ausgegeben wird und der Benutzer erneut 

die rechte Taste verwendet, wird der Zähler auf 0 zurückgesetzt und auf dem Bildschirm erneut das „A“ ausgegeben. 

Unser Roboter arbeitet auch mit Bluetooth. Mit Bluetooth können die Roboter drahtlos kommunizieren. Wir 

haben einen zweiten Roboter eingesetzt, der den Stift hebt und senkt. Er ist der „Sklave“ des Hauptroboters. 

Der Hauptroboter sendet seinem Sklaven Befehle zum Heben und Senken des Stiftes via Bluetooth. 

Der Quellcode des Hauptprogramms sowie die Headerdateien sind mit ausführlichen Kommentaren dieser 

Dokumentation beigefügt. 

7 REFLEXION 

Reflexion der Problemstellung 

Unser Team suchte eine Herausforderung. Wir suchten etwas „Neues“. Ein stationärer Roboter sollte es sein. 

Als wir auf Youtube.com einige Videos über schreibende Roboter gesehen hatten, war unser Ziel klar. Ein 

schreibender Roboter sollte konstruiert und programmiert werden. 

Im Vorfeld war uns eher unklar, dass wir mit solch einer großen Menge an „Neuland“ arbeiten mussten. Zunächst 

standen wir vor dem Problem, dass der „Wait-Befehl“ sehr ungenaue Linien auf das Papier bringt. Mit 

ihm kann man hier nicht arbeiten. Wir stiegen einfach auf einen anderen Befehl um: „MotorRotationCount“. Mit 

ihm zählen wir die Entfernung, die auf dem Blatt zurückgelegt wird. Dieser Befehl ist nicht von der Leistung der 

Motoren und/oder der zur Verfügung stehenden Energie abhängig. Wir bekommen immer dasselbe Ergebnis 

und das brauchen wir für ein genaues Arbeiten. Schon war die erste kleine Hürde gemeistert. 

Alle von uns programmierten Buchstaben mussten irgendwie in einem großen Programm eingebunden werden. 

Eine Möglichkeit wäre natürlich gewesen, alle Programmteile zu einem großen Programm zusammenzufügen. 

Es wäre ein viel zu langer und unübersichtlicher Quellcode entstanden. Herr Dietrich gab uns den Hinweis, 

dass man eine Programmbibliothek erstellen und über sog. Header-Dateien in das Hauptprogramm einbinden 

könne. Nun war es uns möglich, ein übersichtliches und vor allem kurzes Hauptprogrammzu schreiben, 



in dem die kleinen Header-Dateien, in denen die Buchstaben programmiert sind, durch den Preprozessorbefehl 

#include eingebunden und über ihren Namen aufgerufen werden, zu entwerfen. 

Am Ende des Projekts gab es noch eine letzte Schwierigkeit zu meistern: Die interaktive Bildschirmeingabe. 

Man sollte einfach am Display des Roboters Buchstaben auswählen können, die der Roboter dann darstellt. 

Also mussten wir durch Recherchen im Internet nach Befehlen zur Abfrage der Tasten suchen. Mit diesen 

Befehlen konnten wir dann einen Programmteil zur Abfrage kombiniert mit einer Anzeige programmieren. 

Das Projekt, einen schreibenden Roboter zu bauen, hat uns gefordert und gefördert. Wir haben nicht gedacht, 

dass es so viel gibt, an das man denken muss, wenn man einen Roboter baut, der schreiben soll. Die Konstruktion 

und auch das Programm stellten uns vor Fragen, die erst beantwortet werden mussten. 

Abschließend kann man sagen, dass wir einiges im Bereich der Programmierung und der Konstruktion eines 

NXT-Roboters, der in NXC programmiert wird, gelernt haben. Die oben genannten Probleme mussten von uns 

gelöst werden; neue Möglichkeiten der Programmierung wurden uns offenbart. Das Projekt war ein Erfolg. 

Reflexion des Projektmanagements 

Die Projektplanung half uns bei der Bewältigung des Projektes. Wir haben unser Projekt zu Beginn sehr ausführlich 

geplant Durch die genaue Planung konnten wir während des Projektes genau feststellen, wie weit wir 

waren und wo wir uns befanden. Die Arbeit ist durchgehend positiv verlaufen, da wir unsere Ziele kontinuierlich 

erreichten. Das einzige unvorhergesehene Ereignis war, dass wir eines der beiden Maximalziele nicht 

erreichen konnten. Wir mussten leider feststellen, dass unsere Zielsetzung auf Grund der Hardware des NXTs 

nicht umsetzbar ist. Somit war dieses Problem für uns auch nicht zu lösen. Das Projekt hat uns durch die Planung 

in der Teamarbeit und in der Arbeitsteilung gefördert. Durch die verbesserte Aufgabenteilung waren die 

einzelnen Aufgaben besser zu bewältigen. 

Reflexion der Teamarbeit 

Die Teamarbeit in unserer Gruppe war von Anfang an gut. Das hatte auch damit zutun, dass wir seit bereits 

drei Jahren zusammen arbeiten. Es gab keine Verbesserung, da nichts zu bemängeln war. 

Zwischen unseren Mitgliedern gab es so gut wie nie Streitigkeiten. Kleinere Probleme wurden im Handumdrehen 

gelöst und es konnte schnell weiter gearbeitet werden. Nur bei Problemen mit einem PC oder einem der 

genutzten Programme hingen wir öfters fest. Beispielsweise musste Patrick mit seiner gesamten Arbeit der 

ersten Hälfte des Halbjahres aufgrund einer defekten Datei komplett neu beginnen. Solchen Hürden kann man 

nicht aus dem Weg gehen. Sie wurden einfach aufgenommen und die daraufhin zu erledigende Arbeit wurde 

auf alle Gruppenmitglieder verteilt. 

Dies gelang aber nur, da der Arbeitswille in unserer Gruppe stets vorhanden war. Sicherlich gab es kleinere 

Phasen, in welchen etwas weniger gearbeitet wurde, aber durch unsere korrekte und vorausschauende Zeitplanung 

war genug Spielraum für solche Arbeitstage. Falls ein Mitglied oder die gesamte Gruppe den Zeitplan 

nicht einhalten konnte, wurden kleine Arbeiten auch mit nach Hause genommen und erledigt. Bei gegebener 

Langeweile haben manche Teammitglieder sogar zu Hause Programme verfasst, die uns in der Schule wertvolle 

Zeit geraubt hätten. 



An der guten andauernden Stimmung im Team konnte man die Zufriedenheit und das Wohlbefinden aller unserer 

Mitglieder deutlich sehen. 

Es ist wichtig, immer den Zeitplan im Auge zu behalten. Sollte man sich sicher sein, dass man den Zeitplan 

nicht einhalten kann, muss man gegebenenfalls eine geringfügige Änderung vornehmen. Die andere Möglichkeit 

ist, den betreffenden Gruppenmitgliedern zu helfen. Falls die gesamte Gruppe den Zeitplan nicht einhalten 

kann, muss man sich einfach etwas mehr konzentrieren und sich eventuell über die Arbeitsaufteilung Gedanken 

machen und angleichen. 

Reflexion des Projektziels 

In der Summe war unser Projekt erfolgreich. Leider konnten wir unser Maximalziel, mathematische Funktionen 

darzustellen, aufgrund der Hardware nicht erreichen. Alle anderen Ziele haben wir erreicht. 

8 AUSBLICK 

Eine Ausbaustufe unseres Projektes wäre die Erweiterung der Schreibfläche. Zurzeit benutzen wir DIN A5 

Blätter, man kann aber, um mehr Arbeitsfläche zu haben, DIN A4 Blätter nutzen. Dazu währen allerdings mehr 

Bauteile nötig. Unser Baukasten hat unsere Arbeit auf die kleineren Blätter beschränkt. In der Industrie ist 

unser Plotter allerdings nicht nutzbar. Drucker gibt es schon und Schreibmaschinen, die einen Stift führen, 

sind ebenfalls vorhanden. Unser Projekt war lediglich für uns, das Team, ein großer Fortschritt. 

9 BEWERTUNG DER PROJEKTARBEIT 

Die Gruppenarbeit hatte für das Gesamtergebnis unseres Projekts große Vorteile aber auch Nachteile. Im 

Vordergrund steht dabei natürlich, dass unsere Gruppe gut zusammenarbeiten kann. Die gute Kommunikation 

innerhalb sowie außerhalb des Informatikunterrichts sorgte einerseits dafür, dass die Probleme, die bei der 

Programmierung auftraten, rasch gelöst werden konnten. Andererseits wurde durch den Austausch unter den 

Gruppenmitgliedern das Arbeitsklima verbessert. 

Ein großer Vorteil an der Gruppenarbeit, vor allem im Bezug auf den knapp bemessenen Zeitplan, war die 

gemeinsame Vorbereitung. Da die Gruppenmitglieder gemeinsam beschlossen haben, zu welchem Zeitpunkt 

welcher Punkt im Gesamtplan abgeschlossen sein muss, hat sich jedes Gruppenmitglied auf das Gesamtziel 

einstellen und danach arbeiten können. 

Vorteile bot die Gruppenarbeit auch, wenn nicht immer die gesamte Gruppe vollzählig war (vermehrte Krankheitsfälle, 

Marcs Schüleraustausch in Amerika). Die anderen Gruppenmitglieder konnten sich darauf einstellen, 

mit einem Mitglied weniger zu arbeiten, und die Arbeit unter sich aufteilen. Dieses Vorgehen ist bei Einzelarbeit 

natürlich ausgeschlossen. 

In der Aufgabenverteilung unter den Gruppenmitgliedern lag der größte Schwachpunkt unserer Gruppenarbeit. 

Zwar hatten wir gemäß unserem Zeitplan gearbeitet und waren ohne große Verzögerungen von Meilenstein zu 

Meilenstein gekommen, jedoch spaltete der Fortschritt auch die Gruppe. Marc, der auf dem Gebiet Programmierung 

ohnehin im Verständnis und Wissen weiter war als alle anderen, sowohl was die Mitglieder in unserer 

Gruppe angeht, als auch die aller anderen Gruppen, hatte mit Hilfe des Internets auf die Programmierung der 



Bildschirmeingabe hingearbeitet. Dazu gehörte auch die Programmierung einer Uhr auf dem Bildschirm des 

Roboters. Marc programmierte zwar nicht allein, jedoch gab es immer wieder Zeiten, in denen Benjamin und 

Marius nicht den vollen Überblick und Einblick in Marcs Programmierung hatten. 

Aufgrund des Zeitplans war es nicht möglich, allen Mitgliedern immer alle Details des Programms verständlich 

zu machen. 

Durch die Zusammenarbeit mit Herr Dietrich wurde dieses Problem zwar gemindert, aber nicht vollständig 

behoben. Allerdings gab Herr Dietrich nützliche Hinweise und Tipps, die beim Verstehen und Fortführen der 

Programme halfen. 

Was bei der Projektarbeit gefehlt hat, war ein „roter Faden“ durch die Programmierung. Zwar war es gut und 

sollte auch weiter so gehandhabt werden, dass die Gruppen ihr eigenes Thema wählen können (Plotter, Gabelstapler, 

Tanzroboter). Allerdings waren die Gruppen beim Aufbau des Programms fast auf sich alleine gestellt. 

Die Tutorials gaben zwar einen guten Einblick in die Programmierung des Roboters, allerdings war die 

Arbeit mit den Informationen aus den Tutorials nicht mit der Arbeit zu vergleichen, die mit den Informationen 

aus einem richtigen Unterricht entstanden wären. 

10 BILDER 







11 QUELLENVERZEICHNIS 

Genutzt als Anleitung für Teile der Konstruktion: 

• http://www.norgesgade14.dk/ 

Genutzt als Hilfestellung zur Programmierung: 

• http://www.nxtasy.org 

• http://www.mindstormsforum.de 

• www.debacher.de/wiki/NXC 

• http://dienxteebene.blogspot.com/ 

• NXC Guide von John Hansen 

• NXC Guide von Daniele Benedettelli 



12 ENTLASTUNG DES PROJEKTTEAMS 

Hauswurz, 13.06.2009 

______________________________ 

(Benjamin Hosenfeld, Teamleiter) 

Hauswurz, 13.06.2009 

______________________________ 

(Marc Leinweber, Schriftführung) 

Neuhof, 13.06.2009 

______________________________ 

(Marius Ruppel) 

Hauswurz, 13.06.2009 

______________________________ 

(Patrick Kimpel) 

______________________________ 

(Ort, Datum) 

______________________________ 

(Projektauftraggeber) 



13 ANHÄNGE 

Auf den nächsten Seiten finden sich angehängt: 

• Brainstorming 

• Projektauftrag 

• Projektumfeldanalyse 

• Projektstrukturplan 

• Projektablaufplan 

• Aktionsplan 

• Quellcode

DES WPU-KURSES Scribus - Wernher von Braun Schule

Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.

Template löschen?

Als Template speichern?