Telementriedaten des ASURO -> kleines Problem

Hallo alle zusammen,

ich habe mal versucht ein kleines Programm zu schreiben, welches den ASURO von 80 auf 255 in 10er Schritten ein mal vorwärts und ein mal rückwärts beschleunigt.
Dabei sollen:
der Weg,
die Geschwindigkeit
und die Beschleunigung
gemessen werden (Drehzahl fehlt noch).
Leider ist mein Programm etwas zu groß geraten und der ASURO-Flasher meckert. Außerdem geht es nur manchmal. Mal kommen im Hyperterminal die richtigen Werte, mal nur die Überschriften, mal Chinesisch .... mal macht der ASURO gar nix mehr ... liegt evtl an den vielen Prints oder an der Größe des Progs.
Zur Zeit ist der untere Teil des Progs auskommentiert aus Platzgründen des Controllers (steht aber fast das selbe wie oben nur die Richtung und langsamer oder schneller ändern sich -- vlt bekommts ja jemand fertig mit einer "Kopfzeile" das ganze laufen zu lassen da bin ich grade dran)

Code:

---

#include <asuro.h>
#include <string.h> // für strlen

/*Left min/max, right min/max values da minimiert auf acht bit *4

+00150 *4  =        600                                                        //data[1] left
+00222 *4  =        888

+00190 *4  =        760                                                //data[0] right
+00236 *4  =        944

*/


//Variablenverageb

int speed;                                                                        //PWM des Rades
float msleft;                                                                //Metre pro Sekunde (Radgeschwindigkeit links
float msright;                                                                //Metre pro Sekunde (Radgeschwindigkeit rechts

float msleft1;                                                                // Vorherige Geschwindigkeit (für a)
float msright1;                                                                // Vorherige Geschwindigkeit (für a)
       
float mleft;                                                                //Gefahrene Strecke links
float mright;                                                                //Gefahrene Strecke rechts

float aleft;                                                                //Beschleunigung linkes Rad
float aright;                                                                //Beschleunigung rechtes Rad

unsigned int data [2];                                          //Array erstellen mit 2 Speicherzellen für Odometriedaten
                                                                                        //data [0] links T11
                                                                                        //data [1] rechts T12
                                                                                       
int Zeit = 1000;                                                        //Zeit in der die Impulse gezählt werden 1s
int Zeit1 = 0;                                                                //letzte Zeit zur bestimmung der Zeit dif (für a)

int triggerleft  =        (((222-150)/2)+150)*4;                //Helldunkelwechsel linkes Rad
int leftimpuls = 0;                                                        //gezählte Impulse pro Zeit links

int triggerright =  (((236-190)/2)+190)*4;        //Helldunkelwechsel rechtes Rad
int        rightimpuls = 0;                                                        //gezählte Impulse pro Zeit rechts

unsigned int long stopzeit;

float pie        = 3.14;        //15927;                                        //pie
float Umfang = 12; //.0165920775;                                //(38.25*pie);                                        //Umfang in cm
int Muster = 12;                                                        //anzahl der Hell Dunkel übergänge
//-----------------------------------------------------------------------------
int main(void)
{
BackLED(OFF,OFF);                                                        //alle LED werden im Programm zur Veranschaulichung genutzt
StatusLED(RED);                                                                //d.h. wo bin ich im Prog. die Backeled´s sind aus da Odometrie an
       

  Init();
  while(1){ 
//-----------------------------------------------------------------------------
//Intro für Hyperterminal
//-----------------------------------------------------------------------------
SerPrint("\t            Telemetriedaten\n\r\n\r");

//Überschrift im Hyperterminal für Vorwärts

SerPrint("\tVorwärts\n\r\n\r");
//-----------------------------------------------------------------------------
//Los gehts                        beschleunigen
//-----------------------------------------------------------------------------
        StatusLED(GREEN);
          MotorDir(FWD,FWD);                                        //Richtung festlegen
       
        Zeit1 = 0 ;                                                        //muss vor der Schleife genullt werden fals nioch restwert aus letzter Schleife
        msright1 = 0;
        msleft1 = 0;
       
        for (speed=80;speed<=255;speed +=10){  //Geschwindigkeit von 80 auf 255 in 10er schritten
                MotorSpeed(speed,speed);                        //Geschwindigkeit einlesen
                       
                        leftimpuls = 0;                                        //Impullse vor Zählvorgang auf null
                        rightimpuls = 0;                                //Impullse vor Zählvorgang auf null
                       
                        //Detektierung der Impulse
                        stopzeit=Gettime()+Zeit;                  //1 sekunde Hell Dunkel Wechsel detektieren
                        do {
                                OdometrieData(data);                                //Odo daten bereitstellen
                                        if(data[0]==triggerright)                //wenn data = trigerlevel
                                          rightimpuls++;                                //impulse erhöhen
                                        if(data[1]==triggerleft)                //siehe zwei drüber
                                          leftimpuls++;                                        //siehe zwei drüber
                       
                        } while (stopzeit>Gettime());                        //das ganze bis Zeit um (1s)
                       
                        //Auswertung der Impulse
                                                               
                                //Geschwindigkeit
                                msright = (rightimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);  //da ms
                                msleft = (leftimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);        //da ms
                               
                                //Zurückgelegter Weg
                                mright = msright * Zeit;
                                mleft        = msleft * Zeit;
                               
                                //Beschleunigung
                                aright = (msright-msright1) / (Zeit-Zeit1);
                                aleft = (msleft-msleft1) / (Zeit-Zeit1);
                                       
                                Zeit1 = Zeit;                        //jetzige Zeit Zwischenspeichern für a beim nächsen turn
                                msright1 = msright;                //jetzige Geschwindigkeit Zwischenspeichern für a beim nächsen turn
                                msleft1 = msleft;                //jetzige Geschwindigkeit Zwischenspeichern für a beim nächsen turn
                               
                        //Ausgabe
                       
                       
                               
                       
                       
                        //rechtes
                        SerPrint("Rechtes Rad    ");
                        PrintFloat(mright,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msright,2,2);
                        SerPrint(" cm/s"    );
                        PrintFloat(aright,2,2);
                        SerPrint(" cm/s²");
                       
                        //Lehrstellen zwischen rechts und links
                        SerPrint("          ");
                       
                        //links
                        SerPrint("Linkes Rad    ");
                        PrintFloat(mleft,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msleft,2,2);
                        SerPrint(" cm/s    ");
                        PrintFloat(aleft,2,2);
                        SerPrint(" cm/s²");
                       
                        //2*absatz
                       
                        SerPrint("\n\r\n\r");
                        }
//-----------------------------------------------------------------------------
//Langsamer werden
//-----------------------------------------------------------------------------
                Zeit1 = 0 ;
                msright1 =0;
                msleft1 =0;
       
                for (speed=255;speed>=80;speed -=10){
                MotorSpeed(speed,speed);
                       
                        leftimpuls = 0;
                        rightimpuls = 0;
                       
                        //Detektierung der Impulse
                        stopzeit=Gettime()+Zeit;          //1 sekunde Hell Dunkel Wechsel detektieren
                        do {
                                OdometrieData(data);
                                        if(data[0]==triggerright)
                                          rightimpuls--;
                                        if(data[1]==triggerleft)
                                          leftimpuls--;
                       
                        } while (stopzeit>Gettime());
                       
                        //Auswertung der Impulse
                               
                                //Geschwindigkeit
                                msright = (rightimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);  //da ms
                                msleft = (leftimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);        //da ms
                               
                                //Zurückgelegter Weg
                                mright = msright * Zeit;
                                mleft        = msleft * Zeit;
                               
                                //Beschleunigung
                                aright = (msright-msright1) / (Zeit-Zeit1);
                                aleft = (msleft-msleft1) / (Zeit-Zeit1);
                                       
                                Zeit1 = Zeit;
                                msright1 = msright;
                                msleft1 = msleft;
                               
                        //Ausgabe
                       
                       
                               
                       
                       
                        //rechtes
                        SerPrint("Rechtes Rad    ");
                        PrintFloat(mright,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msright,2,2);
                        SerPrint(" cm/s"    );
                        PrintFloat(aright,2,2);
                        SerPrint(" cm/s²");
                       
                        //Lehrstellen zwischen rechts und links
                        SerPrint("          ");
                       
                        //links
                        SerPrint("Linkes Rad    ");
                        PrintFloat(mleft,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msleft,2,2);
                        SerPrint(" cm/s    ");
                        PrintFloat(aleft,2,2);
                        SerPrint(" cm/s²");
                       
                        //2*absatz
                       
                        SerPrint("\n\r\n\r");
                        }               
//-----------------------------------------------------------------------------
//Rückwärts
//-----------------------------------------------------------------------------


//Überschrieft im Hyperterminal

SerPrint("\t            Rückwärts\n\r\n\r");
//-----------------------------------------------------------------------------
//Los gehts                        beschleunigen
//-----------------------------------------------------------------------------       
                StatusLED(YELLOW);
                MotorDir(RWD,RWD);
               
                Zeit1 = 0 ;
                msright1 =0;
                msleft1 =0;
               
        for (speed=80;speed<=255;speed +=10){
                MotorSpeed(speed,speed);
                                               
                        leftimpuls = 0;
                        rightimpuls = 0;
                       
                        //Detektierung der Impulse
                        stopzeit=Gettime()+Zeit;          //1 sekunde Hell Dunkel Wechsel detektieren
                        do {
                                OdometrieData(data);
                                        if(data[0]==triggerright)
                                          rightimpuls++;
                                        if(data[1]==triggerleft)
                                          leftimpuls++;
                       
                        } while (stopzeit>Gettime());
                       
                        //Auswertung der Impulse
                       
                                //Geschwindigkeit
                                msright = (rightimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);  //da ms
                                msleft = (leftimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);        //da ms
                               
                                //Zurückgelegter Weg
                                mright = msright * Zeit;
                                mleft        = msleft * Zeit;
                               
                                //Beschleunigung
                                aright = (msright-msright1) / (Zeit-Zeit1);
                                aleft = (msleft-msleft1) / (Zeit-Zeit1);
                                       
                                Zeit1 = Zeit;
                                msright1 = msright;
                                msleft1 = msleft;
                               
                        //Ausgabe
                       
                       
                               
                       
                       
                        //rechtes
                        SerPrint("Rechtes Rad    ");
                        PrintFloat(mright,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msright,2,2);
                        SerPrint(" cm/s"    );
                        PrintFloat(aright,2,2);
                        SerPrint(" cm/s²");
                       
                        //Lehrstellen zwischen rechts und links
                        SerPrint("          ");
                       
                        //links
                        SerPrint("Linkes Rad    ");
                        PrintFloat(mleft,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msleft,2,2);
                        SerPrint(" cm/s    ");
                        PrintFloat(aleft,2,2);
                        SerPrint(" cm/s²");
                       
                        //2*absatz
                       
                        SerPrint("\n\r\n\r");
                        }
               
               
//-----------------------------------------------------------------------------
//Langsamer werden
//-----------------------------------------------------------------------------

        Zeit1 = 0 ;
        msright1 =0;
        msleft1 =0;
               
        for (speed=255;speed>=80;speed -=10){
                MotorSpeed(speed,speed);                       
                       
                        leftimpuls = 0;
                        rightimpuls = 0;
                       
                        //Detektierung der Impulse
                        stopzeit=Gettime()+Zeit;          //1 sekunde Hell Dunkel Wechsel detektieren
                        do {
                                OdometrieData(data);
                                        if(data[0]==triggerright)
                                          rightimpuls--;
                                        if(data[1]==triggerleft)
                                          leftimpuls--;
                       
                        } while (stopzeit>Gettime());
                       
                        //Auswertung der Impulse
                       
                                //Geschwindigkeit
                                msright = (rightimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);  //da ms
                                msleft = (leftimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);        //da ms
                               
                                //Zurückgelegter Weg
                                mright = msright * Zeit;
                                mleft        = msleft * Zeit;
                               
                                //Beschleunigung
                                aright = (msright-msright1) / (Zeit-Zeit1);
                                aleft = (msleft-msleft1) / (Zeit-Zeit1);
                                       
                                Zeit1 = Zeit;
                                msright1 = msright;
                                msleft1 = msleft;
                               
                        //Ausgabe
                       
                       
                               
                       
                       
                        //rechtes
                        SerPrint("Rechtes Rad    ");
                        PrintFloat(mright,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msright,2,2);
                        SerPrint(" cm/s"    );
                        PrintFloat(aright,2,2);
                        SerPrint(" cm/s²");
                       
                        //Lehrstellen zwischen rechts und links
                        SerPrint("          ");
                       
                        //links
                        SerPrint("Linkes Rad    ");
                        PrintFloat(mleft,2,2);
                        SerPrint (" m    ");
                        PrintFloat(msleft,2,2);
                        SerPrint(" cm/s    ");
                        PrintFloat(aleft,2,2);
                        SerPrint(" cm/s²");
                       
                        //2*absatz
                       
                        SerPrint("\n\r\n\r");
                        }
       
       
                }   
               
          return 0;}

---

Viel spaß und schon mal danke

NomiS

ou Nachtrag das ganze geht nur mit der ganz neuen Lib

Hallo NomiS,
um Platz zu sparen würde ich erst mal folgende Teile zusammenfassen:

Code:

---

SerPrint("            Vorwärts");
SerPrint("\n\r");
SerPrint("\n\r");

---

zu

Code:

---

SerPrint("\tVorwärts\n\r\n\r");

---

Und dies hier:

Code:

---

SerPrint("Linkes Rad");
SerPrint("    ");

---

zu

Code:

---

SerPrint("Linkes Rad    ");

---

Das spart erst einmal die Funktionsaufrufe und die Zuweisungen der Parameter für die Funktion. Kleinkram, aber in deinem Programm läppert es sich doch erheblich.

Gruß Sternthaler

Hi Sternthaler,

hab ich gemacht.
Code ist oben im ersten Eintrag geändert.
Jedoch beträgt das HEX file weiterhin 20kb. Wieviel passt denn eigentlich auf den Speicher?
Und geht das Programm bei jemandem? Mein ASURO hat grade irgendwas. Wenn ich ein und das selbe Programm auf ihn schreibe macht er unterschiedliche Sachen. Vlt. Batterie leer. Muss ich nachher daheim schauen.

Hallo NomiS

Soweit ich's überblicke, sollte dein Code erstmal etwas optimiert werden :

--- Bei den vielen gleichen Ausgaben würde sich wohl eine Funktion ala

schreibeWert(text_parameter, wert_links, wert_rechts, text_einheit)

lohnen.

--- keine floats! Auch mit integern kann man prima rechnen, bzw. speichert man nicht so: float pie = 3.14; sondern int pie =314; und teilt nach der Rechnung das Ergebniss durch 100 (oder verzichtet ganz auf pi und schreibt direkt 314 in die Rechnung):

msright = (rightimpuls * ((Umfang*pie)/Muster))/(Zeit*1000);
wird dann zu
msright = (rightimpuls * ((Umfang*pie/100)/Muster))/(Zeit*1000);

oder, noch besser, man rechnet konstante Werte schon vorher aus:

int pie = 314; //15927; //pie
int Umfang = 12; //.0165920775; //
(38.25*pie); //Umfang in cm
int Muster = 12; //anzahl der Hell Dunkel übergänge

int pie_umfang_muster=pie*umfang/(Muster*100);

msright = (rightimpuls * pie_umfang_Muster / (Zeit*1000);

Was das allerdings soll, verstehe ich nicht ganz. Umfang ist doch schon pi*2r?

--- Warum nimmst du alle Odowerte mal 4? Du füllst nur mit zusätzlichen Nullen auf und vergleichst mit einem Wert, der auch zusätzliche Nullen hat. Lass die Multiplikationen weg, dann kannst du platzsparend und viel schneller mit 8Bit-Werten rechnen.(Der AVR ist ein 8Biter!):

unsigned char triggerleft = (((222-150)/2)+150); //Helldunkelwechsel linkes Rad


--- if(data[0]==triggerright)

Ähm, das verstehe ich auch nicht. Auf == sollte man bei Odowerten nicht prüfen, denn es könnte sein, das genau dieser Wert übersprungen wird. Was passiert eigentlich, wenn mehrmals hintereinander triggerlevel beim selben Segment der Codescheibe erkannt wird? Woran erkennst du das nächste Segment auf der Codescheibe? (data[0] war doch links, oder?)

---Vielleicht sollte man erst den Weg ausrechnen:
weg=impulse/anzahldercodescheibensegmente*umfang

Und dann die Geschwindigkeit:
geschw=weg/zeit

Die Beschleunigung ist dann die Geschwindigkeitsänderung und nicht ganz so einfach zu messen/zu berechnen und hier wohl nicht so sinnvoll.

--- Warum nennst du das "telemetrie"?

Das sind mal die gröbsten Punkte die mir auffallen. Wie ist denn dieses Programm entstanden? Hast du das am Stück eingegeben oder hast du die einzelnen Teile erstmal getestet und dann zusammengefügt?

Gruß

Mic

[Edit]
Oje:

for (speed=80;speed<=255;speed +=10) wenn speed schon >245 ist, muss die Schleife beendet werden.

rightimpuls--; negative Beschleunigung beim Abbremsen?

...
MotorSpeed(0,0);
return 0;}

Der ATMega8 hat 8kB Flashspeicher(Datenblatt)

Zitat:

---

Und geht das Programm bei jemandem?

---

Wohl kaum...

Boa danke radbruch,

coole Ideen. Hab ich morgen mal was zu tun im geschäft!!! ;-)
Ich fang mal von unten an:
telemetrie = na ja ich habe nen namen gebraucht und der hat mir gefallen.
wie mache ich das mit der segmenterkennung? hab im Moment keine so rechte Idee.
Und meine größte frage. Wie schreibt man selbst so ne kleine Funktion wie in den Bibliotheken. Hab das im Geschäft versucht - es wollte aber nicht. Versuche es noch mal. Wie komme ich aus so einer Funktion wieder raus?
Aber erst mal vielen, vielen dank.

Gruß NomiS

Noch mal ein paar fragen!
Wenn ich das triggerlevel nicht mal 4 nehme funktioniert es nicht!
Kann man Variablen auch so definieren int xx 10/20;?
Warum bekomme ich eine 15Kb hex-datei auf einen 8kb prozessor?
das programm entstand so:
Ich wollte die Geschwindigkeit der Räder erhöhen und wieder verringern
Dann kam der Vor und Rücklauf dazu
Dann die Auswertung der Geschwindigkeit
-> bis dahin hat das Prog gestern was ausgegeben (obst stimmt weiß ich nicht ob die Formeln stimmen hab ich noch nicht geprüft aber 9 - 36cm/s dacht ich ist doch ganz gut
Ja dann dachte ich heute ich könnte ja aus der Geschwindigkeit den Rest ermiteln
Was bedeutet:
for (speed=80;speed<=255;speed +=10) wenn speed schon >245 ist, muss die Schleife beendet werden.
und das -- ist ein fehler das Programm war ursprünglich anderst ausgelegt hab ich übersehen deshalb wird im Hyperterminal immer - xx ausgegeben danke

Hallo NomiS,
ja, da hast du noch ein bisschen zu tum.

Zu deinen Fragen:

Zitat:

---

Wenn ich das triggerlevel nicht mal 4 nehme funktioniert es nicht!

---

Die Multiplikation mit 4 lass mal drin.
- int triggerleft = (((222-150)/2)+150)*4;
Hier nutzt du ja die 8-Bit-Werte (222; 150) aus dem Testprogramm von Arexx-Henk. Ein Vergleich nachher mit den 16-Bit-Werten aus OdometrieData() macht hier das *4 also nötig.
Aber ganz wichtig ist der Einwand von radbruch, den Triggerlevel nicht mit == zu vergleichen.

Zitat:

---

Kann man Variablen auch so definieren int xx 10/20;

---

Nein, einer Variablen muss man mit = etwas 'zuweisen'.
Eine Definition wäre mit "#define xx 10/20" gemacht.
Hier würde ich aber von abraten, da dann an allen Stellen, an denen du xx benutzt, der Computer zur Laufzeit die 10/20 rechnen muss.
Bei "int xx = 10/20;" wird diese Rechnung vom Compiler gemacht.
Aber auch das ist nicht gut, da dann ja 0,5 rauskommt, den du im int-Wert nicht speichern kannst.
Hier also unbedingt genau überlegen was du benötigst.

Zitat:

---

Warum bekomme ich eine 15Kb hex-datei auf einen 8kb prozessor?

---

Da schaust du am besten hier: http://www.schulz-koengen.de/biblio/intelhex.htm

Zitat:

---

9 - 36cm/s dacht ich ist doch ganz gut

---

Das sieht bestens aus. 9 cm/s ist gegenüber meinem Asuro sogar ein Top-Wert. Ich bleibe schon bei ca. 15 cm/s stehen. Allerdings bin ich mit ca. 40 dafür ein bisschen schneller.

Zitat:

---

Wie schreibt man selbst so ne kleine Funktion wie in den Bibliotheken.

---

Da haben einige Leute, die schon viel Erfahrung haben, viel Arbeit und Ergeiz reingesteckt. Erfahrung ist hier das Zauberwort. Mit 20 werden das noch längst nicht alle schaffen. Also nicht verzweifeln.

Zitat:

---

wie mache ich das mit der segmenterkennung?

---

Um diese Frage zu beantworten, solltest du mal die Forums-Suche eine zeitlang quälen.
Das wird dir nicht nur eine perfekte Antwort liefern, sondern auch einige andere Fragen sicherlich gut beantworten. Lesen unterstützt die Erfahrung ungemein ;-)

Gruß Sternthaler

die größe der .hex-datei ist gar nicht sooo entscheidend. in dieser datei sind neben dem programm auch noch sämtliche zeilennummern sowie alle möglichen prüfsummen enthalten. diese werden im prozessor nicht mitgespeichert, also wird sie schon deutlich kleiner. meine größte .hex datei ist etwa 14kb groß und hat gerade noch so gepasst.

Ja das dachte ich mir nach Sternthalers link schon. Ich habe zur Zeit leider irgend ein Problem mit dem Compiler. Wenn ich ein und die selbe datei UNVERÄNDERT mehrmals compilieren und dann flashe ist die Packetanzahl und die Größe ab und an mal anderst. Komisch !!!
Na ja
Ich hab mal bisschen was am code geändert. Geht zwar jetzt gar nicht mehr aber ich Poste ihn trotzdem mal. Das ist lediglich der geänderte Teil. Wie man eine Funktion erstellt habe ich aber Leider immer noch nicht heraus. Und verkürzt sich durch Funktionen der code?
Ersetzt der Compiler nicht den Funktionsaufruf mit der Funktion oder gibt es den Teil dann nur einmal als Unterprogramm?

Code:

---

#include <asuro.h>
#include <string.h> // für strlen

/*Left min/max, right min/max values da minimiert auf acht bit *4

+00150 *4  =        600                        744                                //data[0] left
+00222 *4  =        888
                                                                                798
+00190 *4  =        760                852                                        //data[1] right
+00236 *4  =        944

*/
//Statische Vergabe

#define Triggerlevel 798
#define Hysteresis 25
#define LOW 0
#define HIGH 1

//Variablenverageb

int speed;                                                                        //PWM des Rades
float cmsleft;                                                                //Metre pro Sekunde (Radgeschwindigkeit links
float cmsright;                                                                //Metre pro Sekunde (Radgeschwindigkeit rechts

float cmsleft1;                                                                // Vorherige Geschwindigkeit (für a)
float cmsright1;                                                                // Vorherige Geschwindigkeit (für a)
       
float cmleft;                                                                //Gefahrene Strecke links
float cmright;                                                                //Gefahrene Strecke rechts

float aleft;                                                                //Beschleunigung linkes Rad
float aright;                                                                //Beschleunigung rechtes Rad

unsigned int data [2];                                          //Array erstellen mit 2 Speicherzellen für Odometriedaten
                                                                                        //data [0] links T11
                                                                                        //data [1] rechts T12
       
signed int status[2]={0,0};

int Zeit = 1000;                                                        //Zeit in der die Impulse gezählt werden 1s
int Zeit1 = 0;                                                                //letzte Zeit zur bestimmung der Zeit dif (für a)

int leftimpuls = 0;                                                        //gezählte Impulse pro Zeit links
int        rightimpuls = 0;                                                        //gezählte Impulse pro Zeit rechts

unsigned int long stopzeit;

int anzahldercodescheibensegmente_umfang = 1; //Breite eines Segmentes

//-----------------------------------------------------------------------------
int main(void)
{
BackLED(OFF,OFF);                                                        //alle LED werden im Programm zur Veranschaulichung genutzt
StatusLED(RED);                                                                //d.h. wo bin ich im Prog. die Backeled´s sind aus da Odometrie an
       

  Init();
  while(1){ 
//-----------------------------------------------------------------------------
//Intro für Hyperterminal
//-----------------------------------------------------------------------------
SerPrint("\t            Telemetriedaten\n\r\n\r");

//Überschrift im Hyperterminal für Vorwärts

SerPrint("\tVorwärts\n\r\n\r");
//-----------------------------------------------------------------------------
//Los gehts                        beschleunigen
//-----------------------------------------------------------------------------
        StatusLED(GREEN);
          MotorDir(FWD,FWD);                                        //Richtung festlegen
       
        Zeit1 = 0 ;                                                        //muss vor der Schleife genullt werden fals nioch restwert aus letzter Schleife
        cmsright1 = 0;
        cmsleft1 = 0;
       
        for (speed=80;speed>245;speed +=10){  //Geschwindigkeit von 80 auf 255 in 10er schritten
                MotorSpeed(speed,speed);                        //Geschwindigkeit einlesen
                       
                        leftimpuls = 0;                                        //Impullse vor Zählvorgang auf null
                        rightimpuls = 0;                                //Impullse vor Zählvorgang auf null
                       
                        //Detektierung der Impulse
                        stopzeit=Gettime()+Zeit;                  //1 sekunde Hell Dunkel Wechsel detektieren
                       
                        do {
                                OdometrieData(data);                                                                //Odo daten bereitstellen
                                       
                                        //Wechselt linker Sensor von niedrig auf hoch?
                                        if((status[0]==LOW)&&(data[0]>Triggerlevel+Hysteresis)){
                                                status[0] = HIGH;       
                                                leftimpuls++;}       

                                        //Wechselt linker Sensor von hoch auf niedrig?
                                        if((status[0]==HIGH)&&(data[0]<Triggerlevel-Hysteresis)){
                                                status[0] = LOW        ;
                                                leftimpuls++;}
                                               
                                        //Wechselt rechter Sensor von niedrig auf hoch?
                                        if((status[1]==LOW)&&(data[1]>Triggerlevel+Hysteresis)){
                                                status[1] = HIGH;
                                                StatusLED(RED);
                                                rightimpuls++;        }

                                        //Wechselt rechter Sensor von hoch auf niedrig?
                                        if((status[1]==HIGH)&&(data[1]<Triggerlevel-Hysteresis)){
                                                status[1] = LOW;
                                                rightimpuls++;        }
                       
                        } while (stopzeit>Gettime());                        //das ganze bis Zeit um (1s)
                       
                       
                       
                        //Auswertung der Impulse
                                                               
                                                               
                                //Zurückgelegter Weg
                                cmright = ((rightimpuls  / anzahldercodescheibensegmente_umfang)/5); // /5 da Übersetzungsverhältniss 1/5
                                cmleft        = ((leftimpuls  / anzahldercodescheibensegmente_umfang)/ 5 );
                               
                                //Geschwindigkeit
                                cmsright = cmright * (Zeit/1000);
                                cmsleft = cmleft * (Zeit/1000);        //da ms
                               
                                //Beschleunigung
                                aright = (cmsright-cmsright1) / (Zeit-Zeit1);
                                aleft = (cmsleft-cmsleft1) / (Zeit-Zeit1);
                                       
                                Zeit1 = Zeit;                        //jetzige Zeit Zwischenspeichern für a beim nächsen turn
                                cmsright1 = cmsright;        //jetzige Geschwindigkeit Zwischenspeichern für a beim nächsen turn
                                cmsleft1 = cmsleft;                //jetzige Geschwindigkeit Zwischenspeichern für a beim nächsen turn
                               
                        //Ausgabe
                       
                       
                               
                       
                       
                        //rechtes
                        SerPrint("Rechtes Rad    ");
                        PrintFloat(cmright,2,2);
                        SerPrint (" cm    ");
                        PrintFloat(cmsright,2,2);
                        SerPrint(" cm/s"    );
                        PrintFloat(aright,2,2);
                        SerPrint(" cm/s²");
                       
                        //Lehrstellen zwischen rechts und links
                        SerPrint(" - ");
                       
                        //links
                        SerPrint("Linkes Rad    ");
                        PrintFloat(cmleft,2,2);
                        SerPrint (" cm    ");
                        PrintFloat(cmsleft,2,2);
                        SerPrint(" cm/s    ");
                        PrintFloat(aleft,2,2);
                        SerPrint(" cm/s²");
                       
                        //2*absatz
                       
                        SerPrint("\n\r\n\r");
                        }
       
                }   
               
                MotorSpeed(0,0);       
                return 0;}
               
               
/*               
void Odometrie (){               
        do {
                OdometrieData(data);                                                                //Odo daten bereitstellen
                if(data[0]<=760 + 50 || data[0]>=888 -50)                //wenn data = trigerlevel
                rightimpuls++;                                                                //impulse erhöhen
                if(data[1]<=600        +50 || data[1]>8888 - 50)                                                //siehe zwei drüber
                leftimpuls++;                                                                        //siehe zwei drüber
                       
                } while (stopzeit>Gettime());}*/

---

Wie geht den, dass mit Daten direkt in Excel importiert werden? Währe ganz net wenn das Programm das machen würde, dann müsste man nicht immer mit diesem Hyperterminal arbeiten und hätte eine saubere Liste.