Да это товарищ не въехал, что первому сообщению несколько лет :)

Кодировку символов в сообщ #14 уже переписали покороче. Но резерв сокращения еще большой.

Я уже понял. Можно я завтра сброшу скрин с логического анализатора. Или сам файл . Может там что не так. На мой взгляд вроде все путем.

Вы тоже в своем духе.

С годом конечно лажанул.)

Может пригодится кому.

Мой вариант против кода из поста #14 занимает на  1096 байт (почти 8%) меньше 13024 байт против 14120 байт

У человека проблема не с кодом, а с железом 100%.  

1- проверить анализатором правильность инвертирования сигнала CS (на сколько он смещен относительно реального).

2- не справляется ардуина по скорости, я когда у себя делал - менял кварц.

3- на некоторых устройствах пакеты передаются в разнобой (поэтому каждый пакет пронумерован в последних 2 битах последнего байта), по хорошему надо 4 буфера. Или проверять анализатором инкримент пакетов всегда ли они по порядку.

В итоге работало нормально но только на чтение. Мне же надо было еще и передавать данные по этому протоколу, пришлось ставить Teensy3(96MHz) и работать по прерыванию с CLK, был написан эмулятор протокола CCB. В обед выложу рабочие куски кода с обоих устройств (arduino и teensy).

А по хорошему переходите на Stm и будет вам счастье!

 не понял, а почему ардуино не справлятся по скорости? Частото тактового импульса всего 3 MHz

"всего 3 МГц" ?! - это не "всего", это дофига.

У ардуины 16 МГц - и вот тут действительно, "всего". То есть у вас частота ардуины ВСЕГО в 5 раз больше частоты шины. А теперь посмотрите, сколько инструкций у вас в обработчике прерываний. Сильно сомневаюсь, что у ардуины есть хоть малейший шанс успеть, если значения по шине идут с минимальной задержкой.

Теперь понимаю. Если такую вещь  использовать STM32F103C8T6. Я думаю должно хватить. Или может, что еще посоветуете из готовых плат.

хватит с головой

вот этот код работал на uno 100%, но я еще в него подмешивал данные

#include <SPI.h>
byte MyBuff [48];
volatile byte pos;
volatile boolean process_it;
unsigned  R[12];
unsigned  M[3];
int flag = 0;
String inString;

unsigned code[64]={
  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, 0x0040,
  0x4404, 0xA8BC, 0x0404, 0x0400, 0x0004, 0x0080, 0x40FE, 0xEE90, 0xAC66,

  0x809E, 0x001A, 0xE060, 0x0E90, 0x2A4A, 0x2A40, 0x0A1A, 0x4616,
  0x408A, 0x4A8A, 0x4C90, 0x0A4E, 0x0C8E, 0xAA0E, 0x0E56};

char* s[64]={
  "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", " ", ".", "/", ",",
  "+", "&", "-", "-", "-", "_", "(",  ")", "%",

  "\u0411", "\u0413", "\u0416", "\u0417", "\u0418", "\u041B", "\u041F", "\u0424",
  "\u0426", "\u0428", "\u042A", "\u042B", "\u042C", "\u042E", "\u042F"};  

unsigned code1[25]={
  0x003F, 0x0006, 0x00DB, 0x00CF, 0x00E6, 0x00ED, 0x00FD, 0x0007, 0x00FF, 0x00EF,
  0x00F1, 0x00F3, 0x00DC, 0x00DE, 0x0236, 0x00F7, 0x00D4, 0x00F9, 0x0101, 0x00EE,
  0x0039, 0x003E, 0x014F, 0x00C0, 0x0000};

char* m[25]={
  "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
  "F", "P", "o", "d", "M", "A", "n", "E", "T", "Y",
  "C", "U", "B", "-", " "} 
; 

void setup (){
  Serial.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;
    delayMicroseconds(5000);
    pos = 0;
    process_it = false;
    if (MyBuff[3] == 0 && flag <= 8) flag++;
    else flag = 0;
    if (MyBuff[3] != 0 || flag == 8){
      flag = 0;
      DATA();
      while (Serial.available()) {
        char inChar = Serial.read();
        inString += inChar;
        if (inChar == '>'&& flag == 0) {
          DATA_write();
          Serial.println(inString);
          inString = "";
        }
      }
    }
  }
}




void DATA_write(){

  Serial.print("<data:");
  for(byte i=0; i<3; i++){
    if(i==0 && bitRead(MyBuff[29], 4)) Serial.print("i");
    for(byte j=0; j<25; j++){ 
      if(M[i]==code1[j]) Serial.print(m[j]);
    }
  }
  //  if( bitRead(MyBuff[7], 0)) Serial.print(" MENU");
  //  if( bitRead(MyBuff[8], 0)) Serial.print(" S");
  //  if( bitRead(MyBuff[18], 0)) Serial.print(" MUZ");
  //  if( bitRead(MyBuff[19], 4)) Serial.print(" TEL");
  if(bitRead(MyBuff[15], 0)) Serial.print(" TP");
  if(bitRead(MyBuff[13], 4)) Serial.print(" ST");
  if(bitRead(MyBuff[15], 4)) Serial.print(" AF");
  if(bitRead(MyBuff[14], 0)) Serial.print(" RPT");
  if(bitRead(MyBuff[13], 0)) Serial.print(" RND");
  if(bitRead(MyBuff[6], 4)) Serial.print(" BT");
  if(bitRead(MyBuff[20], 0)) Serial.print(" LOUD");
  Serial.print("#");
  for(byte i=0; i<12; i++){
    if(i==11 && bitRead(MyBuff[26], 0)) Serial.print("z");
    if(i==11 && bitRead(MyBuff[25], 4)) Serial.print("*");// знак "
    if(i==9 && bitRead(MyBuff[25], 4)) Serial.print("'");
    if(i==7 && bitRead(MyBuff[17], 3)) Serial.print(".");
    if(i==11)Serial.print("#");  
    for(byte j=0; j<64; j++){ 
      if(R[i]==code[j]) Serial.print(s[j]);
    }
  }
}

void DATA (){

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


  bitWrite(M[2], 8, bitRead(MyBuff[36], 5));
  bitWrite(M[2], 7, bitRead(MyBuff[36], 6));
  bitWrite(M[2], 6, bitRead(MyBuff[42], 5));
  bitWrite(M[2], 5, bitRead(MyBuff[36], 7));
  bitWrite(M[2], 4, bitRead(MyBuff[36], 4));
  bitWrite(M[2], 3, bitRead(MyBuff[31], 4));
  bitWrite(M[2], 2, bitRead(MyBuff[42], 4));
  bitWrite(M[2], 1, bitRead(MyBuff[42], 6));
  bitWrite(M[2], 0, bitRead(MyBuff[42], 7));


  bitWrite(M[1], 9, bitRead(MyBuff[30], 2));
  bitWrite(M[1], 8, bitRead(MyBuff[30], 1));
  bitWrite(M[1], 7, bitRead(MyBuff[30], 6));
  bitWrite(M[1], 6, bitRead(MyBuff[31], 6));
  bitWrite(M[1], 5, bitRead(MyBuff[30], 7));
  bitWrite(M[1], 4, bitRead(MyBuff[30], 5));
  bitWrite(M[1], 3, bitRead(MyBuff[30], 0));
  bitWrite(M[1], 2, bitRead(MyBuff[31], 5));
  bitWrite(M[1], 1, bitRead(MyBuff[31], 7));
  bitWrite(M[1], 0, bitRead(MyBuff[30], 3));


  bitWrite(M[0], 8, bitRead(MyBuff[29], 1));
  bitWrite(M[0], 7, bitRead(MyBuff[29], 0));
  bitWrite(M[0], 6, bitRead(MyBuff[29], 0));
  bitWrite(M[0], 5, bitRead(MyBuff[29], 2));
  bitWrite(M[0], 4, bitRead(MyBuff[28], 4));
  bitWrite(M[0], 3, bitRead(MyBuff[27], 0));
  bitWrite(M[0], 2, bitRead(MyBuff[27], 4));
  bitWrite(M[0], 1, bitRead(MyBuff[30], 4));
  bitWrite(M[0], 0, bitRead(MyBuff[29], 3));

}

а вот с teensy

void setup() {
  PORTA_PCR4  = PORT_PCR_MUX(1); GPIOA_PDDR |= _BV(4);  // 33 PWR
  PORTA_PCR5  = PORT_PCR_MUX(1); GPIOA_PDDR |= _BV(5);  // 24 CAM
  PORTC_PCR4  = PORT_PCR_MUX(1);  // 10 cs
  PORTC_PCR5  = PORT_PCR_MUX(1);  // 13 clock
  PORTC_PCR6  = PORT_PCR_MUX(1); GPIOC_PDDR |= _BV(6);  // 11 data out
  PORTC_PCR7  = PORT_PCR_MUX(1);  // 12 data in
  PORTC_PCR8  = PORT_PCR_MUX(1); GPIOC_PDDR |= _BV(8);  GPIOC_PSOR = _BV(8);  // 28 inc1 = 1
  PORTC_PCR9  = PORT_PCR_MUX(1); GPIOC_PDDR |= _BV(9);  GPIOC_PSOR = _BV(9);  // 27 inc2 = 1
  PORTC_PCR10 = PORT_PCR_MUX(1); GPIOC_PDDR |= _BV(10); GPIOC_PSOR = _BV(10); // 29 remote = 1
  PORTC_PCR11 = PORT_PCR_MUX(1); GPIOC_PDDR |= _BV(11); GPIOC_PSOR = _BV(11); // 30 PAN DETEKT = 1
  Serial.begin (115200);
  CANbus.begin();
}

void Sanyo_CCB() {
  if (!(GPIOC_PDIR & 0x10)) {                                  // 10 cs = 0
    bitWrite(Add, posA, (GPIOC_PDIR & 0x80));                  // читаем адрес
    posA++;
    posKey = 0;
    if (Add == 0x86) DATA();                                   // проверка CRC и разбивка данных
  }
  else {                                                       // 10 cs = 1
    posA = 0;
    if (Add == 0x42) {
      bitWrite(MyBuff[posBy], posBi, (GPIOC_PDIR & 0x80));     // читаем данные дисплея
      posBi--;
      if (posBi < 0) {
        posBi = 31;
        posBy++;
      }
    }
    if (Add == 0x86 || Add == 0x43) {
      posKey++;
      if (posKey == 21 || posKey == Key) GPIOC_PSOR = _BV(6);  // 11 data out = 1
      else GPIOC_PCOR = _BV(6);                                // 11 data out = 0
      posBi = 31;
      posBy = 0;
    }
  }
}

void loop() {
  KEY(); CAN(); INFO_SOURCE();
  uint32_t currentMillis = millis();
  if (currentMillis - previousMillis > 50) {
    previousMillis = currentMillis;
    if (dataOK == 0) {
      DATA_write();
      dataOK = 0;
    }
  }
}

сейчас попробую. Спасибо

Посмотрел код. Если убрать пока всё лишнее, получается то что и у меня сейчас

Буду разбираться дальше.

на teensy без инверсии cs