AVR SPI Master Kommunikation mit Sensor

[Jan H. (jhnet)]

Moin,

ich versuche gerade einen MS5803-14BA Drucksensor mit SPI anzusteuern.

Mein SPI - Code sieht wie folgt aus:

#include "spi.h"
#include <avr/io.h>
#include <stdio.h>
#include "uart.h"

#define SPI_PORT      PORTB
#define SPI_DDR        DDRB

#define  SPI_CS          2  //SS, CSB
#define SPI_MOSI        3  //DO,MOSI
#define SPI_MISO        4  //DI,MISO
#define SPI_SCK          5  //Clock

#define SPI_ENABLE()    SPI_PORT &= ~(1<<SPI_CS);
#define SPI_DISABLE()    SPI_PORT |=  (1<<SPI_CS);
#define SPI_WAIT()      while(!(SPSR & (1<<SPIF)));

void spi_init(uint8_t mode, bool interrupt) {

  SPI_DDR &= ~(1 << SPI_MISO);
  SPI_DDR |= (1 << SPI_SCK);
  SPI_DDR |= (1 << SPI_MOSI);
  SPI_DDR |= (1 << SPI_CS);

  SPCR = ((interrupt ? 1 : 0) << SPIE) | (1 << SPE) | (1 << MSTR)
      | (((mode & 0x02) == 2) << CPOL)  //Clock Polarity
      | (((mode & 0x01) == 1) << CPHA); //Clock Phase

  //SPSR = (1<<SPI2X); //Double the SPI Speed.


}

void spi_writeByte(uint8_t Byte) {
  SPDR = Byte;
  SPI_WAIT();
}

uint8_t spi_rcvByte() {
    uint8_t Byte = 0;
  SPDR = 0x00;
  SPI_WAIT()  ;
  Byte = SPDR;

    //debug
    uart_putc(Byte);
    uart_puts("\n");
    //
  return Byte;
}

uint16_t spi_rcvWord() {
  uint16_t Word = 0;
  Word |= (uint16_t) spi_rcvByte() << 8;
  Word |= spi_rcvByte();
  return Word;
}

uint32_t spi_rcvDWord() {
  uint32_t DWord = 0;
  DWord |= (uint32_t) spi_rcvByte() << 24;
  DWord |= (uint32_t) spi_rcvByte() << 16;
  DWord |= (uint16_t) spi_rcvByte() << 8;
  DWord |= spi_rcvByte();
  return DWord;
}

Ich bekomme aber immer nur 0xFF zurück, wenn ich versuche etwas per SPI 
zu lesen und dann (erstmal zum Testen) per UART weiter an den PC zu 
senden.

Ist mein Code falsch ? Ich nutze einen Atmega168V@3V3,8MHz und für UART 
die Library von Peter Fleury.

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

Was du uns allerdings verschweigst ist, welchen Modus du bei spi_init()
nun eigentlich wählst.

Ehrlich: ich würde den ganzen Firlefanz da weglassen:

static void spi_init(void) {

  SPI_DDR &= ~(1 << SPI_MISO);
  SPI_DDR |= (1 << SPI_SCK);
  SPI_DDR |= (1 << SPI_MOSI);
  SPI_DDR |= (1 << SPI_CS);

  SPCR = _BV(SPE) | _BV(MSTR);

  //SPSR = (1<<SPI2X); //Double the SPI Speed.
}

Laut Datenblatt arbeitet das Teil (wie die meisten SPI-Geräte) im Modus
0, da brauchst das ganze CPHA- und CPOL-Gewusel nicht.  SPI mit
Interrupt braucht man auch nur bei schweinelangsamen Slaves.  Bei all
denen, die mit ein paar MHz SPI-Takt arbeiten (und du hast ja SPI2X
sogar in Erwägung gezogen), ist der Betrieb mit Interrupt langsamer
als das Polling.

[Jan H. (jhnet)]

Ja stimmt, habe ich nicht erwähnt, ich nutze Mode 0 und keine 
Interrupts.

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

Ich habe das Datenblatt noch nicht bis zu Ende gelesen (hatte mir nur
den SPI-Teil angeguckt).  Typischerweise brauchen derartige Sensoren
nach dem Start der Datenkonvertierung relativ lange, bis man die Daten
auch abrufen kann.  Bist du dir sicher, dass du das Timing eingehalten
hast?

(Aus den paar Codefetzen da oben geht praktisch von den weiteren
Zusammenhängen nichts hervor.  => Netiquette)

[Jan H. (jhnet)]

Ich habe mal den Rest Code hochgeladen (abgesehen vom UART, das ist wie 
gesagt der von Fleury).

Laut Datenblatt dauert eine ADC Conversion max. 8.22ms, ich warte 10ms. 
Das sollte ja eigentlich reichen ?

EDIT:
Habe nun mal Mode/Interrupt rausgeschmissen, so wie bei dir oben.

[Karl H. (kbuchegg)]

Was hast du eigentlich mit dem Chip-Select gemacht?

In deinem Code ganz oben sieht es so aus, als ob der verdrahtet wäre. 
Immerhin gibt es ein Makro SPI_ENABLE. Allerdings wird es im ganzen Code 
nirgends verwendet.

[Jan H. (jhnet)]

Ups, ist wohl irgendwie beim umkopieren verloren gegangen. Da neben dem 
AVR nur der genannte Sensor am Bus ist, mache ich in der Initialisierung 
einmal SPI_ENABLE und lasse dann CS dauerhaft low.

[Leo C. (rapid)]

Jan H. schrieb:
> Da neben dem
> AVR nur der genannte Sensor am Bus ist, mache ich in der Initialisierung
> einmal SPI_ENABLE und lasse dann CS dauerhaft low.

Deinen Code habe ich mir nicht angesehen, aber im Beispielcode [1] kommt 
zwischen 'send command' und 'read result' das hier:

csb_hi(); // pull CSB high to finish the conversion
csb_lo(); // pull CSB low to start new command

[1] http://www.amsys.de/sheets/amsys.de.an520_e.pdf

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

Jan H. schrieb:
> und lasse dann CS dauerhaft low.

Ich kenne keinen SPI-Slave, bei dem man das machen darf.

/CS = low ist üblicherweise das Signal, die state machine für den
internen SPI-Slave synchronisiert anzuwerfen.  Am Ende einer
SPI-Transaktion (was auch immer das für den jeweiligen Slave sein mag)
wird dann durch /CS = high die state machine wieder in die Ruhelage
versetzt.  Erst danach ist sie bereit für die nächste SPI-Transaktion.

Ansonsten könnte man das /CS ja gleich hart auf GND verdrahten, "ich
hab' doch nur einen Slave am Bus". :-)

[Jan H. (jhnet)]

Ich habe nun noch mal alle eure Anregungen geprüft und auch den
geposteten Beispielcode (danke dafür!) angeschaut.

Auch mein überarbeiteter Code gibt mir aber für jeden Koeffizienten
C1-C6 immer nur 65535 aus.

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

Jan H. schrieb:
> Auch mein überarbeiteter Code gibt mir aber für jeden Koeffizienten
> C1-C6 immer nur 65535 aus.

Dann wäre es wohl an der Zeit, die Hardware nochmal kritisch unter
die Lupe zu nehmen.  Vielleicht auch mal einen Oszi dranhängen.

[Jan H. (jhnet)]

Jo das wäre auch mein nächster Schritt gewesen. Wollte nur vorher 
sicherstellen, dass ich keinen üblen Patzer im Code habe. Danke !

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

Jan H. schrieb:
> Wollte nur vorher sicherstellen, dass ich keinen üblen Patzer im Code
> habe.

Der sieht erstmal OK aus.  Die auf eine neue Zeile gezogenen Semikolons
muten etwas eigenwillig an, aber das ist reine Kosmetik.

Ich würde wahrscheinlich das /CS schon vor dem delay wieder zurück
nehmen, aber da du ja schon Huddeleien beim Lesen der PROM-Konstanten
hast, muss das Problem woanders sein.

[Jan H. (jhnet)]

So. Das Problem wurde nun endlich behoben. Derjenige von dem ich die 
Platine habe, hat für die Chip Select Leitung nicht /SS Pin benutzt, 
sondern einen willkürlichen.

Im Code musste jedoch zusätzlich zu der gewählten Leitung auch der 
unbeschaltete /SS Pin des ATmegas als Ausgang gesetzt werden.

Danke an Alle die hier geholfen haben !