L3G4200D Register auslesen

Funktioniert Die Kommunikation mit dem Sensor vielleicht so, dass ich 
wenn ich das Ctrl_Reg1 auslesen will, dafür folgendes vom Master senden 
muss:

1      0           100000
Read | no incre. | Ctrl_Reg1

Daraufhin sendet mir der Sensor das Register und ich kann es aus dem 
SPDR auslesen?

Ich kenne mich mit SPI leider noch so gutt wie garnicht aus und möchte 
meinen Sensor nicht gleich mit dem ersten "Befehl" zerstören. Ich wäre 
sehr dankbar für eine Reaktion!

Das ist recht einfach. Ich habe noch Code für den L3G4200D auf der 
Platte liegen (geschrieben für einen Atmega64 mit soft SPI). Den müsst 
ich aber erstmal raussuchen.

@Dennis: Danke für deine Motivation, leider schaffe ich es dennoch nicht 
alleine aus den Datenblättern heraus schlau zu werden, ich möchte auch 
garnicht eine fertige Lösung für eine konkrete Aufgabenstellung, mir 
würde schon reichen das WHO_AM_I Register auszulesen und in einer 
Variable abzuspeichern.

Mein Versuch sieht so aus und gibt mir leider nur 255 zurück, was dann 
wohl für 0b11111111 steht und nicht meinem WHO_AM_I Register entspräche! 
:(

1

#include <avr/io.h>

2

#include <avr/interrupt.h>

3

#include "MrLCD.h"

4

#include <stdlib.h>

5

6

void master_init (void);

7

void master_transmit (unsigned char data);

8

9

int WHO_AM_I = 0;

10

char WHO_AM_I_dez[8];

11

12

int main (void)

13

{

14

15

  master_init ();

16

  sei ();

17

  master_transmit(0b10001111);

18

  WHO_AM_I = SPDR;

19

20

  InitializeMrLCD();

21

22

23

  itoa(WHO_AM_I, WHO_AM_I_dez, 10);

24

25

  GotoMrLCDsLocation(1,1);

26

  Send_A_String(WHO_AM_I_dez);

27

28

  while(1)

29

  {  

30

31

  }

32

}

33

34

void master_init (void)

35

{

36

  DDRB |= 1 << (PB4) | 1 << (PB5) | 1 << (PB7);

37

  DDRB &= ~(1 << PB6);

38

  PORTB |= 1 << (PB4) | 1 << (PB7) | 1 << (PB0);

39

  SPCR |= 1 << (SPE) | 1 << (MSTR) | 1 << (SPR1);

40

  SPSR |= 1 << (SPI2X);

41

}

42

43

void master_transmit (unsigned char data)

44

{

45

  PORTB &= ~(1 << PB0);

46

  SPDR = data;

47

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

48

  PORTB |= 1 << (PB0);

49

}

@Jo:  Ja ich bin sehr an Code interessiert :)

Kann mir nicht vielleicht jemand weiterhelfen?

Wie gesagt mir reichen wirklich nur die nötigen Zeilen um das WHO_AM_I 
Register auf meinem AVR zu empfangen und abzuspeichern.

Hallo Florian,
ich habe mal hier meine BASCOM-Dateien angehäng.

Was ich allerdings benutzt habe war das MinIMU-9 von Pololu
an ein PollinBoard mit ATmega88 drauf. Anschlüsse waren angelötet
mit 10kOhm Pullup-Widerständen gegen +5V.
Auf dem Board sind 3-Achsen Gyro L3G4200D und 3-Achsen Kompass / 
Beschleunigungssensor LSM303DLM.
Sollte mal für ein Mikrokopter sein, habe aber schon länger aus 
Zeitmangel
nichts mehr damit gemacht.

Ich hoffe du kannst was damit anfangen auch wenn es nur BASIC ist.

Und für alle anderen MitLeser:
-> Bitte verzeiht mein schlechten Programmierstil!
   (Aber es hat funktioniert!!)

Holger

@Holger: Vielen Dank für deinen Beitrag, leider suche ich C-Code und SPI 
als Kommunikation. Leider kann ich daher mit deinen Dateien nicht viel 
anfangen.

Ich verzweifele bald :/

@ Florian,

sorry habs gestern vergessen. Wenn du dich noch bis heute Abend gedulden 
kannst - hab die Daten leider nicht auf meinem Arbeitsrechner.

Werde den Code heute abend posten - versprochen ;)

doppelt

So jetzt aber. Die Datei einfach einbinden und dann in der Main 
folgendes aufrufen um die Sensorwerte auszulesen:

1

//Buffer für High und Low Bytes

2

volatile uint8_t low = 0;

3

volatile uint8_t high = 0;

4

5

//Gyro Output

6

volatile int l3g_erg_x = 0;

7

volatile int l3g_erg_y = 0;

8

volatile int l3g_erg_z = 0;

9

10

11

// Pins für SPI konfigurieren

12

init_spi_l3g();

13

14

// GYRO aktivieren und konfigurieren

15

config_l3g();

16

17

////////////////////// READ GYRO DATA IN MULTIPLE READ MODUS ////////////////////

18

    send_byte_l3g(232); 

19

20

    low = read_byte_l3g();

21

    high = read_byte_l3g();

22

    l3g_erg_x = (int)(low + (high << 8));

23

24

    low = read_byte_l3g();

25

    high = read_byte_l3g();

26

    l3g_erg_y = (int)(low + (high << 8));

27

28

    low = read_byte_l3g();

29

    high = read_byte_l3g();

30

    l3g_erg_z = (int)(low + (high << 8));

31

32

    complete_l3g();

33

    /////////////////////////////////////////////////////////////////////////////////

Vielen Dank schon einmal ich werde es mir sofort anschauen! :)
Was genau bedeutet diese Zeile Code?

1

if ( byte & (1<<(7)) )

Florian K. schrieb:
> Vielen Dank schon einmal ich werde es mir sofort anschauen! :)
> Was genau bedeutet diese Zeile Code?
>

1

> if ( byte & (1<<(7)) )

2

>

Ich schau mir das Bit Nummer 7 in der Variablen Byte an und setze 
demgemäß meinen Ausgangspin auf 1 oder 0 je nachdem ob das Bit 1 ist 
oder 0 ist. Das Ganze wird 8 mal durchgeführt bis das ganze Byze 
rausgesendet wurde. Der Code ist deshalb etwas lang geraten. Prinzipiell 
kann man den ganzen Spaß auch in einer For-Schleife machen, dann spart 
man sich eine Menge Zeilen.

PS:

Deine Ausgangspins musst du natürlich noch entsprechend an dein Design 
anpassen. Das vergaß ich oben zu erwähnen.

Ok ich hab es verstanden, ich nahm naiver weise an, das der AVR am 
SPI-BUS zumindest die Chip-Select Leitung selbst steuert und ich direkt 
eine 8-BIT Zahl senden kann.

Naja aber vielen vielen dank! Du hast mir damit sehr geholfen, heute 
habe ich keinen Kopf mehr das anzupassen aber ich werde morgen versuchen 
die Register auszulesen und teile dann nochmal mein Ergebnis mit :)
Genau danach habe ich nun Zwei Tage gesucht :D

> Ok ich hab es verstanden, ich nahm naiver weise an, das der AVR am
> SPI-BUS zumindest die Chip-Select Leitung selbst steuert und ich direkt
> eine 8-BIT Zahl senden kann.

Zur Harware SPI des AVR kann ich nichts sagen. Der Code von oben ist 
Soft-SPI - d.h an allen Portpins verwendbar.

Auf jeden Fall viel Erfolg.

OK das erklärt vermutlich so einiges :/

Dann bin ich weiterhin auf der Suche nach Hilfe!

Florian K. schrieb:
> OK das erklärt vermutlich so einiges :/
>
> Dann bin ich weiterhin auf der Suche nach Hilfe!

Bist du denn auf die Hardware SPI angewiesen? Die brauchst du doch nur, 
wenn du zeitkritische Anwendungen machst.

@Eumel:
Ich meine überall zu lesen das folgende Zeilen ausreichen um ein Byte 
auzulesen:

1

char ReadByteSPI(char addr)

2

{

3

  SPDR = addr;      //Load byte to Data register

4

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

5

  addr=SPDR;

6

  return addr;

7

}

Wobei addr zum Beispiel = 0b10001111 ist um das Register WHO_AM_I 
auszulesen.
Und als Rückgabewert dann 0b11010011 ausgeben sollte

Ich erhalte allerdings immer als Rückgabewert 255.

@ Jo:
Ja ich möchte wirklich gerne den SPI-BUS verwenden!

Vielen Vielen Dank!!!!!
Nun klappt es endlich!
Damit zauberst du mir doch glatt ein lächeln aufs Gesicht.

Also wie gesagt vielen Dank!!! :D

Holger E. schrieb:
> Hallo Florian,
> ich habe mal hier meine BASCOM-Dateien angehäng.
> ....
>
> Ich hoffe du kannst was damit anfangen auch wenn es nur BASIC ist.
>
> Und für alle anderen MitLeser:
> -> Bitte verzeiht mein schlechten Programmierstil!
>    (Aber es hat funktioniert!!)
>
> Holger

Holger, genau dieses Beisp. für den minIMU-9 mit BASCOM hab ich gesucht!
Es funktioniert wunderbar!
DANKE!!!!!

Gruß
  Hans