Vollständiges SPI Beispiel AVR-GCC?

[Hermann Mikroc (Gast)]

Hallo,

leider gibt das Atmel Datenblatt nicht wirklich mehr her, als das hier

void spi_masterInit(void)
{
  SPI_DDR |= (1<<SPI_SS) | (1<<SPI_MOSI) | (1<<SPI_SCK);
  SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR0);
}

void spi_masterTransmit(uint8_t data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
}

void spi_slaveInit(void)
{
  SPI_DDR |= (1<<SPI_MISO);
  SPCR = (1<<SPE);
}

uint8_t spi_slaveReceive(void)
{
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
}

Hier wird aber nicht aufgeführt, wie der Master wieder einlesen kann, 
sowie
wie der Slave etwas ausgeben kann.

[Walter S. (avatar)]

es gibt hier einen Artikel zu SPI

[Hermann Mikroc (Gast)]

Das habe ich mir durchgelesen,
da wird aber nichts weiteres zu geschrieben, was ich benötige.

https://www.mikrocontroller.net/articles/Serial_Peripheral_Interface

[Rudolph R. (rudolph)]

Hermann Mikroc schrieb:
> Hier wird aber nicht aufgeführt, wie der Master wieder einlesen kann,

uint8_t spi_masterTransmit(uint8_t data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
}

Am SPI ist ja auch nicht wirklich viel dran, aber das steht schon im 
Datenblatt.

[holger (Gast)]

>da wird aber nichts weiteres zu geschrieben, was ich benötige.

Dann sag doch mal welchen SPI Chip du bearbeiten möchtest.
Vieleicht kann man dir dann sagen was du benötigst.

[Hermann Mikroc (Gast)]

Ich möchte den MCP23S17 nutzen. Mir gehts hier aber erst einmal allgmein 
ums Verständnis.

Aber wenn

uint8_t spi_masterTransmit(uint8_t data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  return SPDR;
}

SPDR erst gesendet wird, dann verändert sich der Wert doch nicht.

Wenn der Slave auf den Wert 0xff wartet, befindet sich dann automatisch 
die Antwort von meinem Slave in diesem SPDR register?

[Stefan D. (Gast)]

Ja, denn der SPDR des Masters bildet mit dem des Slaves ein 
Schieberegister, wird ein Bit gesendet wird gleichzeitig eins empfangen. 
Daher musst du auch häufig Dummy Bytes schicken, wenn Du Sensorwerte 
eine einlesen willst.

[Hermann Mikroc (Gast)]

Hallo,

hab mal versucht das ganze mit zwei AVRs zu machen

/*MASTER*/
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include "uart/uart.h"
#include "spi/spi.h"


int main(void)
{
  uart_init();
  spi_masterInit();
  DDRA |= (1<<PORTA0) | (1<<SPI_SS);

  sei();
  uart_puts("Hallo\r\n");
  while (1)
  {
    const uint8_t data[8] = {0, 25, 100, 150, 200, 255, 1, 59};
    static uint8_t index = 0;
    
    
    SPI_PORT |= (1<<SPI_SS);
    uint8_t receiveData = spi_masterTransmit(data[index]);
    
    uart_puti_format(index, 2);
    uart_puti_format(data[index], 5);
    uart_puti_format(receiveData, 5);
    uart_puts("\r\n");
    if(receiveData > 0) PORTA ^= (1<<PORTA0);
    
    if(++index == 8)
    {
      index = 0;
      uart_puts("___________\r\n");
    }
    
    SPI_PORT &= (1<<SPI_SS);
    
    _delay_ms(2000);
  }
}

/*SLAVE*/
#include <avr/io.h>
#include <util/delay.h>
#include "spi/spi.h"
#include <avr/interrupt.h>

int main(void)
{
  DDRA |= (1<<PORTA0);
  
  for(uint8_t i = 0; i < 5; i++)
  {
    _delay_ms(100);
    PORTA |= (1<<PORTA0);
    _delay_ms(100);
    PORTA &= ~(1<<PORTA0);
  }
  spi_slaveInit();
  sei();
  
  while (1)
  {
    uint8_t receiveData;
    if(PINA & (1<<PINA7)) {
      receiveData = spi_slaveReceive();
      spi_masterTransmit(receiveData-1);
      PORTA ^= (1<<PORTA0);
    }
  }
}

Erhalte als Antwort immer 255 ;/

 0    0  255
 1   25  255
 2  100  255
 3  150  255
 4  200  255
 5  255  255
 6    1  255
 7   59  255
___________

[Rene Z. (rzimmermann)]

SPI_PORT &= (1<<SPI_SS); --> SPI_PORT &= ~(1<<SPI_SS);

Gruß Rene

[Hermann Mikroc (Gast)]

Hat leider nicht den Erfolg gebraucht.

Die Beschaltung ist aber richtig oder

Namen beziehen sich auf die Portbeschreibung im DB.
M=Master, I=Input, O=Output
AVR1(M)   AVR2(S)
SCK(O) -> SCK(I)
SS(O)  -> SS(I)
MOSI(O)-> MOSI(I)
MISO(I)<- MISO(O)

[Karl H. (kbuchegg)]

>

  while (1)
  {
    uint8_t receiveData;
    if(PINA & (1<<PINA7)) {
      receiveData = spi_slaveReceive();
      spi_masterTransmit(receiveData-1);
      PORTA ^= (1<<PORTA0);
    }

Das ist Quatsch.
Im SLave kannst du natürlich nicht die Funktion spi_masterTransmit 
aufrufen.

Die Sache funktioniert SLave seiteig völlig anders.

Wenn der Master seinen Transmit macht, dann muss im Slave das 
rausgehende Byte bereits im SPDR Register sein.

SPI ist ein Byteaustausch. Die Begriffe Senden bzw. Empfangen verlieren 
hier ihre klassische Bedeutung. SPI ist mehr ein gleichzeitiger 
Byteaustausch.
Du und dein Kumpel sitzen sich am Tisch gegenüber. Jeder hat vor sich 
einen Zettel auf den er etwas aufschreiben kann. Auf dein Kommando hin 
(du bist der Master) nehmt ihr beide euren Zettel jeweils mit der 
rechten Hand und schiebt ihn zum Gegnüber, der ihn mit der linken Hand 
entgegen nimmt.
Daher: Wenn der Master sendet (den Zettel rüberschiebt) muss die Antwort 
vom Slave bereits auf dem Zettel stehen (im SPDR Register), den er zu 
dir rüber schiebt. Da ein Slave logischerweise auf die Art nicht sofort 
auf das soeben von dir übertragene Byte antworten kann, muss der Master 
daher meistens noch ein weiteres Byte nachschieben, mit der er sich dann 
die richtige Antwort auf das zuvor übertragene Kommando holt. Dabei aber 
nicht vergessen: Der Slave benötigt seinerseits ein wenig Zeit um die 
Antwort bereit zu stellen.

Der Slave kann von sich aus überhaupt nichts machen. der Slave kann nur 
warten, bis sich der Master sein Byte geholt hat und im Gegenzug 
gleichzeitig das nächste Byte geschickt hat.

  SPDR = 255;

  while (1)
  {
    uint8_t receiveData;
    if(PINA & (1<<PINA7)) {
      // das erhaltene gleich wieder ins SPDR stellen, so dass
      // es der Master in der nächsten Runde wieder zurück kriegt.
      SPDR = spi_slaveReceive();
      PORTA ^= (1<<PORTA0);
    }

[Jörg W. (dl8dtl) (Moderator)]

Hermann Mikroc schrieb:
> hab mal versucht das ganze mit zwei AVRs zu machen

Slave SPI mit einem Controller ist nichts, was man sich als
Anfängeraufgabe aufstellt.  Anders als ein in Hardware realisierter
SPI-Slave ist ein Controller ziemlich langsam.  Die Zeit, die er
braucht, bis er auf ein Kommando des Masters hin seine Slave-Daten
bereitstellen kann, ist viel länger als bei den üblichen per SPI
angesprochenen ICs.

Konzentrier' dich also lieber drauf, deinen eigentlichen Slave zum
Laufen zu bekommen, statt mit einem Slave-AVR noch eine zweite
Baustelle aufzumachen.

Und nochmal: damit du ein Byte empfangen kannst, musst du ein Byte
zuvor senden und dann auch warten, bis es rausgetaktet ist.  Daher
empfängt man per SPI Daten typischerweise, indem man ein Dummy-Byte
ausgibt.  Du musst also minimal den Opcode (8 Bit), eine
Registeradresse (8 Bit) und ein Nullbyte (Dummy-Byte) schreiben,
erst danach kannst du den Inhalt des adressierten Registers lesen.

Zwischendrin muss /SS auf low bleiben.