Atmega8L8 geht mal, mal nicht

#include <avr/io.h>

#include <util/delay.h>

#include <stdlib.h>

#include <avr/interrupt.h>

#define F_CPU 4000000UL  // Systemtakt in Hz - Definition als unsigned long beachten 

#define BAUD 9600UL      // 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.

#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))

  #error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 

#endif 

#define CR "\r\nS

#define UART_MAXSTRLEN 10

volatile char uart_string[UART_MAXSTRLEN + 1] = "";

char textx[32];

int channel=1;

int channels=2;

int adcKanal = 0;

int plex = 0;

int uart_str_count=0;

//Interrupt zur Kanalansteuerung

//*******************************

ISR(USART_RXC_vect)

{

  unsigned char nextChar;

  // Daten aus dem Puffer lesen 

  nextChar = UDR;

  uart_string[uart_str_count] = nextChar;

  uart_str_count++;

  send_string("ooo");//100

     //Interrupt wirs so lange gelesen, bis ein "Z" kommt, dann wird er verarbeitet

  if( nextChar =='Z')

  {

   channels = 0;

   send_string("dddd");//100

     //send_string(uart_string);

   //annel= atoi(uart_string[1]);

   channels= atoi(&uart_string[1]);

   send_char(uart_string[1]);

     sprintf (textx, "%u", channels);        

     send_string(textx);

   uart_str_count=0;

  }

}

//****************************

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

void init_uart(unsigned int ubrr)

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

 {

        UBRRH = (unsigned char)(ubrr>>8);

        UBRRL = (unsigned char)(ubrr);

        //UCSRB |= (1<<RXEN);

        //UCSRB |= (1<<TXEN);

        //UCSRB |= (1<<RXCIE);

        //UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);

      UBRRH = UBRR_VAL >> 8;

      UBRRL = UBRR_VAL & 0xFF;

      UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0); // Asynchron 8N1 

      UCSRB |= (1<<RXEN)|(1<<TXEN)|(1<<RXCIE);  // UART RX, TX und RX Interrupt einschalten

    sei();

}

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

void init_adc(void) 

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

{

  uint16_t result;

  ADMUX = (0<<REFS1) | (1<<REFS0);      // AVcc als Referenz benutzen

//  ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenzspannung nutzen

  // Bit ADFR ("free running") in ADCSRA steht beim Einschalten

  // schon auf 0, also single conversion

  ADCSRA = (1<<ADPS1) | (1<<ADPS0);     // Frequenzvorteiler

  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest

     also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 

  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten

  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten

     Wandlung nicht übernommen. */

  result = ADCW;

}

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

uint16_t ADC_Read( int channel )/* ADC Einzelmessung */

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

{

  // Kanal waehlen, ohne andere Bits zu beeinflußen

  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);

  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"

  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten

  return ADCW;                    // ADC auslesen und zurückgeben

}

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

void send_char(unsigned char data) 

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

{

        while (!(UCSRA & (1<<UDRE)));

        UDR = data;

}

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

void send_string(char *data) 

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

{

        while (*data) {

                send_char(*data);

                data++;

        }

}

//************

int main(void)

//************

 {

    init_uart(UBRR_VAL);

    init_adc(); 

        uint16_t adcval;

    while (1) {

      int x = 0;

          //Kanal 1

       cli();//interrupts ausschalten

       //hiereine Schleife, in der die ADCs aufgerufen werden

       //for(int x = 0;x<sizeArray;x++)

       for(int x = 0;x<channels;x++)

       {

           char text[32];

         char kanal[100]; 

         channel = x%6;

         //Schalten Multiplexer abhängig vom channel

         plex = x/6;//d.h. 0-5 sind Plex 0;6-11 sind Plex 1.........

         //Kanal ist dann der Rest der Rechnung

         channel = x%6;

         DDRB  = 0xFF;             // (3)

               PORTB = plex;             // (4)

         adcval = ADC_Read(channel);

             sprintf(kanal, "%d" ,channel);

           send_string("c");//99

           send_string("X");//88

         send_string(kanal);//0=48  1=49

         send_string("Y");//89

           sprintf (text, "%u", adcval);        

         send_string(text);

         send_string("Z");//90

         send_string("E");//69

       //send_string(CR);

       //--> ende while......

         }    

       sei();//interrupts einschalten

        _delay_ms(2000);

        }

        return 1;

}

"channels= atoi(&uart_string[1]);"