Hallo,

so habe die Probleme gelöst es funktioniert alles. Naja fast alles, muss jezt noch mein Kommunikation mit VB.Net hinbekommen (auch schon fast am verzweifeln).

Ich möchte mich mal bei allen beteiligten bedanken, für die groß Hilfe, viel Dank!

Das Hauptproblem lag wahrscheinlich darin das mein 12MHz Quarz einen defekt hatte bzw hat, habe das jetzt alles auf dem intern 8MHz laufen und funktioniert alles,
es waren aber auch noch genug kleine fehler dabei.

Ich habe mein Aufteilung mit der "strtok" und "strcpy" funktionen erledigt.
Mit der strtok habe ich auf meine String auf Trennzeichen untersucht
und mit der strcpy in die entsprechenden Variablen gespeichert.

Wenn ich jetzt über das RealTerm eine 1,2,3,4\n sende veränderen sich auch die Blink Zeiten entsprechend.

Hier mal mein Programm
Code:
#include <avr/io.h>
#include <util/delay.h>
#include <stdlib.h>
#include <string.h>
			  
#define F_CPU 8000000  /* evtl. bereits via Compilerparameter definiert */
#define BAUD 300      // Baudrate
 
// Berechnungen
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)   // clever runden
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))     // Reale Baudrate
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD) 		// Fehler in Promille, 1000 = kein Fehler.
 
#include <util/setbaud.h>


struct _S_DATA S_DATA;
int Line[9];			//Array vom Typ int

//------------------------------------------------------------------------------------------

//USART initialisieren
void uart_init(void)
{
	//Set Baudrate
	UBRRH = UBRR_VAL >> 8;
	UBRRL = UBRR_VAL & 0xFF;
	
	UCSRB |= (1<<TXEN) | (1<<RXEN);					//UART TX und RX einschalten
	UCSRC = (1<<URSEL) |(1<<UCSZ1) | (1<<UCSZ0);	// Einstellen des Datenformats: 8 Datenbits, 1 Stoppbit
}

//------------------------------------------------------------------------------------------

struct _S_DATA
{
	char Rot[2];
	char RG [2];
	char GR [2];
	char GE [2];
};
//------------------------------------------------------------------------------------------

//Warteschleife
void delay_ms(unsigned int ms)
{
    unsigned int zaehler;   
    while (ms) {
        zaehler = F_CPU / 5000;       
        while (zaehler) {
            __asm volatile("nop");
            zaehler--;
        }
        ms--;
    }
}
//------------------------------------------------------------------------------------------

// Zeichen senden
int uart_putc(unsigned char c)
{
	while (!(UCSRA & (1<<UDRE)))
	{
	}
	UDR = c;
	return 0;
}
//------------------------------------------------------------------------------------------

//String senden
void uart_puts(char *s)
{
	while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
    }
}
//------------------------------------------------------------------------------------------

//Zeichen empfangen
uint8_t uart_getc(void)
{
	while (!(UCSRA & (1<<RXC)))	//warten bis Zeichen verfügbar 
	;
	return UDR;					//Zeichen aus UDR an Aufrufer zurückgeben

}
//------------------------------------------------------------------------------------------

//Sting empfangen
void uart_gets(char *Buffer, uint8_t MaxLen)
{
	uint8_t NextChar;
	uint8_t StringLen = 0;
 
	NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';

}
//------------------------------------------------------------------------------------------

//String Zerlegung
void string_zer(void)
{

	unsigned char i;			//Case Hochzählung
	char Trennzeichen[]=",";	//Trennungszeichen
	char *ptr;					//Variable zum zwischenspeichern

	i = 2;						//Variable i auf 2 setzten

		ptr=strtok(Line, Trennzeichen);	// Line durchsuchen bis zum Trennzeichen und in ptr zwischen speichern
		strcpy (S_DATA.Rot, ptr);		// Erster Teil in Rot kopiern wo in der Struct _S_DATA liegt
		while (ptr != NULL)				//weiter durchsuchen bis das nächste Trennzeichen oder Ende kommt
		{
			ptr = strtok (NULL, Trennzeichen);	// Line durchsuchen bis zum Trennzeichen oder Ende und in ptr zwischen speichern
			switch (i)							//Um in Unterschiedlichen Variablen zu speichern
			{
				case 2: strcpy(S_DATA.RG,ptr); break;
				case 3: strcpy(S_DATA.GR,ptr); break;
				case 4: strcpy(S_DATA.GE,ptr); break;
			}
			i++;	//Variable i um eins hochzählen
		}
}

//------------------------------------------------------------------------------------------

//Hauptprogramm
int main(void)
{
	//Variablen Deklartion
	int time = 1000;
	int time1 = 1000;

	char Buffer[9];			//String mit maximal 8 zeichen
	int a;					//Umwandlung ascii zu integer
	
	DDRB = 0xFF;
	PORTB = 0xFF;
 
	uart_init();			// UART einstellen

	while (1)
	{
//---------------------------------------------------------------------------------------------	
		if ((UCSRA & (1<<RXC)))					//überprüfen ob neue Zeichen vorhanden sind
		{
			uart_gets(Line, sizeof(Line));		//Zeichen wurden empfangen, jetzt abholen

			string_zer();		//String in seine Teile zerlegen
	
			uart_puts(S_DATA.Rot); 
			uart_puts(S_DATA.GE);
		
			a = atoi (S_DATA.Rot);	//Rot in integer wandeln
			time = a *1000;   // mal 1000 um auf sekunden zu kommen

			itoa (time, Buffer, 10);	//time in char umwandeln

			uart_puts(Buffer);			//Buffer senden
		}
//---------------------------------------------------------------------------------------------
		else
		{
		
			PORTB = 0b00000000;
			delay_ms(time1);
			PORTB = 0b00001111;
			delay_ms(time);
			PORTB = 0b11110000;
			delay_ms(time1);
			PORTB = 0b11111111;
			delay_ms(time);
		}

	}

}