SPI_Transmit(0xAA); //На самом деле, неважно что посылать
USART_Transmit(SPDR); //Посылаем данные из первого регистра
SPI_Transmit(0xAA); //Тут тоже неважно что посылать
USART_Transmit(SPDR); //Посылаем данные из второго регистра

#include <avr\io.h>

#define SPI_PORT PORTB
#define SPI_DDR DDRB

#define MOSI_P PB3
#define MISO_P PB4
#define SCK_P PB5
#define SS_P PB2

// При этом, SS_P подключен к чип-селектку ведеомого устройства


// Эта функция сдвигает по SPI один байт, и возвращает байт,
// прочитанный со слейва
uint8_t spi_shift_byte(uint8_t data)
{    
    SPI_PORT &= ~(1 << SS_P);

    SPDR = data;
    while(!(SPSR & (1 << SPIF)));
    
    SPI_PORT |= (1 << SS_P);
    
    return SPDR;
}


int main(void)
{

    uint8_t data[3]; // Данные прочитанные с АЦП
    
    //////////////////////////////////////////////////////////////////////////
    // Настройки SPI    
    SPI_DDR = (1 << MOSI_P)|(1 << SCK_P)|(1 << SS_P);
    SPI_PORT = (1 << SS_P); // Чипселект в еденице - приемник неактивен
    SPCR = (1 << SPE)|(1 << MSTR)|(1 << SPR1);
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    
    // Далее, судя по документации, делать нужно так:
    
    spi_shift_byte(0x01); // Код команды
    spi_shift_byte(0); // Байт параметров (как я понял). Оставляем пустым
    
    // Далее читаем три байта ригистра АЦП:
    data[2] = spi_shift_byte(0); // Старший байт
    data[1] = spi_shift_byte(0); // Средний байт
    data[2] = spi_shift_byte(0); // Младший байт    
    
}

#include <avr\io.h>
#include <util/delay.h>

#define SPI_PORT PORTB
#define SPI_DDR DDRB

#define MOSI_P PB3
#define MISO_P PB4
#define SCK_P PB5
#define SS_P PB2

#define SELECT() SPI_PORT &= ~(1 << SS_P)
#define DESELECT() SPI_PORT |= (1 << SS_P)

// При этом, SS_P подключен к чип-селектку ведеомого устройства


// Эта функция сдвигает по SPI один байт, и возвращает байт,
// прочитанный со слейва
uint8_t spi_shift_byte(uint8_t data)
{

    SPDR = data;
    while(!(SPSR & (1 << SPIF)));    
    
    return SPDR;
}

adc_read_registers(uint8_t start_address, uint8_t count, uint8_t* buffer)
{
    start_address &= 0x0F;
    count &= 0x0F;

    SELECT();
    
    spi_shift_byte(0x08 | (start_address)); // 0001 rrrr
    spi_shift_byte(count - 1); // xxxx nnnn, почему "минус 1" - написано в документации
  
    // Задержку, я думаю подберете сами...
    _delay_us(25);
    
    for (;count; count--, buffer++)
        *buffer = spi_shift_byte(0); // Читаем count регистров в массив buffer

    DESELECT();
}

adc_write_registers(uint8_t start_address, uint8_t count, uint8_t* buffer)
{
    start_address &= 0x0F;
    count &= 0x0F;
    
    SELECT();
    
    spi_shift_byte(0x50 | (start_address)); // 0101 rrrr
    spi_shift_byte(count - 1); // xxxx nnn, почему "минус 1" - написано в документации
    
    for (;count; count--, buffer++)
        spi_shift_byte(*buffer); // Передаем count значений из массива buffer
        
    DESELECT();
}


int main(void)
{
    //////////////////////////////////////////////////////////////////////////
    // Настройки SPI    
    SPI_DDR = (1 << MOSI_P)|(1 << SCK_P)|(1 << SS_P);
    SPI_PORT = (1 << SS_P); // Чипселект в еденице - приемник неактивен
    SPCR = (1 << SPE)|(1 << MSTR)|(1 << SPR1); // F_CPU/128
    //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

    uint8_t buffer[2] = {0xAA, 0xBB}; // Значения от балды...
    
    // Пишем два регистра и buffer, начиная с решистра №1
    adc_write_registers(1, 2, buffer);
    
    // Читаем 2 регситра в buffer, начиная с регистра №5
    adc_read_registers(5,2,buffer);    
}

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/delay.h>



#define UBRRVAL 47

#define SPI_PORT PORTB
#define SPI_DDR DDRB

#define MOSI_P PB3
#define MISO_P PB4
#define SCK_P PB5
#define SS_P PB2

#define SELECT() SPI_PORT &= ~(1 << SS_P)
#define DESELECT() SPI_PORT |= (1 << SS_P)

unsigned char command,statbuf,buf;


[code]void USART_init(void) {
    //Set baud rate

[/code]
    UBRRL=UBRRVAL;            //low byte
    UBRRH=(UBRRVAL>>8);    //high byte
    //Set data frame format: asynchronous mode,no parity, 1 stop bit, 8 bit size
    UCSRC=(1<<URSEL)|(0<<UMSEL)|(0<<UPM1)|(0<<UPM0)|(0<<USBS)|(0<<UCSZ2)|(1<<UCSZ1)|(1<<UCSZ0);    
    //Enable Transmitter and Receiver and Interrupt on receive complete
    UCSRB=(1<<RXEN)|(1<<TXEN)|(1<<RXCIE);
}
void USART_Transmit(unsigned char data) {

    while ( !( UCSRA & (1<<UDRE)) ) {};
    UDR = data;
}

void SPI_init(void) {

    SPI_DDR = (1 << MOSI_P)|(1 << SCK_P)|(1 << SS_P);
    SPI_PORT = (1 << SS_P); // Чипселект в еденице - приемник неактивен
    SPCR = (1 << SPE)|(1 << MSTR)|(1 << SPR1)|(1 << SPR0); // F_CPU/128
    
}
unsigned char spi_shift_byte(unsigned char data) {
    
    SPDR = data;
    while(!(SPSR & (1 << SPIF)));    
    return SPDR;
}

unsigned char RREG(unsigned char start_address) {
    unsigned char buffer;
    SELECT();
    spi_shift_byte(0x10 | (start_address)); // 0001 rrrr
    spi_shift_byte(0x01); // xxxx nnnn, почему "минус 1" - написано в документации
    _delay_loop_2(250);
    buffer = spi_shift_byte(0xAA); // Читаем count регистров в массив buffer
    DESELECT();
    return buffer;
}

void WREG(unsigned char address, unsigned char value) {
    SELECT();
    spi_shift_byte(0x50 | (address)); // 0101 rrrr
    spi_shift_byte(0x00); // xxxx nnn, почему "минус 1" - написано в документации
    spi_shift_byte(value); // Передаем count значений из массива buffer
    DESELECT();
}

ISR (USART_RXC_vect) {
    
    while ( !(UCSRA & (1<<RXC)) );
    buf=UDR;
    statbuf=0x01;
}

void processing (void) {

    unsigned char SPI_buf;
    
    if ((statbuf==0x01) && (command==0x00)) {
            command=buf;
            buf=0x00;
            statbuf=0x00;
    }
    if  (command!=0x00) {
        switch (command) {
                case 0x31: {
                            USART_Transmit(0x01);
                            command=0x00;
                            break;    
                }
                case 0x32: {
                            if (statbuf==0x01) {
                                                USART_Transmit(0x02);
                                                
                                                SELECT();
                                                
                                                SPDR = 0x51;
                                                while(!(SPSR & (1 << SPIF)));
                                                SPDR = 0x01;
                                                while(!(SPSR & (1 << SPIF)));    
                                                SPDR = 0x05;
                                                while(!(SPSR & (1 << SPIF)));    
                                                SPDR = 0x07;
                                                while(!(SPSR & (1 << SPIF)));
                                                
                                                DESELECT();
                                                
                                                _delay_ms(10000);
                                                
                                                SELECT();
                                                
                                                SPDR = 0x11;
                                                while(!(SPSR & (1 << SPIF)));
                                                SPDR = 0x01;
                                                while(!(SPSR & (1 << SPIF)));
                                                _delay_ms(25);
                                                SPDR = 0xAB;
                                                while(!(SPSR & (1 << SPIF)));    
                                                SPI_buf=SPDR;
                                                USART_Transmit(SPI_buf);
                                                SPDR = 0xAC;
                                                while(!(SPSR & (1 << SPIF)));
                                                SPI_buf=SPDR;
                                                USART_Transmit(SPI_buf);
                                                
                                                DESELECT();
                                                
                                                    buf=0x00;
                                                    statbuf=0x00;
                                                    command=0x00;
                                                }
                            break;                    
                }
                
                default: {
                           command=0x00;
                           break;
                          }
        }                  
    
    }
}


int main (void) {

    USART_init();
    SPI_init();
    sei();
    
    while (1) {
        processing ();
    }
}

delay !!! a = 6; while (a--); // @ 4MHz

delay !!! a= 60; While (a--); // @4MHz

a = 6

a= 60

delay !!! a = 6; while (a--); // @ 4MHz

#include <avr/delay.h> или #include <util/delay.h>
_delay_loop_2(100) ? - 100 в каких единицах ?
_delay_us(50);

1. Совпадат ли значения макроса F_CPU в makefile с реальной частотой контроллера?

2. Какой уровень оптимизации вы используете.

3. В описании функци _delay_ms обратите внимание на предложение:
The maximal possible delay is 262.14 ms / F_CPU in MHz.

#include <avr/delay.h> или #include <util/delay.h>
_delay_loop_2(100) ? - 100 в каких единицах ?