Problem mit der Odometrie Hardwarefehler? [gelöst]

Hallo Leute ich hab ein Problem mit der Odometrie. Wenn ich follgendes Programm flash, aus Mehr Spaß mit ASURO Band II etwas modofieziert:

Code:

---

#include "asuro.h"

/*Schwellwert für die Hell-/Dunkel-Unterscheidung. Eventuell muss damit etwas variiert werden.*/
#define TRIGGERLEVEL 600
#define HYSTERSIS 10
#define LOW 0
#define HIGH 1
#define SPEED 255

int main(void)
{
        unsigned int data[2];
        signed int status[2] = {0, 0};
        signed int difference = 0;
        Init();
        MotorDir(FWD, FWD);
        MotorSpeed(SPEED, SPEED);
        while(1)
        {
                        OdometrieData(data);                                                                               
                if ((status[0]==LOW) && (data[0]>TRIGGERLEVEL+HYSTERSIS))                /*Wenn linker Sensor von niedrig auf hoch wechselt*/
                {
                        status[0]=HIGH;
                        difference++;
                }
                if ((status[0]==HIGH) && (data[0]<TRIGGERLEVEL-HYSTERSIS))        /*Wenn linker Sensor von hoch auf niedrig wechselt*/
                {
                        status[0]=LOW;
                        difference++;
                }
                if ((status[1]==LOW) && (data[1]>TRIGGERLEVEL+HYSTERSIS))                /*Wenn rechter Sensor von niedrig auf hoch wechselt*/
                {
                        status[1]=HIGH;
                        difference--;
                }
                if ((status[1]==HIGH) && (data[1]<TRIGGERLEVEL-HYSTERSIS))        /*Wenn rechter Sensor von hoch auf neidrig wechselt*/
                {
                        status[1]=LOW;
                        difference--;
                }
                PrintInt (difference);
                if (difference<-SPEED)                                                                                        /*Sicherheitsabfragen*/
                {
                        difference=-SPEED;
                }                                               
                if (difference>SPEED)
                {
                        difference=SPEED;
                }                                               
                if (difference>0)
                {
                        MotorSpeed(SPEED-difference, SPEED);                                                        /*Motoren einstellen*/
                }               
                else if (difference<0)
                {
                        MotorSpeed(SPEED, SPEED+difference);
                }
                if (SPEED-difference<=100)
                {
                        difference=0;
                }
        }
}

---

Wenn ich dann die Daten abfrage kommt folgendes:

Code:

---

00000011111.....206206206206.......

---

und wenn 206 kommt bleibt das rechte Rad stehen. Könnte es ein Hardwaredefekt sein oder ist im Programm ein Fehler?

Vielen Dank im vorraus.

du musst die triggerlevel werte anpassen. variiere sie etwas, dann sollte es gehen.

Lass dir zuerst mal deine Werte für die Odometrie ausgeben.
Im Anhang als Beispiel meine Werte.

Du brauchst dir nur in Excel von beiden Odometriereihen den Mittelwert bilden lassen und fertig.

Die Hysterese kannst du dir sparen da es sich ja eh nur um ungefähre Mittelwerte handelt. Außerdem sind die Amplituden der Sinuswellen so groß dass die +-10 der Hysterese nicht ins Gewicht fällt.

Hier ein Beispiel wie du den links und rechts zurückgelegten Weg bekommst. Die von dir gewünschte Differenz ist halt dann einfach counter_l-counter_r
Übrigens entspricht 1 Tick 3mm Fahrstrecke bei der 8er Odometriescheibe.

Code:

---

       
//alle folgenden Variablen sind vom typ int

        OdometrieData(odata);

        if(odata[0]<ODOMETRIE_L && flag_l==0)
        {
            counter_l++;
            flag_l=1;
        }
        else if(odata[0]>ODOMETRIE_L && flag_l==1)
        {
            counter_l++;
            flag_l=0;
        }


        if(odata[1]<ODOMETRIE_R && flag_r==0)
        {
            counter_r++;
            flag_r=1;
        }
        else if(odata[1]>ODOMETRIE_R && flag_r==1)
        {
            counter_r++;
            flag_r=0;
        }

---

Hallo liggi,
auch dir erst mal ein willkommen im Forum.

Folgendes hilft zwar nicht für dein Problem, aber du solltes Bedenken:
Wenn du in der main()-Schleife die PrintInt()-Funktion benutzt, verlierst du auf alle Fälle einige Wechsel an der Odometrie.
Zum übertragen eines einzelnen Zeichens benötigst du ca. 5ms. Um den INT-Wert zu senden scheinst du 3 Zeichen zu benötigen. Das sind dann 15ms.
Wenn du an der Odometrie die Scheiben mit den den 8 Farbwechseln hast (harry3 spricht dann sinnvollerweise von den 8er-Scheiben), hast du bei ca. 50cm/Sekunde (Volldampf mit 255) nur ca. 6ms Zeit zwischen den einzelnen Farbwechseln.
Gerechnet: 1 / (50cm/Sekunde / 12cm/Radumdrehung * 5(Getriebestufe1) * 8(Farbwechsel))
Bei den 16-er-Scheiben sieht es dann natürlich noch schlechter aus, da hier die Zeit auf ca. 3ms zwischen den Farbwechseln schumpft.

Du bekommst hier also nur ungefähr jeden 3(6)-ten Farbwechsel mit. Wenn nun das senden und die Geschwindigkeit eventuell 'synchron' laufen, dann wird du sogar gar keine Wechsel 'sehen'. (Das ist aber sehr unwahrscheinlich).

das ist wahr. besser sammeln, und dann nach der messung kurz stehen bleiben und ein array senden.

Ich hab mir ein int Array mit (soweit ich mich erinnern kann) 200 Elementen gemacht und dann alle 0,5ms gemessen.

Zuerst auf Vollgas beschleunigen, dann kurz warten, dann das Array mit Werten füllen, und letztendlich Motor stoppen und mittels IR Übertragung das Array übermitteln.

Man sieht in der Regel anhand der Sinuskurven eh sehr schön ob man oft genug gemessen hat. Nur wenn die Sinuswelle schön "rund" ist und keine Ecken hat passt die Abtastrate.

alternativ könnte man auch 512 bytes im eeprom speichern. schreibzeit sind etwa 8-10 milliesekunden, was aber dafür immer noch schnell genug ist. leider müsste man dann den wert durch 4 teilen, um ihn in byteform zu bringen, was etwas auf kosten der genauigkeit geht. alternativ würde man den wert um 2 bits nach rechts shiften, das spart rechenzeit. dafür könnte man 512 werte fest speichern, und dann auch später abrufen.

Zitat:

---

alternativ könnte man auch 512 bytes im eeprom speichern. schreibzeit sind etwa 8-10 milliesekunden, was aber dafür immer noch schnell genug ist.

---

8-10ms sind meiner Meinung nach etwas zu langsam um bei Vollgas schön aufgelöste Kurven zu sehen.

Der 10bit Messwert steckt in einem int von 2 byte Größe, also 16bit.
Man könnte den int also in 2 einzelne bytes zerlegen. Und diese kann man ja dann in eeprom schreiben.

Beim Senden an den PC kann man die jeweils zusammengehörenden bytes wieder zu int's zusammenbauen.

das ist wahr, jedoch kann man dann nur noch die hälfte speichern.

ich würde es mal probieren, ohne zeitverzögerung, also schreiben-messen-schreiben-messen usw, das wäre dann ja die bestmögliche frequenz. durch 4 teilen, bzw. nach rechts shiften geht schneller als 2x in den eeprom zu schreiben, deshalb würde ich die bits opfern, zumindest für die ersten tests.
mein asuro ist allerdings grad baustelle.

Zitat:

---

Zitat von harry3

8-10ms sind meiner Meinung nach etwas zu langsam um bei Vollgas schön aufgelöste Kurven zu sehen.

---

Wenn ich nicht total vergesslich wäre, könnte ich glauben, dass ich schon vorgerechnet hatte, das dies nicht nur etwas zu langsam ist, sondern mit Sicherheit ist das zu lahm.

ich versuch mal das grob zu berechnen...

der asuro fährt mit etwa 1 m/s = 1000mm/s
ein tick entspricht gut 3 mm
sind also ca 300 ticks pro sekunde, also 3-4 ms pro tick.

so sollte also jeder 2. bis 3. tick nur ein messwert kommen... das ist wohl wirklich zu wenig. alternative: ein array von 100 werten messen, stehenbleiben, eeprom schreiben, wieder fahren... hmm. ob das sinn macht weiss ich nicht genau, die frage ist wie viele werte durch das stehenbleiben und wieder losfahren verloren gehen. aber so könnte man 500 werte pluss 100 im sram festhalten.

So übertrieben viel Werte braucht man ja garnicht. Es genügen ja schon ein paar Wellenberge/Täler um zu sagen, wo der Mittelwert liegt.
100 Werte sind also weitaus genug, wenn man die Abtastzeit richtig wählt.

@harry3
poste doch einfach das Programm, mit dem du deine Messwerte für den EXCEL-Auszug oben aufgenommen hast.

@liggi
Sonst kannst du natürlich auch mit dem hier, dir die Daten der Odometrie einfach zum PC senden lassen.
Schön langsam an den Rädern drehen, und die Messwerte werden im PC-Programm angezeigt.
Dich dürfte zum Überprüfen, ob deine Hardware in Ordnung ist, vor allem der Teil interessieren:

Zitat:

---

Das Windows-Programm teilt sich in 4 Teile:
2 a) ...
2 b) Permanete Anzeige der Sensordaten vom Asuro
2 c) ...

---

Zitat:

---

Zitat von Sternthaler

@harry3
poste doch einfach das Programm, mit dem du deine Messwerte für den EXCEL-Auszug oben aufgenommen hast.

---

Das Programm hab ich nicht mehr, sonst hätte ich es bereits gepostet.

Hallo harry3,
schade, ich kann hier aber noch das Programm, leider nur *.hex, anbieten, das über den Beitrag
https://www.roboternetz.de/phpBB2/ze...=292879#292879 von ehenkes zu erreichen ist.

- Programm in den Asuro laden.
- Asuro aus- / einschalten ==> Er fährt dann los
- Asuro unter empfangsbereiten IR-Empfänger halten
- Irgendeine Asuro-Taste drücken ==> Messdaten werden übertragen.

Hallo und danke für die bisherige Hilfe. Ich konnte leidern nicht früher antworten. Ich hab das Programm von Sternthaler mal aus probierte und aus gewertet, dass kam dabei raus:

Code:

---

LoggingOdometers V1.0 (2006-05-21, Arexx-Henk)         

Left Odometer

+00154
+00154     
+00156     
+00177     
+00183     
+00201     
+00204     
+00207     
+00198     
+00186     
+00169     
+00160   
+00158
+00167
+00178
+00184
+00198
+00206     
+00198     
+00183     
+00172     
+00157     
+00149     
+00156
+00161
+00179
+00190
+00204
+00206
+00201   
+00189     
+00182     
+00162     
+00155     
+00158     
+00168 
+00179     
+00187
+00202
+00206
+00200
+00186
+00175
+00157     
+00152     
+00152     
+00160     
+00176     
+00184     
+00196
+00201     
+00203
+00194
+00185
+00171
+00163
+00147
+00159     
+00163     
+00184     
+00195     
+00206     
+00207     
+00203
+00192   
+00184
+00161
+00159
+00150
+00161
+00169
+00183     
+00197     
+00204     
+00207     
+00200     
+00191     
+00179
+00158 
+00155
+00155
+00158
+00176
+00179
+00194     
+00207     
+00203     
+00190     
+00178       
+00183
+00198
+00206
+00206
+00197     
+00183     
+00170     
+00151     
+00159     
+00157     
+00172     
+00179     
+00193
+00205
+00204
+00195
+00184
+00171
+00159
+00145
+00157
+00159     
+00182     
+00189     
+00199     
+00201     
+00202     
+00191     
+00182     
+00165
+00160
+00147
+00159
+00168
+00185
+00199     
+00206     
+00206     
+00201     
+00190     
+00182     
+00163
+00152
+00155
+00163     
+00177     
+00185
+00201
+00204
+00205
+00196
+00183
+00171
+00155
+00154
+00150     
+00167     
+00171     
+00184     
+00199     
+00206     
+00201     
+00190     
+00179 
+00159
+00156
+00143
+00163
+00171
+00188     
+00200     
+00206     
+00201     
+00190 
+00169
+00186     
+00199     
+00206     
+00200     
+00193     
+00177
+00171
+00146
+00151
+00153
+00173
+00183     
+00195     
+00200     
+00201     
+00195     
+00186     
+00174
+00156
+00150
+00148
+00169
+00179
+00195
+00205
+00206
+00204
+00195
+00180     
+00170     
+00152     
+00150     
+00153     
+00164     
+00186     
+00197     
+00206     
+00204     
+00200     
+00188
+00177
+00166 
+00147     
+00154     
+00155
+00175
+00176
+00197
+00203
+00205
+00190
+00180
+00159   
+00156   
+00142     
+00156     
+00169     
+00182     
+00199     
+00205     
+00203     
+00195
+00184
+00160
+00158
+00150
+00162
+00173     
+00182     
+00199     
+00204     
+00205     
+00192     

 

Right Odometer

+00213
+00193
+00171     
+00161     
+00149     
+00140     
+00147     
+00166
+00183
+00192
+00196
+00217
+00201
+00184     
+00166     
+00145     
+00141     
+00149     
+00166     
+00179 
+00198
+00208
+00207
+00197
+00180
+00160     
+00143     
+00141     
+00156     
+00172     
+00188
+00206
+00213
+00210
+00200
+00169
+00150   
+00138     
+00138     
+00147     
+00167     
+00181     
+00197 
+00204
+00199
+00199
+00186
+00167 
+00147     
+00134     
+00136     
+00152     
+00171
+00180
+00199
+00210
+00209
+00198
+00179
+00164     
+00146     
+00135     
+00139     
+00153     
+00175     
+00188
+00210
+00215
+00215
+00198
+00173     
+00157     
+00139     
+00131     
+00138     
+00192
+00213
+00203
+00184     
+00166     
+00147     
+00138     
+00143     
+00160     
+00178
+00195
+00207
+00209
+00199
+00182
+00167   
+00150     
+00139     
+00145     
+00167     
+00184     
+00200 
+00211
+00211
+00204
+00173
+00153
+00139
+00140     
+00147     
+00163     
+00180     
+00195     
+00203     
+00201
+00196
+00187
+00169
+00152
+00140
+00140     
+00145     
+00157     
+00175     
+00193     
+00208     
+00208
+00200
+00183
+00164
+00148
+00133
+00131 
+00142     
+00162     
+00179     
+00199     
+00215     
+00216   
+00207
+00184
+00163
+00148
+00136
+00137
+00154     
+00172     
+00185     
+00193     
+00200     
+00216     
+00195     
+00177     
+00156     
+00139         
+00203
+00207
+00202
+00187     
+00169     
+00152     
+00139     
+00138     
+00153     
+00174
+00191
+00208
+00212
+00209
+00193
+00168   
+00152     
+00144     
+00146     
+00156     
+00172     
+00186
+00199
+00204
+00199
+00199
+00185
+00169
+00149     
+00136     
+00135     
+00150     
+00172     
+00182     
+00200
+00211
+00210
+00196
+00173
+00156
+00137     
+00129     
+00136     
+00152     
+00171     
+00188     
+00209
+00214
+00214
+00195
+00172
+00160
+00147 
+00139     
+00144     
+00162     
+00180     
+00193     
+00195   
+00215
+00208
+00190
+00172
+00156
+00140
+00138     
+00153     
+00172     
+00192     
+00206     
+00209     
+00199     
+00183     
+00166     
+00146   
+00212
+00212
+00205
+00177
+00154
+00135
+00137
+00150
+00161
+00174
+00191
+00202
+00201

Left min/max, right min/max values

+00142
+00207

+00129
+00217

---

Also jetzt meine Frage:

Gibt das Programm die Helligkeit nicht zwichen 0 und irgendwas um 1000 aus? Wenn ja, ist es schlimm oder gar ein Problem, dass bei mir die Daten um ca. 180 penndel?

Danke

das hab ich schon von mehreren leuten gehört... scheint wohl gelegentlich so zu sein. theoretisch liegen die werte zwischen 0 und 1023.

Hallo liggi, hi damaltor.
Ich würde darauf tippen, dass die Messwerte nur mit 8 Bit erfasst wurden. (P.S.: Das Programm ist nicht von mir, sonst könnte ich das ja mit Sicherheit sagen.)
Ein Beispiel von mir erfasster Daten bei 'normaler' Schreibtischbeleuchtung und definitive 10 Bit mal als Bild unten.
Wenn du liggi deine Daten bei vollem Sonnenschein aufgenommen hast, dann könnten die Messwerte allerdings locker in den unteren Bereich rutschen. Aber im Moment ist ja keine Sonne da.
Im übrigen kommen bei meinem (funktionierenden) Asuro mit dem Programm zum Schluß folgende Daten raus:
Left min/max, right min/max values
+00097
+00182
+00067
+00171
Das sind nur 8-Bit-Messwerte!

Für 8 Bit spricht auch noch die Überlegung, dass 2 * 237 Daten übertragen wurden. Als INT-Variable gesammelt kämen wir da auf 2 * 237 * 2 Byte Speicher = 948 Byte. Passt zwar noch in den Asuro, aber halte ich für recht hochgegriffen, da ja auch noch Stack und bestimmt ein paar weitere Variablen Platz finden wollen.

Somit sind deine Messdaten im grünen Bereich.

@liggi
Jetzt habe ich dein Programm mal gerade ausproblert. (Besser spät als nie ;-) )
Der Asuro fährt bei mir wunderbar geradeaus und folgende Daten werden übertragen:
1 2 2 2 2 1 2 1 1 1 1 2 2 2 2 2 2 3 3 2 3 4 4 3 3 3 4 4 4 4 4 4 5 6 6 6 7 7 7 6 7 7 7 8 9 9 9 9 10 11 11 11 10 10 10 11 11 11 12 12 13 13 13 13 12 13 12 13 13 13 13 13 13 14 14 14 15 15 15 14 14 14 15 15 15 15 15 15 15 15 14 14 14 13 12 12 12 12 11 12 12 13 12 12 13 12 13
Egal wie ich an den Rädern bremse, bleibt der Wert immer unter 25.

Das hilft dir zwar im Moment nicht weiter, aber unabhängig von irgend einer Übertragungsgeschwindigkeit, ist das Programm funktionsfähig.

Aber folgendes: Multipliziere doch mal den Output deiner Messdaten mit 4:
Left min/max, right min/max values
+00142 * 4 = 568
+00207 * 4 = 828 -- Mittelwert der beiden : 698

+00129 * 4 = 516
+00217 * 4 = 868 -- Mittelwert der beiden : 692

Da in deinem Programm mit:
#define TRIGGERLEVEL 600
#define HYSTERSIS 10
die Werte eigendlich passen könnten, ist das Verhalten deines Asuros zwar 'merkwürdig', aber wie damaltor schon als erstes sagte: "Anpassen vom Triggerlevel" hier wohl sinnvollerweise auf 700, solltest du probieren. Da du bei deinen Werten genügend 'Luft' nach oben und unten hast, darf auch der Wert für HYSTERSIS ruhig auf 20 oder 30 erhöht werden. (Reduziert Fehlauswertungen.)

Danke Leute, jetzt geht alles. Es hat, bis auf das Triggerlevel, gepasst. Das Problem, war das mir irgend wie bei den späteren Programmen ein == stat einem = reingerutscht.

noch mal vielen Dank

bei sonnenschein werden die werte groß... viel licht = kleiner widerstand = hohe spannung am adc = hoher wert.

@liggi
Schön, dass es geht. Schade, dass du erst das funktionierende Programm gepostet hattest. Ja ja viel Wind um nichts gegeben.

@damaltor
hmmm, vertust du dich da mit den Liniensensoren T9 und T10?
Bei denen ist das so, dass die Spannung dann größer wird.
Die ODO-Sensoren T11 und T12 werden gegen Masse gezogen bei viel Licht. Damit geht die Spannung runter.

mmh habs auch grad gemerkt... -.- schaltplan hilft ;)

@damaltor
Zum Schaltplan vom Asuro habe ich mir schon seit langer Zeit ein Icon in der Schnellstartleiste abgelegt. ;-)
Auch ein Knopf zur ATmega8-Doku läßt sich immer gerne drücken. Was fehlt ist der Button zum gekühlten Bier. Da muss immer noch der Asuro fahren. :D
Hey, schau mal auf die Uhr. Musst du morgen nicht zur FH? Oder wird noch gebüffelt?

Hallo Leute ich hab mal eine Frage:
Habt ihr irgendwelche Vorrichtungen um Fremdlich von der Odometrie abzuhallten? Und ist es sinnvoll?

mfg liggi

ein ausgeschnittener teil einer pralinenverpackung (diese plastik einlagen)... halbiert gibt das ne art schirm die etwas helfen kann. oder einen kleinen karton aus pappe bauen.

Hallo
Also ich hab da ein Problem mit meiner Odometrie.
Ich hab grösstenteils den Code von liggi übernommen und ein wenig verändert.
Ich poste jetzt nur mal die Funktion und die definierten Werte, sonst wird das so unübersichtlich.
Was der Code machen soll:
Der Asuro soll geradeausfahren: OK
Sollte ein Taster gedrückt werden soll er aus der Funktion springen und entsprechend reagieren: OK
Wenn er stehen bleibt soll er dies erkennen und reagieren:
Und genau das funktioniert nur teilweise. Wenn ich ihn beim Fahren mit dem Finger stoppe, passiert gar nichts. Erst wenn ich ihn ein paar Ticks mit dem Zahnrad machen lasse erkennt er, dass da was nicht stimmt und fährt zurück.
Könnt ihr euch den Code vll. mal durchgucken und mir sagen wo's hakt?
Bleibt die Schleife irgendwo hängen? Weil eigentlich sollte die ja die ganze Zeit laufen und dann auch ständig prüfen, ob der Asuro steht.

LG Nils

Code:

---

#define TRIGGERLEVEL 600
#define PUFFER 3
#define COUNTERABFRAGE 40

#define LOW 0
#define HIGH 1
#define SPEED 120

int odometrie()
{

      unsigned int data[2]; // für die Odometrie Daten
      signed int status[2] = {0, 0}; // vorheriger Status der Odometrie links und rechts
      signed int difference = 0;
          int weg = 0; // Bei jedem Wechsel der Odometrie wird weg für beide Räder erhöht.
          int weg_alt = 0; // Zwischenspeichern des vorherigen gefahrenen Weges
          int counter = 0;  // Wenn counter einen bestimmten Wert (COUNTERABFRAGE) erreicht, wird weg mit weg_alt verglichen und entsprechend reagiert
 
        MotorDir(FWD,FWD);
        MotorSpeed(SPEED,SPEED);
       
        while(PollSwitch() == 0) 
        {
          OdometrieData(data);                             
                if ((status[0] == LOW) && (data[0] < TRIGGERLEVEL))      /*Wenn linker Sensor von niedrig auf hoch wechselt*/
                  {
                  status[0] = HIGH;
                  difference++;
              weg++;
              }
     
      if ((status[0] == HIGH) && (data[0] > TRIGGERLEVEL))  /*Wenn linker Sensor von hoch auf niedrig wechselt*/
      {
        status[0] = LOW;
        difference++;
          weg++;
      }
      if ((status[1] == LOW) && (data[1] < TRIGGERLEVEL))      /*Wenn rechter Sensor von niedrig auf hoch wechselt*/
      {
        status[1] = HIGH;
        difference--;
        weg++;
      }
      if ((status[1] == HIGH) && (data[1] > TRIGGERLEVEL))  /*Wenn rechter Sensor von hoch auf niedrig wechselt*/
      {
        status[1] = LOW;
        difference--;
        weg++;
      }
     
      if (difference < !SPEED)                                /*Sicherheitsabfragen*/
      {
        difference = !SPEED;
      }                 
      if (difference > SPEED)
      {
        difference = SPEED;
      }   

       
      if (difference > 0)
      {
        MotorSpeed(SPEED - difference, SPEED);                    /*Motoren einstellen*/
      }     
      else if (difference < 0)
      {
        MotorSpeed(SPEED, SPEED + difference);
      }
      if (SPEED - difference <= 100)
      {
        difference=0;
      }
         
    counter++;
          if (counter == COUNTERABFRAGE)
            {
                  counter = 0;
                  if (weg - PUFFER <= weg_alt)
                  {
                    weg_alt = 0;
                    weg = 0;
                       
                        // Zurückfahren mit einer anderen Funktion
                       
                        }
                        else
                        {
                        weg_alt = weg;
                        }
                }
           
       
       
       
       
        }
}

---

[/code]

sorry damaltor,

jetzt hab ich es mit Main auf mal geschafft, frag nicht wie^^

jedenfalls wenn ich das Prog

Code:

---

#include <asuro.h>

int main(void)
{
void PrintInt(int wert)
{
    char text[16]="      ";
    itoa(wert,text,10);
    SerWrite(text,strlen(text));
}

void Msleep(int dauer)
{
    int z;
    for(z=0;z<dauer;z++) Sleep(36);
}
  return 0;
}

---

in meinem AVR Studio 4 hab und F7 drücke kommt ne FehlerMeldung
( Fehlermeldung : avr- objdump -KeinDatenträger
Es befindet sich kein Datenträger im Laufwerk. Legen Sie einen Datenträger in Laufwerk \Device\Harddisk4\DR9 ein

Abbrechen ? Wiederholen? Weiter?)

egal was ich drücke die meldung kommt immer wieder --_-- :-s
obwohl ich asuro.c in Sourcefiles dirn hab und die Lib und Inc datei auch, mit libAsuro.a
und Optimation...auf 00

wenn ich die über den TaskMangaer abschiessen lasse geht alles 1A

und ne 2. Frage....wie schaffe ich es mit einem USB Transciver es mir über den HyperTerminal ausgeben zu lassen?

zeige mal deinen code her bitte.

sorry damaltor,

jetzt hab ich es mit Main auf mal geschafft, frag nicht wie^^ [== erldedigtes Problem ]

jedenfalls wenn ich das Prog

Code:

---

#include <asuro.h>

int main(void)
{
void PrintInt(int wert)
{
    char text[16]="      ";
    itoa(wert,text,10);
    SerWrite(text,strlen(text));
}

void Msleep(int dauer)
{
    int z;
    for(z=0;z<dauer;z++) Sleep(36);
}
  return 0;
}

---

in meinem AVR Studio 4 hab und F7 drücke kommt ne FehlerMeldung
( Fehlermeldung : avr- objdump -KeinDatenträger
Es befindet sich kein Datenträger im Laufwerk. Legen Sie einen Datenträger in Laufwerk \Device\Harddisk4\DR9 ein

Abbrechen ? Wiederholen? Weiter?)

egal was ich drücke die meldung kommt immer wieder --_-- Eh?
obwohl ich asuro.c in Sourcefiles dirn hab und die Lib und Inc datei auch, mit libAsuro.a
und Optimation...auf 00

wenn ich die über den TaskMangaer abschiessen lasse geht alles 1A

und ne 2. Frage....wie schaffe ich es mit einem USB Transciver es mir über den HyperTerminal ausgeben zu lassen?

die fehlermeldung ist etwas suspekt. aber das scheint ein fehler im studio zu sein.

der usb transceiver kann nur mit dem ganz alten treiber von der cd oder mit dem allerneuesten von ftdi text im hyperterminal ausgeben, mit dem treiber von der arexx seite geht das NICHT. wenn du mehr infos brauchst, dann sag bescheid oder frag die suchfunktion mal, das problem ist bekannt.