Initialer Import.HEADmaster

21 files changed, 1668 insertions, 0 deletions

diff --git a/contents/compag/main.php b/contents/compag/main.php
new file mode 100644
index 0000000..276a2cd
--- /dev/null
+++ b/contents/compag/main.php
@@ -0,0 +1,42 @@
+<?php
+	$title = 'Information';
+	$author = 'Jakob';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/compag/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Informationen zur CompAG
+	</h2>
+	<p>
+		Die Computer-AG (kurz CompAG) ist eine Gruppe von Sch&uuml;lern,
+		die in Eigeninitiative, ohne Leitung durch einen Lehrer,
+		das Internetcafe der Lauenburgischen Gelehrtenschule Ratzeburg
+		administrieren, und miteinander ihr Wissen &uuml;ber Computer erweitern.
+		Dabei lernen sie z.B. den Umgang mit unterschiedlichen Computersprachen (C, C++, Ruby, Html, Php),
+		und &uuml;ben sich im Umgang mit dem alternativem Betriebssystem Linux.
+	</p>
+	<p>
+		Wer bei der CompAG mitmachen m&ouml;chte,
+		kann einfach vorbeisehen.
+		Es gibt keine Anwesenheitspflicht,
+		aber da die CompAG auf Eigeninitiative beruht,
+		ist die Anwesenheit und Motivation der Mitglieder
+		Grundlage und Voraussetzung f&uuml;r den Erfolg dieser AG.
+	</p>
+	<p>
+		Die CompAG existiert ca. seit Sommer 2003.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/linux/kommandos.php b/contents/linux/kommandos.php
new file mode 100644
index 0000000..95f15d3
--- /dev/null
+++ b/contents/linux/kommandos.php
@@ -0,0 +1,288 @@
+<?php
+	$title = 'Linux Konsolenbefehle';
+	$author = 'Emily';
+	$editor= 'Jakob';
+	$pathToRoot = "../../";
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+
+	include($pathToRoot . 'sidebars/linux/main.inc.php');
+?>
+
+<div id="inhalt">
+<h2> Linux Konsolenbefehle </h2>
+
+<table>
+ <thead>
+	<tr>
+		<td> Name </td>
+		<td> Beschreibung </td>
+		<td> Anwendung </td>
+	</tr>
+ </thead>
+	<tr>
+		<td> apropos </td>
+		<td> Suche in manual </td>
+		<td></td>
+	</tr>
+	<tr>
+		<td> bash	</td>
+		<td> Kommandointerpreter </td>
+		<td></td>
+	</tr>
+	<tr>
+		<td> cat </td>																			
+		<td> Datei lesen </td>
+		<td> cat [Dateiname] </td>
+	</tr>	
+	<tr>
+		<td> chmod </td>										
+		<td> Rechte &auml;ndern (change modus) </td>
+		<td> siehe Rechteverwaltung </td>
+	</tr>
+	<tr>
+		<td> chgrp </td>							
+		<td> Gruppe &auml;ndern (change group)</td>
+		<td> chgrp [Gruppe] [Datei]</td>
+	</tr>
+	<tr>
+		<td> chown </td>			
+		<td> Benutzer &auml;ndern (change owner, <br /> nur als root m&ouml;glich) </td>
+		<td></td>
+	</tr>
+	<tr>
+		<td> cd	</td>
+		<td> verzeichnis wechseln (change directory) </td>
+		<td> cd [Verzeichnisname] </td>
+	</tr>
+	<tr>
+		<td> cd ~	</td>
+		<td> ins homeverzeichnis </td>
+		<td></td>
+	</tr>
+	<tr>
+		<td> cd .. </td>
+		<td> ins Elternverzeichnis </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> cd /	</td>
+		<td> ins Wurzelverzeichnis </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> clear	</td>
+		<td> Bildschirm leeren </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> cp </td>
+		<td> kopieren (copy) </td>
+		<td> cp [Quelle] [Ziel] </td>
+	</tr>
+	<tr>
+		<td> cp -r </td>
+		<td> Kopieren eines Ordners </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> date	</td>
+		<td> zeigt Datum und Uhrzeit </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> echo	</td>
+		<td> Geschriebenes zurückgeben	</td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> eterm	</td>
+		<td> Konsole </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> exit	</td>
+		<td> aktuellen Prozess beenden </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> gedit </td>
+		<td> grafischer Editor </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> groups		</td>
+		<td> Ausgabe der Gruppen des Benutzers </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> --help	</td>
+		<td> Hilfe </td>
+		<td> [Suchbegriff] --help </td>
+	</tr>
+	<tr>
+		<td> info </td>
+		<td> Hilfe </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> kill	</td>
+		<td> beendet Prozess </td>
+		<td> kill [Nummer des Prozesses] </td>
+	</tr>
+	<tr>
+		<td> kill -sigkill </td>
+		<td> zwingt Prozess zum Beenden </td>
+		<td> kill -sigkill [Name des Prozesses] </td>
+	</tr>
+	<tr>
+		<td> less </td>
+		<td> Datei lesen	(beenden mit q) </td>
+		<td> [Dateiname] 	 </td>
+	</tr>
+	<tr>
+		<td> ln -s	</td>
+		<td> symbolischen Link erstellen (link) </td>
+		<td> [Zielobjekt]	</td>
+	</tr>
+	<tr>
+		<td> ls	</td>
+		<td> Verzeichnisinhalt lesen (list) </td>
+		<td> ls [Verzeichnisname] </td>
+	</tr>
+	<tr>
+		<td> ls -a </td>
+		<td> gesamten Verzeichnisinhalt lesen  </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> ls -lh	</td>
+		<td> Verzeichnisinhalt mit mehr <br />Information lesen (Rechte, ...) </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> ls -R </td>
+		<td> Verzeichnisinhalt rekursiv lesen </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> ls -A </td>
+		<td> . und .. werden nicht angezeigt </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> mkdir </td>
+		<td> Verzeichnis erstellen </td>
+		<td> mkdir [gewünschter Name] </td>
+	</tr>
+	<tr>
+		<td> mv	</td>
+		<td> Verschieben/umbenennen </td>
+		<td> mv [Quelle] [Ziel] </td>
+	</tr>
+	<tr>
+		<td> mv -r </td>
+		<td> Bewegen eines Ordners </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> man </td>
+		<td> ausführliche Hilfe (manual) </td>
+		<td> man [Suchbegriff] </td>
+	</tr>
+	<tr>
+		<td> nano	</td>
+		<td> Texteditor </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> ps -A </td>
+		<td> zeigt alle Prozesse an </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> pstree	</td>
+		<td> zeigt Hierarchie der Prozesse </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> pwd </td>
+		<td> gibt momentanen Pfad aus </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> rm	</td>
+		<td> löschen einer Datei (remove) </td>
+		<td> rm [Dateiname] </td>
+	</tr>
+	<tr>
+		<td> rm -i </td>
+		<td> gefragt löschen	 </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> rmdir </td>
+		<td> Verzeichnis löschen </td>
+		<td> rmdir [Verzeichnisname] </td>
+	</tr>
+	<tr>
+		<td> rmdir -r	</td>
+		<td> auch Tochterverzeichnisse löschen </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> rmdir -i </td>
+		<td> Verzeichnis gefragt löschen </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> shutdown	</td>
+		<td> Herunterfahren </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> ssh </td>
+		<td> Zugriff auf andere Computer </td>
+		<td> ssh [Name des Computers] </td>
+	</tr>
+	<tr>
+		<td> touch </td>
+		<td> leere Datei erstellen	 </td>
+		<td> touch [gewünschter Name] </td>
+	</tr>
+	<tr>
+		<td> wc </td>
+		<td> Wörter zählen (wordCount)	 </td>
+		<td> wc [Dateiname] </td>
+	</tr>
+	<tr>
+		<td> wc	 -l	</td>
+		<td> Zeilen zählen (line)	 </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> which </td>
+		<td> sucht nach Programmen </td>
+		<td> which [Objektname] </td>
+	</tr>
+	<tr>
+		<td> who					 	</td>
+		<td> Zeigen, wer auf diesem Computer <br />eingeloggt ist </td>
+		<td> </td>
+	</tr>
+	<tr>
+		<td> whoami </td>
+		<td> Ausgabe des eingeloggten Nutzernamens </td>
+		<td> </td>
+	</tr>
+	
+</table>
+</div>
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>
+
diff --git a/contents/linux/main.php b/contents/linux/main.php
new file mode 100644
index 0000000..cf8764b
--- /dev/null
+++ b/contents/linux/main.php
@@ -0,0 +1,37 @@
+<?php
+	$author = 'Lena';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/linux/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Linux
+	</h2>
+	<p>
+		Linux ist (wie Windows) ein Betriebssystem, auch OS (Operating System) genannt, allerdings gibt es zahlreiche Unterschiede
+		zu vermerken.
+	</p>
+	<p>
+		Man kann es auf vielen verschiedenen Geräten installieren, auch auf älteren Computer, es gibt sogar eine Distribution 				
+	 	(Version) für den iPod! Es ist ein Multiuser-System, was bedeutet, dass es dafür programmiert wurde, dass an einem Computer mehrere
+	  	Accounts für verschiedene Benutzer erstellt werden können. Das war bei Windows nicht von Anfang an so, erst seit XP. Dadurch ist
+	  	diese Eigenschaft dort nicht besonders gut integriert. Aber das wohl ausschlaggebendste Argument für Linux ist, dass es Open Source
+	  	ist. Das heißt, dass man es sich kostenlos aus dem Internet laden darf und frei auf den Quelltext zugreifen darf.
+	  	Dadurch wird es von vielen Menschen auf der gesamten Welt immer weiter entwickelt und verbessert.
+	</p>
+	<p>
+	
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/linux/rechte.php b/contents/linux/rechte.php
new file mode 100644
index 0000000..91cf779
--- /dev/null
+++ b/contents/linux/rechte.php
@@ -0,0 +1,88 @@
+<?php
+	$title = 'Rechteverwaltung';
+	$autor = 'Lena';
+	$editor= 'Jakob';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+
+	include($pathToRoot . 'sidebars/linux/main.inc.php');
+?>
+<div id = "inhalt">
+<h2>
+	Rechteverwaltung unter Linux
+</h2>
+<p>
+  Dieser Artikel beschäftigt sich mit der Rechteverwaltung unter Linux,
+  und versucht, auf unterschiedliche Aspekte selbiger einzugehen.
+  Dafür versuchen wir zuerst einen Einblick in die aktuellen Einstellungen zu erlangen.
+  Hier verwenden wir den Consolenbefehl "ls -lh", wodurch wir folgende Informationen zu einem Ordner erhalten:
+</p>
+<ol>
+  <li>Die Rechte der Ordner und Datein</li>
+  <li>Die Anzahl der Objekte, die ein Ordner enthält</li>
+  <li>Die Besitzer der Objekte</li>
+  <li>Die Gruppe, der ein Objekt angehärt</li>
+  <li>Der Speicher, den die Objekte belegen</li>
+  <li>Das Änderungsdatum (Jahr, Monat, Tag, Uhrzeit)</li>
+  <li>Der Name des Objektes</li>
+</ol>
+<p>
+	Gehen wir nun näher auf die einzelnen Zeichen ein, die wir bei den Rechten sehen.
+	Der erste Buchstabe gibt an, ob es sich bei dem Objekt um ein Verzeichnis handelt, was durch ein "d" gekennzeichnet ist.
+	Ist es jedoch eine Datei, sehen wir lediglich einen Strich.
+</p>
+<p>
+	Die nachfolgenden Zeichen sind in drei Gruppen einzuteilen, die jeweils aus drei Buchstaben bestehen.
+	Als erstes sehen wir die Rechte des Besitzers der Datei,
+	danach die der Mitglieder der Gruppe, der die Datei angehört
+	und abschließend die Rechte aller anderen Benutzer.
+</p>
+<p>
+	Dabei gibt es folgende Buchstaben:
+</p>
+<code style="white-space:pre" class="table">
+r	Leserecht    (read)
+w	Schreibrecht (write)
+x	Ausführrecht (Execute)
+</code>
+<p>
+	Sehen wir anstelle eines Buchstabens einen Strich, bedeutet das, dass diese Personengruppe das Recht nicht hat.
+	Sind wir aber der Besitzer eines Objekts, oder gar Administrator, kann man diese Rechte ohne Probleme ändern.
+	Das machen wir mit dem Konsolenbefehl "chmod".
+	Wir schreiben nun den Namen der Datei oder des Verzeichnisses, an der wir die Rechteänderung vornehmen möchten.
+	Hinter dem Befehl schreiben wir den Buchstaben, der der Gruppe entspricht, deren Rechte wir ändern.
+</p>
+<code style="white-space:pre" class="table">
+u	Besitzer (user)
+g	Gruppe (group)
+o	andere (other)
+a	alle (all)
+</code>
+<p>
+	Danach schreiben wir entweder "+" oder "-" und dann den Buchstaben für das Recht, das wir dieser Gruppe hinzufÃŒgen 
+	oder entziehen möchten.
+</p>
+<p>
+	Ein Problem ist, dass andere Benutzer, solange sie Schreibrecht auf den Ordner haben, in dem eine deiner Dateien liegt, diese einfach 		löschen können.
+	Das kann man verhindern, indem man "+s" zu einer Gruppe hinzufügt.
+</p>
+<p>
+	Es ist auch möglich, mehrere Rechteänderungen für eine Datei auf einmal vorzunehmen.
+	Auch kann der Besitzer einer Datei oder eines Verzeichnisses kann auch die Gruppe ändern,
+	vorausgesetzt, man ist in dieser Mitglied.
+</p>
+<p>
+	Zu Beginn ist jeder Benutzer nur in der Gruppe, die seinen eigenen Benutzernamen trägt.
+	In der Group-Datei "/etc/group" kann man lesen, welcher Benutzer sich in welcher Gruppe befindet.
+	Der Administrator ist in der Lage, diese Datei zu bearbeiten, wobei die Benutzernamen durch Kommata abgetrennt sind.
+	Auch kann nur der Administrator den Befehl "chown" anwenden, der eine Datei einem anderen Besitzer zuteilt.
+</p>
+</div>
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>
diff --git a/contents/projekte/main.php b/contents/projekte/main.php
new file mode 100644
index 0000000..8c87d69
--- /dev/null
+++ b/contents/projekte/main.php
@@ -0,0 +1,31 @@
+<?php
+	$author = 'Lena';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/projekte/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Projekte
+	</h2>
+	<p>
+		Wir hatten leider noch nicht besonders viele Projekte, ausführlich dokumentiert ist bisher nur der Robocup 2007, zu dem hier auch Informationen über den Roboter, mit dem wir an diesem teilnahmen, zu finden sind. Momentan sind wir in den Vorbereitungen für den Rococup 2008.
+	</p>
+	<p>
+		Diese Website ist das Ergebnis unseres Websdesign-Projekts.
+	</p>
+	<p>
+		Als nächtest werden wir ein Benutzerverwaltungssystem für unsere Schule programmieren.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/projekte/robocup.php b/contents/projekte/robocup.php
new file mode 100644
index 0000000..d8f725d
--- /dev/null
+++ b/contents/projekte/robocup.php
@@ -0,0 +1,100 @@
+<?php
+	$author = 'Lena';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/projekte/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		RoboCup
+	</h2>
+	<p>
+		Bereits beim Robocup 2006 hat die CompAG erfolgreich an der Rescue-Disziplin teilgenommen und wurde bei der Weltmeisterschaft in der vorderen Hälfte platziert. Nun hat die Mitgliederzahl stark zugenommen, sodass wir uns in zwei Teams aufspalteten: CompAG-Rescue und CompAG-Soccer. Unglücklicherweise konnte sich das Soccer-Team aufgrund eines Hardwaredefekts nicht für die German Open qualifizieren. Mit dem Roboter Phobos erreichten wir, das Team CompAG-Rescue, den 12. Platz bei der Vorqualifikation in Magdeburg. Er besteht größtenteils aus Lego und konnte den Parcours weit nicht fehlerfrei bewältigen, denn er war nur mit einigen Helligkeitssensoren zur Linien- und Opfererkennung und Infrarotsensoren zum Umfahren der Hindernisse ausgestattet. Aus diesem Grund haben wir beschlossen, einen vollkommen neuen Roboter zu konstruieren.
+	</p>
+		<h3>
+			Hardware
+		</h3>
+	<p>
+	Die Grundidee der Konstrunktion von Ares ist ein rundes Holzgerüst, das mit drei Omniwheels und halbkreisförmig angeordneten Sensoren an der Unterseite ausgestattet ist.
+	</p>
+	<p>
+	Unter den Bauteilen befinden sich:
+	<ul>
+		<li>1 Hauptplatine RN-Control 1.4 Mega32 von robotikhardware.de</li>
+		<li>2 Motortreiber RN-VN2 DualMotor von robotikhardware.de</li>
+		<li>5 Helligkeitssensoren von Qfix für die Linienerkennung</li>
+		<li>1 Farbsensor TCS 230 für die Opfererkennung</li>
+		<li>2 Ultraschall-Entfernungssensoren SRF10 für die Hinderniserkennung</li>
+		<li>3 Getriebemotoren 50:1 385ER</li>
+		<li>3 Omniwheels 60mm aus PUR (Polyurethan) soft</li>
+		<li>1 Batteriepack 12V</li>
+	</ul>
+</p>
+
+
+		<h4>
+			Funktionen der Bauteile:
+		</h4>
+
+		<h5>
+			1 Hauptplatine RN-Control 1.4 Mega32
+		</h5>
+		<p>
+		Die bei der Qualifikationsrunde für den Roboter Phobos verwendete Platine wurde durch eine neue ersetzt. Der Grund dafür ist, dass sie eine größere Anzahl an Ports besitzt, die wir wegen der größeren Sensorenzahl benötigen. Zusätzlich besitzt sie 8 LEDs zur Werteausgabe und einen Lautsprecher, sodass wir keinen zusätzlichen mehr benötigen. Die Hauptplatine empfängt Werte von den Sensoren und steuert dementsprechend die Motortreiber. Sie ist auf einem zusätzlichen Stockwerk angebracht, da sie auf der Grundfläche keinen Platz mehr fand.
+		</p> 
+
+		<h5>
+			2 Motortreiber RN-VN2 DualMotor
+		</h5>
+		<p>
+		Wie schon an dem Namen zu erkennen ist, kann jede der beiden Motortreiber zwei Motoren ansteuern. Die Geschwindigkeit wird durch ein PWN-Signal von der Hauptplatine geregelt.
+		</p> 
+		<h5>
+			5 Helligkeitssensoren von Qfix
+		</h5>
+		<p>
+		Sie sind in der Form eines Halbkreises an der Unterseite des runden Grundgerüsts befestigt und dienen der Linienerkennung. Eine von ihnen an die Analogports der Hauptplatine gesendete Spannung wird mithilfe des dahinter befindlichen ADC (Analog-Digital-Wandler) in eine Zahl zwischen 0 und 1023 umgewandelt, die die Hauptplatine auswertet: Je größer die Zahl ist, desto dunkler ist die vom Sensor wahrgenommene Umgebung. Es sind fünf anstelle von nur drei Helligkeitssensoren, wie es bei Phobos, der bei Bodenunebenheiten zwischen den Räumen oft vom Weg abgekommen ist, der Fall war. Wir hoffen, durch die Verbesserung eine Punkteeinbuße zu verhindern.
+		</p> 
+		<h5>
+			1 Farbsensor TCS 230
+		</h5>
+		<p>
+		Das ist ein Bauteil, das Phobos nicht besaß; der alte Roboter verwendete für die Opfererkennung genau wie für die Linienerkennung die Helligkeitssensoren. Diese arbeiteten dabei aber sehr unzuverlässig; grüne Opfer wurden nie erkannt, silberne übersehen. Dieses Problem soll der Farbsensor lösen, denn er ist in der Lage nacheinander die Helligkeiten der Farben rot, grün und blau zu messen. Die ermittelten Werte werden über eine Frequenz an die Digitalports der Hauptplatine gesendet. Das Programm überprüft die empfangenen Daten und vergleicht die Kombination der empfangenen Werte (RGB-Wert) mit denen der grünen und silbernen Opfer. Eine LED sorgt dafür, dass die Sensoren an der Unterseite des Roboters korrekt arbeitet können.
+		</p> 
+		<h5>
+			2 Ultraschall-Entfernungssensoren SRF10
+		</h5>
+		<p>
+		Auf dem zusätzlichen Stockwerk des Roboters, auf dem sich auch die Platine befindet, sind die Sensoren in Fahrtrichtung an einem Stück Maschendraht angebracht. Sie liegen relativ hoch, um nicht vom Batteriepack behindert zu werden, das direkt davor befestigt ist. Durch die Versendung von Ultraschallwellen könne sie die Entfernung zu eventuellen Hindernissen messen. Diese errechnet der Sensor anhand der Dauer, die die ausgesendeten Wellen für ihre Rückkehr benötigen, und schickt einen cm-Wert über den I2C-Port, der komplexe Informationen empfangen kann, an die Hauptplatine, die den Motorsteuerungen daraufhin mitteilt, wie die Motoren sich zu verhalten haben. Für diese Art der Hinderniserkennung haben wir uns entschieden, da mit den Infrarotsensoren, die wir beim Qualifikationsturnier für Phobos verwendeten, einige Schwierigkeiten aufgetreten sind: Um einige Hindernisse war mit schwarzem Tape umwickelt, das das Licht schluckte, sodass es nicht zurückkam; das Hindernis wurde somit nicht erkannt und konnte nicht umfahren werden.
+		</p> 
+		<h5>
+			3 Getriebemotoren 50:1 385ER
+		</h5>
+		<p>
+		Die beiden Lego-Motoren, die bei Phobos verwendet wurden, ersetzten wir durch diese leistungsstarken Motoren, die von den Motortreibern angesteuert werden.
+		</p> 
+		<h5>
+			3 Omniwheels 60mm soft
+		</h5>
+		<p>
+		Eines der größten Probleme von Phobos war, dass er mit seinen zwei gewöhnlichen Lego-Rädern und einem Gleiter an der Vorderseite, dessen Rutscheigenschaften jedoch unzureichend waren, nicht wendig genug war, um den scharfen Kurven des Parcours zu folgen. Das wollten wir bei der neuen Konstruktion mit Omniwheels ändern. Sie sind mit Epoxidharz an der Motorachse befestigt.
+		</p> 
+		<h5>
+			1 Batteriepack 12V
+		</h5>
+		<p>
+		Ein 8x12V-Batteriepack, welches vorne am Roboter montiert ist, versorgt den Roboter mit Energie. Seine Befestigung bilden zwei Ringe aus Flachbandkabeln.
+		</p> 
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/projekte/verwaltung.php b/contents/projekte/verwaltung.php
new file mode 100644
index 0000000..ac4ce46
--- /dev/null
+++ b/contents/projekte/verwaltung.php
@@ -0,0 +1,26 @@
+<?php
+	$author = 'Emily';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/projekte/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Verwaltung
+	</h2>
+	<p>
+		Dieses Projekt ist noch in Planung.
+		Wir halten euch über die Fortschritte auf dem Laufenden.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/projekte/webdesign.php b/contents/projekte/webdesign.php
new file mode 100644
index 0000000..9ae9d7e
--- /dev/null
+++ b/contents/projekte/webdesign.php
@@ -0,0 +1,26 @@
+<?php
+	$author = 'Emily';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/projekte/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Webdesign
+	</h2>
+	<p>
+		Das Produkt dieser Lerneinheit ist die Seite, die ihr vor euch seht!
+		Wir haben html, css und php behandelt.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/01-helloworld.php b/contents/wissen/cpp-tutorial/01-helloworld.php
new file mode 100644
index 0000000..3755d94
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/01-helloworld.php
@@ -0,0 +1,53 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		1. Hello World
+	</h2>
+	<p>
+		<code style="white-space:pre">
+	// Dies ist ein Kommentar.
+	/* Dies ist auch ein Kommentar,
+	nur ist er mehrzeilig. */
+		
+#include &lt;iostream&gt;
+	
+int main()
+{
+	std::cout &lt;&lt; &quot;Hello World!&quot; &lt;&lt; std::endl;
+	return 0;
+  
+}
+	
+		</code>
+	</p>
+		<p>
+		In dieser Zeile binden wir die Datei iostream ein. Diese stellt uns die später benutzten Objekte std::cout und 
+std::endl zur Verfügung.
+main ist der Name der Eintrittsfunktion. Das Programm beginnt mit der Ausführung der main-Funktion.
+Die geschweiften Klammern { und } begrenzen den Block, der den Code, der zur main-Funktion gehört, darstellt.
+std::cout ist der Name der Standard-Ausgabe. Mit &lt;&lt; werden Objekte an die Standardausgabe geschickt, hier z. B.der Text &quot;Hello World!&quot;. Texte, die keine Programmbefehle sind, werden in C++ im Allgemeinen mit &quot; &quot; begrenzt. std::endl ist ein besonderes Objekt, dass einen Zeilenumbruch erzeugt. Wie jeder Befehl ist dieser mit einem Semikolon begrenzt, man kann einen sehr langen Befehl also auf mehrere Zeilen aufteilen.
+Der Return-Befehl beendet das Programm und gibt den Rückgabewert des Programms an. Ein Wert von 0 wie hier bedeutet, dass das Prgramm fehlerfrei abgelaufen ist.
+	</p>
+<h3>Aufgabe:</h3>
+<p>
+Erstelle selbstgeschrieben, nicht kopiert,
+ein eigenes helloWorld-Programm,
+das eine von dir festgelegte Zeichenkette ausgibt.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/02-konsole.php b/contents/wissen/cpp-tutorial/02-konsole.php
new file mode 100644
index 0000000..4656607
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/02-konsole.php
@@ -0,0 +1,59 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		2. Konsole
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  char cEingabe;
+  
+  std::cout &lt;&lt; &quot;Bitte geben sie ein einzelnes Zeichen ein,&quot; &lt;&lt; std::endl;
+  std::cout &lt;&lt; gefolgt von einem Druck auf &lt;Enter&gt;&quot; &lt;&lt std::endl;
+  
+  std::cin &gt;&gt; cEingabe;
+  
+  std::cout &lt;&lt &quot;Ihre Eingabe war: &quot; &lt;&lt cEingabe &lt;&lt std::endl;
+     
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+cEingabe ist eine Variable. Variablen werden benutzt, um Werte zu speichern, mit denen das Programm operieren soll.
+Hier handelt es sich um eine Variable vom Typ char, das steht für Character ist bedeutet Buchstabe. Eine
+Variable vom Typ char kann einen einzelnen Buchstaben fassen.
+</p>
+<p>
+std::cin ist das Gegenteil von std::cout, es handelt sich um die Standardeingabe. Mit &gt;&gt; wird eine Eingabe in eine Variable eingelesen. Da cEingabe vom Typ char ist, muss ein einzelner Buchstabe eingeben werden.
+</p>
+<p>
+Wie man sieht, kann man mit std::cout auch Variableninhalte ausgeben. Dabei wird der Variablenname nicht in &quot; &quot; geschrieben, sonst würde ja nur der Name der Variable als Text und nicht der Inhalt der Variable ausgegeben werden.
+</p>
+
+<h3>Aufgabe:</h3>
+<p>
+Erstelle ein Programm, das den Benutzer mit seinen Initialien begrüßt.
+Lasse den Benutzer dabei diese Initialien selbst eingeben.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/03-integer.php b/contents/wissen/cpp-tutorial/03-integer.php
new file mode 100644
index 0000000..ff23570
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/03-integer.php
@@ -0,0 +1,79 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		3. Integer
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+
+  int iX = 5;
+  int iY, iZ;
+
+
+  std::cout &lt;&lt; &quot;Ein paar Werte: &quot; &lt;&lt; iX &lt;&lt; &quot;|&quot; &lt;&lt; iY &lt;&lt; &quot;|&quot; &lt;&lt; iZ &lt;&lt; std::endl;
+  std::cout &lt;&lt; &quot;Geben sie bitte zwei Zahlen ein, bestätigen mit &lt;Enter&gt;&quot; &lt;&lt; std::endl;
+  
+  std::cin &gt;&gt; iY; std::cin &gt;&gt; iZ;
+  
+  iX = iY * iZ;
+  
+  std::cout &lt;&lt; &quot;Das Produkt der Zahlen: &quot; &lt;&lt; iX &lt;&lt; std::endl;
+  std::cout &lt;&lt; &quot;Die Summe der Zahlen: &quot; &lt;&lt; iY + iZ &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+int steht für Integer, das bedeutet Ganzzahl. Hier wird sie auf den Startwert 5 initialisiert.		
+Man kann auch mehrere Variablen gleichzeitig deklarieren.
+Auch die Eingabe funktioniert bei ints wie bei chars, nur dass man jetzt Zahlen eingeben muss.	
+Man kann int-Variablen genauso wie andere Variablen ausgeben. Dabei ist zu beachten, dass iY und iZ noch keine sinnvollen Werte haben.	
+Man kann in C++ sehr einfach rechnen, hier wird iX auf das Produkt von iY und iZ gesetzt.
+	</p>
+	<p>
+Einige Grundrechenarten:
+	</p>
+		<table>
+<tr><td style="width:8em;">iX = iY + iX;</td><td>Addition</td></tr>
+<tr><td>iX = iY - iX;</td><td>Subtraktion</td></tr>
+<tr><td>iX = iY * iZ;</td><td>Multiplikation</td></tr>
+<tr><td>iX = iY / iZ;</td><td>Division (bei ints wird hierbei immer abgerundet)</td></tr>
+<tr><td>iX = iY % iZ;</td><td>Modulo (Rest der Division, Berechnung wie der Rest einer Division in der Grundschule)</td></tr>
+<tr><td>iX += 5;</td><td>Addition mit Zuweisung (iX wird um 5 erhöht)</td></tr>
+<tr><td>iX -= iY;</td><td>Subtraktion mit Zuweisung (iX wird um iY erniedrigt)</td></tr>
+<tr><td>iX++;</td><td>Inkrementierung (Addition von 1)</td></tr>
+<tr><td>iY--;</td><td>Dekrementierung (Subtraktion von 1)</td></tr>
+		</table>
+
+<h3>Aufgabe:</h3>
+	<p>
+Probiere die im Kommentar aufgeführten Grundrechenarten aus,
+und verstehe ihre Wirkung (% ist nicht immer gleich verständlich).
+Programmiere dann einen einfachen Taschenrechner,
+der zu zwei eingegebenen Zahlen automatisch
+die 4 Grundrechenarten anwendet,
+und alle Ergebnisse ausgibt.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php b/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php
new file mode 100644
index 0000000..a26d85c
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/04-kontrollstrukturen.php
@@ -0,0 +1,111 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+	
+	/*$content = str_replace('/*','</code><p>',$content);*/
+?>
+
+<div id="inhalt">
+	<h2>
+		4. Kontrollstrukturen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  int iX;
+  
+  std::cout &lt;&lt; &quot;Geben sie eine Zahl ein!&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; iX;
+
+  if(iX == 0)
+  {
+    std::cout &lt;&lt; &quot;iX ist 0!&quot; &lt;&lt; std::endl;
+  }
+
+
+  else if(iX &gt; 0)
+  {
+    std::cout &lt;&lt; &quot;iX ist nicht 0!&quot; &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+if bedeutet &quot;wenn&quot;, der nachfolgende Block wird nur ausgeführt, wenn die Bedingung wahr ist. Die Bedinung ist, dass iX 0 ist; zum Vergleich wird == benutzt, da = ja schon der Zuweisungsoperator ist.else heißt &quot;sonst&quot; und darf nur nach einem if-Block stehen. Er wird ausgeführt, wenn der if-Block
+nicht ausgeführt wird.
+</p>
+<p>
+Weitere Informationen:
+</p>
+<p class="absatzunten">
+Es gibt Variablen vom Typ bool,
+sie speichern die Werte true oder false,
+die unserem Wahr oder Falsch entsprechen.
+bool a = true; ist ein Beispiel dafür.
+</p>
+<p>
+Bei einer if-Abfrage gibt es folgende Operatoren:
+</p>
+<table>
+<tr><td style="width: 3em;">==</td><td>gleich</td></tr>
+<tr><td>!=</td><td>ungleich</td></tr>
+<tr><td>&gt;</td><td>größer</td></tr>
+<tr><td>&lt;</td><td>kleiner</td></tr>
+<tr><td>&gt;=</td><td>größergleich</td></tr>
+<tr><td>&lt;=	</td><td>kleinergleich</td></tr>
+<tr><td>!</td><td>nicht</td></tr>
+<tr><td>()</td><td>In Abfragen wie in Rechnungen kann man Klammern benutzen, um Zusammenhänge darzustellen.</td></tr>
+<tr><td>&&</td><td>und</td></tr>
+<tr><td>||</td><td>oder</td></tr>
+</table>
+<p class="absatzoben">
+Beispiele:
+</p>
+<table>
+<tr><td style="width: 11em;">a == b</td><td>ist a gleich b?</td></tr>
+<tr><td>a != b</td><td>ist a ungleich b?</td></tr>
+<tr><td>(a == b) || (a == c)</td><td>ist a gleich b oder a gleich c?</td></tr>
+</table>
+
+<h3>Aufgabe:</h4>
+<p>
+Benutze die if-Abfragen,
+um eine verbesserte Version des Taschenrechners zu schreiben,
+bei der es möglich ist, die Grundrechenart für die Berechnung
+selbst auszuwählen.
+</p>
+<p>
+Stelle fest, wie die Variablen gesetzt sein müssen, damit die Abfrage true ist:
+</p>
+<p>
+<code style="white-space: pre">
+	int a,b,c;
+	bool x,y,z;
+	if(!(a &gt; (b + c) || a &lt; (b + c)) && (x || !(y != z)))
+</code>
+</p>
+<p>
+Vereinfache diese Anweisung!
+</p>
+
+		</code>
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/05-switch.php b/contents/wissen/cpp-tutorial/05-switch.php
new file mode 100644
index 0000000..89a325e
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/05-switch.php
@@ -0,0 +1,76 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		5. Switch
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+
+int main()
+{
+  int iX = 0;
+  
+  std::cout &lt;&lt; &quot;Geben sie eine Zahl ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; iX;
+  
+  switch(iX)
+  {
+    case 0:
+      std::cout &lt;&lt; &quot;Nichts kannst du dir doch selbst merken ;)&quot; &lt;&lt; std::endl;
+      break;
+    case 1:
+      std::cout &lt;&lt; &quot;Hagga!&quot; &lt;&lt; std::endl;
+    case 2:
+      std::cout &lt;&lt; &quot;Hast du 1 oder 2 eingegeben?&quot; &lt;&lt; std::endl;
+      break;
+    case 5:
+      std::cout &lt;&lt; &quot;Ein echter Discordier! ;)&quot; &lt;&lt; std::endl;
+      break;
+    default:
+      std::cout &lt;&lt; &quot;Was, denkst du, sollte hier stehen?&quot; &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+switch ist eine Art Mehrfach-if, das einen Ausdruck (hier die Variable iX) auf mehrere Werte überprüft.
+</p>
+<h3>Aufgabe:</h3>
+<p>
+Verstehe die Funktionsweise der switch-Anweisung,
+und stelle fest, was das fehlende break; nach case 1: bewirkt.
+</p>
+<p>
+Vielleicht magst du auch den Taschenrechner auf ein schöneres Menü umbauen,
+bei dem du nun mithilfe von switch Entscheidungen fällst.
+Dazu kann der Benutzer einen char eingeben,
+Bedenke beim überprüfen aber, dass chars z. B. so abgefragt werden,
+wenn du ein Zeichen meinst:
+</p>
+<p>
+<code style="white-space: pre;">
+char c = 'a';
+if(c == 'b')
+</code>
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/06-schleifen.php b/contents/wissen/cpp-tutorial/06-schleifen.php
new file mode 100644
index 0000000..508c106
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/06-schleifen.php
@@ -0,0 +1,73 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt";>
+	<h2>
+		6. Schleifen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int main()
+{
+  int iX, iY;
+  iX = 0;
+
+  while(iX != 5)
+  {
+    std::cout &lt;&lt; &quot;Geben sie eine diskordische Zahl ein!&quot; &lt;&lt; std::endl;
+    std::cin &gt;&gt; iX;
+  }
+
+
+  for(int i = 0; i < 25; i++)
+  {
+    std::cout &lt;&lt; &quot;iX * &quot; &lt;&lt; i &lt;&lt; &quot;: &quot; &lt;&lt; i * iX &lt;&lt; std::endl;
+  }
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	<p>
+Das erste ist eine while-Schleife. Sie wird so lange ausgeführt, wie die Bedingung wahr ist,
+in diesem Fall also solange iX ungleich 5 ist.
+	</p>
+  <p>
+Die for-Schleife folgt folgendem Schema:
+	</p>
+	<p>
+for(Variable; Bedingung; Inkrementor)
+	</p>
+	<p>
+Am Anfang wird einmal der Befehl &lt;Variable&gt; ausgeführt, nach jedem Durchlauf wird einmal &lt;Inkrementor&gt;
+ausgeführt, und die Schleife läuft, solange die Bedinung wahr ist.
+	</p>
+<h3>Aufgabe:</h3>
+<p>
+Erstelle ein Programm, das mit Hilfe einer
+Funktion eine beliebige Potenz einer Zahl berechnen kann.
+Baue diese Funktion in einen Taschenrechner ein,
+der sich nur beendet, wenn der Benutzer es wünscht,
+sodass mehrere Rechnungen hintereinander möglich sind.
+</p>
+<p>
+Dies ist der letzte Taschenrechner, versprochen! ;)
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/07-funktionen.php b/contents/wissen/cpp-tutorial/07-funktionen.php
new file mode 100644
index 0000000..485e733
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/07-funktionen.php
@@ -0,0 +1,61 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		7. Funktionen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+	
+int summe(int iX, int iY)
+{
+  // Hier wird die Summe von iX und iY zurückgegeben.
+  return iX + iY;
+}
+	
+int main()
+{
+  int x,y;
+  
+  std::cout &lt;&lt; &quot;Geben sie bitte zwei Zahlen ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; x;
+  std::cin &gt;&gt; y;
+  std::cout &lt;&lt; &quot;Die Summe ihrer Zahlen ist: &quot; &lt;&lt; summe(x, y) &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+<p>
+In diesem Programm werden erstmal eigene Funktionen benutzt.
+</p>
+<p>
+Der Name unserer ersten Funktion ist summe.
+int ist dabei der Rückgabewert, d. h., beim Aufruf der Funktion gibt die Funktion eine Ganzzahl
+an den Aufrufer zurück. iX und iY ist Parameter, d. h., dies sind Variablen, die vom Aufrufer
+übergeben werden.
+</p>
+<h3>Aufgabe:</h3>
+<p>
+Erstelle ein Programm, das mit Hilfe einer
+Funktion überprüft, ob eine Zahl ohne Rest
+durch 2 teilbar ist.
+</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/08-arrays.php b/contents/wissen/cpp-tutorial/08-arrays.php
new file mode 100644
index 0000000..748017d
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/08-arrays.php
@@ -0,0 +1,81 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		8. Arrays
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+
+int main()
+{
+	
+  int iX[5];
+  
+  std::cout &lt;&lt; &quot;Geben sie bitte einen Wert ein.&quot; &lt;&lt; std::endl;
+  int a = 0;
+  std::cin &gt;&gt; a;
+  
+  // Füllen des Arrays
+  for(int i = 0; i &lt; 5; i++)
+    iX[i] = a + i;
+  
+  // Ausgabe des Arrays
+  for(int i = 0; i &lt; 5; i++)
+    std::cout &lt;&lt; iX[i] &lt;&lt; std::endl;
+  
+  return 0;
+}
+	
+		</code>
+			</p>
+<p>
+Ein Array ist eine Variable, die nicht nur einen Wert, sondern mehrere speichern kann.
+Man kann sich ein Array als eine Art Regal mit einer bestimmten Anzahl von Fächern vorstellen.
+Hier wird ein Array vom Typ int mit 5 Fächern deklariert, d. h., er kann 5 Ganzzahlen speichern.
+</p>
+<p>
+Arrays können wie andere Variablen angesprochen werden, nur dass man nach dem Namen immer noch
+den Index des anzusprechenden Feldes in [] schreibt, also z. B.:
+iX[2] = 4;
+std::cout &lt;&lt; iX[2];
+Die Indizes beginnen mit 0, d. h., hier wären die 5 Felder mit den Zahlen 0 bis 4, also iX[0] bis iX[4]
+bezeichnet.
+</p>
+<p>
+Eine besonders mächtige Eigenschaft von Arrays ist es,
+dass man beim Zugriff Variablen als Index benutzen kann,
+und so z. B. mit for-Schleifen ganze Array verarbeiten kann.
+</p>
+<p>
+Arrays können auch mehrere Dimensionen haben:
+int iY[5][5]; deklariert ein Array mit 5 * 5 Feldern.
+</p>
+<h3>Aufgabe:</h3>
+	<p>
+Erstelle ein Tic-Tac-Toe-Spiel
+und benutze ein Array für dein Spielfeld.
+Versuche zuerst, ein Spielfeld mit Testwerten auszugeben.
+Danach baue die möglichkeit ein, Felder zu besetzen.
+Zum Schluss kannst du eine Gewinnüberprüfung einbauen,
+sodass 2 Spieler an der Konsole gegeneinander spielen können.
+Ob und wie du Funktionen und andere Elemente sinnvoll benutzt,
+findest du im Weiterem besser selbst heraus.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/09-strings.php b/contents/wissen/cpp-tutorial/09-strings.php
new file mode 100644
index 0000000..2630176
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/09-strings.php
@@ -0,0 +1,67 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		9. Strings
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+	
+int main() 
+{
+  std::string s;
+  std::string s2(&quot;Text&quot;);
+  
+  // Ausgabe
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+  
+  // Eingabe
+  std::cout &lt;&lt; &quot;Gib einen Text ein.&quot; &lt;&lt; std::endl;
+  std::cin &gt;&gt; s;
+  
+  std::cout &lt;&lt; &quot;&quotDas war dein Text: &quot; &lt;&lt; s &lt;&lt; std::endl;
+  
+  std::cout &lr;&lt; &quot;1. Buchstabe: &quot; &lt;&lt; s[0] &lt;&lt; std::endl;
+
+  std::cout &lt;&lt; &quot;Dein Text ist so lang: &quot; &lt;&lt; s.length() &lt;&lt; std::endl;
+  
+  // Hier wird ein Buchstabe geändert
+  s2[2] = 's';
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+  
+  // Und hier einer angefügt
+  s2 += &quot;s&quot;;
+  std::cout &lt;&lt; s2 &lt;&lt; std::endl;
+}
+	
+		</code>
+	</p>
+	<p>
+		Jetzt müssen wir neben iostream auch die Datei string einbinden, da wir den String nutzen wollen.
+	</p>
+	<p>
+		Mit Klammern kann man sie mit einem Text initialisieren. Man kann wie in Arrays auf einzelne Buchstaben zugreifen.
+		Man darf dabei natürlich nicht über das Ende des Strings hinaus, daher kann man die Länge mit der length()-Methode bestimmen
+	</p>
+<h3>Aufgabe:</h3>
+	<p>
+Schreibe ein Programm, das Strings verwendet!
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/cpp-tutorial/10-klassen.php b/contents/wissen/cpp-tutorial/10-klassen.php
new file mode 100644
index 0000000..96905c7
--- /dev/null
+++ b/contents/wissen/cpp-tutorial/10-klassen.php
@@ -0,0 +1,115 @@
+<?php
+	$author = 'Jakob und Matthias';
+	$pathToRoot = '../../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/cpp.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		10. Klassen
+	</h2>
+	<p>
+		<code style="white-space:pre">
+#include &lt;iostream&gt;
+#include &lt;string&gt;
+	
+class Person
+{
+  private:
+    std::string name;
+    int alter;
+    
+  public:
+    /* Dies sind sogenannte Kontruktoren,
+     * sie haben keinen Rückgabewert und den gleichen Namen wie die Klasse;
+     * sie werden beim erstellen einer neuen Variable vom Typ der Klasse benutzt.
+     */
+    Person();
+    Person(std::string n, int a);
+    
+    void printName();
+    void setName(std::string n);
+    
+    void printAlter();
+    void setAlter(int a);
+};
+	
+Person::Person() {
+  name = &quot;Unbekannt&quot;;
+  // -1 bedeutet bei uns jetzt, dass wir das Alter nicht wissen
+  alter = -1;
+}
+	
+Person::Person(std::string n, int a) {
+  name = n;
+  alter = a;
+}
+	
+void Person::printName() {
+  std::cout &lt;&lt; &quot;Der Name ist: &quot; &lt;&lt; name &lt;&lt; std::endl;
+}
+	
+void Person::setName(std::string n) {
+  name = n;
+}
+	
+void Person::printAlter() {
+  if(alter &lt; 0) std::cout &lt;&lt; &quot;Das Alter ist unbekannt.&quot; &lt;&lt; std::endl;
+  else std::cout &lt;&lt; &quot;Das Alter ist: &quot; &lt;&lt; alter &lt;&lt; std::endl;
+}
+	
+void Person::setAlter(int a) {
+  alter = a;
+}
+	
+int main() {
+  // Hier wird der Konstruktor Person() benutzt
+  Person p;
+  	
+  // Hier wird der Konstruktor Person(std::string n, int a) benutzt
+  Person p2(&quot;Hans&quot;, 20);
+  	
+  p.printName();
+  p.printAlter();
+  	
+  p2.printName();
+  p2.printAlter();
+  	
+  p.setName(std::string(&quot;Horst&quot;));
+  p.setAlter(19);
+  p.printName();
+  p.printAlter();
+  
+  return 0;
+}
+	
+		</code>
+	</p>
+	
+	<p>
+		Im letzten Teil haben wir std::string kennengelernt. Dieser Typ ist eine sogenannte Klasse. In diesem Teil lernen wir nun, wie wir selbst solche Typen definieren.
+	</p>
+	<p>
+		Wir wollen also eine Klasse erstellen, die einen Eintrag einer Personen-Kartei darstellt.
+	</p>
+	<p>
+ 		Der Name des neuen Typs steht hinter class, in diesem Fall Person.
+	</p>
+	<p>
+	  Unter private stehen Einträge, die nur innerhalb der Klasse verfügbar sind, unter public stehen solche, die auch von außen aus aufrufbar sind. Man kann in einer Klasse sowohl Variablen, als auch Funktionen, sogenannte Methoden, definieren
+	</p>
+	<p>
+Außerhalb der Klasse werden die Methoden dann mit Inhalt gefüllt. Mit :: beschreibt man, zu welcher Klasse die Methoden gehören. Die Variablen der Klasse können dabei genauso benutzt werden wie die Variablen der Funktion.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/hardware.php b/contents/wissen/hardware.php
new file mode 100644
index 0000000..b9a2c71
--- /dev/null
+++ b/contents/wissen/hardware.php
@@ -0,0 +1,124 @@
+<?php
+    $title = 'Hardwarekomponenten';
+	$author = 'Jakob';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/main.inc.php');
+?>
+
+<div id="inhalt">
+<h2>
+Hardwarekomponenten im Computer
+</h2>
+	
+	<h3>Festplatte</h3>
+	<p>
+		In der Regel verk&ouml;rpert die Festplatte den Haupt-Massenspeicher f&uuml;r Daten in einem Computer.
+		Hier werden alle Daten angefangen vom Bootloader und dem Betriebssystem bis hin zu einzelnen Verzeichnissen und Ordnern
+		der Benutzer abgelegt. Festplatten werden &uuml;ber IDE- oder SATA-Kabel mit dem Mainboard verbunden.
+		Die Festplatte speichert Daten magnetisch in Bin&auml;rer Form.
+		Die Daten bleiben dabei auch nach einem Stromausfall erhalten.
+	</p>
+	
+	
+	<h3>CPU (Prozessor)</h3>
+	<p>
+		CPU steht kurz f&uuml;r "Central Prozessing Unit".
+		Damit ist die CPU/der Prozessor die zentrale Recheneinheit eines Computers.
+		Hier werden alle grundlegenden Rechenaufgaben erledigt.
+		(Genaueres &uuml;ber Register, etc.)
+	</p>
+	
+	
+	<h3>Grafikkarte</h3>
+	<p>
+		Die Grafikkarte sorgt daf&uuml;r das der Computer z. B. Bilder grafisch anzeigen kann.
+	</p>
+	
+	
+	<h3>Netzwerkkarte</h3>
+	<p>
+		Es gibt unterschiedlichste Netzwerkkarten, die es einem Computer erm&ouml;glichen,
+		mit anderem zu einem Netzwerk verbunden zu werden.
+		Abh&auml;ngig vom Typ der Netzwerkkarte k&ouml;nnen f&uuml;r das Netzwerk unterschiedliche Medien genutzt werden.
+		So kann z.B. ein einfaches Kabelnetzwerk aufgebaut werden,
+		oder ein Funknetz zur Kommunikation genutzt werden.
+	</p>
+	
+	
+	<h3>Soundkarte</h3>
+	<p>
+		Die Soundkarte sorgt daf&uuml;r das der PC T&ouml;ne ausgeben kann.
+	</p>
+	
+	
+	<h3>Arbeitsspeicher/RAM</h3>
+	<p>
+		RAM steht kurz f&uuml;r "Random Access Memory".
+		Es handelt sich hierbei um einen fl&uuml;chtigen Zwischenspeicher(Daten gehen ohne Strom verloren),
+		der dazu dient, unterschiedliche Datenobjekte f&uuml;r den "sp&auml;teren" Gebrauch zu speichern,
+		und diese schneller als die Festplatte bereitzustellen.
+	</p>
+	
+	
+	<h3>L&uuml;fter</h3>
+	<p>
+		In den meisten F&auml;llen werden L&uuml;fter zur Luftk&uuml;hlung eines Computers verwendet.
+		Sie verhindern ein &uuml;berhitzen des Computers.
+	</p>
+	
+	
+	<h3>CD/DVD-Laufwerk/Brenner</h3>
+	<p>
+		Ein CD/DVD-Laufwerk erm&ouml;glicht den Lesezugriff auf CD's und DVD's.
+		Auf ihnen k&ouml;nnen mittelgro&szlig; Datenmengen gespeichert sein,
+		und komfortabel transportiert werden.
+		Handelt es sich zus&auml;tzlich um einen Brenner, ist auch das Schreiben von Daten m&ouml;glich.
+	</p>
+	
+	
+	<h3>Floppy/Disketten-Laufwerk</h3>
+	<p>
+		Es kann Daten von Disketten lesen und auf diese schreiben.
+	</p>
+	
+	
+	<h3>Tastatur</h3>
+	<p>
+		Die Tastatur ist ein Eingabeger&auml;t, das die einfache und komfortable Eingabe von Texten erm&ouml;glicht.
+	</p>
+	
+	
+	<h3>Maus</h3>
+	<p>
+		Die Maus ist auch ein Eingabeger&auml;t, sie steuert den Cursor auf dem Bilschirm.
+		Die Maus stellt damit eine Zeigerfunktion f&uuml;r grafische Oberfl&auml;chen zur Verf&uuml;gung.
+	</p>
+	
+	
+	<h3>Monitor/Bildschirm</h3>
+	<p>
+		Der Bildschirm ist standardm&auml;&szlig;g das grafische Ausgabemedium eines Computers,
+		und liefert das Feedback zu den Benutzereingaben.
+	</p>
+	
+	
+	<h3>Netzteil</h3>
+	<p>
+		Das Netzteil versorgt alle dem Computer zugeh&ouml;rigen Bauteile mit Strom.
+	</p>
+	
+</div>
+
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
+
+
+
diff --git a/contents/wissen/main.php b/contents/wissen/main.php
new file mode 100644
index 0000000..fb2fdf3
--- /dev/null
+++ b/contents/wissen/main.php
@@ -0,0 +1,28 @@
+<?php
+	$author = 'Emily';
+	$pathToRoot = '../../';
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+	
+	include($pathToRoot . 'sidebars/wissen/main.inc.php');
+?>
+
+<div id="inhalt">
+	<h2>
+		Wissen
+	</h2>
+	<p>
+	  Hier könnt ihr euch umfassend über die Themen informieren, die wir in der ComputerAG behandelt haben. 
+	  Mit diesem Material könnt ihr euch dieses Wissen auch selbst aneignen. Falls euch ein Gebiet 
+	  besonders interessiert, besucht uns doch einmal im Internetcafe. Wir sind gerne bereit, unser Wissen
+	  an euch weiterzugeben.
+	</p>
+</div>
+	
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>	
diff --git a/contents/wissen/ruby.php b/contents/wissen/ruby.php
new file mode 100644
index 0000000..54da336
--- /dev/null
+++ b/contents/wissen/ruby.php
@@ -0,0 +1,103 @@
+<?php
+	$author = 'Tobias';
+	$editor= 'Jakob';
+	$pathToRoot = "../../";
+?>
+<?php
+	include($pathToRoot . 'includes/firstinclude.inc.php');
+	include($pathToRoot . 'includes/header.inc.php');
+	include($pathToRoot . 'includes/mainmenu.inc.php');
+
+	include($pathToRoot . 'sidebars/wissen/main.inc.php');
+?>
+<div id="inhalt">
+<h2>
+	Eine kleine Einführung zu Ruby
+</h2>
+<p>
+  Ruby ist ein Skriptsprache, das heißt sie wird nicht compiliert, wie z.B. C++, sondern sie wird interpretiert.
+  Ruby ist leicht und schnell zu erlernen, doch sie ist nicht zu unterschätzen.
+  Man kann mit Ruby eine ganze Ecke Sachen machen,
+  wie z.B. kleine Spiele programmieren.
+  Ruby ist gut geeignet für Einsteiger.
+  Da sich die meisten Programmiersprachen sehr ähnlich sind,
+  empfielt es sich, als Einsteiger mit Ruby zu beginnen und dann später auf andere Sprachen umzusteigen, wie z.B. C++.
+</p>
+<h3>
+	Wir beginnen mit einem Codebeispiel:
+</h3>
+<code style="white-space:pre">
+loop do
+  puts "Bitte geben sie etwas ein!"
+  eingabe = gets
+  if eingabe.chomp == ""
+    puts "Hey! Sie sollten etwas eingeben! ;)"
+  else
+    for i in 1..3
+      puts "Das haben sie eingegeben:"
+      puts eingabe
+    end
+  end
+end
+</code>
+<ul>
+  <li>
+    'loop' steht für Schleife. Hier sehen wir eine Endlosschleife.
+  </li>
+  <li>
+    'puts' steht für 'put string' und giebt einen String aus.
+  </li>
+  <li>
+    'gets' steht für 'get string' und nimmt einen eingegebenen String in das Programm auf. In diesem fall wird das Eingegebene in 'eingabe' gespeichert.
+  </li>
+  <li>
+    Hier ist eine Fallunterscheidung, genannt 'if'-Anweisung.
+  </li>
+  <li>
+    Alles, was zwischen 'else' und dem dazugehörigem 'end' steht, wird ausgeführt, wenn die Bedingungen der 'if'-Anweisung nicht zutreffen.
+  </li>
+  <li>
+    Hier ist eine Schleife, die das, was zwischen 'for' und 'end' 3 mal ausführt.
+  </li>
+  <li>
+    Hier wird ausgegeben, was in 'eingabe' gespeichert ist.
+  </li>
+  <li>
+    Das 'end' beendet einde Schleife(wie in diesem Fall), am Ende einer 'if'-Anweisung, oder eines 'else'-Blocks.
+  </li>
+</ul>
+<h3>
+	Im folgendem werden ein paar verwendete Begriffe erklärt:
+</h3>
+<dl>
+  <dt>
+    String
+  </dt>
+  <dd>
+    Ein String, so nennt man eine Zeichenkette, die aus Zeichen,
+    wie z.B. Buchstaben und Zahlen, bestehen kann.
+    Der Computer kann den Wert einer Zahl,
+    die in einem String steht nicht erkennen, ohne sie vorher umzuwandeln.
+  </dd>
+  <dt>Compilieren</dt>
+  <dd>
+    Compiliert werden Quelltexte, wie zum Beispiel die der Programmiersprache C++.
+    Der Quelltext wird geschrieben und danach von einem Compiler Compiliert,
+    was soviel bedeutet wie übersetzt, in Maschienencode, den der Computer versteht.
+    Den vorher geschriebenen Quelltext braucht man dann nicht mehr um das Programm zu starten,
+    sondern nurnoch das Compilierte Programm.
+  </dd>
+  <dt>Interpretieren</dt>
+  <dd>
+    Interpretiert wird der Programmcode von Skripten,
+    die in einer Skriptsprache wie z.B. Ruby geschrieben wurden.
+    Hier wird das Programm nicht einmal übersetzt,
+    sondern der so genannte Interpreter übersetzt immer nur das Stück Code, 
+    dass er gerade braucht.
+  </dd>
+</dl>
+</div>
+<?php
+	include($pathToRoot . 'includes/footer.inc.php');
+	include($pathToRoot . 'includes/lastinclude.inc.php');
+?>