SPI immer gleiche Antwort

[Chris T. (chris0086)]

Hallo Leute,
ich habe ein Problem mit der SPI Übertragung, habe da noch nicht viel 
gemacht.
Also nach einem Reset des Controllers wird vom Slave Chip, ein LIS3DH 
Beschleunigungssensor nach Anforderung der richtige Registerinhalt 
gesendet. Wenn ich jetzt ein anderes Register auslesen will kommt 
trotzdem immer wieder der gleiche Registerinhalt des alten Registers. 
Das stimmt natürlich nicht so.
Weiterhin weis ich nicht genau an welcher Stelle ich den Wechsel von Low 
auf High der CS Leitung rein packe. Die soll ja laut Diagramm im 
Datenblatt(S.22) high werden wenn SCK auch gerade high wird.
Falls wer Zeit hat kann mal jemand über meinen code schauen und den oder 
die bösen Fehler suchen?
Die Kommunikation läuft zum testen einfach so, ich schicke über die 
serielle 3 Bytes, das erste ist die Adresse, das zweite ist der Wert 
welcher eventuell geschrieben werden soll, das dritte Byte gibt an ob 
schreiben, dann 1 oder lesen dann 0.
Verwendeter Controller ist ein Atmega16 mit 8MHz Takt.

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include <avr/eeprom.h>
#include <string.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <string.h>
#include <stdlib.h>

/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 8000000UL
#endif

/* 9600 baud   */
#define BAUD1 9600UL          // Baudrate
#define UBRR_VAL_UART ((F_CPU+BAUD1*8)/(BAUD1*16)-1)   // clever runden

#define DDR_SPI      DDRB  // Portrichtungsregister
#define DD_MOSI      DDB5
#define DD_MISO      DDB6
#define DD_SCK      DDB7
#define DD_SS      DDB4
#define PORT_SPI    PORTB

#define WHO_AM_I    0x0F
uint8_t u8_spi_write_buffer[8];
uint8_t u8_spi_read_buffer[8];
uint8_t rx_start = 0;
uint8_t receive_string[4];
volatile uint8_t rxc = 0;
void USART_Transmit( char data )
{
  /* Wait for empty transmit buffer */
  while ( !( UCSRA & (1<<UDRE)) )
    ;
  /* Put data into buffer, sends the data */
  UDR = data;
}


void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
      USART_Transmit(*s);
        s++;
    }
}


void SPI_MasterInit(void)
{
  DDR_SPI |= (1<<DD_MOSI) | (1<<DD_SCK) | (1<<DD_SS);
  DDR_SPI &= ~(1<<DD_MISO);
  SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR1) |(1<<SPR0) | (1<<CPOL); //SPI einschalten

}


uint8_t SPI_MasterTransmit(char data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  /* Return data register */
  return SPDR;
}


void SPI_Transmit(uint8_t rw,uint8_t *value,uint8_t max)
{

  uint8_t i;
  if(rw) //Schreiben
  {
    value[0] |= (1<<7);
  }
  for(i=0;i<max;i++)
  {

    u8_spi_read_buffer[i]=(SPI_MasterTransmit(value[i]));

  }
}


ISR(USART_RXC_vect)
{
  uint8_t i;
  i= rx_start;
  receive_string[i] = UDR;
  i++;

  if(i==3)
  {
    i=0;
    rxc=1;
  }
  rx_start = i;
}
int main(void)
{


  //Timer konfigurieren
  //stetige Wertanforderung
  TCCR1B |= (1<<CS12) | (1<<CS10); // standard = 9 Sekunden
  TCNT1 = 0; //29536; = 5 Sekunden

  //Timer für Fehleranzeige
  TCCR0 |= (1<<CS02) | (1<<CS00);

    //USART initialisieren

  //USART0
    UBRRH = UBRR_VAL_UART >> 8;
    UBRRL = UBRR_VAL_UART& 0xFF;

    //USART0
    UCSRB |= (1<<TXEN);                // UART TX einschalten
    UCSRB |= (1<<RXEN);
    UCSRB |= (1<<RXCIE);
    UCSRC |= (1<<URSEL)|(1<<UCSZ0)| (1<<UCSZ1);    // Asynchron 8N1

    sei();
    USART_Transmit('O');
    USART_Transmit('K');

    DDRC &= ~(1<<PC0);
    PORTC |= (1<<PC0);

  //ChipslesctPin auf Ausgang
  DDR_SPI |= (1<<DD_SS);

  SPI_MasterInit();

  // x und y Achsen deaktivieren
  u8_spi_write_buffer[0] = 0x20;
  u8_spi_write_buffer[1] = 0x04;
  //SPI_Transmit(u8_spi_write_buffer,2);
  //USART_Transmit(u8_spi_read_buffer[0]);
  //USART_Transmit(u8_spi_read_buffer[1]);

while(1)
{
  if(rxc)
  {
    u8_spi_write_buffer[0] = receive_string[0];
    u8_spi_write_buffer[1] = receive_string[1];

    PORT_SPI &= ~(1<<DD_SS);

    SPI_Transmit(receive_string[2],u8_spi_write_buffer,2);

    USART_Transmit(u8_spi_read_buffer[0]);
    USART_Transmit(u8_spi_read_buffer[1]);
    USART_Transmit('|');
    rxc = 0;
  }
}

}

Grüße Christian

[Wolfgang (Gast)]

Chris T. schrieb:
> Die soll ja laut Diagramm im
> Datenblatt(S.22) high werden wenn SCK auch gerade high wird.

Wahre Gleichzeitigkeit gibt es nicht.

Bei der stiegenden Flanke von SPC müssen die Daten stabil sein. CS muss 
rechtzeitig vor der Übertragung auf Low liegen und geht irgendwann 
danach wieder auf High.

[holger (Gast)]

>CS muss rechtzeitig vor der Übertragung auf Low liegen und geht irgendwann
>danach wieder auf High

In seinem Programm geht es nie High.

[Nils Z. (nils_z)]

holger schrieb:
> In seinem Programm geht es nie High.

Was zur Folge hat, dass immer wieder das gleiche Register ausgelesen 
wird, weil die Adresse nur im ersten Byte nach Beginn einer Übertragung 
gesetzt wird. Die Übertragung endet aber erst durch CS auf HIGH, was 
nicht passiert.

[Wolfgang (Gast)]

Nils Z. schrieb:
> Was zur Folge hat, dass immer wieder das gleiche Register ausgelesen
> wird, weil die Adresse nur im ersten Byte nach Beginn einer Übertragung
> gesetzt wird. Die Übertragung endet aber erst durch CS auf HIGH, was
> nicht passiert.

Ganz so einfach ist das auch nicht. Da gibt es noch das MS Bit.

Seite 23:
"In multiple read/write commands further blocks of 8 clock periods is 
added. When MS bit is ‘0’ the address used to read/write data remains 
the same for every block. When MS bit is ‘1’ the address used to 
read/write data is increased at every block."

[Chris T. (chris0086)]

Ich habe das jetzt mal so abgeändert das ich nach Übertragung CS wieder 
auf High ziehe:

  if(rxc)
  {
    u8_spi_write_buffer[0] = receive_string[0];
    u8_spi_write_buffer[1] = receive_string[1];

    PORT_SPI &= ~(1<<DD_SS);

    SPI_Transmit(receive_string[2],u8_spi_write_buffer,2);
    PORT_SPI |= (1<<DD_SS);
    USART_Transmit(u8_spi_read_buffer[0]);
    USART_Transmit(u8_spi_read_buffer[1]);
    USART_Transmit('|');
    rxc = 0;
  }

Jetzt bekomme ich nach der ersten Übertragung (Gesendet 0f 00 00):
FF 33 7C --> Stimmt.
Wenn ich das gleiche aber nochmal sende, erhalte ich dann immer:
FF FF 7C egal welches Register ich anspreche (7C ist der |)

Also so ganz läufts immer noch nicht.

Das MS Bit ist bisher immer 0 da ich ja nur ein Byte lesen will

[Nils Z. (nils_z)]

Chris T. schrieb:
> Jetzt bekomme ich nach der ersten Übertragung (Gesendet 0f 00 00):
> FF 33 7C --> Stimmt.
> Wenn ich das gleiche aber nochmal sende, erhalte ich dann immer:
> FF FF 7C egal welches Register ich anspreche (7C ist der |)

Kannst du mal mit Oszilloskop oder Logic-Analyser nachsehen, was beim 
zweiten mal auf den Leitungen am Sensor wirklich gesendet / empfangen 
wird? Dann wüsste man, ob der Fehler in deiner Sende- oder in der 
Empfangsroutine zu suchen ist.


Wolfgang schrieb:
> Ganz so einfach ist das auch nicht. Da gibt es noch das MS Bit.
>
> Seite 23:
> "In multiple read/write commands further blocks of 8 clock periods is
> added. When MS bit is ‘0’ the address used to read/write data remains
> the same for every block. When MS bit is ‘1’ the address used to
> read/write data is increased at every block."

Da hast du natürlich recht, ich bin stillschweigend davon ausgegangen, 
dass er das Bit nicht gesetzt hat, weil keine Multibytezugriffe erfolgt 
sind.

[Chris T. (chris0086)]

Mein toller Logic analyzer clon ist irgendwie stumm und Oszi hab ich 
leider nicht da :(

Hat noch jemand eine Idee?

[Bastian W. (jackfrost)]

Willsz du beim ersten  Auslesen nur 0F ausgelesen ? Wenn ja warum 
sendest du zwei Dummybytes. Vor allem sind die direkten Register mit der 
nachfolgenden Adresse ja "reserved"

Gruß JackFrost

[Chris T. (chris0086)]

Das dritte Byte diente nur um auszuwählen zwischen lesen und schreiben 
es werden nur zwei Bytes gesendet.
Jetzt hab ich auch meinen Logiganalyzer zum laufen bekommen.
Leider wird schon nichts mehr gesendet, obwohl ich gar nicht viel am 
Code verändert habe.
Hier jetzt mal der aktuelle Code:

#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <inttypes.h>
#include <avr/eeprom.h>
#include <string.h>
#include <util/delay.h>
#include <avr/wdt.h>
#include <string.h>
#include <stdlib.h>

/* define CPU frequency in Mhz here if not defined in Makefile */
#ifndef F_CPU
#define F_CPU 8000000UL
#endif

/* 9600 baud   */
#define BAUD1 9600UL          // Baudrate
#define UBRR_VAL_UART ((F_CPU+BAUD1*8)/(BAUD1*16)-1)   // clever runden

#define DDR_SPI      DDRB  // Portrichtungsregister
#define DD_MOSI      DDB5
#define DD_MISO      DDB6
#define DD_SCK      DDB7
#define DD_SS      DDB4
#define PORT_SPI    PORTB

#define WHO_AM_I    0x0F
uint8_t u8_spi_write_buffer[8];
uint8_t u8_spi_read_buffer[8];
uint8_t rx_start = 0;
uint8_t receive_string[4];
volatile uint8_t rxc = 0;
void USART_Transmit( char data )
{
  /* Wait for empty transmit buffer */
  while ( !( UCSRA & (1<<UDRE)) )
    ;
  /* Put data into buffer, sends the data */
  UDR = data;
}


void uart_puts (char *s)
{
    while (*s)
    {   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
      USART_Transmit(*s);
        s++;
    }
}


void SPI_MasterInit(void)
{
  DDR_SPI |= (1<<DD_MOSI) | (1<<DD_SCK) | (1<<DD_SS);
  DDR_SPI &= ~(1<<DD_MISO);
  SPCR = (1<<SPE) | (1<<MSTR) | (1<<SPR1) |(1<<SPR0) | (1<<CPOL); //SPI einschalten

}


uint8_t SPI_MasterTransmit(char data)
{
  SPDR = data;
  while(!(SPSR & (1<<SPIF)));
  /* Return data register */
  return SPDR;
}


void SPI_Transmit(uint8_t rw,uint8_t *value,uint8_t max)
{

  uint8_t i;

  for(i=0;i<max;i++)
  {

    u8_spi_read_buffer[i]=(SPI_MasterTransmit(value[i]));

  }
}


ISR(USART_RXC_vect)
{
  uint8_t i;
  i= rx_start;
  receive_string[i] = UDR;
  i++;

  if(i==3)
  {
    i=0;
    rxc=1;
  }
  rx_start = i;
}
int main(void)
{


  //Timer konfigurieren
  //stetige Wertanforderung
  TCCR1B |= (1<<CS12) | (1<<CS10); // standard = 9 Sekunden
  TCNT1 = 0; //29536; = 5 Sekunden

  //Timer für Fehleranzeige
  TCCR0 |= (1<<CS02) | (1<<CS00);

    //USART initialisieren

  //USART0
    UBRRH = UBRR_VAL_UART >> 8;
    UBRRL = UBRR_VAL_UART& 0xFF;

    //USART0
    UCSRB |= (1<<TXEN);                // UART TX einschalten
    UCSRB |= (1<<RXEN);
    UCSRB |= (1<<RXCIE);
    UCSRC |= (1<<URSEL)|(1<<UCSZ0)| (1<<UCSZ1);    // Asynchron 8N1

    sei();
    USART_Transmit('O');
    USART_Transmit('K');

    DDRC &= ~(1<<PC0);
    PORTC |= (1<<PC0);

  //ChipslesctPin auf Ausgang
  DDR_SPI |= (1<<DD_SS);

  SPI_MasterInit();
  PORT_SPI |= (1<<DD_SS);
  // x und y Achsen deaktivieren
  u8_spi_write_buffer[0] = 0x20;
  u8_spi_write_buffer[1] = 0x04;
  //SPI_Transmit(u8_spi_write_buffer,2);
  //USART_Transmit(u8_spi_read_buffer[0]);
  //USART_Transmit(u8_spi_read_buffer[1]);

while(1)
{
  if(rxc)
  {
    u8_spi_write_buffer[0] = receive_string[0];
    u8_spi_write_buffer[1] = receive_string[1];

    PORT_SPI &= ~(1<<DD_SS);

    SPI_Transmit(receive_string[2],u8_spi_write_buffer,2);
    PORT_SPI |= (1<<DD_SS);
    USART_Transmit(u8_spi_read_buffer[0]);
    USART_Transmit(u8_spi_read_buffer[1]);
    USART_Transmit('|');
    rxc = 0;
  }
}

}

Ich weis jetzt echt nichtmehr weiter :(
Im Anhang die Aufnahme

[Chris T. (chris0086)]

Okay er sendet erstmal wieder hatte bei dem Empfangsarray das volatile 
vergessen.
Aber er empfängt noch nichts...

[David P. (chavotronic)]

Bist du sicher mit dem Protokoll? Auf den ersten Blick sieht es so aus 
als werden die Werte bei steigender Clock Flanke übernommen, scheint bei 
dir nicht so zu sein.

[Chris T. (chris0086)]

Ja danke für den Hinweis, hab das CPOL Bit mal gelöscht und siehe da, er 
antwortet wie er soll, oh man das war wieder ein Hickhack, da war an 
mehreren Stellen ein kleiner Fehler...

[David P. (chavotronic)]

du hast bestimmt den falschen SPI Mode erwischt.

Edit: Wie ich sehe hat's jetzt geklappt :)

[Chris T. (chris0086)]

Ich weis ja ich habe jetzt hier schon einige Nerven strapaziert, aber 
ich treibs mal noch ein Stück weiter.

Ich kann die Register lesen und schreiben aber wie müssen die Register 
gesetzt werden damit ich mal einen Beschleunigungswert bekomme?
Also ich schnipse mit dem Finger gegen den Sensor da sollte doch ein 
Wert ungleich 0 mal auszulesen sein...

EDIT: Ok es gibt eine Application note, die wird ich mir erstmal rein 
ziehen.

[Nils Z. (nils_z)]

Chris T. schrieb:
> Ich kann die Register lesen und schreiben aber wie müssen die Register
> gesetzt werden damit ich mal einen Beschleunigungswert bekomme?

Ich arbeite auch gerade mit dem Sensor, die Aufteilung und Gliederung 
von Datenblatt und Appnote finde ich nicht gelungen, leider sind da auch 
mehrere grobe Fehler drinnen, Register werden unterschiedlich 
bezeichnet. Pass mit den Beispielen in der Appnote auf, da muss man alle 
Werte hinterfragen, die sind nicht immer richtig.

Um vom Sensor Werte zu bekommen, musst du als minimale Konfiguration in 
CTRL_REG1 die Bits ODR3-0 setzen. Default ist 0000 (binär). Im 
Datenblatt steht auf S.29 "0000:50 Hz; ", das ist falsch, sieht man in 
der Tabelle auf S.30. 0000 ist power down, daher kannst du nichts 
auslesen.

Noch ein Beispiel für einen Fehler:
AN3308, S.24: "Write A7h into CTRL_REG1// ODR = 100 Hz"
0xA = 1010 (bin), wieder mit der Tabelle im Datenblatt auf S. 30 
vergleichen, 1010 kommt da für ODR3-0 garnicht vor. Richtig für 100Hz 
wäre 0101 = 0x5. Der gleiche Fehler ist noch öfter in der Appnote, bin 
selbst darüber gestolpert.

Ich behaupte wirklich ungern, dass der Hersteller hier so viele Fehler 
gemacht hat, wenn ich mich geirrt haben sollte, wäre ich dankbar, wenn 
mir jemand zeigt, warum.

[Chris T. (chris0086)]

Hallo Nils,
danke für die Hinweise :-)
Habe das alles jetzt soweit laufen das ich
einen Interrupt am pin bekomme wenn ein bestimmtes Threshold 
überschritten wurde gemäß Anleitung aus der AP nur die Werte in den 
Register ein wenig abgeändert, da mich nur die Werte für die 
Beschleunigung in Z-Richtung interessieren:

Write A7h into CTRL_REG1
// Turn on the sensor and enable X, Y, and Z
// ODR = 100 Hz
2 Write 00h into CTRL_REG2 // High-pass filter disabled
3 Write 40h into CTRL_REG3 // Interrupt driven to INT1 pad
4 Write 00h into CTRL_REG4 // FS = 2 g
5 Write 08h into CTRL_REG5 // Interrupt latched
6 Write10h into INT1_THS // Threshold = 250 mg
7 Write 00h into INT1_DURATION // Duration = 0
8 Write 0Ah into INT1_CFG // Enable XH and YH interrupt generation
9 Poll INT1 pad; if INT1=0 then go to 8
// Poll RDY/INT pin waiting for the
// wake-up event
10 Read INT1_SRC
// Return the event that has triggered the
// interrupt

Kannst du mir sagen wie ich an den größten Wert welche bei Überschreiten 
der Schwelle detektiert wurde?

Wenn ich dann nach dem Interruptregister manuell die Register OUT_1_L 
etc. auslesen bekomme ich da 0 Werte.

Auch hab ich noch nicht geblickt welches Register ich genau auslesen 
muss wenn ich den Wert von der Z-Beschleunigung möchte.

Muss ich da OUT_3_L und OUT_3_H auslesen? Ist dort der Wert für die Z 
Achse gespeichert?

[Chris T. (chris0086)]

So habe das jetzt so angepasst das ich so bald der Interrupt kommt 
direkt das entsprechende Register auslese. Das funktioniert schon mal 
prinzipiell.
Nur wie ich jetzt auf den Beschleunigungswert komme ist mir trotz 
appnote noch schleierhaft. Wie muss man das denn rechnen das man da auf 
den Wert kommt?
Hier erstmal der Code:

while(1)
{
  u8_spi_write_buffer[0] = 0x31;
  u8_spi_write_buffer[1] = 0;
  SPI_Transmit(receive_string[2],u8_spi_write_buffer,2);

  if( u8_spi_read_buffer[1] & 0x40)
  {
    u8_spi_write_buffer[0] = 0x2c;
    u8_spi_write_buffer[1] = 0;
    u8_spi_write_buffer[2] = 0;
    SPI_Transmit(receive_string[2],u8_spi_write_buffer,3);
    acceleration_l = u8_spi_read_buffer[1];
    acceleration_h = u8_spi_read_buffer[2];
    USART_Transmit(acceleration_l);
    USART_Transmit(acceleration_h);
    USART_Transmit('|');

  }
  _delay_ms(50);
}

In der Appnote steht auf Seite 14 dazu eine Tabelle aber ich weis nicht 
wie die da auf den g Wert kommen mit den Zahlen...

[Wolfgang (Gast)]

Chris T. schrieb:
> In der Appnote steht auf Seite 14 dazu eine Tabelle aber ich weis nicht
> wie die da auf den g Wert kommen mit den Zahlen...

Per Dreisatz und Kalibrierkoeffizienten?

[Chris T. (chris0086)]

Ich glaub ich habe es, das müssten schon zweierkomplemente sein, da der 
Wert ein INT -Wert ist...
Hab das jetzt so gelöst und erhalte auch Werte welche durchaus stimmen 
könnten.

    int16_t g_level;
    g_level = (int16_t)(((  acceleration_h) << 8) | acceleration_l);
    USART_Transmit('|');
    char buffer[10];
    itoa(g_level,buffer,10);
    uart_puts(buffer);

Kann das passen? BLE ist bei mir 0

[Nils Z. (nils_z)]

Sorry, habe nicht viel Zeit, daher nur recht knapp:

Um an die Beschleunigungen zu kommen, musst du die Register OUT_Z_L / H 
auslesen (0x2c, 0x2d, aus der Tabelle im Datenblatt auf S.26). Die Werte 
sind im Zweierkomplement (steht auf S.33).
Die Register OUT_x_L/H sind für die zusätzlichen ADC-Kanäle (in der 
Tabelle auf S. 26 steht auch ADC im Namen dabei, die Namen sind leider 
nichtmal im Datenblatt einheitlich :( ).

Die Interpretation der Werte ist in der Appnote auf S.14 halbwegs 
ersichtlich. Der maximale/minimale Wert einer Achse in g ergibt sich 
durch die Full Scale selection (2, 4, 8 oder 16g, Datenblatt S.31).
Der Wert pro digit auch, siehe Tabelle im Datenblatt auf S. 10.

Um die Werte auf Plausibilität zu prüfen, einfach den Sensor in Bezug 
auf die Achse passen hinlegen, dann müsste die Beschleunigung je nach 
Lage +1g, 0g oder -1g sein.