I2C Beschleunigungssensor ADXL375

[Thomas M. (pomestomi)]

Hallo Leute,

ich bin grade dabei den ADXL375 Beschleunigungssensor mit einem 
ATMega328PU über I2C auszulesen.

Dazu hab ich mir die Dateien von Peter Fleurys Projekt I2CMaster in mein 
Atmel Solution eingebunden. Wenn ich die Verbindung mittels 
i2c_start(DEV, I2C_Write) teste, kommt eine 0 zurück, was bedeutet, dass 
die Verbindung zwischen µC und Sensor funktioniert.
Ich Debugge den Aufbau Mittels MAX232 und HTerm am PC, damit ich weis, 
was los ist.

Jetzt versuche ich das Register 0x00 des ADXL375 zu lesen, was mir aber 
nicht gelingt. Ich sollte hierbei den ID Code 0xE5 zurückbekommen, HTerm 
zeigt aber 8 bytes an ( siehe Anhang ), die keinen Sinn ergeben.

Der kurze Programmcode ist auch als Screenshot dabei. Mit integriert ist 
natürlich die RS232 und I2C initialisation.

Eine Idee von mir wäre, dass ich eventuell Datentypen miteinander 
vertausch, wie es nicht sein sollte? Wisst ihr eine Lösung?

Mit freundlichen Grüßen
Thomas

[holger (Gast)]

>Den Fall hast du aber nicht. Du willst lediglich vom Baustein lesen.
>Aber auch dazu musst du die Adresse von der du lesen willst an den
>Baustein geben.
>
>d.h. der Ablauf ist
>
>  i2c_start( DEV_375 + I2C_READ );
>  i2c_write( 0x00 );    // von Adresse 0 lesen
>  data = i2c_readNAK();
>  i2c_stop();

Tut mir leid Karl Heinz, aber das ist falsch und das Programm
im Bild sieht besser aus;)

[holger (Gast)]

>Eine Idee von mir wäre, dass ich eventuell Datentypen miteinander
>vertausch, wie es nicht sein sollte? Wisst ihr eine Lösung?

println() erwartet sicher einen String, du gibst aber nur ein char.
Deshalb kommt der Müll da vermutlich raus.

[Thomas M. (pomestomi)]

Hallo holger,

das dacht ich mir schon fast. Es ist in der Tat so, dass ein String 
erwartet wird. Ich denk mal die Suchfunktion wird was passendes finden, 
wie ich Char in String konvertier. Ich probiers morgen mal aus und 
schau, was passiert. :)

Mit freundlichen Grüßen,
Thomas

[Thomas M. (pomestomi)]

Hallo Leute,

ich brauch wohl doch nochmal Hilfe. Der Funktion zum Senden von Daten 
über den UART ist genau die aus diesem Forum (siehe Bild). Der char, den 
ich senden will, hat den Wert 0xE5. Dies entspricht meines Wissens nach 
einfach der Binärzahl 0b11100101. Wie kann ich jetzt nur E5 oder eben 
die Binärzahl über UART senden?

Mit freundlichen Grüßen,
Thomas

[Felix P. (fixxl)]

Wenn du den gelesenen unsigned char über die UART binär ausgeben willst, 
kannst du so etwas versuchen. Das Array sollte mindestens 11 Bytes lang 
sein ('0', 'b', 8 Stellen für Bits, abschließende 0).

void char2binarray(uint8_t dat, char* array) {
  array[0] = '0';
  array[1] = 'b';

  for(uint8_t i=2; i<10; i++) {
    array[i] = (dat&0x80)?'1':'0';
    dat <<= 1;
  }
  array[10] = '\0';
}

Die Funktion rufst du direkt nach dem Einlesen mit
char2binarray(data, array) auf und danach kannst du dir die Daten via 
println(array) über UART ausgeben lassen.

Nachtrag: char als Variablenname zu verwenden, ist keine gute Idee ;-)

Nächster Nachtrag: Für Hex-Darstellung geht es so:

char nibble2hex(uint8_t zahl) {
  zahl &= 0x0F;
  if (zahl > 9) {
    return zahl - 10 + 'A';
  } else {
    return zahl + '0';
  }
}

void char2hexarray(uint8_t dat, char* array) {
  array[0] = '0';
  array[1] = 'x';
  array[2] = nibble2hex(dat >> 4);
  array[3] = nibble2hex(dat & 0x0F);
  array[4] = '\0';
}

Im Hauptprogramm char2hexarray(data, array) aufrufen und dann per 
println(array) ausgeben.

[Thomas M. (pomestomi)]

Hallo Felix,

so wie ich das verstehe, soll die Funktion ein Array mit den Werten vom 
Char füllen. Das passiert mit der Zeile

array[i] = (char&0x80)?'1':'0'

wo entweder eine 1 oder eine 0 ins Array geschrieben wird. Aber was 
bedeutet die Und-Verknüpfung von char und 0x80? Bei der Definition 
uint8_t char meckert der Compiler logischerweise, weil ja zwei 
Datentypen definiert werden. Der Ansatz ist gut, ich versteh ihn nur 
noch nicht ganz.

Mit freundlichen Grüßen,
Thomas

[Karl H. (kbuchegg)]

Thomas Maier schrieb:
> Hallo Felix,
>
> so wie ich das verstehe, soll die Funktion ein Array mit den Werten vom
> Char füllen. Das passiert mit der Zeile
>
> array[i] = (char&0x80)?'1':'0'
>
> wo entweder eine 1 oder eine 0 ins Array geschrieben wird. Aber was
> bedeutet die Und-Verknüpfung von char und 0x80?

Er will an dieser Stelle wissen, ob das Bit 7 in 'char' gesetzt ist oder 
nicht.
Je nachdem weißt er dann ins Array das Zeichen '1' oder das Zeichen '0' 
zu.

> Bei der Definition
> uint8_t char meckert der Compiler logischerweise, weil ja zwei
> Datentypen definiert werden. Der Ansatz ist gut, ich versteh ihn nur
> noch nicht ganz

Gehen wir von innen nach aussen.
Der Kern lässt sich auch so schreiben

    if( dat & 0x80 )
      array[i] = '1';
    else
      array[i] = '0';

( das ist nichts anderes als die Langform zu der kürzeren Variante
   array[i] = ( dat & 0x80 ) ? '1' : '0';
)

wenn also Bit 7 in value auf 1 ist, dann soll im Array an der i-ten 
Stelle das zeichen '1' eingetragen werden. Wenn nicht (dann muss das Bit 
0 sein) dann eben das Zeichen '0'.

Aber eigentlich will man ja nicht das 7-Bit, sondern nacheinander die 
Bits 7, 6, 5, 4, ... entsprechend auswerten. Wie macht man das dann?
Nun, man kann immer noch immer das 7.Bit betrachetn, wenn man dazu 
einfach nur im Gegenzug die Bits um jeweils 1 Stelle nach links 
verschiebt.

     dat <<= 1;

macht genau das.

Das ganze macht man 8 mal . und schon hab wir die nächste Zutat auf dem 
Weg von innen nach aussen: Eine Schleife die 8 mal durchlaufen wird. Da 
es sowieso noch eine Steuerung braucht, die dafür sorgt, dass das i in 
array[i] hochzählt, bietet es sich an, da gleich eine for-Schleife dafür 
zu benutzen.

  for(uint8_t i=2; i<10; i++) {
    array[i] = (dat&0x80)?'1':'0';
    dat <<= 1;
  }

von 2 bis 10 deshalb, weil vor den Bits ja nach der Textbestandteil "0b" 
auftauchen soll. Das sind nun mal 2 Zeichen.

[Thomas M. (pomestomi)]

Hallo Leute,

> Nachtrag: char als Variablenname zu verwenden, ist keine gute Idee ;-)

Dieser Nachtrag hat den Groschen fallen lassen :). Vielen Dank dafür!
Und auch vielen Dank an Karl Heinz für den C-Crashkurs. Es läuft alles 
und ich habs kapiert!

Mit freundlichen Grüßen,
Thomas