Raspberry&ATmega8A

Ich komme eher aus der Microchip-Ecke, aber müsstest du nicht auch beim 
ATmega das Receive-Flag (SPIF oder?) zurücksetzen? Da du nach dem Senden 
den Receive-Buffer zurücksetzt, würde das schon Sinn machen, dass er 
ständig was ausgibt. Mal Nullen, mal eine Zehn.

btw:
die CPU vom RasperryPi kann "etwas" schneller laufen als mit 500KHz ;)
--> ARM1176JZF-S (700 MHz)

EDIT:

btw.
benutzen ATmegas fürs Senden und Empfangen DEN SELBEN Buffer (SPDR)? 0.0

orgsi1990 schrieb:
> void SPI_SlaveSend(char data)
> {  SPDR = data;
>   while(!(SPSR & (1<<SPIF)))
>   {}
>   SPDR = 0;
> }

Verdammt, sorry... ich war gerade bei UART.
SPI funktioniert natürlich nur mit einem Buffer.

Nach dem Überblicken des Datenblattes fällt mir auf, dass ich bei 
ATmegas anscheinend zu wenig Ahnung habe.
Ich kann leider doch nicht wirklich weiter helfen.

Im Datenblatt ist exakt dein Beispiel:

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

orgsi1990 schrieb:

>   while(1)
>   {
>       data = SPI_SlaveReceive();
>       SPI_SlaveSend(data);
>         }

Du hast da einen Denkfehler.
Ein Slave kann von sich aus überhaupt nichts senden!

SPI wird komplett vom Master angeleiert. Er hat zu jedem Zeitpunkt das 
sagen.

SPI funktioniert so, wie wenn du und dein Kumpel sich am Tisch gegenüber 
sitzen. Du bist der Master und er ist der Slave.

Jeder hat vor sich einen Zettel liegen, auf den er das zu übermittelnde 
aufschreibt (was bei einem µC natürlich lediglich 1 Byte ist).
Auf dein(!) Kommando nehmt ihr beide den Zettel jeweils mit der rechten 
Hand und schiebt ihn zum Gegenüber rüber während jeder mit der linken 
Hand jeweils den Zettel vom Gegenüber in Empfang nimmt.

SPI ist also ein gleichzeitig ablaufender Datenaustausch zwischen Master 
und Client. Die Initiative liegt dabei ausschliesslich beim Master! Von 
sich aus kann ein Slave überehaupt nichts tun. Er kann nur reagieren 
wenn vom Master ein Datenaustausch initiert wird.

Ein Slave schreibt den zu übermittelnden Wert ganz einfach ins SPDR 
Register. Bei der nächsten Übertragung, die vom Master angeleiert wird, 
wird dann dieser Inhalt an den Master übertragen, während gleichzeitig 
das Byte vom Master in den Slave übertragen wird und als neuer Wert im 
SPDR Register landet. Das bedeutet aber auch: der Wert, den der Slave zu 
Master übertragen will, der muss schon im SPDR stehen, noch bevor der 
Master die nächste Übertragung machen wird.

Hier

1

char SPI_SlaveReceive(void)

2

{  char data;

3

  while(!(SPSR & (1<<SPIF)))

4

  {}

5

  data = SPDR;

6

  SPDR = 0;

7

  return data;

8

}

laufen 2(!) Vorgänge ab. Auf der einen Seite findet eine Übertragung vom 
Master zum Slave ins SPDR Register statt. Auf der anderen Seite findet 
aber auch eine Übertragung vom Slave zu Master statt.

Probier mal folgendes

1

int main()

2

{

3

  SPI_SlaveInit();

4

  char data;

5

6

  SPDR = 0xFF;

7

  while(1)

8

  {

9

    data = SPI_Exchange();

10

  }

11

}

12

13

void SPI_SlaveInit(void)

14

{  DDRB |= (1<<PORTB4);

15

  SPCR = (1<<SPE);

16

}

17

18

char SPI_Exchange(void)

19

{

20

  char data;

21

22

  while(!(SPSR & (1<<SPIF)))

23

  {}

24

25

  data = SPDR;

26

  SPDR = data + 2;    // einen größeren Wert bereit stellen. Der Master

27

                      // holt sich den dann bei der nächsten Übertragung ab

28

  return data;

29

}

orgsi1990 schrieb:
> Hmn...
> Okay jetzt bin ich auch etwas weiter allein von der Überlegung her.
> Ich dachte der ATmega meldet sich direkt zurück und nicht das der master
> den wert abholt.
>
> Also bräuchte man theoretisch auch nur MOSI--->MISO ?
> Oder steh ich da auf dem Schlauch ?

MOSI   --- Master Out - Slave In
MISO   --- Master In  - Slave Out

1

      Master                        Slave

2

    +---------+                  +------------+

3

    |   MOSI  |----------------->| MOSI       |

4

    |   MISO  |<-----------------| MISO       |

5

    |         |                  |            |

Da jeder Teilnehmer weiß, ob er Master oder Slave ist, ist daher immer 
ein Ausgang mit einem Eingang verbunden. MOSI wird mit MOSI verbunden. 
MISO mit MISO


(und natürlich die CLock Leitung und die Slave Select Leitung)

SPI Mode und Frequenz (250 kHz) stimmt auch beim Rpi?

Den den du dir aussuchst einfach Mode 0.

Du musst schon bei beiden den selben Mode eingestellt haben.