Parsen klappt nur bis zur ersten Stelle.

[Markus P. (sebastianwurst)]

Ich will ein String z.B "99|11|01|00" auf jede Stelle zwischen den "|" 
aufbröseln. Dieses versuche ich mit dem Code (s.unten), die Ausgabe auf 
UART ist jedoch nur : Stelle 1:99

PS. Das -----Jippie---- wird auf der UART ausgegeben!

Warum kommt Stelle 2.4 nicht zum Vorschein?

if (usart_status.usart_ready) 
  {
       
      if (!strcmp(usart_rx_buffer,"99|11|01|00")) 
      {  
      usart_write("----Jipppieee----");
      }       

  

      int o=0;
      char* pToken = strtok(usart_rx_buffer,"|");
      
      if (pToken)
      {
        usart_write("Stelle 1: %s\n\r",pToken);
        o++;
      
      while ( (pToken = strtok(NULL, "|")) )
        {
          if(o==1)
          printf("Stelle 2: %s\n\r",pToken);
          
          if(o==2)
          printf("Stelle 3: %s\n\r",pToken);
        
          if(o==3)
          {
          printf("Stelle 4: %s\n\r",pToken);
            usart_status.usart_ready =0;
          }
          o++;        
        
        }
      }
         
  }

[Krapao (Gast)]

Wahrscheinlich weil dein printf() nicht an der erwarteten Stelle 
ausgibt. Das erste Ergebnis gibtst du mit usart_write() aus, die 
Nachfolger mit printf(). An der Benutzung des strtok() sehe ich auf den 
oberflächlichen Blick nix kritisches 
(http://www.elook.org/programming/c/strtok.html)

[Matthias L. (Gast)]

In was willst du das denn zerlegen? In einzelne Strings, oder in 
einzelne (zB) uint8_t ??

[Matthias L. (Gast)]

Ich hab sowas ähnliches letztens auf Arbeit programmiert. Auf das 
Problem hier würde ich das etwa so machen:

//-----------------------------------------------
uint8_t  sString[] = "99|54|34|55";
uint8_t  au8Value[4];

void parse void ( uint8_t* sChar, uint8_t* sValue, uint8_t u8Len )
{
  uint8_t  u8State     = 0;
  uint8_t  u8StateLast = 255;
  uint8_t  u8Cnt       = 0;
  //-----------------------------------------------------------
  while ( *sChar != 0x00 )
  {
    switch ( u8State )
    {
    case 0:
      if ( u8StateLast != u8State )
      {
        u8StateLast= u8State;
        *sValue = 0;
      }
      if ( *sChar == '|' )
      {
        u8State = 1;
      }
      else if (    ( *sChar >= '0' )
                && ( *sChar <= '9' )  )
      {
        *sValue = (10 * *sValue) + ( *sChar - '0' );
      }
      break;

    case 1:
      u8StateLast= u8State
      sValue++;
      if ( ++u8Cnt == u8Len ) return;
      break;
    }
    sChar++;

  }

}


//-----------------------------------------------
memset ( au8Value, 0, sizeof(au8Value) );
parse( sString, au8Value, 4 );

// in au8Value sollten jetzt die Ziffern stehen.

[STK500-Besitzer (Gast)]

( (pToken = strtok(NULL, "|")) )

Soweit ich die Doku zu strtok verstanden habe, versuchst du in einem 
NULL-String dein Trennzeichen zu finden...

[gaast (Gast)]

Nein.
http://www.imb-jena.de/~gmueller/kurse/c_c++/c_strtok.html

[Yalu X. (yalu) (Moderator)]

Krapao schrieb:
> Das erste Ergebnis gibtst du mit usart_write() aus, die Nachfolger mit
> printf().

Das wird es wohl gewesen sein. Der Rest ist in Ordnung.

[Markus P. (sebastianwurst)]

Yalu X. schrieb:
> Krapao schrieb:
>> Das erste Ergebnis gibtst du mit usart_write() aus, die Nachfolger mit
>> printf().
>
> Das wird es wohl gewesen sein. Der Rest ist in Ordnung.

Einfach zu unkonzentriert ... und kopiert ... sorry für die doofe, 
unnützige Frage! Habe es zwar noch nicht ausprobiert, aber das wird's 
sein.

[Markus P. (sebastianwurst)]

Matthias Lipinsky schrieb:
> Ich hab sowas ähnliches letztens auf Arbeit programmiert. Auf das
> Problem hier würde ich das etwa so machen:
>
> [c]
>
> //-----------------------------------------------
> uint8_t  sString[] = "99|54|34|55";
> uint8_t  au8Value[4];
>
> void parse void ( uint8_t* sChar, uint8_t* sValue, uint8_t u8Len )
> {
>   uint8_t  u8State     = 0;
>   uint8_t  u8StateLast = 255;
>   uint8_t  u8Cnt       = 0;
>   //-----------------------------------------------------------

Danke, das kann ich gut gebrauchen.

[Matthias L. (Gast)]

>Danke, das kann ich gut gebrauchen.

Und? Geht das?

[Markus P. (sebastianwurst)]

Ich bin gerade dabei...
Ich versuch gerade mein Code abzuändern damit ich die gesendeten 
Stringstücke in ein Char- oder Int-Array packe.
Aber das klappt noch nicht. Siehst Du da irgend ein Bock drin?
Leider bin ich zu doof um dein Code komplett zu verstehen, da tu ich 
mich dann immer schwer damit den einfach zu verwenden, auch wenn er 
klappen würde...

    
  if (usart_status.usart_ready) 
  {
       
      if (!strcmp(usart_rx_buffer,"99|11|01|00")) 
      {  
      usart_write("----Jipppieee----");
      }       


  
      int o=0;
       char* pToken = strtok(usart_rx_buffer,"|");      
     
       
       if (pToken)
       {
         usart_write("--Stelle 1: %s--\n\r",pToken);
        ReceiveSerial[1] = atoi(pToken);
        usart_write_char(ReceiveSerial[1]);  
         o++;
       
       while ((pToken = strtok(NULL, "|")) )
         {
           if(o==1)
          {
           usart_write("--Stelle 2: %s--\n\r",pToken);
           ReceiveSerial[2] = atoi(pToken);  
                    usart_write_char(ReceiveSerial[2]);  
           }
      
           if(o==2)
          {
           usart_write("--Stelle 3: %s--\n\r",pToken);
           ReceiveSerial[3] = atoi(pToken);  
          usart_write_char(ReceiveSerial[3]);
          }
          
           if(o==3)
           {
           usart_write("--Stelle 4: %s--\n\r",pToken);
          ReceiveSerial[4] = atoi(pToken);  
          usart_write_char(ReceiveSerial[4]);
           }
           o++;          
         }
         
       }
     

    usart_status.usart_ready =0;       
  }

[Markus P. (sebastianwurst)]

Vergessen: So ist das ReceiveSerial deklariert;

char ReceiveSerial[5];

[Karl H. (kbuchegg)]

Markus P. schrieb:

>          usart_write("--Stelle 1: %s--\n\r",pToken);
>         ReceiveSerial[1] = atoi(pToken);
>         usart_write_char(ReceiveSerial[1]);

Ich kenn zwar deine FUnktionen nicht, aber ich denke nicht, dass du hier 
usart_write_char benutzen willst.

Du hast an dieser Stelle keine Character mehr (und auch keine Strings), 
sondern bereits Zahlen!

Ergo wirst du eine Funktion benutzen wollen, die auch eine Zahl ausgeben 
kann. Zb so was:

void usart_write_int( int number )
{
  char buffer[10];
  itoa( number, buffer, 10 );
  uart_write( buffer );
}

PS: du tust dir unter UMständen leichter, wenn du es dir zur Regel 
machst, dass du den Datentyp char ausschliesslich und nur für Character 
benutzt. Also alles was mit Texten (aka. Strings) bzw. Einzelzeichen wie 
sie in Texten vorkommen reservierst.

Wenn du einen kleinen Integer meinst, also eine Variable die Zahlen 
speichert, so wie in 5 Äpfel oder 28 Grad Celsius, dann benutzt du 
ausschliesslich uint8_t, int8_t (oder uint16_t oder int16_t): Dann 
erinnert dich der Datentyp immer daran, womitr du es zu tun hast: Mit 
Zeichen ('a', 'b', c' aber auch '0', '1', ...) oder mit kleinen Zahlen 
(5, 8, 7). Es hilft auch, wenn du Variablen danach benennst, wozu sie 
dienen, welchen Wert sie enthalten. ReceiveSerial ist da nicht sehr 
hilfreich. Der Name erzählt dir nichts.

PS: strtok ist hier ziemlich kompliziert einzusetzen. Matthias hat dir 
schon gezeigt, wie das einfacher geht. Es ist nicht immer die einfachste 
Variante einen String erst in Einzelteile aufzusplitten und dann mit den 
Einzelteilen etwas zu machen. In deinem Fall, wenn es sich nur um Zahlen 
handelt, die aus dem kompletten String extrahierst und in ein Array 
ablegst, ist es einfacher, wenn man den String einfach ein Zeichen nach 
dem nächsten durchgeht und entscheidet was mit diesem Zeichen zu machen 
ist.
Entweder es ist ein digit (also '0' bis '9'), dann gehört es zur gerade 
geparsten Zahl dazu. Das ist aber leicht zu bewerkstelligen. Denn wie 
wird aus der Zahl 64 und einer daran anzuhängenden 3 die Zahl 643? 
Simpel. 64 * 10 macht 640 (damit hast du die ganze Zahl um 1 Stelle nach 
links 'geschoben' und dann kannst du einfach die 3 dazuaddieren. Du 
kriegst dann 643. Und wenn daran dann noch eine 8 drann soll, dann geht 
das wieder nach dem gleichen Muster: 643*10  macht 6430, und da dann 
noch die 8 dazuaddiert macht 6438. Schau dir nochmal Matthias Code an, 
ob du die Operation dort findest.

Und dann kann in deinem Eingabestring noch das Zeichen | vorkommen. Das 
ist aber leicht. Das schaltet einfach nur weiter in welches Arrayelement 
die nächsten digits reinkommen.

[Matthias L. (Gast)]

>Leider bin ich zu doof um dein Code komplett zu verstehen, da tu ich
>mich dann immer schwer damit den einfach zu verwenden, auch wenn er
>klappen würde...


Versuche doch einfach meinen COde nachzuvollziehen. Du kannst ja hier 
nachfragen.

Karl Heinz hat Dir ja schon paar Tipps gegeben.

[Markus P. (sebastianwurst)]

Danke das mach ich, morgen geh ich da wieder bei...

[DirkB (Gast)]

Und wenn man sowas:

           if(o==1)
          {
           usart_write("--Stelle 2: %s--\n\r",pToken);
           ReceiveSerial[2] = atoi(pToken);  
                    usart_write_char(ReceiveSerial[2]);  
           }

 mehrmals hat, kann man es auch zusammenfassen:

//           if(o==1) // wird jetzt nicht mehr gebraucht und gilt auch für andere werte
          {
           usart_write("--Stelle %d: ",o);
           usart_write("%s--\n\r",pToken);
           ReceiveSerial[o+1] = atoi(pToken);  
                    usart_write_int(ReceiveSerial[o+1]);  
           }

Beachten musst du dann nur noch, dass du nicht mehr als 4 Werte 
einliest.

[Markus P. (sebastianwurst)]

Hi,
ich habe mir jetzt noch einmal deinen Code (Lippy) angeguckt und da ist 
mir auch einiges klar geworden. Zumindest verstehe ich den Code wenn man 
folgenden Dreher beseitigt:

Vorher:

    case 1:
      u8StateLast= u8State; // <----
      sValue++;
      if ( ++u8Cnt == u8Len ) return;
      break;

Nachher:

    case 1:
      u8State = u8StateLast; // <----
      sValue++;
      if ( ++u8Cnt == u8Len ) return;
      break;

Ist doch Richtig oder? Doch so ganz klappt es dann auch noch nicht. 
Ausgabe von "12|34|56|78" ist:
12
4
6
8

Bei folgendem Code:

void usart_write_int(int data)
{
  char Bufferchar[10];
  
      itoa(data, Bufferchar, 10);    
            usart_write_str( Bufferchar);
      usart_write_str("\r\n");
      
}

Und das in der USART-Abfrage:

  
  if (usart_status.usart_ready) 
  {
       
      if (!strcmp(usart_rx_buffer,"99|11|01|00")) 
      {  
      usart_write("----Jipppieee----");
      }       


memset ( au8Value, 0, sizeof(au8Value) );
parse( usart_rx_buffer, au8Value, 4 );


// in au8Value sollten jetzt die Ziffern stehen.

  usart_write_int(au8Value[0]);
  usart_write_int(au8Value[1]);
  usart_write_int(au8Value[2]);
  usart_write_int(au8Value[3]);      
     
     
usart_status.usart_ready = 0;
           
  }

Da mein "usart_rx_buffer" so deklariert ist (kein unsigned):

    #define BUFFER_SIZE  50
  char usart_rx_buffer[BUFFER_SIZE];

bekomme ich noch die Warnung:

main.c:1428: warning: pointer targets in passing argument 1 of 'parse' 
differ in signedness.

Das kann doch eigentlich damit nichts zu tun haben, oder?
Stehe gerade bissel auffen Schlauch. Irgendwie jetzt einen zu viel in 
der Case1:, finde den Bock nicht...

[MWS (Gast)]

Markus P. schrieb:
> Ausgabe von "12|34|56|78" ist:
> 12
> 4
> 6
> 8

Verständlich, wenn man sich den Code durchdenkt. Der läuft in case 0: 
auf ein "|", dann wird der State = 1, Zeichenpointer wird erhöht, zeigt 
nun auf die erste Ziffer, läuft im nächsten Durchgang aber erstmal in 
den case 1: Block und erhöht danach wieder den Zeichenpointer, also wird 
erst ab der zweitem Ziffer erfasst.

Würde das sChar++ an's Ende des Case 0: Blocks stellen.

Das find' ich unschön:
> switch ( u8State )
>     {
>     case 0:
>       if ( u8StateLast != u8State )

Unter case 0: muss u8State = 0 sein, sonst wär' man nicht dort, also 
kann man gleich
if ( u8StateLast != 0 )
bzw.
if ( u8StateLast )
schreiben.

[Karl H. (kbuchegg)]

Wo kommt eigentlich der String her?
Anderes Programm (per UART) oder Mensch?

Grund: Wenn der String von einem anderen Programm kommt, kann man davon 
ausgehen, dass ernicht fehlerhaft ist. Bei einer menschlichen Eingabe 
muss man mehr Aufwand treiben um Fehler abzufangen.

Annahme: anderes Programm
So gesehen sehe ich nämlich den Vorteil der State-Machine da drinnen 
noch nicht.

#include <stdio.h>

uint8_t parse( const char* sChar, uint8_t* sValue, uint8_t u8Len )
{
  uint8_t nrArg = 0;

  sValue[nrArg] = 0;

  while( *sChar ) {
    if( *sChar == '|' ) {
      nrArg++;
      if( nrArg == u8Len - 1 )
        return nrArg + 1;
      sValue[nrArg] = 0;
    }

    else if( *sChar >= '0' && *sChar <= '9' )
      sValue[nrArg] = 10 * sValue[nrArg] + (*sChar - '0');

    sChar++;
  }

  return nrArg + 1;
}

int main()
{
  uint8_t Args[10];
  uint8_t parsedArgs;
  uint8_t i;
  
  char String[] = "12|56|34|58";

  parsedArgs = parse( String, Args, sizeof(Args)/sizeof(*Args) );

  printf( "Anzahl geparster Argumente %d\n", (int)parsedArgs );
  for( i = 0; i < parsedArgs; ++i )
    printf( "%d ", Args[i] );
  printf( "\n" );
}

Der String darf dabei nicht leer sein und darf auch nicht mit einem | 
aufhören (sonst ist die als Rückmeldung gelieferte Anzahl geparster 
Argumente um 1 zu hoch). Bei einem Programm-generierten String ist das 
kein Problem, bei einer menschlichen Eingabe ist das nicht akzeptabel.

[Matthias L. (Gast)]

>Ist doch Richtig oder?

Nein. War schon richtig, aber

>Doch so ganz klappt es dann auch noch nicht. Ausgabe von "12|34|56|78" ist:
>12
>4
>6
>8

Oh. Ja, ich seh es. Karl Heinz hat recht. Die State Maschine bringt hier 
nix. Das ist zu einfach ;-)

Versuch mal das.

//-----------------------------------------------
uint8_t  sString[] = "99|54|34|55";
uint8_t  au8Value[4];

void parse void ( uint8_t* sChar, uint8_t* sValue, uint8_t u8Len )
{
  uint8_t  u8Cnt       = 0;
  //-----------------------------------------------------------
  while ( *sChar != 0x00 )
  {
    //-- Trennzeichen ? -----------------------
    if ( *sChar == '|' )
    {
      sValue++;
      if ( ++u8Cnt == u8Len ) return;
    }
    //-- Ziffer -------------------------------
    else if (    ( *sChar >= '0' )
              && ( *sChar <= '9' )  )
    {
      *sValue = (10 * *sValue) + ( *sChar - '0' );
    }
    //-- weiter -------------------------------
    sChar++;
  }

}

Ein Leerstring, bzw ein Enden mit | sollte kein Thema sein.

EDIT:

>Unter case 0: muss u8State = 0 sein, sonst wär' man nicht dort, also
>kann man gleich
>if ( u8StateLast != 0 )
>bzw.
>if ( u8StateLast )
>schreiben.

Das ist schon richtig. Gilt aber nur für case 0. Die von mir gewählte 
Schreibweise gilt für jeden case. So kann ich einfach CTRL+C/V machen. 
Ohne die Konstante da anpassen zu müssen.

Beitrag "Re: Programm bzw. Ablaeufe steuern"

[MWS (Gast)]

Matthias Lipinsky schrieb:
> Das ist schon richtig. Gilt aber nur für case 0. Die von mir gewählte
> Schreibweise gilt für jeden case. So kann ich einfach CTRL+C/V machen.

Da sparst ja bei 2 States enorm an Zeit :D
Eventuell im Code noch sValue mit 0 initialisieren ?

[Matthias L. (Gast)]

>Da sparst ja bei 2 States enorm an Zeit :D

Ja ;-) Aber wie gesagt, das Bsp war von ner Programmierung auf Arbeit. 
DOrt war das PRoblem etwas größer, und die Schrittkette macht dort Sinn. 
Deshalb hatte ich die hier einfach gelassen. Aber nicht nötig.


>Eventuell im Code noch sValue mit 0 initialisieren ?

So recht..?

//-----------------------------------------------
uint8_t  sString[] = "99|54|34|55";
uint8_t  au8Value[4];

void parse void ( uint8_t* sChar, uint8_t* sValue, uint8_t u8Len )
{
  uint8_t  u8Cnt       = 0;
  //-----------------------------------------------------------
  *sValue = 0;

  while ( *sChar != 0x00 )
  {
    //-- Trennzeichen ? -----------------------
    if ( *sChar == '|' )
    {
      *++sValue = 0;
      if ( ++u8Cnt == u8Len ) return;
    }
    //-- Ziffer -------------------------------
    else if (    ( *sChar >= '0' )
              && ( *sChar <= '9' )  )
    {
      *sValue = (10 * *sValue) + ( *sChar - '0' );
    }
    //-- weiter -------------------------------
    sChar++;
  }

}

[MWS (Gast)]

Matthias Lipinsky schrieb:
> So recht..?

Einwandfrei ;-)

[Markus P. (sebastianwurst)]

Danke euch, jetzt sind mir auch die Zeiger wieder ein bissel näher 
gekommen! Da tue ich mich immer noch schwer mit..
Was ich nur gemerkt habe ist dass void parse void (... Bei mir ein 
Fehker auslöst. Ich habe nirgends was zum Thema gefunden. Void parse(... 
wird richtig compiliert!

Und warum muss man hier denn nicht mit dem Zeiger arbeiten?

    //-- weiter -------------------------------
    sChar++;

[Matthias L. (Gast)]

>Was ich nur gemerkt habe ist dass void parse void (... Bei mir ein
>Fehker auslöst.

Ja. Das ist mir noch nicht aufgefallen. Was hab ich denn da für einen 
Mist getippt. So muss es heissen:

void parse ( ...
{
  ..

>Und warum muss man hier denn nicht mit dem Zeiger arbeiten?
>    sChar++;

Tut man doch. Man schiebt den Zeiger ein Element weiter. Würde man 
*sChar schreiben, würde man auf den Zeiger (als da wo der hinzeigt) 
zugreifen.

[Markus P. (sebastianwurst)]

Danke das klappt.
Einzig noch die Fehlermeldung

main.c:1417: warning: pointer targets in passing argument 1 of 'parse' differ in signedness

Liegt ja an den:

   #define BUFFER_SIZE  50
  char usart_rx_buffer[BUFFER_SIZE];

wenn ich das nur Ändere zieht das einen Rattenschwanz hinter sich...


@ Karl-Heinz
>Wo kommt eigentlich der String her?
>Anderes Programm (per UART) oder Mensch?
Das kommt vom anderen Programm (VB-Oberfläche)

[Markus P. (sebastianwurst)]

Vielleicht könntest Du mir auch noch dieses Erklären:

    //-- Trennzeichen ? -----------------------
    if ( *sChar == '|' )
    {
      *++sValue = 0;
      if ( ++u8Cnt == u8Len ) return;
    }

Was passiert da mit dem:  *++sValue = 0;
Also wenn das Trennzeichen kommt dann wird der Zeiger um Einen erhöht, 
also eine Positon weiter und gleichzeitig auf Null geschriebn ?
Das verstehe ich nicht.
Vielleicht hilft einer...

[Matthias L. (Gast)]

>Was passiert da mit dem:  *++sValue = 0;
>Also wenn das Trennzeichen kommt dann wird der Zeiger um Einen erhöht,
>also eine Positon weiter und gleichzeitig auf Null geschriebn ?
>Das verstehe ich nicht.
>Vielleicht hilft einer...

Jein. Gleichzeitig findet garnix statt. Zuerst wird das ++sValue 
bearbeitet. Also der Zeiger namens sValue um ein Element 
weitergeschoben. Anschließend folgt die Zuweisung *sValue = 0; Also wird 
der Zeiger dereferenziert (auf den/die Speicher/zellen zugegriffen, wo 
er hinzeigt) und da eine Null reingeschrieben.


>Einzig noch die Fehlermeldung

Das ist keine Fehlermeldung, sondern eine Warnung. Diese besagt, das der 
Zeiger, den die Funktion parse als erstes Element erwartet ( ein: 
uint8_t*, also ein Zeiger auf uint8_t), du aber beim Aufruf einen Zeiger 
auf ein char mit gibst. Ich glaube das ging im Compiler einzustellen, 
aber char ist wohl vorzeichenbehaftet (signedness).

Kleiner Tip. Wenn ich Strings darstellen will, deklariere ich die immer 
so:

uint8_t sString[] ...

Selbst für einen Puffer von Daten nehme ich meistens uint8_t, sofern 
diese irgendwie Byteorientiert vorliegen.

[Markus P. (sebastianwurst)]

Soweit klappt das jetzt.

Doch habe ich einige Probleme wenn ich die au8Value-Variable an eine ISR 
übergebe die größer als [0] ist

    memset ( au8Value, 0, sizeof(au8Value) );
    parse( usart_rx_buffer, au8Value, 4 );


    // in au8Value sollten jetzt die Ziffern stehen.

    usart_write_int(au8Value[0]);
    usart_write_int(au8Value[1]);
    usart_write_int(au8Value[2]);
    usart_write_int(au8Value[3]);      
       
    u8_Uebergabe = au8Value[0];

Bei au8Value[0] funktioniert die Übergabe am die ISR einwandfrei. Wenn 
ich jedoch [1],[2] oder[3] nehme bleibt der yC hängen. Warum auch immer. 
Die Ausgaben auf die USART sind alle Gleich...

ISR (TIMER1_COMPA_vect)
{
TriacZuenden(u8_Uebergabe ,16);

Dekleration im main.c

volatile uint8_t u8_Uebergabe =80;

Dekleration im main.h

extern volatile uint8_t u8_Uebergabe;

[numurai (Gast)]

Markus P. schrieb:
> Dekleration
DEKLARATION bitte, wenn überhaupt auf Deutsch.

[Karl H. (kbuchegg)]

Markus P. schrieb:

> Doch habe ich einige Probleme wenn ich die au8Value-Variable an eine ISR
> übergebe die größer als [0] ist

Mehr Code

[Markus P. (sebastianwurst)]

Also das ist die void parse:

void parse void ( uint8_t* sChar, uint8_t* sValue, uint8_t u8Len )
{
  uint8_t  u8Cnt       = 0;
  //-----------------------------------------------------------
  *sValue = 0;

  while ( *sChar != 0x00 )
  {
    //-- Trennzeichen ? -----------------------
    if ( *sChar == '|' )
    {
      *++sValue = 0;
      if ( ++u8Cnt == u8Len ) return;
    }
    //-- Ziffer -------------------------------
    else if (    ( *sChar >= '0' )
              && ( *sChar <= '9' )  )
    {
      *sValue = (10 * *sValue) + ( *sChar - '0' );
    }
    //-- weiter -------------------------------
    sChar++;
  }

}

Morgen könnt ich noch die einzelnen Dateien posten

[Markus P. (sebastianwurst)]

Hier hab ich die main's.
Stand ist jetzt das der Triac, der in der ISR gezündet wird, einwandfrei 
funktioniert wenn ich die

u8_Uebergabe = au8Value[0];

verwende.
Sobald ich aber
u8_Uebergabe = au8Value[1];
oder
u8_Uebergabe = au8Value[2];
oder
u8_Uebergabe = au8Value[3];
nehme funktioniert das Ganze evtl ein mal und dann hängt sich der yC 
auf. Zu mindest geht dann auch nichts mehr über die USART.
Ich weiss nicht wo er da hängen könnte?
Vielleicht sieht es einer???

[Markus P. (sebastianwurst)]

Vielleicht Einer nen Tipp??? Sitze immer noch davor...

[Matthias L. (Gast)]

>>u8_Uebergabe = au8Value[2];

Daran ist nichts auszusetzen. Der Fehler muss woanders liegen.

[Markus P. (sebastianwurst)]

Findest du denn in der Main irgendwas komisches?