u8 buf[3801];
u8 crc8_crn = 0; // CRC8 для текущей команды
u8 crc8_prev = 0; // CRC8 для предыдущей команды
u8 crc8 = 0xFF; // CRC8 для подсчета, используется как буфер
u8 comand_crn[5] = {0,0,0,0,0}; // Запрос текущий
u8 comand_prev[5] = {0,0,0,0,0}; // Запрос предыдущий



u8 crc8_array[256] =
{...};


void ReadADC(void); // тение данных с АЦП
u8 ReadWriteSPI1(u8 data); // Чтение и запись с SPI1
u8 CalcCOMAND_CRC8(u8 col); // Расчет CRC8 приходящей команды
u8 crc8_table(u8 data); // Расчет CRC8 по таблице
void CalcBUF_CRC8(void); // Расчет CRC8 у buf[] и запись в последний номер crc8

int main (void){

// System initialization, this will map the exception vectors.
SystemInit(APBDIVISOR);

// initialization PLL
PLLInit();

// Power Control
PowerControl();

// First disable interrupts.
__disable_interrupt();

// Setup interrupt controller.
InitVIC();
InitTimer0Interrupt(Timer0Beat);

// Periodic timer initialization.
InitTimer0();
// Enable interrupts.
__enable_interrupt();

// Start periodic timer.
// StartTimer0();

// Set up peripheral registers.
InitGPIO();
InitSPI1();

u8 i = 0;
u8 fg;

crc8_prev = 0;

for (;;){ // Loop forever.

fg = ReadWriteSPI1(0);
if (fg != 0) {
comand_crn[0] = fg;
S1SPDR = 0;
i = 1;
while (SPI1_SSEL == 0){
if ((S1SPSR & 0x80)) {
comand_crn[i++] = S1SPDR;
S1SPDR = 0;
}
}// end While


// Проверка CRC8 приходящего запроса
crc8 = 0xFF;
crc8_crn = CalcCOMAND_CRC8(i-1);// щас фиксированно 3 байта приходит

if (crc8_prev == 0)
{
//====================================================
// Сначала отвечаем на запрос (предыдущий)
for (u16 k = 0; k <=3800; k++)
{ReadWriteSPI1(buf[k]);};
//====================================================
// Затем выполняем команду
switch (comand_crn[0]){ // В зависимости какая команда пришла
//----------------------------------------------------
case 'k' : //0x6B = 107 // Команда ""
.....
break;
//----------------------------------------------------
case 'z' : //'z' = 122 = 0x7A - Команда "Тест памяти"
.....
break;
//----------------------------------------------------
case 0xA0 : //'' 160 = - Команда ""
.....
break;
//----------------------------------------------------
default: {
....
}
//----------------------------------------------------
}// Конец swith
crc8_prev = crc8_crn;
for (u8 ct = 0; ct <= 4; ct++)
{comand_prev[ct] = comand_crn[ct];};
} //else { S1SPDR = 0;}
}// Есть ли команда
}// For - LOOP

}// End Main

u8 ReadWriteSPI1(u8 data){
S1SPDR = data;
while (!(S1SPSR & 0x80));
return S1SPDR;
};

u8 crc8_table(u8 data){
crc8 = crc8_array[(data ^ crc8)&0xff];
return crc8;
}


u8 CalcCOMAND_CRC8(u8 col){
crc8 = 0xFF;
for (u8 n = 0; n <= 2; n++)
{ crc8 = crc8_array[((comand_crn[n])^ crc8)&0xff]; }
return crc8;
}

void CalcBUF_CRC8(void){
crc8 = 0xFF;
for (u16 n = 0; n <= 3799; n++)
{ crc8 = crc8_table(buf[n]); }
buf[3800] = crc8;
}

  // Проверка CRC8 приходящего запроса
      crc8 = 0xFF;
      crc8_crn = CalcCOMAND_CRC8(i-1);// щас фиксированно 3 байта приходит

  for (;;){   // Loop forever.
    fg = ReadWriteSPI1(0);
    if (fg != 0) {
      comand_crn[0] = fg;
      S1SPDR = crc8; // Чтоб видно было что crc8 нулевое или нет....
      i = 1;
      while (SPI1_SSEL == 0){
        if ((S1SPSR & 0x80)) {
          comand_crn[i++] = S1SPDR;
          S1SPDR = 0;
        }
      }// end While  
//     if (crc8 == 0)  - нет проверки crc8
      {
//====================================================      
// Сначала отвечаем на запрос (предыдущий)        
        for (u16 k = 0; k <=3800; k++)
        {ReadWriteSPI1(0xF0/*buf[k]*/);};
//====================================================

void InitSPI1()
{  PINSEL1 |= 0x2A8;
/*
  S1SPCR_bit.BITENABLE = 0;  // BITENABLE = 0 Передача и прием 8 бит..
  S1SPCR_bit.CPHA      = 0;  // CPHA = 0 (фаза синхроимпульса - выборка по фронту SCK)
  S1SPCR_bit.CPOL      = 0;  // CPOL = 0 (SCK имеет Активный Высокий уровень)
  S1SPCR_bit.MSTR      = 0;  // MSTR = 0 Режим SPI Slave (подчиненный)
  S1SPCR_bit.LSBF      = 0;  // LSBF = 0 Первый бит старший
  S1SPCR_bit.SPIE      = 0;  // SPIE = 0 Прерывания от SPI1 запрещены.
  */
  S1SPCR = 0;
  S1SPDR = 0;   }

u8 ReadWriteSPI1(u8 data){
  S1SPDR = data;
  while (!(S1SPSR & 0x80));
  return S1SPDR;
};

S1SPDR = 0;
  while (!(S1SPSR & 0x80));
  fg = S1SPDR;
    if (fg != 0) {
      comand_crn[0] = fg;

  PINSEL1 |= 1;  // Вывод как EINT0
  EXTMODE = 1;   // Срабатывание на перепад
  EXTPOLAR = 0;  // На отрицательный перепад

void InitEINT0Interrupt()
{
  VICIntSelect &= ~VIC_EINT0_bit;
  VICVectAddr0 = (unsigned int)&EINT0Interrupt;
  VICVectCntl0 = 0x20 | VIC_EINT0; // Enable vector interruзе
  VICIntEnable = VIC_EINT0_bit;    // Enable interrupt.
}

__irq __arm void EINT0Interrupt(void)
{
  VICIntEnClear = 0x00004000; // Disable EINT0 in the VIC
  
  u8 fg;
  countercom = 0;
  EXTINT = 1;  // Сбросить флаг внешного прерывание EINT0
  
  while (!(S1SPSR & 0x80)) { };
  fg = S1SPDR;
  if (fg != 0) {
    countercom++;
    comand_crn[countercom] = fg;
            S1SPDR = 0;
  }
  else {S1SPDR = 0;}
  
  EXTINT = 0x01;                       // Clear the peripheral interrupt flag
  VICIntEnable = 0x00004000;    // Enable EINT0 in the VIC
  VICVectAddr = 0;                    // reset VIC
}

for (;;){   // Loop forever.
    while (!(FIO0PIN & 0x10000)){ // пока чипселект в активном уровне
      while (!(S1SPSR & 0x80)){}; // ждем флага о получении байта
      if (S1SPDR != 0xAA) {нога в верх}
      else {нога вниз}
    }// end While  
    нога вниз;
  }