Empfangen über SPI von ADC-Daten

[Benedikt H. (benni_1)]

Hallo,
ich habe folgendes Problem:
Ich möchte mit einem ATmega128 von einem ADC (LTC2452) über SPI 
Messwerte einlesen.
Dabei verwende ich folgende Funktion zum empfangen eines Bytes:

uint8_t SPI_receive_byte()  // Byte empfangen
{
  SPDR = 0;    // Wert in Buffer speichern
  while(!(SPSR)&(1<<SPIF));
        // warten bis Zeichen verfügbar (Übertragung fertig)
  return SPDR;          // empfangenen Wert zurückgeben
}

Von dieser Funktion erhalte ich jedoch keinen Rückgabewert, laut 
Oszilloskop gibt der ADC aber Werte aus.
Laut Datenblatt müssen zwei Byte für eine vollständige Übertragung 
empfangen werden.
Vielen Dank im Vorraus

[holger (Gast)]

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

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

[Benedikt H. (benni_1)]

Vielen Dank für die schnelle Antwort Holger!

Aber leider konnte ich das Problem dadurch nicht beheben.
Es kann doch nicht so schwer sein, als Master Daten über das SPI zu 
empfangen. (das Senden an DigiPots funktioniert ja auch)

Der ATmega scheint einfach keine Daten annehmen zu wollen. Hat irgendwer 
noch eine andere Idee?

[Frank (Gast)]

Wie sieht die Konfiguration der SPI aus?
Polarität?
Mode?
CLK rate?
...

Richtig angeschlossen?
Schaltplan?
...

[Benedikt H. (benni_1)]

Hallo Frank!

Ja, richtig angeschlossen, durchgepiepst und mit dem Oszilloskop auf 
beiden Seiten des Busses gemessen.
ATmega <-> ADC
SCK    -> SCK
Enable -> /CS
MISO   -> SDO (serial data out)
(MOSI gibt's nicht)
-----
Die CLK-Rate des ADC geht bis 2MHz und ist auf 1MHz eingestellt.
Polarität und Mode passt auch.
-----
hier etwas mehr Code:

void spiInit(void) //Datasheet pg. 162
{

  DDRB |= ((1<<PB5)|(1<<PB7));    // MOSI, SCK => Output
  DDRB &= ~(1<<PB6);              // MISO => Input

  DDRD |= ((1<<PC0));             //ADC SS-Pin => Output

  SPCR |= ((1<<SPE)|(1<<MSTR)|(1<<SPR0)); // SPI enable, Master, f/16 
  SPCR |= (1<<CPOL);      // CLK mit falling Edge beginnen
  SPCR |= (1<<CPHA);      // Sample auf Trailing-Edge
}

uint16_t SPI_receive_ADC()  
{
  cli();      // Interrupts deaktivieren
  PORTC |= (1<<PC0);  // ADC Enable aus
    PORTC &= ~(1<<PC0);  // Enable-Pin für ADC aktivieren

  uint16_t averageData = 0;    
  averageData = (SPI_receive_byte()<<8);
  averageData |= SPI_receive_byte();

  PORTC |= (1<<PC0);  // ADC Enable aus
  sei();      // Interrupts aktivieren
  return averageData;
}

uint8_t SPI_receive_byte()  // Byte empfangen
{
  SPDR = 0x00;            // Wert in Buffer schreiben
  while(!(SPSR&(1<<SPIF)));  // warten bis Übertragung fertig
  return SPDR;        // empfangenen Wert zurückgeben
}

[holger (Gast)]

Setz PB0 (SS) mal auf Ausgang.

[Jim M. (turboj)]

>  DDRD |= ((1<<PC0));

Sollte das nicht besser DDRC sein? Außerdem musst Du bei AVRs den NSS 
Pin als Ausgang schalten, sonst tut SPI Master Mode nicht richtig.

Edit: Mist, zu langsam. ;-)

[Benedikt H. (benni_1)]

Zwar schon etwas spät für eine Antwort, aber falls es zufällig jemanden 
interessiert:
Offensichtlich hatte ich zu irgendeinem Zeitpunkt am ATmega den MISO Pin 
als Output gesetzt und HIGH drauf geschrieben. Gleichzeitig hat mein 
SPI-Slave ein LOW an seinem MISO Pin gesetzt.
Somit hatte ich einen Kurzschluss zwischen ATmega und Slave und der AVR 
hat zuerst schlapp gemacht. Als ich einen neuen Chip eingelötet habe hat 
wieder alles funktioniert.

Ich kann also nur jedem raten, den MISO Pin seines ATmegas mit einem 
100ohm Widerstand gegen Kurzschlüsse abzusichern..