Um dem Asuro die Befehle zu übermitteln bauen wir einen der unteren Lichtsensoren des Asuros auf die Oberseite der Platine.

Eine andere Möglichkeit geeignete Lichtsensoren in den Asuro einzubauen, damit der Asuro Lichtsignale bzw. Lichtbefehle empfangen und durchführen kann, wäre eine Erweiterungsplatine, die oberhalb des Asuros eingebaut werden muss.
Die entsprechenden Lichtsensoren kann man dann auf der Platine einarbeiten.



Wir haben uns aber schließlich dazu entschieden einen der unteren Lichtsensoren des Asuros auf die Oberseite der Platine zu bauen, da ein Lichtsensor oberhalb des Asuros sein muss, um die Lichtsignale empfangen zu können.
Der andere Lichtsensor soll weiterhin unterhalb des Asuros bleiben.[Muss eventuell als Linienfolger dienen.]
Diese Möglichkeit ist einfacher und schneller durchzuführen, weswegen wir uns für sie entschieden haben.

Wir haben uns jetzt überlegt das wir eine der beiden Lichtsensoren an der unterseite desRoboters auf die oberseite löten um mit ihr die befehle an den Asuro zu übermitteln.
Die Befehle kommen dan mit einer Lampe an den Roboter die wir mit dem Comuter verbinden.
Um den Roboter zu steuern werden wir die Befehle in eine Art morsealphabeht umsetzten die dem roboter sagen in welche richtung er fahren soll.

Problem 1:
Die Lampe muss an den Computer angeschlossen werden um die Befehle des Programmes mithilfe von morsezeichen an den Lichtsensor zu übermitteln.

Lösung:
Es gibt eine Platine die an den Druckerausgang des Computers angeschlossen werden kann die die befehle übermittelt.

Problem 2:
Der Asuro muss die Befehle empfangen und richtig umsetzen können,die per Licht gesendet werden,um Problemlos das Labyrinth zu durchqueren.(Entfernung,Drehung..)

Lösung:
Wir löten einen der unteren Fototransistoren (T9 oder T10) auf die Oberseite des ASUROS,da er nur so die Befehle richtig empfangen kann.
Außerdem muss ein Programm entwickelt werden,damit der ASURO die Lichtsignale richtig deuten kann.

Zeitschema und Darstellung des Morsealphabets

Der Code verwendet drei Symbole, die Punkt (•), Strich (−) und Pause ( ) genannt werden, gesprochen als Dit, Dah und „Schweigen“. Die Länge eines Dit bestimmt die Geschwindigkeit, mit der gesendet werden kann, und ist die grundlegende Zeiteinheit. Dazu ein Beispiel:
Genauer gilt Folgendes:
• Ein Dah ist üblicherweise dreimal so lang wie ein Dit.
• Die Pause zwischen zwei gesendeten Symbolen ist ein Dit lang.
• Zwischen Buchstaben in einem Wort wird eine Pause von Dah eingeschoben.
• Die Pause zwischen Wörtern beträgt sieben Dits.

Benötigte Morsezeichen:

Vorwärts: V · · · —
Rechtsdrehung: R · — ·
Linksdrehung: L · — · ·
Stop: S · · ·

Zahlen (zur Angabe der Streckenlänge in cm):

0 − − − − −
1 · − − − −
2 · · − − −
3 · · · − −
4 · · · · −
5 · · · · ·
6 − · · · ·
7 − − · · ·
8 − − − · ·
9 − − − − ·

Hatten wir nicht festgelegt, dass der Suro immer in 20cm-Schritten vorwärts fährt?

Die definitive Entscheidung stand noch aus.

stimmt

... mal sehen was wir dann letztendlich am Besten umsetzen können.

Das Programm,das wir zur Übermittlung der Morsezeichen benötigen,es funktioniert aber nur mit einem Linux-PC:

#include <stdio.h>
#include <msleep.h>
#include <asm/io.h>
#include <stdlib.h>

void warte(int p)
{
msleep(p*50);

}
int main()
{
int kurz=100;
int ar[300];
int Anzahl = 0;
int i = 0;
int x = 0;
int z = 0;
int te;
int bug = 0;
char y;
char s[200];
ar[65]=66; //A
ar[66]=132; //B
ar[67]=164; //C
ar[68]=131; //D
ar[69]=1; //E
ar[70]=36; //F
ar[71]=195; //G
ar[72]=4; //H
ar[73]=2; //I
ar[74]=116; //J
ar[75]=163; //K
ar[76]=68; //L
ar[77]=194; //M
ar[78]=130; //N
ar[79]=227; //O
ar[80]=100; //P
ar[81]=212; //Q
ar[82]=67; //R
ar[83]=3; //S
ar[84]=129; //T
ar[85]=35; //U
ar[86]=20; //V
ar[87]=99; //W
ar[88]=148; //X
ar[89]=180; //Y
ar[90]=196; //Z
ar[97]=66; //a
ar[98]=132; //b
ar[99]=164; //c
ar[100]=131; //d
ar[101]=1; //e
ar[102]=36; //f
ar[103]=195; //g
ar[104]=4; //h
ar[105]=2; //i
ar[106]=116; //j
ar[107]=163; //k
ar[108]=68; //l
ar[109]=194; //m
ar[110]=130; //n
ar[111]=227; //o
ar[112]=100; //p
ar[113]=212; //q
ar[114]=67; //r
ar[115]=3; //s
ar[116]=129; //t
ar[117]=35; //u
ar[118]=20; //v
ar[119]=99; //w
ar[120]=148; //x
ar[121]=180; //y
ar[122]=196; //z
ar[48]=253; //0
ar[49]=125; //1
ar[50]=61; //2
ar[51]=29; //3
ar[52]=13; //4
ar[53]=5; //5
ar[54]=133; //6
ar[55]=197; //7
ar[56]=229; //8
ar[57]=245; //9
ioperm(0x378,3,1);

while (1)
{
for (i=0; i<199; i++)
{
s[i]=0;
}
i=0;
printf("Bitte gib den Text ein, den du morsen willst.\n");
do {
s[i]=getchar();
} while (s[i++]!=10);
s[i-1]='\0';
//outb(255,0x378);
//warte(1);
//outb(0, 0x378);
if (s[0]=='q'&&s[1]==' ') break;
for (i=0;s[i]!='\0';i++)
{
Anzahl = ar[s[i]]&7;
z=128;
for (x=0;x<Anzahl;x++)
{
if(s[i]!=' ')
{
if(ar[s[i]]&z)
{
outb(255, 0x378);
warte(3);
outb(0, 0x378);
warte(1);
printf("-");
}
else
{
outb(255,0x378);
warte(1);
outb(0, 0x378);
warte(1);
printf(".");
}
z=z/2;
}
}
warte(2);
printf (" ");
if (s[i]==' ')
{
warte(2);
printf (" ");
}
}
printf ("\n");
}
return 0;
}

hat sich überhaupt schon mal einer gedanken dazu gemacht wie der pc die lichtsignale versenden soll??

Ja!