AVR Freaks

while (rx_counter0)     // anything there ?
   getchar();           // eat it.

printf("Hello World\r\n");
while (1) {
    if (kbhit()) {
        putchar(getchar());
    }
}

/*****************************************************
Project : automatic system for final project
Version : 1.0
Date    : 4/20/2012
Author  : E-1 
Company : E-1 Engineering Inc.
Comments: Simple implementation of my program model for my main system :)


Chip type               : ATmega324PA
Program type            : Application
AVR Core Clock frequency: 18.432000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 512
*****************************************************/

#include 
#include 
#include 
#include 


#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)

//PWM
#define left_pwm OCR1BL
#define right_pwm OCR1AL


//global variables
char start, packet, val1, val2, val3, val4, val5, val6, val7, val8;
eeprom char id[3];
eeprom char location[4][3] = { {0, 0, 0},
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}
};
int id_count = 0, count = 0, soft_left, soft_right, row = 0, line = 0;

// USART0 Receiver buffer
#define RX_BUFFER_SIZE0 32
char rx_buffer0[RX_BUFFER_SIZE0];

#if RX_BUFFER_SIZE0 <= 256
unsigned char rx_wr_index0, rx_rd_index0, rx_counter0;
#else
unsigned int rx_wr_index0, rx_rd_index0, rx_counter0;
#endif

// This flag is set on USART0 Receiver buffer overflow
bit rx_buffer_overflow0;


// USART0 Receiver interrupt service routine
interrupt [USART0_RXC] void usart0_rx_isr(void)
{
    char status, data;
    status = UCSR0A;
    data = UDR0;
    start = data;
    packet = data;

    if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN)) == 0) {
        rx_buffer0[rx_wr_index0++] = data;
#if RX_BUFFER_SIZE0 == 256
        // special case for receiver buffer size=256
        if (++rx_counter0 == 0) {
#else
        if (rx_wr_index0 == RX_BUFFER_SIZE0)
            rx_wr_index0 = 0;
        if (++rx_counter0 == RX_BUFFER_SIZE0) {
            rx_counter0 = 0;
#endif
            rx_buffer_overflow0 = 1;
        }
    }
}

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

#pragma used-
#endif

// Get a character from the USART1 Receiver
#pragma used+
char getchar1(void)
{
    char status, data;
    while (1) {
        while (((status = UCSR1A) & RX_COMPLETE) == 0);
        data = UDR1;
        if ((status & (FRAMING_ERROR | PARITY_ERROR | DATA_OVERRUN)) == 0)
            return data;
    }
}

#pragma used-

// Write a character to the USART1 Transmitter
#pragma used+
void putchar1(char c)
{
    while ((UCSR1A & DATA_REGISTER_EMPTY) == 0);
    UDR1 = c;
}

#pragma used-


inline void init()
{

    // Crystal Oscillator division factor: 1
#pragma optsize-
    CLKPR = 0x80;
    CLKPR = 0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif


    // Port B initialization
    PORTB = 0x0F;
    DDRB = 0x00;

    //Port C initialization
    PORTC = 0x00;
    DDRC = 0xF0;

    //Port D initialization
    PORTD = 0x30;
    DDRD = 0x30;

    //for dynamixel
    PORTD.7 = 0;
    DDRD.7 = 1;


    //motor config
    //using OCR1AL & OCR1BL
    TCCR1A = 0xF1;
    TCCR1B = 0x02;
    TCNT1H = 0x00;
    TCNT1L = 0x00;
    ICR1H = 0x00;
    ICR1L = 0x00;
    OCR1AH = 0x00;
    OCR1AL = 0x00;
    OCR1BH = 0x00;
    OCR1BL = 0x00;


    // USART0 initialization
    // Communication Parameters: 8 Data, 1 Stop, No Parity
    // USART0 Receiver: On
    // USART0 Transmitter: On
    // USART0 Mode: Asynchronous
    // USART0 Baud Rate: 115200
    UCSR0A = 0x00;
    UCSR0B = 0x98;
    UCSR0C = 0x06;
    UBRR0H = 0x00;
    UBRR0L = 0x09;

    // USART1 initialization
    // Communication Parameters: 8 Data, 1 Stop, No Parity
    // USART1 Receiver: On
    // USART1 Transmitter: On
    // USART1 Mode: Asynchronous
    // USART1 Baud Rate: 115200
    UCSR1A = 0x00;
    UCSR1B = 0x18;
    UCSR1C = 0x06;
    UBRR1H = 0x00;
    UBRR1L = 0x09;




}

void packet_received()
{

    putchar(0x10);
    val1 = packet;
    putchar(0x20);
    val2 = packet;
    putchar(0x30);
    val3 = packet;
    putchar(0x40);
    val4 = packet;

}

//motor movement---------------------
void forward(int left, int right)
{

    left_pwm = left;
    right_pwm = right;
    PORTC.7 = 1;
    PORTC.6 = 0;
    PORTC.5 = 1;
    PORTC.4 = 0;
};
void backward(int left, int right)
{

    left_pwm = left;
    right_pwm = right;
    PORTC.7 = 0;
    PORTC.6 = 1;
    PORTC.5 = 0;
    PORTC.4 = 1;
};
void left(int left, int right)
{

    left_pwm = left;
    right_pwm = right;
    PORTC.7 = 1;
    PORTC.6 = 0;
    PORTC.5 = 0;
    PORTC.4 = 1;
};
void right(int left, int right)
{

    left_pwm = left;
    right_pwm = right;
    PORTC.7 = 0;
    PORTC.6 = 1;
    PORTC.5 = 1;
    PORTC.4 = 0;
};
void stop()
{
    PORTC.7 = 0;
    PORTC.6 = 0;
    PORTC.5 = 0;
    PORTC.4 = 0;
}

//-----------------------------------------
void arrange_position()
{
    while (val4 > 77) {
        putchar(0x40);
        val4 = packet;
        right(254, 250);
    };
    while (val4 > 50) {
        putchar(0x40);
        val4 = packet;
        left(254, 250);
    };
}

void dynamixel_push()
{
    putchar1(0xFF);
    putchar1(0xFF);
    putchar1(0x00);
    putchar1(0x07);
    putchar1(0x03);
    putchar1(0x1E);
    putchar1(0x10);
    putchar1(0x03);
    putchar1(0x00);
    putchar1(0x03);
    putchar1(0xC1);
    delay_ms(1000);
}

void dynamixel_pull()
{
    putchar1(0xFF);
    putchar1(0xFF);
    putchar1(0x00);
    putchar1(0x07);
    putchar1(0x03);
    putchar1(0x1E);
    putchar1(0xFE);
    putchar1(0x01);
    putchar1(0x00);
    putchar1(0x03);
    putchar1(0xD5);
    delay_ms(1000);
}

void preliminary()
{
    while (1) {


        if (start == 0xFF) {
            break;
        };
        if (packet == 0xAA) {
            id[id_count] = getchar();

            switch (id[id_count]) {
            case '9':
                location[1][1] = 1;
                break;
            case 'F':
                location[2][1] = 1;
                break;
            case '%':
                location[1][2] = 1;
                break;
                //some extra books
            case '3':
                location[2][2] = 1;
                break;
            case '<':
                location[1][1] = 1;
                break;
            default:
                break;
            };


            id_count++;
            if (id_count == 2) {
                id_count = 0;
            };
        };
        if (PINB.0 == 0) {
            putchar(0x01);
            delay_ms(250);
        };
        if (PINB.1 == 0) {
            putchar(0x02);
            delay_ms(250);
        };
        if (PINB.2 == 0) {
            putchar(0x03);
            delay_ms(250);
        };
        if (PINB.3 == 0) {
            putchar(0x04);
            delay_ms(250);
        };

    }
}
void transmit()
{
    PORTD.7 = 1;
    DDRD.7 = 1;
}

void receive()
{
    PORTD.7 = 0;
    DDRD.7 = 1;
}

void soft_start()
{
    soft_left = soft_right = 0;
    while (soft_left < 255 || soft_right < 255) {
        forward(soft_left, soft_right);
        soft_left++;
        soft_right++;
        delay_ms(5);
    }
}
void straight()
{
    while (1) {

        packet_received();
        forward(255, 255);


        if (val1 < 45) {
            forward(254, 255);
            delay_ms(60);

        };
        if (val1 > 76 && val1 < 86) {
            forward(255, 250);
            delay_ms(80);
        };
        if (val4 == 0) {
            forward(255, 255);
            delay_ms(1200);
            stop();
            break;
        };

        delay_ms(5);

    }

}
void turn_left()
{
    left(254, 250);
    delay_ms(800);
    while (val4 < 45) {
        packet_received();
        left(254, 250);
        delay_ms(250);
    }

    stop();
}

void turn_right()
{
    right(254, 250);
    delay_ms(800);
    while (val4 > 50) {
        packet_received();
        left(254, 250);
        delay_ms(250);
    }

    stop();
}

void main(void)
{
    init();
#asm("sei")

    preliminary();

    while (1) {
        // soft_start();  //'heating' the system ^_^
        //straight(); 
        //turn_left();
        while (1) {
            packet_received();
            forward(0, 255);
            if (val1 < 45) {
                break;
            };

            delay_ms(1);
        }
        stop();

    }
}

// for interrupt-driven RX on USART0:
#define kbhit()    (rx_counter0 != 0)

// for polled RXC
#define kbhit()    (UCSR0A & (1<<RXC0))

while (kbhit()) getchar();

#include 

char c;
printf("type away regardless.   Typing 'S' will sleep the display for a second\r\n");
while (1) {
    if (kbhit()) {
        c = getchar();
        if (c == 'S') delay(1000);
        putchar(c);
    }
}