Probleme mit SS der AVR Hardware SPI im Slave Betrieb

[Tim T. (tim_taylor)]

Hallo,

ich versuche nun schon seit mehreren Stunden einen Atmega8 (oder auch 
Atmega328P) dazu zu überreden als SPI Slave zu laufen, aber es will 
einfach nicht funktionieren.

Wenn ich den !SS Pin manuell auf GND lege, funktioniert die Hardware-SPI 
wie gewünscht, nur eben nicht wenn sie selber den !SS Pin auswerten 
soll.

Minimal Beispiel Hardware-SPI (nur Empfang):

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#define SPI_SS   PB2
#define SPI_MOSI PB3
#define SPI_MISO PB4
#define SPI_CLK  PB5

volatile uint8_t BUFFER[256];
volatile uint8_t r, w;


void init_uart(uint32_t baud){
 uint16_t ubrr = ( (F_CPU + baud * 8) / (16 * baud) ) - 1;
 UBRRH = (uint8_t)(ubrr >> 8);
 UBRRL = (uint8_t)(ubrr & 0xFF);
 UCSRB = (1 << TXEN);
 // Asynchron 8N1
 UCSRC = (1 << URSEL) | (0 << UMSEL) | (0 << UPM1) | (0 << UPM0) | (0 << USBS) | (0 << UCSZ2) | (1 << UCSZ1) | (1 << UCSZ0);
}

static inline uint8_t send_byte(uint8_t data) {
 // Senden, wenn UDR frei ist
 if (UCSRA & (1 << UDRE)) {   
  UDR = data;
  return 1;
 }
 return 0;
}

ISR(SPI_STC_vect) {
 BUFFER[w++] = SPDR;
}

int main(void) {
 init_uart(115200);
 // MISO Output, Rest Inputs (aber eigentlich egal)
 DRB = (1 << SPI_MISO);
 // SPI data output register (MISO)
 SPDR = 0x00;
 // Enable SPI Interrupt, enable SPI, MSB first, SPI Slave, CPOL 1, CPHA 1
 SPCR = (1 << SPIE) |  (1 << SPE) | (0 << DORD) | (0 << MSTR) | (1 << CPOL) | (1 << CPHA);
 sei();
 while(1) {
  if ( r != w ) if ( send_byte(BUFFER[r]) ) r++;
 };
 return 0;
}

Das dass SS Signal nicht richtig funktioniert kann ich ausschließen, da 
eine schnell zusammengestrickte Software-SPI (auch nur Empfang) 
anstandslos funktioniert:

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>

#define SPI_SS   PB2
#define SPI_MOSI PB3
#define SPI_MISO PB4
#define SPI_CLK  PB5

volatile uint8_t BUFFER[256];
volatile uint8_t r, w;


void init_uart(uint32_t baud){
 uint16_t ubrr = ( (F_CPU + baud * 8) / (16 * baud) ) - 1;
 UBRRH = (uint8_t)(ubrr >> 8);
 UBRRL = (uint8_t)(ubrr & 0xFF);
 UCSRB = (1 << TXEN);
 // Asynchron 8N1
 UCSRC = (1 << URSEL) | (0 << UMSEL) | (0 << UPM1) | (0 << UPM0) | (0 << USBS) | (0 << UCSZ2) | (1 << UCSZ1) | (1 << UCSZ0);
}

static inline uint8_t send_byte(uint8_t data) {
 // Senden, wenn UDR frei ist
 if (UCSRA & (1 << UDRE)) {   
  UDR = data;
  return 1;
 }
 return 0;
}

int main(void) {
 uint8_t temp;
 uint8_t data = 0;
 uint8_t bitpos = 0;
 uint8_t old_clk = 1;
 init_uart(115200);
 // MISO Output, Rest Inputs (aber eigentlich egal)
 DDRB = (1 << SPI_MISO);
 while(1) {
  temp = PINB;
  // SS high, Reset der bereits empfangenen Daten und des Bitzählers
  if ( temp & (1 << SPI_SS) ) {
   bitpos = 0;
   data = 0;
   old_clk = 1;
   if ( r != w ) if ( send_byte(BUFFER[r]) ) r++;
  }
  // SS low
  else {
   // CLK high
   if ( temp & (1 << SPI_CLK) ) {
    // steigende Flanke?
    if ( !old_clk ) {
     if ( temp & (1 << SPI_MOSI) ) data |= 0x01;
     if ( ++bitpos > 7 ) {
      bitpos = 0;
      BUFFER[w++] = data;
      data = 0;
     }
     else {
      data <<= 1;
     }
     old_clk = 1;
    }
   }
   // CLK low
   else {
    old_clk = 0;
    if ( r != w ) if ( send_byte(BUFFER[r]) ) r++;
   }
  }
 };
 return 0;
}

Das Einzige was ich mir irgendwie vorstellen kann, ist das der SS vor 
der 1. SPI_CLK zu spät runter oder nach der letzten Clock zu schnell 
wieder hoch geht, hab dafür aber keine Information irgendwo gefunden, 
wie lange er vor der ersten SPI_CLK mindestens schon auf low stehen muss 
oder nach der letzten SPI_CLK noch low bleiben muss.

F_CPU ist 14.745600 MHz (Baudraten Quarz)
SPI CLK ist etwa 175 kHz
SS geht 2 SPI_CLK vor der 1. positiven SPI_CLK Flanke auf low und 2 
SPI_CLK nach der letzten positiven SPI_CLK Flanke auf high.

Falls irgendwer dazu Ideen oder Informationen hat, bitte gerne.

[karlman (Gast)]

Tim T. schrieb:
> Minimal Beispiel Hardware-SPI (nur Empfang):
>

>  // MISO Output, Rest Inputs (aber eigentlich egal)
>  DRB = (1 << SPI_MISO);
>

Compiliert das denn überhaupt?

[Stefan F. (Gast)]

karlman schrieb:
> Tim T. schrieb:
>> Minimal Beispiel Hardware-SPI (nur Empfang):
>>>  // MISO Output, Rest Inputs (aber eigentlich egal)
>>  DRB = (1 << SPI_MISO);
>>
> Compiliert das denn überhaupt?

Warum nicht, SPI_MISO ist 4.

[karlman (Gast)]

Stefanus F. schrieb:
> karlman schrieb:
>> Tim T. schrieb:
>>> Minimal Beispiel Hardware-SPI (nur Empfang):
>>>>  // MISO Output, Rest Inputs (aber eigentlich egal)
>>>  DRB = (1 << SPI_MISO);
>>>
>> Compiliert das denn überhaupt?
>
> Warum nicht, SPI_MISO ist 4.

.. und DRB?

[Tim T. (tim_taylor)]

karlman schrieb:
> Tim T. schrieb:
>> Minimal Beispiel Hardware-SPI (nur Empfang):
>>

>>  // MISO Output, Rest Inputs (aber eigentlich egal)
>>  DRB = (1 << SPI_MISO);
>>

>
> Compiliert das denn überhaupt?

Jop, das kompiliert, ist nur beim Copy&Paste bzw. dem bearbeiten beim 
nachträglichen Einrücken ein D verloren gegangen, da steht natürlich 
DDRB = (1 << SPI_MISO);