Interrupt in ISR freigeben

[Hubert (Gast)]

Hallo!

ich habe ein Problem, undzwar habe ich einen Interrupt, der absoluten 
Vorrang hat, das heißt es muss auch möglich sein, dass er einen anderen 
Interrupt unterbricht.

Ist dies überhaupt möglich?

Ich verwende AVR-GCC und einen AtMega644

Danke euch.

Besten Gruß
Hubert

[Klaus (Gast)]

Nein. Bei den AVRs unterbricht ein Interrupt nicht die Ausführung einer 
gerade abgearbeiteten Interrupt-Routine.

Allenfalls könnte man das emulieren, in dem man in einer ISR die 
Interrupt-Flags prüft ob inzwischen ein anderer Interrupt aufgetreten 
ist.
Natürlich ist die Reaktionszeit länger im Vergleich zum eingebauten 
Interrupt-Mechanismus.

[Klaus (Gast)]

Wenn Du mal beschreibst, warum Du das brauchst, könnte man sich noch 
andere Wege überlegen.

[Hubert (Gast)]

Danke Klaus!

Ich verwende das One-Wire Bussystem von Peter Dannegger.

Dabei wird bei einem Pin Change, ein Interrupt ausgeführt, und mit dem 
Timerzustand verglichen, um zu wissen wie lange die Bitdauer war.

Problem ist nun, dass ich jede Sekunde mein Display mit neuen Werten 
aktualisieren, das ganze in einem Interrupt. Dieser dauert etwas länger, 
und wenn in dieser Zeit ein Pin Change Interrupt auftritt, kommt es 
zeitweise vor, dass es Timing Probleme gibt, und das Byte nicht korrekt 
erkannt wird.

Gruß
Hubert

[Klaus (Gast)]

>Problem ist nun, dass ich jede Sekunde mein Display mit neuen Werten
>aktualisieren, das ganze in einem Interrupt.

Dann liegt hier der Ansatzpunkt für eine Lösung.
Ist das ein Interrupt dessen eigentlicher Zweck darin besteht die 1s 
abzumessen? Nur das Du halt darin auch noch das Display aktualisierst?
Was dauert in dem Interrupt so lange?
Verkürze es. Falls möglich setze in diesem Interrupt nur ein Flag und 
mache die Display-Aktualisierung aus einer Endlosen Schleife in main.

[J.-u. G. (juwe)]

Hubert schrieb:
> Problem ist nun, dass ich jede Sekunde mein Display mit neuen Werten
> aktualisieren, das ganze in einem Interrupt.

Besser: in dem 1-Sekunden Interrupt nur ein Flag setzen und die
Displayaktualisierung dann ausserhalb der ISR machen.

[Hubert (Gast)]

Danke euch zwei!

Das hört sich tatsächlich intelligenter an.

Es geht darum, dass ich einen Coloumb Zähler auch habe, daher muss ich 
auch alle 1 Sekunde den Strom messen, und zählen, um im endeffekt die 
entnommene Ladung zu kennen.

Ich habe für das Display leider auch viele Berechnungen und if-Abfragen, 
da ich Fonts verwende, da die Display eigenen zu klein sind für meinen 
Verwendungszweck.

Ich denke ich würde es verkürzen können, wenn ich Float variablen 
verwende, aber aus früheren Zeiten weiß ich, dass man dies tunlichst 
vermeiden sollte, gerade bei µC weils viel Speicher und Rechenfähigkeit 
bedarf.

Momentan "male" ich einfach das Komma hin.

das heißt ich habe eine Abfrage, bei allen 10er Schritten, um den 
Kommapunkt jeweils richtig setzen zu können.

Das heißt ich nehme die Integer Zahl, wandle sie in einen String, und 
danach setze ich den Punkt korrekt, daher muss ich je nach 10er Schritt 
den Punkt unterschiedlich setzen.

bei 1000 zb. an der 3 Stelle.
bei 100 an der 2. Stelle.

Ich hoffe man kann verstehen wie ich das meine.

Grüße
Hubert

[Klaus (Gast)]

Aus einem anderen Grund war meine Aussage sowieso falsch. Enabled man in 
der einen Interruptroutine die interrupts wieder so kann ein weiterer 
Interrupt die laufende ISR unterbrechen. Sorry.

Ganz einfach ist das dennoch nicht und für einen Anfänger nicht zu 
empfehlen. Die Methode mit dem Flag ist einfacher zu verstehen und zu 
handhaben. Ausserdem ist nested interrupts in der Regel garnicht 
erforderlich.

[Klaus (Gast)]

>Ich hoffe man kann verstehen wie ich das meine.

Das Problem ist, das ich nicht verstehe was Du damit sagen willst. Du 
stellst ja keine Frage.

Interrupts so kurz und einfach wie irgend möglich. Das ist alles.

[J.-u. G. (juwe)]

Hubert schrieb:
> Momentan "male" ich einfach das Komma hin.
>
> das heißt ich habe eine Abfrage, bei allen 10er Schritten, um den
> Kommapunkt jeweils richtig setzen zu können.
>
> Das heißt ich nehme die Integer Zahl, wandle sie in einen String, und
> danach setze ich den Punkt korrekt, daher muss ich je nach 10er Schritt
> den Punkt unterschiedlich setzen.
>
> bei 1000 zb. an der 3 Stelle.
> bei 100 an der 2. Stelle.
>
> Ich hoffe man kann verstehen wie ich das meine.

Ist schon in Ordnung so. Aber bitte ausserhalb von Interrupt Routinen.

[Hubert (Gast)]

Also besser viele Abfragen als eine Float variable zu verwenden?

Grüße
Hubert

[Klaus (Gast)]

>Also besser viele Abfragen als eine Float variable zu verwenden?

Nein. Nur: Die ursprüngliche Frage ist beantwortet,

Falls Du ein noch ein anderes Problem hast mach besser einen neuen 
Thread auf.

Aber kurz: Float ist immer Sch.... Ob das nun "viele Abfragen" notwendig 
macht ist eine ganz andere Frage und hängt davon ab was Du tun willst 
und wie Du es tun willst. Aus Deiner Beschreibung geht das so nicht 
hervor. Intuitiv würde ich sagen, das Ausgaben von eigenen Fonts oder 
Kommas auf dem Display nicht mehr Abfragen benötigen wenn sie im 
Interrupt erledigt werden als wenn sie nicht im Interrupt erledigt 
werden.

[Klaus (Gast)]

Ich habe so den Verdacht, dass Du den Font zur Laufzeit irgendwie neu 
berechnest. Das ist natürlich wenn möglich zu vermeiden. Aber mach am 
besten einen Thread für diese Problem auf.

[J.-u. G. (juwe)]

Klaus schrieb:
> Das Problem ist, das ich nicht verstehe was Du damit sagen willst. Du
> stellst ja keine Frage.

Ich denke er hat ein paar if-Abfragen um herauszufinden, wo der 
Dezimaltrenner zu setzen ist.

Hubert schrieb:
> Also besser viele Abfragen als eine Float variable zu verwenden?

Wie sehen denn Deine Werte aus. Bei 16bit integer und zwei 
Nachkommastellen reichen doch zwei if-Abfragen.

[Sam .. (sam1994)]

Hubert schrieb:
> Also besser viele Abfragen als eine Float variable zu verwenden?

Ja, float sollte man auf dem Avr grundsätzlich vermeiden (kostet dich 
übrigens ein paar kb Flash).

printf macht auch nichts anderes als bei Float einen Punkt reinzusetzen 
- nur der Rechenaufwand ist deutlich höher als bei Festkomma.

Und Funktionen sollte man in der ISR in C erst recht nicht aufrufen, da 
der Compiler da mal ein haufen register sichert, was pro register 2 
Takte kostet.

[Peter R. (pnu)]

"Ich hab einen Interupt, der höchste Priorität hat,...usw." ist 
mißverständlich

m.E. richtiger formuliert:

"Ich möchte einem Interupt höchste Priorität geben, der im Moment 
niedrigrangiger ist"

Bei den AVR's ( kann nur für atmega8 sprechen) ist die Priorität 
entsprechend der Tabelle der Int-Vektoren zugeteilt, also int0 hat 
höchste Priorität.

Int0 kann aber, wenn er frei ist, per software aufgerufen werden.

Man schreibt also in die Routine niedriger Priorität den Befehl, mit dem 
das int0-flag gesetzt wird.

Int0 wird dadurch aufgerufen, als int0-Routine muss dann im Programm 
eben die Routine des Ints niedriger Priorität stehen.

mit den retis und den flags wirds eventuell verzwickt, aber gehen tuts 
wohl.

[Hubert (Gast)]

Hallo Klaus

Natürlich macht es in der Geschwindigkeit keinen Unterschied ob ich 
diese Abfragen im Interrupt mache oder nicht, aber ich dachte, ich 
stelle diese Frage gleich hier, um nicht für alles einen neuen Thread 
aufmachen zu müssen.

Momentan sieht das ganze so aus:

ultoa(totalvolt,Text2,10);

if(totalvolt<100000)
{   Text2[7]=0;
  Text2[6]=0;
        Text2[5]=0;
  Text2[4]=Text2[1];
  Text2[3]='.';
  Text2[2]=Text2[0];
  Text2[1]=' ';
  Text2[0]=' ';
}
else if(totalvolt<1000000)
{   Text2[7]=0;
  Text2[6]=0;
  Text2[5]=0;
  Text2[4]=Text2[2];
  Text2[3]='.';
  Text2[2]=Text2[1];
  Text2[1]=Text2[0];
  Text2[0]=' ';
}
else if(totalvolt<10000000)
{   Text2[7]=0;
  Text2[6]=0;
  Text2[5]=0;
  Text2[4]=Text2[2];
  Text2[3]='.';
}
else
{   for(char i=0;i<10;i++)
    Text2[i]=0;
}
WriteText(Text2,179,10);

[Klaus (Gast)]

>Natürlich macht es in der Geschwindigkeit keinen Unterschied

Das habe ich auch nicht geschrieben. Du hast von der Anzahl Abfragen 
geschrieben und ich habe geantwortet, das die Anzahl nicht 
unterschiedlich sein wird.

>aber ich dachte, ich stelle diese Frage gleich hier, um nicht für alles >einen 
neuen Thread aufmachen zu müssen.

Warum? Was ist daran nachteilig einen neuen Thread aufzumachen. Aber da 
das ein neues Thema ist, wird es hier als Vorteil empfunden, wenn dafür 
ein neuer Thread aufgemacht wird.

[Sam .. (sam1994)]

> der Compiler da mal ein haufen register sichert, was pro register 2
> Takte kostet.
korriegiere: Sind 4, da sie zurückgeschrieben werden müssen.

Schreib doch deine eigene itoa Funktion inkl. Kommasetzung.

[Thomas E. (thomase)]

Hubert schrieb:
> Ist dies überhaupt möglich?

Wenn ein Interrupt ausgelöst wurde, werden alle Interrupts global 
abgeschaltet. Alles, was du tun musst, ist am Anfang der ISR diese mit 
sei() wieder einschalten. Anstatt daruf zu warten, daß sie mit reti von 
selbst wieder eingeschaltet werden.

Kannst du auch vom  Compiler frühest möglich einbauen lassen:

ISR(XXX_vect, ISR_NOBLOCK)
{
  ...
}

siehe auch AVR-Libc >> Library Reference >> <avr/interrupt.h>:Interrupts
>> Nested Interrupts

mfg.

[Karl H. (kbuchegg)]

Thomas Eckmann schrieb:
> Hubert schrieb:
>> Ist dies überhaupt möglich?
>
> Wenn ein Interrupt ausgelöst wurde, werden alle Interrupts global
> abgeschaltet. Alles, was du tun musst, ist am Anfang der ISR diese mit
> sei() wieder einschalten.

Im Prinzip geb ich dir recht. technisch wäre das eine Möglichkeit.

Aber in seinem Fall ist es die weitaus bessere Variante, seine ISR 
Routine auszumisten. Er hat da viel zu viele Dinge drinnen, im 
speziellen offenbar die Ausgabe auf ein GLCD, die da nicht 
hineingehören.

Spielt man nach den Regeln, dann benötigt man keine derartigen dirty 
Tricks, wie die Freigabe der Interrupts in einer ISR.

[Thomas E. (thomase)]

Karl Heinz Buchegger schrieb:
> Spielt man nach den Regeln, dann benötigt man keine derartigen dirty
> Tricks, wie die Freigabe der Interrupts in einer ISR.

Das ist sicherlich richtig. Aber die Frage war halt, ob es möglich ist. 
Das heisst ja nicht, daß man  das unbedingt machen muß. Wobei es bei 
wirklich zeitkritischen Sachen, wie beispielsweise Soft-USB, durchaus 
hilfreich sein kann.

mfg.

[Peter D. (peda)]

Karl Heinz Buchegger schrieb:
> Er hat da viel zu viele Dinge drinnen, im
> speziellen offenbar die Ausgabe auf ein GLCD, die da nicht
> hineingehören.

Besonders lustig wirds, wenn das Main ebenfalls aufs GLCD schreibt und 
die sich dann gegenseitig in die Quere kommen.
Das gibt dann nen hübschen Pixel-Salat.


Peter

[Hubert (Gast)]

Hallo!

Ich habe gerade, wie empfohlen, meine eigene "itoa" geschrieben.

void itoa2(unsigned long n, char s[], char vor, char nach, char div)
{   char i=0;
    
    for(char x=0;x<div;x++)
    n /= 10;
    
    for(i;i<vor+nach+1;i++)
    {  if(i==nach)
       s[i] = '.';
       
       else
       {  if(n > 0)
           s[i] = n % 10 + '0';
   
           else
           s[i] = ' ';
          
          n /= 10;
       }        
    }
    s[i] = '\0';    
    reverse(s);
}

Kann das vielleicht jemand von euch Profis überfliegen, und mir sagen, 
ob das noch verbesserungswürdig ist.

Das ganze funktioniert so:

zb. 100000 soll zu 10.000 werden:
itoa2(100000,s,2,3,1);

Vorkomma  = 2
Nachkomma = 3
Divisor   = 1

Das heißt bei 10000 kommt " 1.000" heraus. So ist es gewunschen, es soll 
praktisch das Komma immer fix sein, wobei auch die Länge es Strings 
konstant sein muss, und alles davor mit ' ' aufgefüllt werden muss.

Danke schonmal

Grüße
Hubert

[Sam .. (sam1994)]

Das /10 finde ich nicht so schön, da Divisionen auf dem Avr nicht so 
günstig sind. Wenn schon Divisionen im Programm sind, ist das aber egal. 
Mit einem 10^x Array könnte man da noch ein bisschen rausholen.

[Hubert (Gast)]

Hallo!

naja ich brauche ja auch Zahlen wir 23442. Da sollte das 10^x Array doch 
keinen Vorteil haben oder ?

Wie siehts mit der restlichen Programmierung aus?

Das einzige Problem was ich habe ist bei Zahlen die "  .xx" ergeben, 
dass ich hier eine Null vor dem Komma erhalte, ich denke das geht nur 
mit paar Abfragen, was die Funktion wieder etwas länger und langsamer 
machen dürfte oder ?

Lg
Hubert

[Stefan P. (form)]

Klaus schrieb:
> Nein. Bei den AVRs unterbricht ein Interrupt nicht die Ausführung einer
> gerade abgearbeiteten Interrupt-Routine.

Das geht schon,

ISR(INT0_vect, ISR_NAKED)

wenn man sich dann um das sichern der Register usw. selbst kümmert.

Aber wie schon erwähnt ist das nicht zu empfehlen, ausser es geht 
wirklich nicht anders.

[Sam .. (sam1994)]

Hubert schrieb:
> naja ich brauche ja auch Zahlen wir 23442. Da sollte das 10^x Array doch
> keinen Vorteil haben oder ?

Ungetestet, so ähnlich mache ich es:

uint16_t _10[] = {10000, 1000, 100, 10}; //Hier nimmst du deine 10ner Zahlen raus und teilst nicht mehr durch 10
void itoa2(uint16_t n, char* s, uint8_t dot)
{   
    char* str = s;
    for(uint8_t i = 0; i < 4; i++, str++)
    {
        if(dot-- == 0)
            *str++ = '.';
        *str = '0';
        while(n >= _10[i])
        {
            n -= 10[i];
            (*str)++;
        }
    }
    *str = '0' + n;
     str = s;
     while(*str == '0')
        *str++ = ' ';
     if(*str == '.')
        *(str-1) = '0';
}

[Stefan E. (sternst)]

Stefan P. schrieb:
> Klaus schrieb:
>> Nein. Bei den AVRs unterbricht ein Interrupt nicht die Ausführung einer
>> gerade abgearbeiteten Interrupt-Routine.
>
> Das geht schon,
> ISR(INT0_vect, ISR_NAKED)
> wenn man sich dann um das sichern der Register usw. selbst kümmert.

Auf was willst du hinaus? Zwischen einer naked ISR und sich 
unterbrechenden ISRs besteht überhaupt kein Zusammenhang.

[Sam .. (sam1994)]

Verdammt! Abschließende 0 vergessen:

*str++ = '0' + n;
*str = 0;
str = s;

Meine Funktion braucht laut avrstudio kanpp 400Cycles. Deine liegt bei 
6000. Das liegt wahrscheinlich an den vielen Divisionen. Außerdem dreht 
deine Funktion das Ergebnis um.

[Hubert (Gast)]

Hallo Samuel!

Wahnsinn dein Programm ist echt super.

Einzig eine Frage habe ich, undzwar, ich möchte einstellen können 
wieviele Nachkommastellen ich habe. Und leider weiß ich nicht, wie ich 
das integrieren kann. Genausowenig wie ich verstehe, warum es "i<4" ist.

So viel ich es auch versuche, ich kann es nicht 100%ig verstehen. Leider 
hab ich mit diesen vielen Pointer Operationen nicht so viel Erfahrung.

Danke !!!

Grüße
Hubert

[Sam .. (sam1994)]

verstehen solltest du es schon. Ich kommentiere es mal ein bisschen.

Die < 4 steht für die 5 Stellen abzüglich der letzen, welche am Ende 
einfach addiert wird.

Ein Pointer zeigt auf die eine Stelle eines char arrays. Inkreminiert 
man ihn, zeigt er auf die nächste.

uint16_t _10[] = {10000, 1000, 100, 10}; //Hier nimmst du deine 10ner Zahlen raus und teilst nicht mehr durch 10
void itoa2(uint16_t n, char* s, uint8_t dot, uint8_t len)
{   
    char* str = s;           //Pointer kopieren
    for(uint8_t i = 0; i < 4; i++, str++)
    {
        *str = '0';          //0 an aktuelle string Position setzen
        while(n >= _10[i])   
        {
            n -= _10[i];     //sooft man 10^x subtrahieren kann
            (*str)++;        //inkreminiert man die vorige 0
        }
        if(--dot == 0)       //Punkt setzen wenn 
            *str++ = '.';    //dot == 0 ist
    }
    *str++ = '0' + n;        //letzte Ziffer ist das was übrig geblieben ist
    *(s+len) = 0;            //Abschließende 0
    str = s;                 //Startpos des strings
    while(*str == '0')       //Führende 0len löschen
        *str++ = ' ';
    if(*str == '.')          //Vor komma eine null setzen (falls gelöscht)
        *(str-1) = '0';
}

Wenn du alle Stellen ohne Komma haben willst musst du die Funktion mit 
len=5 und dot>=5 aufrufen. Mit Komma und alle Stellen mit len=6. Len 
bestimmt im Endeffekt nur die Länge des Strings.

[Hubert (Gast)]

Hallo!
Danke das du es kommentiert hast, das hilft echt weiter! Und ich möchte 
es ja auch lernen, so gut programmieren würd ich auch gern können.

Allerdings gibt es ein Problem.

Gebe ich als Zahl "12345" an, als dot "2" und als len "4" dann kommt 
"1." heraus.

Ich hab mir die Funktion angeschaut, ändere ich die Funktion auf das:

    for(uint8_t i = 0; i < 4; i++, str++)
    {   if(dot-- == 0)       //Punkt setzen wenn 
            *str++ = '.';    //dot == 0 ist
            
        *str = '0';          //0 an aktuelle string Position setzen
        while(n >= _10[i])   
        {
            n -= _10[i];     //sooft man 10^x subtrahieren kann
            (*str)++;        //inkreminiert man die vorige 0
        }
    }

Dann funktioniert alles.

Kannst du mir eventuell sagen, was --dot macht? Ich kenne ausschließlich 
dot--

Eine weitere Frage wäre noch, und zwar

*str++ = '0' + n;

heißt dass, an die aktuelle Position wid '0' + n geschrieben, und erst 
DANN wird der Pointer incrementiert? Wenn ja, wie weiß man sowas? Es 
könnte doch genausogut vorher incrementiert werden und erst nachher 
hineingeschrieben?

Grüße
Hubert

[Hubert (Gast)]

Folgendes wäre mir für eine Integer to Ascii Funktion eingefallen ( also 
signed )

    *str++ = ' ';
    
    if(n < 0)
    {   n = -n;
        *(str-1) = '-';
    }

Das  hätte ich am Anfang dazugeschrieben.
Was sagst du dazu?

Danke!

Grüße

Hubert

[(prx) A. K. (prx)]

Hubert schrieb:

> Ich verwende das One-Wire Bussystem von Peter Dannegger.
> Dabei wird bei einem Pin Change, ein Interrupt ausgeführt, und mit dem
> Timerzustand verglichen, um zu wissen wie lange die Bitdauer war.

Ist der Controller hierbei der 1-Wire Master oder der Slave?

[Hubert (Gast)]

Der Master !

Grüße
Hubert

[(prx) A. K. (prx)]

Dann scheint mir die Methode, dafür einen Interrupt zu verwenden, 
ziemlich anspruchsvoll. Denn dadurch landest du bei der beschriebenen 
Forderung, auf diesen Interrupt extrem schnell reagieren zu können.

Was spricht dagegen, den 1-Wire Code wie sonst üblich im Hauptprogramm 
abzuwickeln? Der sorgt dort zwar für abgeschaltete Interrupts im Bereich 
von unter 20µs, um das Timing sicher einzuhalten, aber das wird nur zum 
Problem, wenn noch mehr derart Zeitkritisches dabei ist.

Ebenso unverständlich bleibt mir, weshalb die sekündliche komplexe 
Aktivität unbedingt im Interrupt ablaufen muss. Der übliche Ansatz ist 
eine sekündliche Signalisierung im Interrupt mit der eigentlichen 
Aktivität im diese Signalisierung abfragenden Hauptprogramm.

[Sam .. (sam1994)]

Hubert schrieb:
> Gebe ich als Zahl "12345" an, als dot "2" und als len "4" dann kommt
> "1." heraus.

Hab das nochmal schnell debuggt:

Kleiner aber feiner Fehler:

uint16_t _10[] = {10000, 1000, 100, 10}; //Hier nimmst du deine 10ner Zahlen raus und teilst nicht mehr durch 10
void itoa2(uint16_t n, char* s, uint8_t dot, uint8_t len)
{   
    char* str = s;           //Pointer kopieren
    for(uint8_t i = 0; i < 4; i++, str++)
    {
        *str = '0';          //0 an aktuelle string Position setzen
        while(n >= _10[i])   
        {
            n -= _10[i];     //sooft man 10^x subtrahieren kann
            (*str)++;        //inkreminiert man die vorige 0
        }
        if(--dot == 0)       //Punkt setzen wenn 
            *++str = '.';    //dot == 0 ist
    }
    *str++ = '0' + n;        //letzte Ziffer ist das was übrig geblieben ist
    *(s+len) = 0;            //Abschließende 0
    str = s;                 //Startpos des strings
    while(*str == '0')       //Führende 0len löschen
        *str++ = ' ';
    if(*str == '.')          //Vor komma eine null setzen (falls gelöscht)
        *(str-1) = '0';
}

*++str = '.';
Das ++ muss hier vor str, da für den Punkt erst zum nächsten Zeichen 
gesprungen wird.
x++ gibt x zurück und erhöht x.
++x erhöht x und gibt dann x zurück.

Dadurch, dass dot nun unter While steht, kann der Punkt nur nach einer 
Zahl gesetzt werden (dot=1 heißt nach der ersten Zahl folgt der Punkt, 
dot=0 bedeutet kein Punkt). Nimm die Variante die dir besser gefällt.

[Hubert (Gast)]

Hallo Samuel!

Das heißt es ist beides gleich schnell und gut und macht keinen 
Unterschied oder?

Empfiehlt es sich 2 Funktionen für long und integer zu schreiben, oder 
sollte ich immer die long to Ascii Funktion verwenden?

Grüße

Hubert

[Sam .. (sam1994)]

Hubert schrieb:
> Das heißt es ist beides gleich schnell und gut und macht keinen
> Unterschied oder?

Einmal wird davor inkreminiert einmal danach. MAcht keinen zeitlichen 
Unterschied.

> Empfiehlt es sich 2 Funktionen für long und integer zu schreiben, oder
> sollte ich immer die long to Ascii Funktion verwenden?

Wenn du genügend Flash frei hast, ja, wenn nicht nimm nur Eine.
Evtl. sollte man bei einer Funktion, den Anfang des Strings zurückgeben, 
damit man bei 123 nicht 5 Leerzeichen davorhat:

while(*str == '0')       //Führende 0len löschen
        str++;
if(*str == '.')          //Vor komma eine null setzen (falls gelöscht)
       *--str = '0';
return str;

[Peter D. (peda)]

Klaus schrieb:
>>aber ich dachte, ich stelle diese Frage gleich hier, um nicht für alles >einen
> neuen Thread aufmachen zu müssen.
>
> Warum? Was ist daran nachteilig einen neuen Thread aufzumachen. Aber da
> das ein neues Thema ist, wird es hier als Vorteil empfunden, wenn dafür
> ein neuer Thread aufgemacht wird.

Stimmt!

Wenn man hier auf das neue Thema antwortet, hilft das nur dem einen, da 
niemand anderes es hier suchen und finden wird.
Daher werde ich hier auch nicht antworten.
Ein bischen mitdenken sollte man schon und nicht so egoistisch sein.


Peter