Arduino.ru

зачем функции дублируешь?

часть кода можно сделать не повторением, а циклом

сам код писал?

Я же написал что многого не понимаю, подскажи пожалуйста как это сделать, хотя бы пример.

Код писал сам, человек помог только разделить данные которые в обычный сериал выводяться, которые в программный код мой.

железо под рукой проверить?

код рабочий?

Код рабочий данные с магнитолы выводятся. Проверить смогу через часика два, всё на работе. Может по телефону пообщаемся?

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
long  R[11];

long code[38]={0xE1E, 0x4E90, };

char simb[38]={  'A',    'B', };  
  

void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it)  {
    MyBuff [pos] = 0;  
    for (int i=0;  i <= 35; i++){    
      if (i<=34){
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
        else{
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
      }
      else{
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
      }
    }

    DISP ();
    DATA ();

    pos = 0;
  } 
  process_it = false;
}


void DATA ()
{
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ

  bitWrite(R[0], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[26], 5)); 
  //    bitWrite(R[0], 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R[0], 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R[0], 0, bitRead(MyBuff[25], 4));

  bitWrite(R[1], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[1], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[1], 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R[1], 12, bitRead(MyBuff[24], 4));
  bitWrite(R[1], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[1], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[1], 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R[1], 8, bitRead(MyBuff[24], 0));
  bitWrite(R[1], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[1], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[1], 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R[1], 0, bitRead(MyBuff[21], 0));


  bitWrite(R[2], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R[2], 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R[2], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R[2], 8, bitRead(MyBuff[21], 4));
  bitWrite(R[2], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R[2], 0, bitRead(MyBuff[19], 0));

  bitWrite(R[3], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R[3], 12, bitRead(MyBuff[18], 0));
  bitWrite(R[3], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R[3], 8, bitRead(MyBuff[19], 4));
  bitWrite(R[3], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[3], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[3], 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R[3], 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ

  bitWrite(R[4], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R[4], 12, bitRead(MyBuff[16], 0));
  bitWrite(R[4], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R[4], 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R[4], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R[4], 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "

  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R[5], 12, bitRead(MyBuff[14], 0));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R[5], 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R[5], 0, bitRead(MyBuff[13], 0));

  bitWrite(R[6], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R[6], 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R[6], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R[6], 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[6], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R[6], 0, bitRead(MyBuff[8], 0));// ?

  bitWrite(R[7], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R[7], 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R[7], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R[7], 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R[7], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[7], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[7], 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R[7], 0, bitRead(MyBuff[6], 0));// ?

  bitWrite(R[8], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R[8], 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R[8], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R[8], 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[8], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R[8], 0, bitRead(MyBuff[4], 0));// ?

  bitWrite(R[9], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[9], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[9], 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R[9], 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R[9], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[9], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[9], 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R[9], 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[9], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[9], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[9], 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R[9], 0, bitRead(MyBuff[27], 4));// ?

  bitWrite(R[10], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R[10], 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R[10], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R[10], 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R[10], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R[10], 0, bitRead(MyBuff[29], 4));// ?

}


void DATA_write(){
  for(byte i=10;i>=0;i--){ //перебираем R
  
    if(i==10 && z == 0x01) mySerial.print("z");
    if(i==10 && z == 0x02) mySerial.print(">");
      
    if(i==6 && t == 0x01) mySerial.print(".");
    if(i==6 && t == 0x02) mySerial.print(":");
      
    for(byte j=0;j<38;j++){ //перебираем соды
      if(R[i]==code[j] mySerial.print(simb[j]);
    }
  }
}
void DISP (){
  DATA_write();
  mySerial.println("  ");
}

заполни остатки массивов code и simb. то есть добавляешь в code и соответствующий в simb в том же порядке

Не работает???

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
long  R[11];

long code[41]={
  0xE1E, 0x4E90, 0x9A, 0x4A90, 0x49E, 0x41E, 0xC9A, 0xE0E, 0x4090, 0xA88, 0xA00E, 0x8A, 0x2A2A, 0x8A2A, 0xA9A, 0x61E, 0x8A9A, 0x861E, 0xCB0, 0x4010, 0xA8A, 0x204A, 0x8A4A, 0xA060, 0xE86, 0x20D0, 0xA00, 0x69C, 0xE94, 0xE06, 0xC96, 0xC9E, 0xA12, 0xE9E, 0xE96, 0x2ADA, 0x00, 0x8000, 0x2040, 0x404};
char simb[41]={
  'A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','1','2','3','4','5','6','7','8','9','0',' ',',','/','-' }; 
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it)  
  {
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++) 
    {    
      if (i<=34) 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
        else
        {
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
      }
      else 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);

        }
        else Serial.println(MyBuff[i], HEX);

      }
    }

    DISP ();
    DATA ();

    pos = 0;



  } 
  process_it = false;


}


void DATA ()
{
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ

  bitWrite(R[0], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[26], 5)); 
  //    bitWrite(R[0], 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R[0], 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R[0], 0, bitRead(MyBuff[25], 4));

  bitWrite(R[1], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[1], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[1], 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R[1], 12, bitRead(MyBuff[24], 4));
  bitWrite(R[1], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[1], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[1], 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R[1], 8, bitRead(MyBuff[24], 0));
  bitWrite(R[1], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[1], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[1], 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R[1], 0, bitRead(MyBuff[21], 0));


  bitWrite(R[2], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R[2], 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R[2], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R[2], 8, bitRead(MyBuff[21], 4));
  bitWrite(R[2], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R[2], 0, bitRead(MyBuff[19], 0));

  bitWrite(R[3], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R[3], 12, bitRead(MyBuff[18], 0));
  bitWrite(R[3], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R[3], 8, bitRead(MyBuff[19], 4));
  bitWrite(R[3], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[3], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[3], 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R[3], 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ

  bitWrite(R[4], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R[4], 12, bitRead(MyBuff[16], 0));
  bitWrite(R[4], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R[4], 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R[4], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R[4], 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "

  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R[5], 12, bitRead(MyBuff[14], 0));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R[5], 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R[5], 0, bitRead(MyBuff[13], 0));

  bitWrite(R[6], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R[6], 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R[6], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R[6], 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[6], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R[6], 0, bitRead(MyBuff[8], 0));// ?

  bitWrite(R[7], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R[7], 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R[7], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R[7], 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R[7], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[7], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[7], 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R[7], 0, bitRead(MyBuff[6], 0));// ?

  bitWrite(R[8], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R[8], 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R[8], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R[8], 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[8], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R[8], 0, bitRead(MyBuff[4], 0));// ?

  bitWrite(R[9], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[9], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[9], 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R[9], 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R[9], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[9], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[9], 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R[9], 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[9], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[9], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[9], 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R[9], 0, bitRead(MyBuff[27], 4));// ?

  bitWrite(R[10], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R[10], 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R[10], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R[10], 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R[10], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R[10], 0, bitRead(MyBuff[29], 4));// ?

}


void DATA_write()
{
  for(byte i=10; i>=0; i--)//перебираем R
  {  
    for(byte j=0; j<41; j++)//перебираем коды
    { 
      if(R[i]==code[j]) mySerial.print(simb[j]);
    }
  }
}

void DISP ()
{
  DATA_write();
  mySerial.println("  ");
}

попробуй еще раз свой первоначальный код. работает также или нет

и попробуй это

кстати в массиве не 41, а 40 элементов))

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
unsigned long  R[11];

unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it)  
  {
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++) 
    {    
      if (i<=34) 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
        else
        {
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
      }
      else 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);

        }
        else Serial.println(MyBuff[i], HEX);

      }
    }
    
    DATA ();
    DATA_write();
    pos = 0;
  } 
  process_it = false;
}


void DATA (){
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ

  bitWrite(R[0], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[26], 5)); 
  //    bitWrite(R[0], 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R[0], 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R[0], 0, bitRead(MyBuff[25], 4));

  bitWrite(R[1], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[1], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[1], 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R[1], 12, bitRead(MyBuff[24], 4));
  bitWrite(R[1], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[1], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[1], 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R[1], 8, bitRead(MyBuff[24], 0));
  bitWrite(R[1], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[1], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[1], 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R[1], 0, bitRead(MyBuff[21], 0));


  bitWrite(R[2], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R[2], 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R[2], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R[2], 8, bitRead(MyBuff[21], 4));
  bitWrite(R[2], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R[2], 0, bitRead(MyBuff[19], 0));

  bitWrite(R[3], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R[3], 12, bitRead(MyBuff[18], 0));
  bitWrite(R[3], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R[3], 8, bitRead(MyBuff[19], 4));
  bitWrite(R[3], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[3], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[3], 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R[3], 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ

  bitWrite(R[4], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R[4], 12, bitRead(MyBuff[16], 0));
  bitWrite(R[4], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R[4], 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R[4], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R[4], 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "

  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R[5], 12, bitRead(MyBuff[14], 0));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R[5], 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R[5], 0, bitRead(MyBuff[13], 0));

  bitWrite(R[6], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R[6], 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R[6], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R[6], 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[6], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R[6], 0, bitRead(MyBuff[8], 0));// ?

  bitWrite(R[7], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R[7], 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R[7], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R[7], 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R[7], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[7], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[7], 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R[7], 0, bitRead(MyBuff[6], 0));// ?

  bitWrite(R[8], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R[8], 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R[8], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R[8], 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[8], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R[8], 0, bitRead(MyBuff[4], 0));// ?

  bitWrite(R[9], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[9], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[9], 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R[9], 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R[9], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[9], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[9], 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R[9], 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[9], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[9], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[9], 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R[9], 0, bitRead(MyBuff[27], 4));// ?

  bitWrite(R[10], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R[10], 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R[10], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R[10], 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R[10], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R[10], 0, bitRead(MyBuff[29], 4));// ?

}


void DATA_write()
{
  for(byte i=10; i>=0; i--)//перебираем R
  {  
    for(byte j=0; j<40; j++)//перебираем коды
    { 
      if(R[i]==code[j]) mySerial.print(simb[j]);
    }
  }
  mySerial.println("  ");
}

все равно не работает, в mySerial пустоту шлёт, без переноса строки.

а в Serial только один раз и всё.

странно. проверим сначала одну штуку

кинь сюда что в терминал придет

и пожалуйста не переформатируй код. мне так проще

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
unsigned long  R[11];

unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 
  
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it){
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++){    
      if (i<=34){
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
        else{
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
      }
      else{
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
      }
    }
    
    DATA_write();
    pos = 0;
  } 
  process_it = false;
}


void DATA_write(){
    for(byte j=0; j<40; j++){ 
      Serial.print(code[j], HEX);
      Serial.print(" = ");
      Serial.println(simb[j]);
    }
}

2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204C 03 FE
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = Ið00 00 00 00 00 00 00 00 00 00 61 80 00 00 00 00 00 00 00 00 00 00 05 E9 00 00 00 00 00 00 00 00 00 7C 00 7E
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = I
A88 = J
A00E = K
8A = L
2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204A = V
8A4A = W
A060 = X
E86 = Y
20D0 = Z
A00 = 1
69C = 2
E94 = 3
E06 = 4
C96 = 5
C9E = 6
A12 = 7
E9E = 8
E96 = 9
2ADA = 0
0 =  
8000 = ,
2040 = /
404 = -
00 00 00 00 00 00 00 00 00 00 61 80 00 00 00 00 00 00 00 00 00 00 05 E9 00 00 00 00 00 00 00 00 00 7C 00 7E
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = I
A88 = J
A00E = K
8A = L
2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204A = V
8A4A = W
A060 = X
E86 = Y
20D0 = Z
A00 = 1
69C = 2
E94 = 3
E06 = 4
C96 = 5
C9E = 6
A12 = 7
E9E = 8
E96 = 9
2ADA = 0
0 =  
8000 = ,
2040 = /
404 = -
00 00 00 00 00 00 00 00 00 00 61 80 00 00 00 00 00 00 00 00 00 00 05 E9 00 00 00 00 00 00 00 00 00 7C 00 7E
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = I
A88 = J
A00E = K
8A = L
2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204A = V
8A4A = W
A060 = X
E86 = Y
20D0 = Z
A00 = 1
69C = 2
E94 = 3
E06 = 4
C96 = 5
C9E = 6
A12 = 7
E9E = 8
E96 = 9
2ADA = 0
0 =  
8000 = ,
2040 = /
404 = -
00 00 00 00 00 00 00 00 00 00 61 80 00 00 00 00 00 00 00 00 00 00 05 E9 00 00 00 00 00 00 00 00 00 7C 00 7E
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = I
A88 = J
A00E = K
8A = L
2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204A = V
8A4A = W
A060 = X
E86 = Y
20D0 = Z
A00 = 1
69C = 2
E94 = 3
E06 = 4
C96 = 5
C9E = 6
A12 = 7
E9E = 8
E96 = 9
2ADA = 0
0 =  
8000 = ,
2040 = /
404 = -
00 00 00 00 00 00 00 00 00 00 61 80 00 00 00 00 00 00 00 00 00 00 05 E9 00 00 00 00 00 00 00 00 00 7C 00 7E
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H
4090 = I
A88 = J
A00E = K
8A = L
2A2A = M
8A2A = N
A9A = O
61E = P
8A9A = Q
861E = R
CB0 = S
4010 = T
A8A = U
204A = V
8A4A = W
A060 = X
E86 = Y
20D0 = Z
A00 = 1
69C = 2
E94 = 3
E06 = 4
C96 = 5
C9E = 6
A12 = 7
E9E = 8
E96 = 9
2ADA = 0
0 =  
8000 = ,
2040 = /
404 = -
00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 12 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
E1E = A
4E90 = B
9A = C
4A90 = D
49E = E
41E = F
C9A = G
E0E = H

хорошо. теперь этот код и также выложи что в терминал придет

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
unsigned long  R[11];

unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 
  
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it){
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++){    
      if (i<=34){
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
        else{
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
      }
      else{
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
      }
    }
    
    DATA_write();
    pos = 0;
  } 
  process_it = false;
}


void DATA_write(){
    for(byte i=0; i<11; i++){ 
      Serial.print("R");
      Serial.print(i);
      Serial.print(" = ");
      Serial.print(R[i]);
      Serial.print(" символ ");
      for(byte j=0; j<40; j++){ 
        if(R[i]==code[j]) Serial.println(simb[j]);
      }
    }
}

00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 0 Ñимвол  
R1 = 0 Ñимвол  
R2 = 0 Ñимвол  
R3 = 0 Ñимвол  
R4 = 0 Ñимвол  
R5 = 0 Ñимвол  
R6 = 0 Ñимвол  
R7 = 0 Ñимвол  
R8 = 0 Ñимвол  
R9 = 0 Ñимвол  
R10 = 0 Ñимвол  
00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 0 Ñимвол  
R1 = 0 Ñимвол  
R2 = 0 Ñимвол  
R3 = 0 Ñимвол  
R4 = 0 Ñимвол  
R5 = 0 Ñимвол  
R6 = 0 Ñимвол  
R7 = 0 Ñимвол  
R8 = 0 Ñимвол  
R9 = 0 Ñимвол  
R10 = 0 Ñимвол  
00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 0 Ñимвол  
R1 = 0 Ñимвол  
R2 = 0 Ñимвол  
R3 = 0 Ñимвол  
R4 = 0 Ñимвол  
R5 = 0 Ñимвол  
R6 = 0 Ñимвол  
R7 = 0 Ñимвол  
R8 = 0 Ñимвол  
R9 = 0 Ñимвол  
R10 = 0 Ñимвол  
00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 0 Ñимвол  
R1 = 0 Ñимвол  
R2 = 0 Ñимвол  
R3 = 0 Ñимвол  
R4 = 0 Ñимвол  
R5 = 0 Ñимвол  
R6 = 0 Ñимвол  
R7 = 0 Ñимвол  
R8 = 0 Ñимвол  
R9 = 0 Ñимвол  
R10 = 0 Ñимвол  
00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0

получаеться смещение данных из spi , 4 лишних байта спереди

spi я не трогал. тоже самое. теперь R не должны быть нулями и какой то текст должен получится

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
unsigned long  R[11];

unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 
  
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it){
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++){    
      if (i<=34){
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
        else{
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
      }
      else{
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
      }
    }
    DATA();
    DATA_write();
    pos = 0;
  } 
  process_it = false;
}



void DATA_write(){
    for(byte i=0; i<11; i++){ 
      Serial.print("R");
      Serial.print(i);
      Serial.print(" = ");
      Serial.print(R[i]);
      Serial.print(" simvol ");
      for(byte j=0; j<40; j++){ 
        if(R[i]==code[j]) Serial.println(simb[j]);
      }
    }
}

void DATA (){
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
 
  bitWrite(R[0], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[26], 5));
  //    bitWrite(R[0], 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R[0], 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R[0], 0, bitRead(MyBuff[25], 4));
 
  bitWrite(R[1], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[1], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[1], 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R[1], 12, bitRead(MyBuff[24], 4));
  bitWrite(R[1], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[1], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[1], 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R[1], 8, bitRead(MyBuff[24], 0));
  bitWrite(R[1], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[1], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[1], 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R[1], 0, bitRead(MyBuff[21], 0));
 
 
  bitWrite(R[2], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R[2], 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R[2], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R[2], 8, bitRead(MyBuff[21], 4));
  bitWrite(R[2], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R[2], 0, bitRead(MyBuff[19], 0));
 
  bitWrite(R[3], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R[3], 12, bitRead(MyBuff[18], 0));
  bitWrite(R[3], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R[3], 8, bitRead(MyBuff[19], 4));
  bitWrite(R[3], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[3], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[3], 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R[3], 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
 
  bitWrite(R[4], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R[4], 12, bitRead(MyBuff[16], 0));
  bitWrite(R[4], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R[4], 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R[4], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R[4], 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "
 
  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R[5], 12, bitRead(MyBuff[14], 0));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R[5], 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R[5], 0, bitRead(MyBuff[13], 0));
 
  bitWrite(R[6], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R[6], 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R[6], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R[6], 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[6], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R[6], 0, bitRead(MyBuff[8], 0));// ?
 
  bitWrite(R[7], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R[7], 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R[7], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R[7], 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R[7], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[7], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[7], 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R[7], 0, bitRead(MyBuff[6], 0));// ?
 
  bitWrite(R[8], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R[8], 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R[8], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R[8], 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[8], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R[8], 0, bitRead(MyBuff[4], 0));// ?
 
  bitWrite(R[9], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[9], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[9], 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R[9], 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R[9], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[9], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[9], 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R[9], 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[9], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[9], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[9], 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R[9], 0, bitRead(MyBuff[27], 4));// ?
 
  bitWrite(R[10], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R[10], 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R[10], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R[10], 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R[10], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R[10], 0, bitRead(MyBuff[29], 4));// ?
 
}

R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0
R0 = 9380 simvol R1 = 0 simvol  
R2 = 2578 simvol 7
R3 = 32768 simvol ,
R4 = 3728 simvol R5 = 2144 simvol R6 = 57568 simvol R7 = 0 simvol  
R8 = 0 simvol  
R9 = 14 simvol R10 = 10400 simvol 00 00 00 00 00 00 00 00 10 00 1E 90 EE 00 61 80 90 E0 08 13 10 A0 01 1E 11 4A 25 E9 2A 00 00 00 10 0D A4 A0

текста не будет, если в конечном итоге так и останеться , я сдвину MyBuff на 4 байта и всё будет ок

да убери 4 байта и проверь. посмотрим что получится

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;

bool flag=0;

unsigned long  R[11];

unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 
  
void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it){
    MyBuff [pos] = 0; 

    for (int i=0;  i <= 35; i++){    
      if (i<=34){
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
        else{
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");
        }
      }
      else{
        if (MyBuff[i]<=15){
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
      }
    }
    DATA();
    DATA_write();
    pos = 0;
  } 
  process_it = false;
}



void DATA_write(){
    for(byte i=0; i<11; i++){ 
      Serial.print("R");
      Serial.print(i);
      Serial.print(" = ");
      Serial.print(R[i], HEX);
      Serial.print(" simvol ");
      for(byte j=0; j<40; j++){ 
        if(R[i]==code[j]){
          Serial.println(simb[j]);
          flag=1;
        }
        if(flag==0) Serial.println(" ");
        flag=0;
      }
    }
}

void DATA (){
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
 
  bitWrite(R[0], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[26], 5));
  //    bitWrite(R[0], 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R[0], 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R[0], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R[0], 0, bitRead(MyBuff[25], 4));
 
  bitWrite(R[1], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[1], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[1], 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R[1], 12, bitRead(MyBuff[24], 4));
  bitWrite(R[1], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[1], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[1], 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R[1], 8, bitRead(MyBuff[24], 0));
  bitWrite(R[1], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[1], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[1], 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R[1], 0, bitRead(MyBuff[21], 0));
 
 
  bitWrite(R[2], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R[2], 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R[2], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R[2], 8, bitRead(MyBuff[21], 4));
  bitWrite(R[2], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R[2], 0, bitRead(MyBuff[19], 0));
 
  bitWrite(R[3], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R[3], 12, bitRead(MyBuff[18], 0));
  bitWrite(R[3], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R[3], 8, bitRead(MyBuff[19], 4));
  bitWrite(R[3], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[3], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[3], 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R[3], 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
 
  bitWrite(R[4], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R[4], 12, bitRead(MyBuff[16], 0));
  bitWrite(R[4], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R[4], 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R[4], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R[4], 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "
 
  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R[5], 12, bitRead(MyBuff[14], 0));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R[5], 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R[5], 0, bitRead(MyBuff[13], 0));
 
  bitWrite(R[6], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R[6], 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R[6], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R[6], 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[6], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R[6], 0, bitRead(MyBuff[8], 0));// ?
 
  bitWrite(R[7], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R[7], 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R[7], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R[7], 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R[7], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[7], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[7], 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R[7], 0, bitRead(MyBuff[6], 0));// ?
 
  bitWrite(R[8], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R[8], 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R[8], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R[8], 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[8], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R[8], 0, bitRead(MyBuff[4], 0));// ?
 
  bitWrite(R[9], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[9], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[9], 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R[9], 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R[9], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[9], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[9], 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R[9], 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R[9], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[9], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[9], 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R[9], 0, bitRead(MyBuff[27], 4));// ?
 
  bitWrite(R[10], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R[10], 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R[10], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R[10], 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R[10], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R[10], 0, bitRead(MyBuff[29], 4));// ?
 
}

Получилось вывести , стабильно ваводится если в MyBuff писать через Serial.print.

Объясни пожалуйста как добавить точку между 4 и 5 символом если считать справа на лево?

вот рабочий код

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
unsigned long  R[11];
byte  t;
byte  z;


unsigned long code[40]={
  0x0E1E, 0x4E90, 0x009A, 0x4A90, 0x049E, 0x041E, 0x0C9A, 0x0E0E, 0x4090, 0x0A88, 
  0xA00E, 0x008A, 0x2A2A, 0x8A2A, 0x0A9A, 0x061E, 0x8A9A, 0x861E, 0x0CB0, 0x4010, 
  0x0A8A, 0x204A, 0x8A4A, 0xA060, 0x0E86, 0x20D0, 0x0A00, 0x069C, 0x0E94, 0x0E06, 
  0x0C96, 0x0C9E, 0x0A12, 0x0E9E, 0x0E96, 0x2ADA, 0x0000, 0x8000, 0x2040, 0x0404};
char simb[40]={
  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
  'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '1', '2', '3', '4', '5', '6',
  '7', '8', '9', '0', ' ', ',', '/', '-' }; 

void setup (){
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop (){ 
  if (process_it){
    MyBuff [pos] = 0; 
    Serial.print(MyBuff[0], HEX);
    Serial.print(MyBuff[1], HEX);
    Serial.print(MyBuff[2], HEX);
    Serial.print(MyBuff[3], HEX);
    Serial.print(MyBuff[4], HEX);
    Serial.print(MyBuff[5], HEX);
    Serial.print(MyBuff[6], HEX);
    Serial.print(MyBuff[7], HEX);
    Serial.print(MyBuff[8], HEX);
    Serial.print(MyBuff[9], HEX);
    Serial.print(MyBuff[10], HEX);
    Serial.print(MyBuff[11], HEX);
    Serial.print(MyBuff[12], HEX);
    Serial.print(MyBuff[13], HEX);
    Serial.print(MyBuff[14], HEX);
    Serial.print(MyBuff[15], HEX);
    Serial.print(MyBuff[16], HEX);
    Serial.print(MyBuff[17], HEX);
    Serial.print(MyBuff[18], HEX);
    Serial.print(MyBuff[19], HEX);
    Serial.print(MyBuff[20], HEX);
    Serial.print(MyBuff[21], HEX);
    Serial.print(MyBuff[22], HEX);
    Serial.print(MyBuff[23], HEX);
    Serial.print(MyBuff[24], HEX);
    Serial.print(MyBuff[25], HEX);
    Serial.print(MyBuff[26], HEX);
    Serial.print(MyBuff[27], HEX);
    Serial.print(MyBuff[28], HEX);
    Serial.print(MyBuff[29], HEX);
    Serial.print(MyBuff[30], HEX);
    Serial.print(MyBuff[31], HEX);
    Serial.print(MyBuff[32], HEX);
    Serial.print(MyBuff[33], HEX);
    Serial.print(MyBuff[34], HEX);
    Serial.println(MyBuff[35], HEX); 
    pos = 0;

    DATA();
    DATA_write();
  } 
  process_it = false;
}



void DATA_write(){
  for(byte i=0; i<11; i++){ 
    for(byte j=0; j<40; j++){ 
      if(R[i]==code[j]) mySerial.print(simb[j]);
    }
    if (i==10)   mySerial.println("");
  }
}

void DATA (){
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗНАК " : " МЕЖДУ 4 И 5 РАЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗНАК " . " МЕЖДУ 4 И 5 РАЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗНАК " > " В КОНЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0));// ЗНАК " z " В КОНЦЕ ПОЛЯ

  bitWrite(R[10], 15, bitRead(MyBuff[26], 7));
  bitWrite(R[10], 14, bitRead(MyBuff[26], 6));
  bitWrite(R[10], 13, bitRead(MyBuff[26], 5));
  bitWrite(R[10], 11, bitRead(MyBuff[26], 3));
  bitWrite(R[10], 10, bitRead(MyBuff[26], 2));
  bitWrite(R[10], 9, bitRead(MyBuff[26], 1));
  bitWrite(R[10], 7, bitRead(MyBuff[25], 3));
  bitWrite(R[10], 6, bitRead(MyBuff[25], 2));
  bitWrite(R[10], 5, bitRead(MyBuff[25], 1));
  bitWrite(R[10], 4, bitRead(MyBuff[25], 0));
  bitWrite(R[10], 3, bitRead(MyBuff[25], 7));
  bitWrite(R[10], 2, bitRead(MyBuff[25], 6));
  bitWrite(R[10], 1, bitRead(MyBuff[25], 5));


  bitWrite(R[9], 15, bitRead(MyBuff[24], 7));
  bitWrite(R[9], 14, bitRead(MyBuff[24], 6));
  bitWrite(R[9], 13, bitRead(MyBuff[24], 5));
  bitWrite(R[9], 11, bitRead(MyBuff[24], 3));
  bitWrite(R[9], 10, bitRead(MyBuff[24], 2));
  bitWrite(R[9], 9, bitRead(MyBuff[24], 1));
  bitWrite(R[9], 7, bitRead(MyBuff[22], 7));
  bitWrite(R[9], 6, bitRead(MyBuff[22], 6));
  bitWrite(R[9], 5, bitRead(MyBuff[22], 5));
  bitWrite(R[9], 4, bitRead(MyBuff[22], 4));
  bitWrite(R[9], 3, bitRead(MyBuff[21], 3));
  bitWrite(R[9], 2, bitRead(MyBuff[21], 2));
  bitWrite(R[9], 1, bitRead(MyBuff[21], 1));


  bitWrite(R[8], 15, bitRead(MyBuff[20], 3));
  bitWrite(R[8], 14, bitRead(MyBuff[20], 2));
  bitWrite(R[8], 13, bitRead(MyBuff[20], 1));
  bitWrite(R[8], 11, bitRead(MyBuff[21], 7));
  bitWrite(R[8], 10, bitRead(MyBuff[21], 6));
  bitWrite(R[8], 9, bitRead(MyBuff[21], 5));
  bitWrite(R[8], 7, bitRead(MyBuff[20], 7));
  bitWrite(R[8], 6, bitRead(MyBuff[20], 6));
  bitWrite(R[8], 5, bitRead(MyBuff[20], 5));
  bitWrite(R[8], 4, bitRead(MyBuff[20], 4));
  bitWrite(R[8], 3, bitRead(MyBuff[19], 3));
  bitWrite(R[8], 2, bitRead(MyBuff[19], 2));
  bitWrite(R[8], 1, bitRead(MyBuff[19], 1));


  bitWrite(R[7], 15, bitRead(MyBuff[18], 3));
  bitWrite(R[7], 14, bitRead(MyBuff[18], 2));
  bitWrite(R[7], 13, bitRead(MyBuff[18], 1));
  bitWrite(R[7], 11, bitRead(MyBuff[19], 7));
  bitWrite(R[7], 10, bitRead(MyBuff[19], 6));
  bitWrite(R[7], 9, bitRead(MyBuff[19], 5));
  bitWrite(R[7], 7, bitRead(MyBuff[18], 7));
  bitWrite(R[7], 6, bitRead(MyBuff[18], 6));
  bitWrite(R[7], 5, bitRead(MyBuff[18], 5));
  bitWrite(R[7], 4, bitRead(MyBuff[18], 4));
  bitWrite(R[7], 3, bitRead(MyBuff[17], 2));
  bitWrite(R[7], 2, bitRead(MyBuff[17], 1));
  bitWrite(R[7], 1, bitRead(MyBuff[17], 0));


  bitWrite(R[6], 15, bitRead(MyBuff[16], 3));
  bitWrite(R[6], 14, bitRead(MyBuff[16], 2));
  bitWrite(R[6], 13, bitRead(MyBuff[16], 1));
  bitWrite(R[6], 11, bitRead(MyBuff[17], 7));
  bitWrite(R[6], 10, bitRead(MyBuff[17], 6));
  bitWrite(R[6], 9, bitRead(MyBuff[17], 5));
  bitWrite(R[6], 7, bitRead(MyBuff[16], 7));
  bitWrite(R[6], 6, bitRead(MyBuff[16], 6));
  bitWrite(R[6], 5, bitRead(MyBuff[16], 5));
  bitWrite(R[6], 4, bitRead(MyBuff[16], 4));
  bitWrite(R[6], 3, bitRead(MyBuff[15], 3));
  bitWrite(R[6], 2, bitRead(MyBuff[15], 2));
  bitWrite(R[6], 1, bitRead(MyBuff[15], 1));


  bitWrite(R[5], 15, bitRead(MyBuff[14], 3));
  bitWrite(R[5], 14, bitRead(MyBuff[14], 2));
  bitWrite(R[5], 13, bitRead(MyBuff[14], 1));
  bitWrite(R[5], 11, bitRead(MyBuff[15], 7));
  bitWrite(R[5], 10, bitRead(MyBuff[15], 6));
  bitWrite(R[5], 9, bitRead(MyBuff[15], 5));
  bitWrite(R[5], 7, bitRead(MyBuff[14], 7));
  bitWrite(R[5], 6, bitRead(MyBuff[14], 6));
  bitWrite(R[5], 5, bitRead(MyBuff[14], 5));
  bitWrite(R[5], 4, bitRead(MyBuff[14], 4));
  bitWrite(R[5], 3, bitRead(MyBuff[13], 3));
  bitWrite(R[5], 2, bitRead(MyBuff[13], 2));
  bitWrite(R[5], 1, bitRead(MyBuff[13], 1));


  bitWrite(R[4], 15, bitRead(MyBuff[12], 3));
  bitWrite(R[4], 14, bitRead(MyBuff[12], 2));
  bitWrite(R[4], 13, bitRead(MyBuff[12], 1));
  bitWrite(R[4], 11, bitRead(MyBuff[13], 7));
  bitWrite(R[4], 10, bitRead(MyBuff[13], 6));
  bitWrite(R[4], 9, bitRead(MyBuff[13], 5));
  bitWrite(R[4], 7, bitRead(MyBuff[12], 7));
  bitWrite(R[4], 6, bitRead(MyBuff[12], 6));
  bitWrite(R[4], 5, bitRead(MyBuff[12], 5));
  bitWrite(R[4], 4, bitRead(MyBuff[12], 4));
  bitWrite(R[4], 3, bitRead(MyBuff[8], 3));
  bitWrite(R[4], 2, bitRead(MyBuff[8], 2));
  bitWrite(R[4], 1, bitRead(MyBuff[8], 1));


  bitWrite(R[3], 15, bitRead(MyBuff[7], 3));
  bitWrite(R[3], 14, bitRead(MyBuff[7], 2));
  bitWrite(R[3], 13, bitRead(MyBuff[7], 1));
  bitWrite(R[3], 11, bitRead(MyBuff[8], 7));
  bitWrite(R[3], 10, bitRead(MyBuff[8], 6));
  bitWrite(R[3], 9, bitRead(MyBuff[8], 5));
  bitWrite(R[3], 7, bitRead(MyBuff[7], 7));
  bitWrite(R[3], 6, bitRead(MyBuff[7], 6));
  bitWrite(R[3], 5, bitRead(MyBuff[7], 5));
  bitWrite(R[3], 4, bitRead(MyBuff[7], 4));
  bitWrite(R[3], 3, bitRead(MyBuff[6], 3));
  bitWrite(R[3], 2, bitRead(MyBuff[6], 2));
  bitWrite(R[3], 1, bitRead(MyBuff[6], 1));


  bitWrite(R[2], 15, bitRead(MyBuff[5], 3));
  bitWrite(R[2], 14, bitRead(MyBuff[5], 2));
  bitWrite(R[2], 13, bitRead(MyBuff[5], 1));
  bitWrite(R[2], 11, bitRead(MyBuff[6], 7));
  bitWrite(R[2], 10, bitRead(MyBuff[6], 6));
  bitWrite(R[2], 9, bitRead(MyBuff[6], 5));
  bitWrite(R[2], 7, bitRead(MyBuff[5], 7));
  bitWrite(R[2], 6, bitRead(MyBuff[5], 6));
  bitWrite(R[2], 5, bitRead(MyBuff[5], 5));
  bitWrite(R[2], 4, bitRead(MyBuff[5], 4));
  bitWrite(R[2], 3, bitRead(MyBuff[4], 3));
  bitWrite(R[2], 2, bitRead(MyBuff[4], 2));
  bitWrite(R[2], 1, bitRead(MyBuff[4], 1));


  bitWrite(R[1], 15, bitRead(MyBuff[3], 3));
  bitWrite(R[1], 14, bitRead(MyBuff[3], 2));
  bitWrite(R[1], 13, bitRead(MyBuff[3], 1));
  bitWrite(R[1], 11, bitRead(MyBuff[4], 7));
  bitWrite(R[1], 10, bitRead(MyBuff[4], 6));
  bitWrite(R[1], 9, bitRead(MyBuff[4], 5));
  bitWrite(R[1], 7, bitRead(MyBuff[3], 7));
  bitWrite(R[1], 6, bitRead(MyBuff[3], 6));
  bitWrite(R[1], 5, bitRead(MyBuff[3], 5));
  bitWrite(R[1], 4, bitRead(MyBuff[3], 4));
  bitWrite(R[1], 3, bitRead(MyBuff[27], 7));
  bitWrite(R[1], 2, bitRead(MyBuff[27], 6));
  bitWrite(R[1], 1, bitRead(MyBuff[27], 5));


  bitWrite(R[0], 15, bitRead(MyBuff[28], 7));
  bitWrite(R[0], 14, bitRead(MyBuff[28], 6));
  bitWrite(R[0], 13, bitRead(MyBuff[28], 5));
  bitWrite(R[0], 11, bitRead(MyBuff[27], 3));
  bitWrite(R[0], 10, bitRead(MyBuff[27], 2));
  bitWrite(R[0], 9, bitRead(MyBuff[27], 1));
  bitWrite(R[0], 7, bitRead(MyBuff[28], 3));
  bitWrite(R[0], 6, bitRead(MyBuff[28], 2));
  bitWrite(R[0], 5, bitRead(MyBuff[28], 1));
  bitWrite(R[0], 4, bitRead(MyBuff[28], 0));
  bitWrite(R[0], 3, bitRead(MyBuff[29], 7));
  bitWrite(R[0], 2, bitRead(MyBuff[29], 6));
  bitWrite(R[0], 1, bitRead(MyBuff[29], 5));

}

void T ()
{
  if (t == 0x01) mySerial.print(".");
  if (t == 0x02) mySerial.print(":");
}
void Z ()
{
  if (z == 0x01) mySerial.print("z");
  if (z == 0x02) mySerial.print(">");
}

нифига не понял. где?

стабильно ваводится если в MyBuff писать через Serial.print.

точку просто в цикле если i==4 то вывести точку

вот этот кусок мне кажется странный. process_it после каждого байта равен true, значит легко возможно такое что часть массива будет со старыми данными, а часть с новыми, так как вывод работает когда true

ISR (SPI_STC_vect){
  byte c = SPDR; 
  if (pos < sizeof MyBuff){
    MyBuff [pos++] = c;
    process_it = true;
  }
}

и еще pos каждый раз при выводе приравниваем нулю. магнитола выдает например 20й байт, а ты его пишешь в первый например так как в это время выводил и обнулил только что pos. хотя может я не заметил как ты это обходишь и почему работает. работает да и ладно)))

Всё сейчас работает как должно, спасибо! Скетч уменьшился в 2 раза. 

Проблема только с MyBuff[3] в нем данные передаються только 1 раз за 8 тактов, выглядит так, пример, только MyBuff[3] :

00

AE

00

00

00

00

00

00

00

AE

00

00

00

00

00

00

00

AE

как сделать так , если в MyBuff[3] 00 больше 7 раз то буферер сбрасываеться на 00, а если меньше 7 то оставлять значение не равное 00 ?

а как же цифры 1 и 4? при которых тоже нули. отсеять легко, но как определить что отсеивать. то что больше нуля не подходит. нужно еще что то

А если счетчик по переносу строки сделать? И если  MyBuff[3] = 0 больше 7 раз то сбросить в R[1] биты 4,5,6,7,12,13,14,15 в 0, а если хоть раз какое то другое значение проскакивает то не сбрасывать в 0 ? Цифры 1 и 4 читаются из других буферов.

почему бы и нет. хотя может вообще отсеивать варианты где MyBuff[3] = 0? и без счетчика вообще

разобрался почему если кучу serial.print сделать то нормально работает? дело в задержке?

Нет еще не разобрался, я пока дома. Но мне кажется что я данные беру для записи в R из буфера serial порта

с чего бы)))

Serial.print(MyBuff[0], HEX);

это просто отправка. а так как таких строк много они создают задержку. возможно нужна просто задержка delay

Я пробовал как ты вчера говорил delay(1) и 10 и 100,не работает. Может надо микросекундные задержки использовать?

хз. надо экспериментировать. ну если работает и так оставь. или быстродействия не хватает?

просто разбирательство может много времени занять

Приветствую. Начал заниматься таким же проектом, но с другой магнитолой. Но возникли проблемы на первом этапе: не могу правильно считать данные по SPI в режиме Slave. Реализую на Arduino Nano.

#include <SPI.h>
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;

void setup () {
  Serial.begin (115200);
  pinMode(MISO, OUTPUT);
  SPI.beginTransaction (SPISettings (4000000, MSBFIRST, SPI_MODE3));
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect) {
  byte c = SPDR;
  if (pos < sizeof MyBuff) {
    MyBuff [pos++] = c;
    process_it = true;
  }
}

void loop () {
  if (process_it) {
    MyBuff [pos] = 0;
    for (int i = 0;  i <= 35; i++)
    {
      if (i <= 34)
      {
        if (MyBuff[i] <= 15)
        {
          Serial.print("0");
          Serial.print(MyBuff[i], HEX);
          Serial.print(" ");
        }
        else
        {
          Serial.print(MyBuff[i], HEX);
          Serial.print(" ");
        }
      }
      else
      {
        if (MyBuff[i] <= 15)
        {
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);
        }
        else Serial.println(MyBuff[i], HEX);
        pos = 0;
        process_it = false;
        }
    }
  }
  
}

Вот, что получается: первая строка то, что должно быть

88 80 40 98 0A 48 A0 11 40 00 00 00 00 00 00 00 03 FD 00 00 00 00 00 0A 00 03 FE 38 D8 21 C1 00 00 00 0B FF
88 80 98 0A 48 11 00 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 00 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A FE 38 D8 C1 00 00 0B FF 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF FF 00 00 00 00 00
88 80 98 0A 48 00 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 00 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 00 11 40 00 00 00 00 00 03 FD FD 00 00 00 00 0A 03 FE FE 38 D8 C1 00 00 0B FF FF 00 00 00 00 00
88 80 98 0A 48 11 40 00 00 00 00 00 03 FD FD 00 00 0A 00 03 FE 38 D8 C1 00 00 0B FF FF FF FF 00 00 00 00 00

В чем загвоздка?

Заранее спасибо.

Подскажите в каком направлении работать 

Что вижу сразу - вы по SPI принимаете каждый раз разное кол-во символов, правильно? А вот в цикле for строка 27 выводите на печать всегда весь буфер целиком.

Это вам еще везет, что у вас печатается "почти то, что надо" - в принципе, мог вообще выводится сплошной мусор...

на драйвер дисплея идут четыре посылки по 9 байт. В двух последних байтах каждой посылки свои служебные данные(протокол ССВ). Они мне не нужны. Дисплей имеет 12 знакомест по 13 сегментов плюс значки(их я определил с помощью логического анализатора). Т.е. Вы предлагаете попробовать выводить частями? Позже попробую.

нет, вы не поняли. Причем тут вообще дисплей и его знакоместа?? Я ничего не предлагаю , я указываю, где у вас ошибка. Прочитайте еще раз ВНИМАТЕЛЬНО мое предыдущее сообщение.

если честно пока не понял. В данном примере , что выше это определенный текст не меняющийся во времени. И этот текст передается в 36 байтах. И мне чтобы работать дальше, нужно добиться стабильного приема этих данных, потом уже буду их обрабатывать. А сейчас по два байта в каждой посылке теряются, а где то появляются в другом месте, а где то идет смещение.

Если можно объясните поподробней. на ардуино пока собирал только элементарные схемы, а с таким проектом впервые.

Во-первых, если у вас в посылке 36 байт, то буфер ровно в 36 байт для нее мал, должно быть минимум 37,  так как 36 байт строка + 1 байт терминатор "\0" .

Во-вторых, ваш код будет работать, только если все 36 символов приходят одной посылкой. Если же они приходят частями  - то есть два варианта:

а) дождаться, пока придут все 36 байт, а только потом выводить

б) сразу выводить то, что пришло (менее 36 байт)

В вашем же коде - "ни вашим ни нашим" - вы принимаете часть пакета, записываете в буфер, даже запоминаете длину строки в переменной pos - но почему-то выводите на печать не принятый пакет, а весь буфер целиком, хотя может быть приняли всего пару байт, а остальное в буфере - "мусор"

попробуйте пока два маленьких исправления

1. В строке 2 установите длину MyBuff не 36, а 37 или более (я бы, на время тестов, поставил побольше - 64)

2. Строку 20 запишите так:

if (pos == 36) process_it = true;

88 80 40 98 0A 48 A0 11 40 00 00 00 00 00 00 00 03 FD 00 00 00 00 00 0A 00 03 FE 38 D8 21 C1 00 00 00 0B FF
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A 48 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 A0 40 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
80 98 0A 48 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A 48 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00
88 80 98 0A A0 11 40 00 00 00 00 00 03 FD 00 00 00 00 00 03 FE 38 D8 C1 00 00 0B FF 88 80 98 0A A0 11 40 00

при 37 байт первый байт показывает правильно потом нули и билибирда потом. При 64 см. выше

11 40, 03 FD, 03 FE, 0B FF это как раз служебные данные. И по прежнему 2 байта вообще теряется в посылке.

какие? - последние?

посмотрите выше во вложении . Первая строка то что должно быть. Третий и шестой. а в конце всей передачи начинают повторяться данные из первой посылки. иногда проскакивают и пропадащие байты , но не на своем месте

Посмотрел внимательно на то, что у вас принимается - мне кажется. что на потери не похоже.

 Взгляните - только в первой строке у вас посылки по 9 байт. Потом 5 строк - все пакеты идут по строго 7 байт. Потом строка по 6 байт в посылке. Потом опять по 7....

Если что-то теряется - оно теряется слишком стабильно, так при ошибках не бывает. Думаю, вам нужно получше изучить протокол.

где пропадающие байты?

в первой строке я Вам ставлю что должно быть сто процентов. Это данные с логического анализатора

в десятой строке  появился 6 байт(48). но там и какоето смещение

кстати, MyBuff тоже должен быть volatile

то же самое

Вот и я всю голову сломал. По всякому скетч правил. Даже ставил как int MyBuff. Появлялись пропавшие байты, но исчезали другие. А посылка также была и3 7 байт

В setup() еще можно попробовать явно разрешить прием по прерыванию:

SPCR |= _BV(SPIE);

Это делал. Без изменений

Можно так попробовать сократить

#include <SPI.h>
#include <SoftwareSerial.h>
SoftwareSerial mySerial(8, 9);
byte MyBuff [36];
volatile byte pos;
volatile boolean process_it;
byte  t;
byte  z;
long  R1;
long  R2;
long  R3;
long  R4;
long  R5;
long  R6;
long  R7;
long  R8;
long  R9;
long  R10;
long  R11;

void setup ()
{
  Serial.begin (115200);
  mySerial.begin(115200);
  pinMode(MISO, OUTPUT); 
  SPI.setDataMode(SPI_MODE3);
  SPI.setBitOrder(MSBFIRST);
  SPI.setClockDivider(SPI_CLOCK_DIV4);
  SPI.attachInterrupt();
  SPCR |= _BV(SPE);
  pos = 0;
  process_it = false;
}

ISR (SPI_STC_vect)
{
  byte c = SPDR; 
  if (pos < sizeof MyBuff)
  {
    MyBuff [pos++] = c;
    process_it = true;
  }
}  


void loop ()
{ 

  if (process_it)
  {

    MyBuff [pos] = 0;  


    for (int i=0;  i <= 35; i++) 
    {    
      if (i<=34) 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
        else
        {
          Serial.print(MyBuff[i], HEX); 
          Serial.print(" ");

        }
      }
      else 
      {
        if (MyBuff[i]<=15) 
        {
          Serial.print("0");
          Serial.println(MyBuff[i], HEX);

        }
        else Serial.println(MyBuff[i], HEX);

      }
    }

    DISP ();
    DATA ();

    pos = 0;
  } 
  process_it = false;
}


void DATA ()
{
  bitWrite(t, 1, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(t, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(z, 1, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(z, 0, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ

  bitWrite(R1, 15, bitRead(MyBuff[26], 7));
  bitWrite(R1, 14, bitRead(MyBuff[26], 6));
  bitWrite(R1, 13, bitRead(MyBuff[26], 5)); 
  //    bitWrite(R1, 12, bitRead(MyBuff[26], 4));// ЗÐÐК " > " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R1, 11, bitRead(MyBuff[26], 3));
  bitWrite(R1, 10, bitRead(MyBuff[26], 2));
  bitWrite(R1, 9, bitRead(MyBuff[26], 1));
  //    bitWrite(R1, 8, bitRead(MyBuff[26], 0)); // ЗÐÐК " z " Ð’ КОÐЦЕ ПОЛЯ
  bitWrite(R1, 7, bitRead(MyBuff[25], 3));
  bitWrite(R1, 6, bitRead(MyBuff[25], 2));
  bitWrite(R1, 5, bitRead(MyBuff[25], 1));
  bitWrite(R1, 4, bitRead(MyBuff[25], 0));
  bitWrite(R1, 3, bitRead(MyBuff[25], 7));
  bitWrite(R1, 2, bitRead(MyBuff[25], 6));
  bitWrite(R1, 1, bitRead(MyBuff[25], 5));
  //    bitWrite(R1, 0, bitRead(MyBuff[25], 4));

  bitWrite(R2, 15, bitRead(MyBuff[24], 7));
  bitWrite(R2, 14, bitRead(MyBuff[24], 6));
  bitWrite(R2, 13, bitRead(MyBuff[24], 5));
  //    bitWrite(R2, 12, bitRead(MyBuff[24], 4));
  bitWrite(R2, 11, bitRead(MyBuff[24], 3));
  bitWrite(R2, 10, bitRead(MyBuff[24], 2));
  bitWrite(R2, 9, bitRead(MyBuff[24], 1));
  //    bitWrite(R2, 8, bitRead(MyBuff[24], 0));
  bitWrite(R2, 7, bitRead(MyBuff[22], 7));
  bitWrite(R2, 6, bitRead(MyBuff[22], 6));
  bitWrite(R2, 5, bitRead(MyBuff[22], 5));
  bitWrite(R2, 4, bitRead(MyBuff[22], 4));
  bitWrite(R2, 3, bitRead(MyBuff[21], 3));
  bitWrite(R2, 2, bitRead(MyBuff[21], 2));
  bitWrite(R2, 1, bitRead(MyBuff[21], 1));
  //    bitWrite(R2, 0, bitRead(MyBuff[21], 0));


  bitWrite(R3, 15, bitRead(MyBuff[20], 3));
  bitWrite(R3, 14, bitRead(MyBuff[20], 2));
  bitWrite(R3, 13, bitRead(MyBuff[20], 1));
  //    bitWrite(R3, 12, bitRead(MyBuff[20], 0));// ÐÐДПИСЬ " LOUD "
  bitWrite(R3, 11, bitRead(MyBuff[21], 7));
  bitWrite(R3, 10, bitRead(MyBuff[21], 6));
  bitWrite(R3, 9, bitRead(MyBuff[21], 5));
  //    bitWrite(R3, 8, bitRead(MyBuff[21], 4));
  bitWrite(R3, 7, bitRead(MyBuff[20], 7));
  bitWrite(R3, 6, bitRead(MyBuff[20], 6));
  bitWrite(R3, 5, bitRead(MyBuff[20], 5));
  bitWrite(R3, 4, bitRead(MyBuff[20], 4));
  bitWrite(R3, 3, bitRead(MyBuff[19], 3));
  bitWrite(R3, 2, bitRead(MyBuff[19], 2));
  bitWrite(R3, 1, bitRead(MyBuff[19], 1));
  //    bitWrite(R3, 0, bitRead(MyBuff[19], 0));

  bitWrite(R4, 15, bitRead(MyBuff[18], 3));
  bitWrite(R4, 14, bitRead(MyBuff[18], 2));
  bitWrite(R4, 13, bitRead(MyBuff[18], 1));
  //    bitWrite(R4, 12, bitRead(MyBuff[18], 0));
  bitWrite(R4, 11, bitRead(MyBuff[19], 7));
  bitWrite(R4, 10, bitRead(MyBuff[19], 6));
  bitWrite(R4, 9, bitRead(MyBuff[19], 5));
  //    bitWrite(R4, 8, bitRead(MyBuff[19], 4));
  bitWrite(R4, 7, bitRead(MyBuff[18], 7));
  bitWrite(R4, 6, bitRead(MyBuff[18], 6));
  bitWrite(R4, 5, bitRead(MyBuff[18], 5));
  bitWrite(R4, 4, bitRead(MyBuff[18], 4));
  bitWrite(R4, 3, bitRead(MyBuff[17], 2));
  bitWrite(R4, 2, bitRead(MyBuff[17], 1));
  bitWrite(R4, 1, bitRead(MyBuff[17], 0));
  //  bitWrite(R4, 0, bitRead(MyBuff[17], 3));// ЗÐÐК " . " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ

  bitWrite(R5, 15, bitRead(MyBuff[16], 3));
  bitWrite(R5, 14, bitRead(MyBuff[16], 2));
  bitWrite(R5, 13, bitRead(MyBuff[16], 1));
  //    bitWrite(R5, 12, bitRead(MyBuff[16], 0));
  bitWrite(R5, 11, bitRead(MyBuff[17], 7));
  bitWrite(R5, 10, bitRead(MyBuff[17], 6));
  bitWrite(R5, 9, bitRead(MyBuff[17], 5));
  //    bitWrite(R5, 8, bitRead(MyBuff[17], 4));// ЗÐÐК " : " МЕЖДУ 4 И 5 Ð ÐЗРЯДОМ
  bitWrite(R5, 7, bitRead(MyBuff[16], 7));
  bitWrite(R5, 6, bitRead(MyBuff[16], 6));
  bitWrite(R5, 5, bitRead(MyBuff[16], 5));
  bitWrite(R5, 4, bitRead(MyBuff[16], 4));
  bitWrite(R5, 3, bitRead(MyBuff[15], 3));
  bitWrite(R5, 2, bitRead(MyBuff[15], 2));
  bitWrite(R5, 1, bitRead(MyBuff[15], 1));
  //    bitWrite(R5, 0, bitRead(MyBuff[15], 0));// ÐÐДПИСЬ " TP "

  bitWrite(R6, 15, bitRead(MyBuff[14], 3));
  bitWrite(R6, 14, bitRead(MyBuff[14], 2));
  bitWrite(R6, 13, bitRead(MyBuff[14], 1));
  //    bitWrite(R6, 12, bitRead(MyBuff[14], 0));
  bitWrite(R6, 11, bitRead(MyBuff[15], 7));
  bitWrite(R6, 10, bitRead(MyBuff[15], 6));
  bitWrite(R6, 9, bitRead(MyBuff[15], 5));
  //    bitWrite(R6, 8, bitRead(MyBuff[15], 4));// ÐÐДПИСЬ " AF "
  bitWrite(R6, 7, bitRead(MyBuff[14], 7));
  bitWrite(R6, 6, bitRead(MyBuff[14], 6));
  bitWrite(R6, 5, bitRead(MyBuff[14], 5));
  bitWrite(R6, 4, bitRead(MyBuff[14], 4));
  bitWrite(R6, 3, bitRead(MyBuff[13], 3));
  bitWrite(R6, 2, bitRead(MyBuff[13], 2));
  bitWrite(R6, 1, bitRead(MyBuff[13], 1));
  //    bitWrite(R6, 0, bitRead(MyBuff[13], 0));

  bitWrite(R7, 15, bitRead(MyBuff[12], 3));
  bitWrite(R7, 14, bitRead(MyBuff[12], 2));
  bitWrite(R7, 13, bitRead(MyBuff[12], 1));
  //    bitWrite(R7, 12, bitRead(MyBuff[12], 0));// ?
  bitWrite(R7, 11, bitRead(MyBuff[13], 7));
  bitWrite(R7, 10, bitRead(MyBuff[13], 6));
  bitWrite(R7, 9, bitRead(MyBuff[13], 5));
  //    bitWrite(R7, 8, bitRead(MyBuff[13], 4));// ÐÐДПИСЬ "  "
  bitWrite(R7, 7, bitRead(MyBuff[12], 7));
  bitWrite(R7, 6, bitRead(MyBuff[12], 6));
  bitWrite(R7, 5, bitRead(MyBuff[12], 5));
  bitWrite(R7, 4, bitRead(MyBuff[12], 4));
  bitWrite(R7, 3, bitRead(MyBuff[8], 3));
  bitWrite(R7, 2, bitRead(MyBuff[8], 2));
  bitWrite(R7, 1, bitRead(MyBuff[8], 1));
  //    bitWrite(R7, 0, bitRead(MyBuff[8], 0));// ?

  bitWrite(R8, 15, bitRead(MyBuff[7], 3));
  bitWrite(R8, 14, bitRead(MyBuff[7], 2));
  bitWrite(R8, 13, bitRead(MyBuff[7], 1));
  //    bitWrite(R8, 12, bitRead(MyBuff[7], 0));// ?
  bitWrite(R8, 11, bitRead(MyBuff[8], 7));
  bitWrite(R8, 10, bitRead(MyBuff[8], 6));
  bitWrite(R8, 9, bitRead(MyBuff[8], 5));
  //    bitWrite(R8, 8, bitRead(MyBuff[8], 4));// ÐÐДПИСЬ " ST "
  bitWrite(R8, 7, bitRead(MyBuff[7], 7));
  bitWrite(R8, 6, bitRead(MyBuff[7], 6));
  bitWrite(R8, 5, bitRead(MyBuff[7], 5));
  bitWrite(R8, 4, bitRead(MyBuff[7], 4));
  bitWrite(R8, 3, bitRead(MyBuff[6], 3));
  bitWrite(R8, 2, bitRead(MyBuff[6], 2));
  bitWrite(R8, 1, bitRead(MyBuff[6], 1));
  //    bitWrite(R8, 0, bitRead(MyBuff[6], 0));// ?

  bitWrite(R9, 15, bitRead(MyBuff[5], 3));
  bitWrite(R9, 14, bitRead(MyBuff[5], 2));
  bitWrite(R9, 13, bitRead(MyBuff[5], 1));
  //    bitWrite(R9, 12, bitRead(MyBuff[5], 0));// ?
  bitWrite(R9, 11, bitRead(MyBuff[6], 7));
  bitWrite(R9, 10, bitRead(MyBuff[6], 6));
  bitWrite(R9, 9, bitRead(MyBuff[6], 5));
  //    bitWrite(R9, 8, bitRead(MyBuff[6], 4));// ÐÐДПИСЬ "  "
  bitWrite(R9, 7, bitRead(MyBuff[5], 7));
  bitWrite(R9, 6, bitRead(MyBuff[5], 6));
  bitWrite(R9, 5, bitRead(MyBuff[5], 5));
  bitWrite(R9, 4, bitRead(MyBuff[5], 4));
  bitWrite(R9, 3, bitRead(MyBuff[4], 3));
  bitWrite(R9, 2, bitRead(MyBuff[4], 2));
  bitWrite(R9, 1, bitRead(MyBuff[4], 1));
  //    bitWrite(R9, 0, bitRead(MyBuff[4], 0));// ?

  bitWrite(R10, 15, bitRead(MyBuff[3], 3));
  bitWrite(R10, 14, bitRead(MyBuff[3], 2));
  bitWrite(R10, 13, bitRead(MyBuff[3], 1));
  //    bitWrite(R10, 12, bitRead(MyBuff[3], 0));// ?
  bitWrite(R10, 11, bitRead(MyBuff[4], 7));
  bitWrite(R10, 10, bitRead(MyBuff[4], 6));
  bitWrite(R10, 9, bitRead(MyBuff[4], 5));
  //    bitWrite(R10, 8, bitRead(MyBuff[4], 4));// ÐÐДПИСЬ "  "
  bitWrite(R10, 7, bitRead(MyBuff[3], 7));
  bitWrite(R10, 6, bitRead(MyBuff[3], 6));
  bitWrite(R10, 5, bitRead(MyBuff[3], 5));
  bitWrite(R10, 4, bitRead(MyBuff[3], 4));
  bitWrite(R10, 3, bitRead(MyBuff[27], 7));
  bitWrite(R10, 2, bitRead(MyBuff[27], 6));
  bitWrite(R10, 1, bitRead(MyBuff[27], 5));
  //    bitWrite(R10, 0, bitRead(MyBuff[27], 4));// ?

  bitWrite(R11, 15, bitRead(MyBuff[28], 7));
  bitWrite(R11, 14, bitRead(MyBuff[28], 6));
  bitWrite(R11, 13, bitRead(MyBuff[28], 5));
  //    bitWrite(R11, 12, bitRead(MyBuff[28], 4));// ?
  bitWrite(R11, 11, bitRead(MyBuff[27], 3));
  bitWrite(R11, 10, bitRead(MyBuff[27], 2));
  bitWrite(R11, 9, bitRead(MyBuff[27], 1));
  //    bitWrite(R11, 8, bitRead(MyBuff[27], 0));// ÐÐДПИСЬ "  "
  bitWrite(R11, 7, bitRead(MyBuff[28], 3));
  bitWrite(R11, 6, bitRead(MyBuff[28], 2));
  bitWrite(R11, 5, bitRead(MyBuff[28], 1));
  bitWrite(R11, 4, bitRead(MyBuff[28], 0));
  bitWrite(R11, 3, bitRead(MyBuff[29], 7));
  bitWrite(R11, 2, bitRead(MyBuff[29], 6));
  bitWrite(R11, 1, bitRead(MyBuff[29], 5));
  //    bitWrite(R11, 0, bitRead(MyBuff[29], 4));// ?

}



void T ()
{
  if (t == 0x01) mySerial.print(".");
  if (t == 0x02) mySerial.print(":");
}
void Z ()
{
  if (z == 0x01) mySerial.print("z");
  if (z == 0x02) mySerial.print(">");
}
void DATA_R (long R)
{
  if (R == 0x8A9A) mySerial.print("Q");
  if (R == 0x204A) mySerial.print("V");
  if (R == 0x2040) mySerial.print("/");
  if (R == 0x61E) mySerial.print("P");
  if (R == 0xA88) mySerial.print("J");
  if (R == 0x4E90) mySerial.print("B");
  if (R == 0xA060) mySerial.print("X");
  if (R == 0xE86) mySerial.print("Y");
  if (R == 0xA8A) mySerial.print("U");
  if (R == 0xCB0) mySerial.print("S");
  if (R == 0xE0E) mySerial.print("H");
  if (R == 0xC9A) mySerial.print("G");
  if (R == 0xE1E) mySerial.print("A");
  if (R == 0xA9A) mySerial.print("O");
  if (R == 0xA00E) mySerial.print("K");
  if (R == 0x9A) mySerial.print("C");
  if (R == 0x4A90) mySerial.print("D");
  if (R == 0x2A2A) mySerial.print("M");
  if (R == 0x4010) mySerial.print("T");
  if (R == 0x4090) mySerial.print("I");
  if (R == 0x41E) mySerial.print("F");
  if (R == 0x861E) mySerial.print("R");
  if (R == 0x49E) mySerial.print("E");
  if (R == 0x8A) mySerial.print("L");
  if (R == 0x8A2A) mySerial.print("N");
  if (R == 0x8000) mySerial.print(",");
  if (R == 0x404) mySerial.print("-");
  if (R == 0x2ADA) mySerial.print("0");
  if (R == 0xA00) mySerial.print("1");
  if (R == 0x69C) mySerial.print("2");
  if (R == 0xE94) mySerial.print("3");
  if (R == 0xE06) mySerial.print("4");
  if (R == 0xC96) mySerial.print("5");
  if (R == 0xC9E) mySerial.print("6");
  if (R == 0xA12) mySerial.print("7");
  if (R == 0xE9E) mySerial.print("8");
  if (R == 0xE96) mySerial.print("9");
  if (R == 0x00) mySerial.print(" ");

}

void DISP ()
{

  DATA_R (R11);
  DATA_R (R10);
  DATA_R (R9);
  DATA_R (R8);
  DATA_R (R7);
  DATA_R (R6);
  DATA_R (R5);
  T ();
  DATA_R (R4);
  DATA_R (R3);
  DATA_R (R2);
  DATA_R (R1);
  Z ();
  mySerial.println("  ");

}

Юлиан все в том же стиле :)

Вы ответили на вопрос, заданный 2.5 года назад. Код давно уже переписали - в сообщ #14 - причем почти на 100 строк лучше, чем у вас.

Бесконечные bitWrite тоже можно переписать покороче. выиграв еще строк 100-150...

Не понял что сократить. Его код и был взят за основу. Только первая часть. С следующей частью, кодировкой символов еще предстоит работать