testing serial behaviour

#include <mega32a.h>
#include <delay.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <spi.h>
#undefine USE_AUTO_MANUAL
#define MAX         10
#define MAXANGLE    1999
#define MINANGLE    999
#define MOTOR_PLUS  0x01
#define MOTOR_MINUS 0x02

#ifndef USE_AUTO_MANUAL


#ifndef RXB8
#define RXB8 1
#endif

#ifndef TXB8
#define TXB8 0
#endif

#ifndef UPE
#define UPE 2
#endif

#ifndef DOR
#define DOR 3
#endif

#ifndef FE
#define FE 4
#endif

#ifndef UDRE
#define UDRE 5
#endif

#ifndef RXC
#define RXC 7
#endif

#define FRAMING_ERROR (1<<FE)
#define PARITY_ERROR (1<<UPE)
#define DATA_OVERRUN (1<<DOR)
#define DATA_REGISTER_EMPTY (1<<UDRE)
#define RX_COMPLETE (1<<RXC)

// USART Receiver buffer
#define RX_BUFFER_SIZE 8
char rx_buffer[RX_BUFFER_SIZE];

#if RX_BUFFER_SIZE <= 256
unsigned char rx_wr_index,rx_rd_index,rx_counter;
#else
unsigned int rx_wr_index,rx_rd_index,rx_counter;
#endif

// This flag is set on USART Receiver buffer overflow
bit rx_buffer_overflow;

// USART Receiver interrupt service routine
interrupt [USART_RXC] void usart_rx_isr(void)
{
char status,data;
status=UCSRA;
data=UDR;
if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN))==0)
   {
   rx_buffer[rx_wr_index++]=data;
#if RX_BUFFER_SIZE == 256
   // special case for receiver buffer size=256
   if (++rx_counter == 0)
      {
#else
   if (rx_wr_index == RX_BUFFER_SIZE) rx_wr_index=0;
   if (++rx_counter == RX_BUFFER_SIZE)
      {
      rx_counter=0;
#endif
      rx_buffer_overflow=1;
      }
   }
}

#ifndef _DEBUG_TERMINAL_IO_
// Get a character from the USART Receiver buffer
#define _ALTERNATE_GETCHAR_
#pragma used+
char getchar(void)
{
char data;
while (rx_counter==0);
data=rx_buffer[rx_rd_index++];
#if RX_BUFFER_SIZE != 256
if (rx_rd_index == RX_BUFFER_SIZE) rx_rd_index=0;
#endif
#asm("cli")
--rx_counter;
#asm("sei")
return data;
}
#pragma used-
#endif

// USART Transmitter buffer
#define TX_BUFFER_SIZE 8
char tx_buffer[TX_BUFFER_SIZE];

#if TX_BUFFER_SIZE <= 256
unsigned char tx_wr_index,tx_rd_index,tx_counter;
#else
unsigned int tx_wr_index,tx_rd_index,tx_counter;
#endif

// USART Transmitter interrupt service routine
interrupt [USART_TXC] void usart_tx_isr(void)
{
if (tx_counter)
   {
   --tx_counter;
   UDR=tx_buffer[tx_rd_index++];
#if TX_BUFFER_SIZE != 256
   if (tx_rd_index == TX_BUFFER_SIZE) tx_rd_index=0;
#endif
   }
}

#ifndef _DEBUG_TERMINAL_IO_
// Write a character to the USART Transmitter buffer
#define _ALTERNATE_PUTCHAR_
#pragma used+
void putchar(char c)
{
while (tx_counter == TX_BUFFER_SIZE);
#asm("cli")
if (tx_counter || ((UCSRA & DATA_REGISTER_EMPTY)==0))
   {
   tx_buffer[tx_wr_index++]=c;
#if TX_BUFFER_SIZE != 256
   if (tx_wr_index == TX_BUFFER_SIZE) tx_wr_index=0;
#endif
   ++tx_counter;
   }
else
   UDR=c;
#asm("sei")
}
#pragma used-
#endif

struct cmd //command struct
{
    char str[MAX], num[MAX];
    int i;
} cmd, *cmdptr;
#endif

#ifdef USE_AUTO_MANUAL
volatile unsigned char mode;

interrupt [EXT_INT0] void ext_int0_isr(void)
{
// Place your code here
        if(mode++ >= 1)
            mode = 0;
        printf("%d",mode);
}
interrupt [TIM0_COMP] void timer0_comp_isr(void)
{
        //these are the states of the automatic mode they are drove by counter 0
        static unsigned int OCR1Avar = 1499;
        static unsigned char state = 1;
        static unsigned char count = 0;
        count++;
        if(!mode)
        {

                if(count >= 10)
                {
                        switch(state)
                        {
                        case 1:
                                if(OCR1A++ < MAXANGLE);
                                else
                                        state = 2;
                        break;
                        case 2:
                                if(OCR1B++ < MAXANGLE);
                                else
                                        state = 3;
                        break;
                        case 3:
                                if(OCR1Avar++ <= MAXANGLE)
                                        spi(MOTOR_PLUS);
                                else
                                        state = 4;
                        break;
                        case 4:
                                if(OCR1B-- > MINANGLE);
                                else
                                        state = 5;
                        break;
                        case 5:
                                if(OCR1A-- > MINANGLE);
                                else
                                        state = 6;
                        break;
                        case 6:
                                if(OCR1B++ < MAXANGLE);
                                else
                                        state = 7;
                        break;
                        case 7:
                                if(OCR1Avar-- >= MINANGLE)
                                        spi(MOTOR_MINUS);
                                else
                                        state = 8;
                        break;
                        case 8:
                                if(OCR1B-- > MINANGLE);
                                else
                                        state = 1;
                        break;
                        }
                        count = 0;
                }
        }
}

#endif
void init()
{
    PORTA = 0x00;
    DDRA = 0xFF;
    PORTB = 0x00;
    DDRB = 0xB0;
    PORTC = 0xFE;
    DDRC = 0x01;
    PORTD = 0x04;
    DDRD = 0x32;

    TCCR0=0x09;
    TCNT0=0x00;
    OCR0=0x0F;
    TCCR1A=0xA2;
    TCCR1B=0x19;
    TCNT1H=0x00;
    TCNT1L=0x00;
    ICR1H=0x4E;
    ICR1L=0x1F;
    OCR1A = 1499;
    OCR1B = 1499;

    TIMSK=0x00;

    /*UCSRA=0x02;
    UCSRB=0b11011000;
    UCSRC=0x06;
    UBRRH=0x00;
    UBRRL=0x0C;*/
    UCSRA=0x02;
    UCSRB=0xD8;
    UCSRC=0x06;
    UBRRH=0x00;
    UBRRL=0x0C;

    ACSR=0x80;
    SFIOR=0x00;

    GICR|=0x40;
    MCUCR=0x02;
    MCUCSR=0x00;
    GIFR=0x40;

    SPCR=0x50;
    SPSR=0x00;
}
#ifndef USE_AUTO_MANUAL
int command_split(struct cmd* command)
{
    unsigned char i = 0;
    int c;
    while((c = getchar()) != EOF && c != ':' && i < MAX)
        command->str[i++] = c;
    command->str[i] = '\0';
    i = 0;
    while((c = getchar()) != EOF && i < MAX)
        command->num[i++] = c;
    command->num[i] = '\0';
    command->i = atoi(command->num);
    if(!strcmpf(cmd.str,"nothing"));
    if(!strcmpf(cmd.str,"vertical"))
        return 1;
    else if(!strcmpf(cmd.str,"horzental"))
        return 2;
    else if(!strcmpf(cmd.str,"grab"))
        return 3;
}
#endif

void main(void)
{
    #ifdef USE_AUTO_MANUAL
    unsigned int Press_Conf = 0;
    #endif
    char c, i;
    // Global enable interrupts
    #asm("sei")
    init();
    while (1)
    {
        // Place your code here
        #ifdef USE_AUTO_MANUAL
        if(mode == 1)
        {
            Press_Conf++;
            if(Press_Conf >= 200)
            {
                if(PINC.7 == 0)
                {
                    if(OCR1A < MAXANGLE)
                        OCR1A++;
                }
                else if(PINC.6 == 0)
                {
                    if(OCR1A > MINANGLE)
                        OCR1A--;
                }
                if(PINC.5 == 0)
                {
                    if(OCR1B < MAXANGLE)
                        OCR1B++;
                }
                else if(PINC.4 == 0)
                {
                    if(OCR1B > MINANGLE)
                        OCR1B--;
                }
                if(PINC.3 == 0)
                {
                    spi(0x01);
                }
                else if(PINC.2 == 0)
                {
                    spi(0x02);
                }
                Press_Conf = 0;
            }
        }//end of mode 1
        #endif
        #ifndef USE_AUTO_MANUAL
        cmdptr = &cmd; //command struct object assignment
        i = command_split(cmdptr);
        switch(i)
        {
            case 1: for(i = 0;i < cmd.i;i++)
                    {
                        PORTA ^= 1 << PINA0;
                        delay_ms(10);
                    }
            break;
            case 2: PORTA ^= 1 << PINA1;
            break;
            case 3: PORTA ^= 1 << PINA2;
            break;
        }
        #endif
    }
}