LTC2498 und Atmega128rfa1: c-code Beispiel

[Jeanette S. (jeanny)]

Hallo zusammen!

Ich versuche via SPI die Sensorwerte des LTC2498 abzufragen.

Der Beispielcode im Datenblatt des Atmega128rfa1 zeigt zwar die 
notwendigen Einstellungen im Controlregister zum Betrieb als Master und 
eine Transmit-Funktion, aber bei mir bleiben noch ein paar Fragen offen:

- das Beispiel enthält die Transmit-Funktion für ein char. Der ltc2498 
benötigt als Daten-Input allerdings 13Bit - Kann ich diese übermitteln 
bzw. wie?

- wie kann ich das 32-Bit lange word vom Sensor (MISO des Masters) 
einlesen? Über das SPDR-Register? Da stehe ich allerdings wieder vor dem 
Problem mit den 8-Bit-Begrenzung...

- Wie müsste der generelle Ablauf in der Schleife des main-Programms des 
Masters sein?:
1. SlaveSelect des Slaves (ltc2498) auf low
2. MOSI des Masters schreiben (SDI des Slaves)
3. MISO des Masters lesen (SDO des Slaves)
4. SlaveSelect des Slaves auf high
Ist dies so richtig? bzw. wo bräuchte ich noch eventuelle Wartezeiten 
etc.?


Hat zufällig jemand ein c-Beispiel, wie man wia einem ATmega und SPI die 
Sensordaten des ltc2498 auslesen kann?

Danke Euch schon mal!

[Jeanette S. (jeanny)]

Hat keiner Erfahrung mit dem LTC2498? Oder ähnlichem?

[Jeanette S. (jeanny)]

Ich bin inzwischen einen Schritt weiter und denke, dass ich prinzipiell
verstanden habe, wie's laufen muss.

Die Werte, die ich erhalte ergeben jedoch keinen Sinn (zB wenn ich den
Temperatursensor auf dem Chip auslesen will, steigen die Werte stetig
an) und ich finde das Problem nicht.

Mein Code ist eigentlich recht simple (uart-init etc. habe ich jetzt
hier mal weggelassen, da das problemlos funktioniert):

void SPI_MasterInit(void)
{
  //Outputs: MOSI, SCK, SS
  DDRB = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);

  //Enable SPI, Master-Mode, set clock rate fck/16
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR0);
}


int SPI_MasterTransmit(char MOSI)
{
  //start Transmission
  SPDR = MOSI;

  //white for transmission complete
  while(!(SPSR & (1<<SPIF)));

  //returned data from slave to master
  return SPDR;
}


int main()
{

  char str[20];

  // Thermoelement an CH0 und CH1
  char masterOut1 = 0b10100000;
  //char masterOut2 = 0b10000000;

  // interne Temperaturmessung:
  char masterOut2 = 0b11000000;

  char result;
  uint32_t masterIn = 0;
  uint32_t Temp = 0;

  uart_init();

  SPI_MasterInit();


  for(;;)
  {

    _delay_ms(500);

    //CS des Thermochips auf low
    PORTB &= !(1<<DD_SS);


    //Byte1
    result = SPI_MasterTransmit(masterOut1);
    masterIn = (result & 0b00011111);  //die ersten drei Bit löschen

    //Byte2
    result = SPI_MasterTransmit(masterOut2);
    masterIn = (masterIn<<8) + result;

    //Byte3
    result = SPI_MasterTransmit(0);
    masterIn = (masterIn<<8) + result;

    //Byte4
    result = SPI_MasterTransmit(0);
    masterIn = (masterIn<<8) + result;


    //CS des Thermochips auf high
    PORTB |= (1<<DD_SS);


    masterIn = (masterIn>>5); //die letzten 5 Bit löschen

    sendestring(" masterIn: ");
    sprintf(str, "%ld", masterIn);
    sendestring(str);

    //bei interner Temperaturmessung: Temperatur in °C berechnen laut 
Datenblatt Seite21
    Temp = (masterIn*4/1570)-273;

    sendestring(" Temp: ");
    sprintf(str, "%ld", Temp);
    sendestring(str);

    _delay_ms(2000);
  }


  return 0;
}

Sieht einer von Euch vielleicht, woran es liegen könnte?

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

Jeanette Seewald schrieb:

> - das Beispiel enthält die Transmit-Funktion für ein char. Der ltc2498
> benötigt als Daten-Input allerdings 13Bit - Kann ich diese übermitteln
> bzw. wie?

Mit der Hardware-SPI kann man nur Vielfache von 8 bit übertragen.
Wenn der LTC2498 also auch mit 16 Bit klarkommt, dann geht es,
sonst müsste man auf Software-Bitbanging ausweichen.  (Edit: hab'
mir das Datenblatt angeguckt, der kommt mit 4 x 8 Bit klar.)

> - wie kann ich das 32-Bit lange word vom Sensor (MISO des Masters)
> einlesen? Über das SPDR-Register? Da stehe ich allerdings wieder vor dem
> Problem mit den 8-Bit-Begrenzung...

SPI transportiert nur Daten gleichzeitig in beiden Richtungen.
Üblicherweise schiebt man, wenn man nur lesen will, dann auf der
Ausgabe (also über SPDR) entsprechend viele Dummybytes raus.  Du
musst also jeweils:

. ein Nullbyte nach SPDR schreiben,
. warten, bis die SPI alles rausgetaktet hat (SPIF-Bit)
. ein Datenbyte von SPDR lesen,
. wieder von vorn beginnen, solange noch nicht alles da ist

Erst ganz am Ende wieder deselektieren.

So im Großen und Ganzen hast du das, glaub ich, schon aufgeschrieben.
Der einzige offensichtliche Fehler ist, dass die bitweise Negation
nicht durch „!“, sondern durch “~” erfolgt (beim Setzen des /SS-Pins).

Allerdings braucht das Teil natürlich Zeit zum Konvertieren.  Beim
ersten Versuch wirst du also noch nichts zurück lesen können, sondern
erst bei den folgenden.

Vielleicht solltest du ja das /EOC-Bit auch nicht einfach nur
wegwerfen, sondern mal testen, ob da wirklich bereits das Ende einer
Konvertierung angezeigt worden ist.  Ansonsten kannst du auch einfach
auf /EOC testen, indem du nur das /CS aktivierst und dann nachsiehst,
ob MISO auf low geht (ohne irgendwelche weiteren SPI-Aktionen):

bool isConversionReady(void)
{
   PORTB &= ~(1<<DD_SS);
   bool eoc = (PINB & (1<<DD_MISO)) == 0;
   PORTB |= (1<<DD_SS);
   return eoc;
}

[Bronco (Gast)]

Ein Tip:
Beim SPI kann man die Clock Polarity (CPOL), die Clock Phase (CPHA) und 
die Data order (DORD) konfigurieren.
Wenn diese falsch sind, kann es zu seltsamen Phänomen kommen.

Ich hatte mal einen SPI-Sensor, der jeden zweiten Meßwert falsch 
geschickt hat. Grund war, daß CPOL/CPHA falsch konfiguriert war, und 
daher das 1.SPI-Telegram für den Sensor unvollständig war und erst mit 
dem 2. SPI-Telegram die Kommunikation für ihn abgeschlossen war.

Hier hilft es sehr, SDO/SDI/SCK mit dem Oszi anzuschauen.

[A. W. (uracolix)]

So ganz genau hab ich das DB zwar auch noch nicht verstanden, aber kann 
es
sein, dass der Chip waehrend du das aktuelle Kommando schreibst, das 
Ergebnis der vorherigen Messung ausgibt? So wuerde ich Bild 2 auf S. 14 
deuten.

Am besten du rechnest erst mal nicht mit den Werten herum sondern dumpst
den Output vom SPI unveraendert (printf debugging) ... du solltest dann
die statischen Muster (feste 0/1 bits im Datenstrom) an den erwarteten 
Stellen vorfinden.

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

A. W. schrieb:
> dass der Chip waehrend du das aktuelle Kommando schreibst, das
> Ergebnis der vorherigen Messung ausgibt

Ja, so sehe ich das auch.

[Jeanette S. (jeanny)]

Jörg Wunsch schrieb:
> dass der Chip waehrend du das aktuelle Kommando schreibst, das
>> Ergebnis der vorherigen Messung ausgibt

Ich versuche im Moment ja nur den Wert des internen Temperatursensors 
auszulesen, welche relativ konstant sein müsste (liegt ja bei mir auf 
dem Tisch). Da ich das jetzt sowieso jede Sekunde mal mache, müsste mir 
das Problem des vorherigen Messwertes eigentlich im Moment egal sein, 
oder nicht? Dann stimmt halt der erste Messwert nicht.


Bronco schrieb:
> Beim SPI kann man die Clock Polarity (CPOL), die Clock Phase (CPHA) und
> die Data order (DORD) konfigurieren.

Im Datenblatt des LTC2498 heißt es: The input data is then shifted via 
SDI pin on each rising edge of SCK. The output data is shifted out the 
SDO pin on each falling edge of SCK.
Müsste das bedeuten, dass ich CPOL und CPHA so einstellen muss:
CPOL=1, CPHA=0: Sample (Falling), Setup (Rising)

Oder muss ich genau gegengleich arbeiten?


A. W. schrieb:
> Am besten du rechnest erst mal nicht mit den Werten herum sondern dumpst
> den Output vom SPI unveraendert (printf debugging)

Das habe ich auch mal versucht (mir jedes result einzeln anschauen). Das 
ganze verhält sich aber recht eigenartig. Entweder hat es extreme 
Schwankungen, negative Werte, oder es bleibt komplett konstant, auch 
wenn ich versuche, die Temperatur etwas zu ändern.

[A. W. (uracolix)]

>Das habe ich auch mal versucht (mir jedes result einzeln anschauen). Das
>ganze verhält sich aber recht eigenartig. Entweder hat es extreme
>Schwankungen, negative Werte, oder es bleibt komplett konstant, auch
>wenn ich versuche, die Temperatur etwas zu ändern.

Kannst du mal die Werte in hexadezimal anschauen? Da sieht man recht 
schoen welches Bit wackelt. Im naechsten Schritt beim Debugging dieses 
Problems kommt dann wohl der "Graf Oszillo" ins Spiel ;-).

[Oliver (Gast)]

Jeanette Seewald schrieb:
> The output data is shifted out the
> SDO pin on each falling edge of SCK.

Da wird der Datenpin am MISO-Pin auf den neuen  Wert gesetzt, damit ist 
das das Setup. Also Setup auf der falling edge.

Ob die falling edge jetzt die leading oder die trailing edge ist (ob SCK 
also high oder ,ow active ist), kann man dem nicht entnehmen. Das sollte 
aber auch irgendwie aus dem Datenbaltt ersichtlich sein.

Sehr vermutlich ist aber die rising edge auch die leading edge, damit 
wären CPOL und CPHA beide auf 0 zu setzen.

Oliver

[Bronco (Gast)]

Jeanette Seewald schrieb:
> Müsste das bedeuten, dass ich CPOL und CPHA so einstellen muss:
> CPOL=1, CPHA=0: Sample (Falling), Setup (Rising)
>
> Oder muss ich genau gegengleich arbeiten?

Also ich hätte mal getippt: CPOL=0 und CPHA=0
Aber ob das stimmt, mußt Du ausprobieren.

Probier mal folgendes:
- Gib Dir das ganze SPI-Telegram als Hex- oder besser noch Binär-Werte 
aus.
- Schaue Dir mehrere SPI-Telegramme hintereinander an und prüfe, ob es 
zu "wandernden" Muster kommt.
- Probier mal die 4 möglichen CPOL/CPHA-Kombinationen durch, was sich 
ändert, ob sich etwas stabilisert, usw.

Wie schon gesagt: am einfachsten siehst Du das am Oszi

PS: Zwischen SS-Aktivierung und Telegram-Beginn bzw. Telegram-Ende und 
SS-Deaktivierung gibt es auch Wartezeiten, die im Datenblatt des LTC 
angegeben sein sollten. Brücksichtigt?

[Jeanette S. (jeanny)]

Ich danke euch allen sehr für die Hilfe.

Leider musste ich das ganze Projekt (inkl. Hardware) heute abgeben (ich 
fliege übermorgen für 6 Monate nach Singapur).

Die Werte, die ich zuletzt auslesen konnte, haben war quantitativ nicht 
gepasst, aber zumindest qualitativ bei Erwärmung der Chips einen 
eindeutigen Anstieg gezeigt.

Ich habe in meinem zusammenfassenden Bericht den Link zu diesem Thread 
mit reingenommen - vielleicht wird sich mein Nachfolger mit weiteren 
Fragen melden :)

[Hector C. (Firma: Technische Universität München) (cuenca)]

Hallo zusammen!

Ich versuche via SPI die Sensorwerte des LTC2498 abzufragen wie meine 
Vorgängerin Jeanette Seewald.
Ich wäre sehr dankbar für eure Tipps zu meiner derzeitigen
Problemstellung.

Ich denke dass, die kode am anfang das Bild 2 auf S.14(DATAsheet 
LTC2498) folgt.

Ich habe versucht mit SPI (CPOL, CPHA) 4 Modus, MSB-LSB mit den DORD 
ändern, die Clock-Bitrate mit SPRO Und SPR1.

Da dieser im DATAsheet LTC2498 sagt, dass der Konvertierungsprozess 
endet bei Übertragung von 32-Bit oder ist unterbrochen, CS hoch und 
setzen, die auf dem Datenblatt des ATmega128RFA1(seite 335) sagt:

"The system is single buffered in the transmit direction and double 
buffered in the
receive direction.
This means that bytes to be transmitted cannot be written to the SPI
Data Register before the entire shift cycle is completed. When receiving 
data, however,
a received character must be read from the SPI Data Register before the 
next character
has been completely shifted in. Otherwise, the first byte is lost."

Ich habe versucht alles, zum beispiel:
Wie bekomme Ich nicht das erste byte ganz, das erste Byte der 
Informationen zu verlieren, für die Umwandlung von der LTC Dies ist: Ich 
habe 1. Byte des Getriebes in einem ersten Abstieg und Aufstieg über CS 
genommen.(Dummy BYTE)

  SPI_MasterInit();

  PORTB &= ~(1<<DD_SS);
  SPI_MasterTransmit(0);
  PORTB |= (1<<DD_SS);

  for(;;)
  {
  
    _delay_ms(500);

    //CS des Thermochips auf low
    PORTB &= ~(1<<DD_SS);

    
    //Byte1
    result = SPI_MasterTransmit(masterOut1);    
    masterIn = result;

    //Byte2
    result = SPI_MasterTransmit(masterOut2);
    masterIn = (masterIn<<8) + result;


    //Byte3
    result = SPI_MasterTransmit(0);
    masterIn = (masterIn<<8) + result;


    //Byte4
    result = SPI_MasterTransmit(0);
    masterIn = (masterIn<<8) + result;

    
    //CS des Thermochips auf high
    PORTB |= (1<<DD_SS);

Jetzt 4-Byte empfange Ich ganz, aber das Ergebnis ist immer noch zu 
wenig.
Ich bekomme daten mehr stabil aber DATAout Wert sollte etwa 80. 000, 
aber ich bekomme über 1000.

Vielleicht sollte ich mehr Zeit zur Konversion geben?

Ich habe kein Oszilloskop, und ich habe keine Ideen mehr.

Danke Euch schon mal!

[Hector C. (Firma: Technische Universität München) (cuenca)]

Hat keiner Erfahrung mit dem LTC2498? Oder ähnlichem?

[A. W. (uracolix)]

>Ich habe kein Oszilloskop,
Sag jetzt nicht, dass an der TU-Muenchen kein Oszi aufzutreiben ist und 
sich das Forum deswegen den Gehirnfasching geben muss, den Code durch 
angucken zu debuggen.

Was soll der 1 Byte 0-Befehl am Anfang machen? Der LTC braucht immer 32 
bit?

Was steht in Masterout1/2? Ist das IM bit gesetzt?

[Hector C. (Firma: Technische Universität München) (cuenca)]

Vielleicht, aber im Moment kann ich nicht. Glauben Sie, dass nur mit der 
Oscilocopio ich wüsste wo das Problem liegt?

A. W. schrieb:
> Was soll der 1 Byte 0-Befehl am Anfang machen?
Jetzt denke Ich war totaler Unfug meinerseits,
Ich dachte, dass da die SPI Verbindung verlieren das erste Byte macht, 
könnte ein leeres Byte senden und dann in der zweiten Abfahrt des CS 
würde das LTC eine neue datainput/dataoutput starten.

>Der LTC braucht immer 32 bit?

Das glaube ich, datasheetLTC2498(seite 16):
The LTC2498 serial output stream is 32 bits long.

> Was steht in Masterout1/2?
Entschuldigung! Jetzt zeige Ich Sie,

// Thermoelement an CH0 und CH1
char masterOut1 = 0b10100000;

//Interne Temperaturmessung:
char masterOut2 = 0b11000000;

Wie am anfang.

>Ist das IM bit gesetzt?
IM Bit ist aktiviert. Ich versuche im Moment ja nur den Wert des 
internen Temperatursensors
auszulesen.

Ich zeige jede SPI-Telegramme hintereinander an und prüfe, ob es
zu "wandernden" Muster kommt. Das erste Byte kommt 11111, nicht 8 bit, 
das verstehe Ich nicht.
Villeicht bekomme ich nicht gut die Daten aus LTC2498 mit Master(MOSI) 
konfiguration?
Ich zeige das Kode und die Ergebnises aus Hterm:

#include <avr/io.h>
#include <stdio.h>
#include <stdint.h>
#include <stdlib.h>
#include <util/delay.h>


#define DD_MISO 3
#define DD_MOSI 2
#define DD_SCK 1
#define DD_SS 0




void uart_init()
{
  uint16_t temp = ((8000000)/(9600.0*16)-1); //Berechnung Übertragungsgeschwindigkeit


  UCSR0B |= (1<<TXEN0)|(1<<RXEN0)|(1<<RXCIE0); //Senden und Empfangen freischalten

  UBRR0L = temp; //Übertragungsgeschwindigkeit übermitteln
  UBRR0H = temp>>8;

  UCSR0C |= (1<<UCSZ00)|(1<<UCSZ01);  //Übertragungsformat: 8-Bit

}


int sendestring(char *s)
{
  int i=0;

  for(i=0; s[i] != '\0'; i++)
  {
    while bit_is_clear(UCSR0A, UDRE0); //warten, bis UDRE0 = 1 (Senderegister frei)
    
    UDR0 = s[i]; //ein Zeichen senden

  }

  return 0;
}




void SPI_MasterInit(void)
{
  //Outputs: MOSI, SCK, SS
  DDRB = (1<<DD_MOSI)|(1<<DD_SCK)|(1<<DD_SS);

  //Enable SPI, Master-Mode, set clock rate fck/16
  SPCR = (1<<SPE)|(1<<MSTR)|(1<<SPR1);
}


int SPI_MasterTransmit(char MOSI)
{
  //start Transmission
  SPDR = MOSI;
  
  //white for transmission complete
  while(!(SPSR & (1<<SPIF)));

  //returned data from slave to master
  return SPDR;
}




int main()
{

  char str[20];

  // Thermoelement an CH0 und CH1
  char masterOut1 = 0b10100000;
  //char masterOut2 = 0b10000000;

  // interne Temperaturmessung:
  char masterOut2 = 0b11000000;

  char result;
  uint32_t masterIn = 0;
  uint32_t Temp = 0;

  uart_init();  

  SPI_MasterInit();

  
  for(;;)
  {
  
    _delay_ms(500);

    //CS des Thermochips auf low
    PORTB &= ~(1<<DD_SS);

    
    //Byte1
    result = SPI_MasterTransmit(masterOut1);
    //result = SPI_MasterTransmit2;
    //SPI_MasterTransmit2;    
    masterIn = (result & 0b00011111);  //die ersten drei Bit löschen


    //für Debugging
    sendestring(" result1: ");
    itoa(result, str, 2); //binär darstellen
    sendestring(str);

    //Byte2
    result =SPI_MasterTransmit(masterOut2);
    //result = SPI_MasterTransmit2;
    masterIn = (masterIn<<8) + result;
    

      //für Debugging
    sendestring(" result2: ");
    itoa(result, str, 2); //binär darstellen
    sendestring(str);

    //Byte3
    result =SPI_MasterTransmit(0);
    //result = SPI_MasterTransmit2;
    masterIn = (masterIn<<8) + result;
    
      //für Debugging
    sendestring(" result3: ");
    itoa(result, str, 2); //binär darstellen
    sendestring(str);

    //Byte4
    result =SPI_MasterTransmit(0);
    //result = SPI_MasterTransmit2;
    masterIn = (masterIn<<8) + result;

      //für Debugging
    sendestring(" result4: ");
    itoa(result, str, 2); //binär darstellen
    sendestring(str);

    
    PORTB |= (1<<DD_SS);  //CS des Thermochips auf high
  
    _delay_ms(2000);

    masterIn = (masterIn>>5) & 0b00000000111111111111111111111111; //die letzten 5 Bit löschen

      //für Debugging
    sendestring(" resultmasterIn: ");
    itoa(masterIn, str, 2); //binär darstellen
    sendestring(str);

    sendestring(" masterIn: ");
    sprintf(str, "%ld", masterIn);
    sendestring(str);

    //bei interner Temperaturmessung: Temperatur in °C berechnen laut Datenblatt Seite21
    Temp = (masterIn*4/1570)-273;

    sendestring(" Temp: ");
    sprintf(str, "%ld", Temp);
    sendestring(str);

    _delay_ms(2000);
  }


  return 0;
}

result1: 11111
result2: 11111110
result3: 11001100
result4: 1010000
resultmasterIn: 1111011001100010
masterIn: 16774754
Temp: 42465

[Hector C. (Firma: Technische Universität München) (cuenca)]

Ich habe alle Dutzende Male geprüft und Ich habe Dutzende von Combos 
versucht. Ich verstehe nicht, warum die Daten bekomme ich nicht logisch 
sind.

Hat jemand eine ähnliche Erfahrung gehabt?

Danke Euch schon mal!

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

int ... char ...

Was ist ein "char"?  Ein Zeichen in der Ein- oder Ausgabe.

Wenn man eine kleine Ganzzahl haben möchte (small integer), dann bitte
int8_t benutzen, wenn es vorzeichenbehaftet sein soll, und uint8_t,
wenn es kein Vorzeichen haben soll.

Dein "int" bei SPI_MasterTransmit() in Verbindung mit der Addition
für masterIn versaut dir hier das Ergebnis.

Deklariere SPI_MasterTransmit() mit einem Rückkehrtyp von "uint8_t",
gleichfalls alle Variablen, die bislang als "char" deklariert sind.

Normalerweise würde man auch schreiben:

masterIn = (masterIn<<8) | result;

statt einer Addition.

[Hector C. (Firma: Technische Universität München) (cuenca)]

Jörg Wunsch schrieb:

> Dein "int" bei SPI_MasterTransmit() in Verbindung mit der Addition
> für masterIn versaut dir hier das Ergebnis.
> Deklariere SPI_MasterTransmit() mit einem Rückkehrtyp von "uint8_t",
> gleichfalls alle Variablen, die bislang als "char" deklariert sind.

Ich habe gerade es geändert.

> masterIn = (masterIn<<8) | result;

Ich habe es geändert.

uint8_t SPI_MasterTransmit(uint8_t MOSI)
{
  //start Transmission
  SPDR = MOSI;
  
  //white for transmission complete
  while(!(SPSR & (1<<SPIF)));

  //returned data from slave to master
  return SPDR;
}




int main()
{

  char str[20];

  // Thermoelement an CH0 und CH1
  uint8_t masterOut1 = 0b10100000;
  //char masterOut2 = 0b10000000;

  // interne Temperaturmessung:
  uint8_t masterOut2 = 0b11000000;

  int8_t result1;
  int8_t result2;
  int8_t result3;
  int8_t result4;
  uint32_t masterIn = 0;
  uint32_t Temp = 0;

  uart_init();  

  SPI_MasterInit();

  
  for(;;)
  {
  
    _delay_ms(500);

    //CS des Thermochips auf low
    PORTB &= ~(1<<DD_SS);

    
    //Byte1
    result1 = SPI_MasterTransmit(masterOut1);

    //für Debugging
    sendestring(" result1: ");
    itoa(result1, str, 2); //binär darstellen
    sendestring(str);

    //Byte2
    result2 =SPI_MasterTransmit(masterOut2);
    
    masterIn = (result1<<8) | result2;
    

      //für Debugging
    sendestring(" result2: ");
    itoa(result2, str, 2); //binär darstellen
    sendestring(str);

    //Byte3
    result3 =SPI_MasterTransmit(0);
    
    masterIn = (masterIn<<8) | result3;
    
      //für Debugging
    sendestring(" result3: ");
    itoa(result3, str, 2); //binär darstellen
    sendestring(str);

    //Byte4
    result4 =SPI_MasterTransmit(0);
  
    masterIn = (masterIn<<8) | result4;

      //für Debugging
    sendestring(" result4: ");
    itoa(result4, str, 2); //binär darstellen
    sendestring(str);

    
    PORTB |= (1<<DD_SS);  //CS des Thermochips auf high

Ich habe versucht wieder 4 SPI modes  mit die neue Konfigurationen aber 
es funktionert nicht.

result1: 11 result2: 1111111111111111 result3: 1111111111111111 result4: 
1111111111111111 resultmasterIn: 1111111111111111 masterIn: -1 
Temp:2735374

SPI ist Duplexkommunikation und Ich sende und bekomme zur gleichen Zeit 
bei "result" variable.
Villeicht mein inputData (MasterOut1, MasterOut 2) wird von LTC2498 
nicht gut gelesen?  Ich lese aus LTC2498Datasheet:
"A new configuration can be loaded into the device by
setting EN2 = 1"
So Ich glaube alles gut konfiguriert ist.

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

Hector Cuenca schrieb:
> masterIn: -1

Beschaff' dir bitte das Oszilloskop.

Das sieht ja verdammt danach aus, als würde der LTC2498 einfach gar
nicht reagieren.

Überprüfe auch nochmal die Verdrahtung, ob da alles in Ordnung ist.

[Hector C. (Firma: Technische Universität München) (cuenca)]

Hallo Zussamen,

Ich habe auch dem gleichen Problem. Ich werde endlich mit dem 
Oszilloskop-Signal überprüfen. Ich will wissen vor der Prüfung des 
Oszilloskops, wenn das Signal wie das Bild sein soll

Konnte Sie mir sagen, ob das Signal bekomme ich dem in Anlage ähneln 
soll?
Weiß ich, dass es hängt die SPI-Verbindung konfigurieren, muss jedoch 
wie in der Abbildung?

Danke Euch schon mal!

[Hector C. (Firma: Technische Universität München) (cuenca)]

Hallo Zussamen,

Weiß jemand, wie es sein sollte?

Danke Euch schon mal!