Return to Answer

But the datasheet says that speeds of Fosc/4 are possible in slave mode, which would be 4MHz in this case. Would that be achievable if I removed the ISR and just used a busy loop?

Well, yes the datasheet has an example of doing a busy loop:

char SPI_SlaveReceive(void)
{
/* Wait for reception complete */
while(!(SPSR & (1<<SPIF)))
;
/* Return Data Register */
return SPDR;
}

Regardless of what they claim, what you intend has to be physically possible. So with Fosc/4, assuming a 16 MHz clock, you have 2 μs for a byte to arrive (250 ns * 8). So the hardware may well be able to receive one byte in that time, and you may just have enough clock cycles to notice it arriving and plonk it into memory somewhere (although things could be tight) but you won't have time to send a different response after each incoming byte, because you only have around 250 ns to do it in, and the loop that detects the interrupt will probably use up most or all of that.

After a bit of mucking around, I got it to work at 250 kHz where the objective was just for the slave to return some data (after all, I presume that is what the slave is supposed to do).

Master

#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) {
 // packet size of 200
 byte buffer[200];
 // perform transfer
 digitalWrite(SS, LOW);
 delay (1); // give slave time to react
 SPI.transfer(buffer, sizeof(buffer));
 digitalWrite(SS, HIGH); // SS is pin 10
 // tally results
 byte successes = 0, failures = 0;
 for (byte index = 0; index < sizeof(buffer); index++)
 if (buffer[index] == index) successes++; else failures++;
 // print results
 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); // give the slave time to be ready
 for (byte attempt = 1; attempt <= 10; attempt+=2) {
 do_transfer(attempt, 0x00);
 do_transfer(attempt+1, 0xFF);
 wdt_reset();
 }
 while(true); // end of program
}

Slave

#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)
 {
 // handle pin change interrupt for D8 to D13 here
 // ignore transition to HIGH
 if (digitalRead (SS) == HIGH)
 return;
 
 SPDR = 0;
 
 for (byte i = 0; i < TEST_SIZE; i++)
 {
 SPDR = my_data [i];
 while(!(SPSR & (1<<SPIF)))
 {
 // if SS went high, give up
 if (PINB & (1 << 2))
 return;
 }
 } // end of for loop
 
 } // end of PCINT0_vect
void setup(void) {
 pinMode(MISO, OUTPUT); // MISO needs to be an output
 SPCR |= _BV(SPE); // enable SPI in slave mode
 power_timer0_disable();
 for (int i = 0; i < TEST_SIZE; i++)
 my_data [i] = i;
 // pin change interrupt for D10
 PCMSK0 |= bit (PCINT2); // want pin 10
 PCIFR |= bit (PCIF0); // clear any outstanding interrupts
 PCICR |= bit (PCIE0); // enable pin change interrupts for D8 to D13
 SPDR = 0;
 set_sleep_mode (SLEEP_MODE_IDLE);
}
void loop (void) 
 {
 sleep_mode ();
 }

At the next clock divisor (SPI_CLOCK_DIV32) I started getting occasional errors. After all, Fclk/32 is only 2 μs per clock pulse and 16 μs per byte, and the necessary stuff in the inner loop must be taking that long — I didn't calculate the individual instruction times, you are welcome to do that. :)

I was hoping to get better performance than that, but then I realised that even with a tight sending loop in the slave, you can't afford to send before the master has acknowledged the previous byte (ie. that it has read it) so you still have the tight interval between the end of one byte and the start of the next, which is the time in which you have to prepare the next byte for sending.

It's not as bad if you are the master, because you control when the byte starts, so you can take as long as you want between bytes.