Как заставить Arduino надежно работать в качестве ведомого устройства SPI?

Ваша проблема здесь - это выбор времени. Я попробовал вашу настройку и обнаружил, что действительно получаю случайные ошибки на частоте 125 кГц. Отключение таймера 0 (как было предложено Chrisl) исправило это:

  power_timer0_disable();

Но хотя сейчас он работает до 250 кГц, я получаю много ошибок на частоте 500 кГц.

Хорошо, время между тактовыми импульсами теперь составляет 2 мкс, однако, как я описываю здесь, время, необходимое для выполнения ISR, такого как SPI_STC_vect, составляет 2,625 мкс, поэтому он не может справляться с необходимостью помещать туда данные каждые 2 с.

На самом деле у вас есть немного больше времени, чем 2 мкс, потому что критическое время - это время между окончанием первого байта (когда вызывается ISR) и временем до начала второго байта, когда мастер начнет выборку вашего ответа.

Смотрите скриншот ниже с указанием критического времени, выделенного желтым цветом.

Это время составляет 2,45 мкс, а ISR занимает 2,625 мкс. Теперь кое-что из этого - эпилог ISR, который на самом деле не будет иметь большого значения, но вы можете видеть, что дела обстоят туго. Трудно точно сказать, в какой момент процессор начинает вызывать ISR после поступления последнего бита, и длина инструкции, которую он выполняет в данный момент, может быть влияющим фактором.

Я заставил ваши скетчи работать на частоте 250 кГц со следующими поправками к ведомому устройству:

#include "pins_arduino.h"
#include <avr/power.h>
#include <avr/sleep.h>

void setup(void) {
  pinMode(MISO, OUTPUT);          // MISO должен быть выходом
  SPCR |= _BV(SPE);               // включить SPI в подчиненном режиме
  SPCR |= _BV(SPIE);              // включить прерывания
  SPDR = 66;
  power_timer0_disable(); 
  set_sleep_mode (SLEEP_MODE_IDLE);
}

ISR (SPI_STC_vect) { SPDR = 66; }   // просто отправляйте 66, пока коровы не вернутся домой

void loop (void) 
 {
 sleep_mode ();
 }

Режим ожидания в режиме ожидания гарантирует, что процессор не находится на полпути к выполнению инструкции, когда возникает прерывание.

Как и ожидалось (по вышеуказанным причинам), он не работал на частоте 500 кГц.

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

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

Но в техническом описании указано, что скорости Fosc / 4 возможны в подчиненном режиме, который в данном случае будет составлять 4 МГц. Было бы это достижимо, если бы я удалил ISR и просто использовал цикл занятости?

Ну, да, в таблице данных есть пример выполнения цикла занятости:

char SPI_SlaveReceive(void)
{
/* Дождитесь завершения приема */
while(!(SPSR & (1<<SPIF)))
;
/* Вернуть регистр данных */
return SPDR;
}

Независимо от того, что они утверждают, то, что вы намереваетесь, должно быть физически возможным. Таким образом, с Fosc / 4, предполагая тактовую частоту 16 МГц, у вас есть 2 мкс для поступления байта (250 нс * 8). Таким образом, аппаратное обеспечение вполне может получить один байт за это время, и у вас может быть достаточно тактовых циклов, чтобы заметить его поступление и поместить его куда-нибудь в память (хотя это может быть затруднительно), но у вас не будет времени отправлять другой ответ после каждого входящего байта, потому что у вас есть только на это уходит около 250 нс, и цикл, который обнаруживает прерывание, вероятно, израсходует большую часть или все это.

Немного повозившись, я заставил его работать на частоте 250 кГц, где целью было просто, чтобы ведомое устройство возвращало некоторые данные (в конце концов, я предполагаю, что это то, что должно делать ведомое устройство).

Мастер

#define MOSI    12
#define SCK     13

#include <SPI.h>
#include "pins_arduino.h"
#include <avr/wdt.h>

void setup(void) {
    Serial.begin(9600);

    digitalWrite(SS, HIGH);
    pinMode(SS, OUTPUT);
    digitalWrite(SS, HIGH);

    digitalWrite(SCK, HIGH);
    pinMode(SCK, OUTPUT);
    pinMode(MOSI, OUTPUT);

    SPI.begin();
    SPI.setClockDivider(SPI_CLOCK_DIV64);     

    Serial.println("\n\nSTARTING...\n");
    
}

void do_transfer(byte attempt, byte payload) {

    // размер пакета 200
    byte buffer[200];

    // выполнить
    digitalWrite(SS, LOW);
    delay (1);    // дайте ведомому устройству время для реагирования
    SPI.transfer(buffer, sizeof(buffer));
    digitalWrite(SS, HIGH);    // SS - вывод 10

    // подсчет результатов
    byte successes = 0, failures = 0;
    for (byte index = 0; index < sizeof(buffer); index++)
        if (buffer[index] == index) successes++; else failures++;

    // печать результатов
    Serial.print("Attempt ");
    Serial.print(attempt);
    Serial.print(" with payload ");
    Serial.print(payload);
    Serial.print(": ");
    if (failures == 0)
        Serial.print("SUCCESS");
    else {
        Serial.print(successes);
        Serial.print(" correct bytes, ");
        Serial.print(failures);
        Serial.print(" incorrect bytes");
        for (byte index = 0; index < sizeof(buffer); index++) {
            if (index % 10 == 0)
                Serial.print("\n\t");
            if (buffer[index] == index)
                Serial.print("-");
            else
                Serial.print(buffer[index]);
            if (index < sizeof(buffer) - 1)
                Serial.print("\t");
        }
    }
    Serial.println();
    Serial.println();
}

void loop(void) {
    delay(800);                                                         // дайте ведомому устройству время для готовности

    for (byte attempt = 1; attempt <= 10; attempt+=2) {
        do_transfer(attempt, 0x00);
        do_transfer(attempt+1, 0xFF);
        wdt_reset();
    }
    while(true);                                                        // завершение программы
}

Подчинение

#include "pins_arduino.h"
#include <avr/power.h>
#include <avr/sleep.h>

const int TEST_SIZE = 200;

volatile byte my_data [TEST_SIZE];

volatile byte dummy;

ISR (PCINT0_vect)
 {
 // обработайте прерывание смены вывода для D8 на D13 здесь

  // игнорировать переход к ВЫСОКОМУ
  if (digitalRead (SS) == HIGH)
    return;
    
  SPDR = 0;
  
  for (byte i = 0; i < TEST_SIZE; i++)
    {
    SPDR = my_data [i];
    while(!(SPSR & (1<<SPIF)))
      {
      // если SS поднялся высоко, сдавайся
      if (PINB & (1 << 2))
        return;
      }
    } // конец цикла for

    
 }  // конец PCINT0_vect

void setup(void) {
  pinMode(MISO, OUTPUT);          // MISO должен быть выходом
  SPCR |= _BV(SPE);               // включить SPI в подчиненном режиме
  power_timer0_disable();
  for (int i = 0; i < TEST_SIZE; i++)
    my_data [i] = i;

  // прерывание смены контактов для D10
  PCMSK0 |= bit (PCINT2);  // требуется вывод 10
  PCIFR  |= bit (PCIF0);   // очистить все незавершенные прерывания
  PCICR  |= bit (PCIE0);   // включить прерывания смены контактов для D8 на D13

  SPDR = 0;

  set_sleep_mode (SLEEP_MODE_IDLE);

}


void loop (void) 
  {
  sleep_mode ();
  }

В следующем тактовом делителе (SPI_CLOCK_DIV32) Я начал время от времени получать ошибки. В конце концов, Fclk / 32 составляет всего 2 мкс на тактовый импульс и 16 мкс на байт, и необходимые вещи во внутреннем цикле должны занимать столько времени — я не рассчитывал время отдельных команд, вы можете это сделать. :)

Я надеялся получить более высокую производительность, чем это, но потом я понял, что даже при плотном цикле отправки в подчиненном устройстве вы не можете позволить себе отправлять до того, как ведущий подтвердит предыдущий байт (т. Е. что он прочитал его) таким образом, у вас все еще есть жесткий интервал между концом одного байта и началом следующего, то есть время, за которое вы должны подготовить следующий байт к отправке.

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