Problem mit I2C

[Andy (Gast)]

Hallo,

Ich benutze das RD4247Mag3110-Evaluationskit von Freescale zum Aufbau
eines eKompasses.

Auf diesem Board befindet sich zum einen der
MMA8451Q-Beschleunigungssensor(3-Achsen) und der bereits erwähnte
Magnetfeldsensor MAG3110(3-Achsen).

Die beiden hängen an einem I2C-Bus.

Nun hab ich aber dass Problem, dass sich der Beschleunigungssensor ohne
Probleme auslesen lässt, aber der Magnetfeldsensor leider Probleme
macht.

Dieser liefert mir beim ACK-Bit bei richtiger Addressierung ein Bit mit
halber VCC, was der Master aber leider (natürlich) als NACK erkennt.
Adressiere ich den Magnetfeldsensor absichtlich falsch, liefert er mir
ein NACK mit normalem Pegel von VCC, wie es auch normalerweise sein
sollte.

An den Routinen kanns nicht legen, da der Beschleunigungssensor das
gleiche Kommunikationsprotokoll hat wie der Magnetfeldsensor, und dieser
ja funktioniert.

Ich habe bereits mehrere Pullups von 4,7k bis 1k versucht, leider ändert
sich hierbei nichts.

Bin momentan Ratlos, und wär für jeden Tip dankbar.

Gruß
Andy

[Sven B. (scummos)]

Kannst du mal das Steuerprogramm für den Magnetfeldsensor posten? Ich 
hab das Ding auch (funktioniert gut), erinnere mich aber, dass es ein 
bisschen knifflig in Betrieb zu nehmen war.
Wenn ich daheim bin, poste ich mein Steuerprogramm mal.

[Andy (Gast)]

Wär super von dir.

Hier mal der i2c-code, is momentan eh nur ganz simpel gehalten.
Wollte damit nur am anfang das auslesen der Register probieren.

#include <stdio.h>

#include "derivative.h" /* include peripheral declarations */

#define GPIO_PIN_MASK            0x1Fu
#define GPIO_PIN(x)              (((1)<<(x & GPIO_PIN_MASK)))

void transfer_complete(void);
  
int acceleration_x;
int acceleration_y;
int debug = 0;


int counter;
int i;
int test;

int main(void)
{
  
  // Turn on I2C0 clock
    SIM_SCGC4 |= 0xC0; 
        
  // Turn on all port clocks
    SIM_SCGC5 = SIM_SCGC5_PORTA_MASK | SIM_SCGC5_PORTB_MASK | SIM_SCGC5_PORTC_MASK | SIM_SCGC5_PORTD_MASK | SIM_SCGC5_PORTE_MASK | SIM_SCGC5_PORTF_MASK;

  // Einstellen des Taktes MCGOUTCLK = 50 MHz
    MCG_C1 |= MCG_C1_CLKS(2);           // Externer Takt als Quelle
    
    PORTE_PCR19 = PORT_PCR_MUX(4); // SCL
    PORTE_PCR18 = PORT_PCR_MUX(4); // SDA 
    
  // I2C1 clock configuration
    I2C0_F = 0x23;              // I2C bus clock 100 kHz

  for(;;) {     
    // read out MMA7660FC tilt register to enable next interrupt  
    I2C0_C1 |= I2C_C1_IICEN_MASK;        // enable I2C0
      I2C0_C1 |= I2C_C1_MST_MASK;          // I2C0 is master, start condition
      for (i = 0; i < 100; i++);          // wait
      I2C0_C1 |= I2C_C1_TX_MASK;          // transmit mode  
      I2C0_D = 0x1C;                // MMA7660FC write address  1C/38
      transfer_complete();            // wait until transfer is complete
      if (I2C0_S & I2C_S_RXAK_MASK)
        printf("Fehler, kein ACK bekommen");
      I2C0_D = 0x07;                // address MMA7660FC tilt register  07/0D
      transfer_complete();            // wait until transfer is complete
      if (I2C0_S & I2C_S_RXAK_MASK)
        printf("Fehler, kein ACK bekommen");
      I2C0_C1 |= I2C_C1_RSTA_MASK;        // repeat start condition  
      for (i = 0; i < 100; i++);          // wait
      I2C0_D = 0x1D;                // MMA7660FC read address   1D/39
      transfer_complete();            // wait until transfer is complete
      if (I2C0_S & I2C_S_RXAK_MASK)
        printf("Fehler, kein ACK bekommen");
      I2C0_C1 &= ~I2C_C1_TX_MASK;          // receive mode
      I2C0_C1 |= I2C_C1_TXAK_MASK;        // no acknowledge needed
      acceleration_x = I2C0_D;          // dummy read to start receiving
      transfer_complete();            // wait until transfer is complete
      I2C0_C1 &= ~I2C_C1_MST_MASK;        // send stop condition
      acceleration_x = I2C0_D;          // read out data   
      I2C0_C1 &= ~I2C_C1_IICEN_MASK;        // disable I2C0
      
      printf("%d\n\r", acceleration_x);
      
      for (i = 0; i < 100000; i++);          // wait
      
  }
  
  return 0;
}




// function to test transfer complete flag
void transfer_complete(void)
{
  test = 1;
  while (test)
  {
    if (I2C0_S & I2C_S_TCF_MASK)
        {
          test = 0;
        }
  }
}

[Andy S. (andy87)]

Sven B. schrieb:
> Ich
> hab das Ding auch (funktioniert gut), erinnere mich aber, dass es ein
> bisschen knifflig in Betrieb zu nehmen war.

Wenn du denn schon mal in Gebrauch hattest, würd mich interresieren 
welche Genauigkeit du mit dem MAG3110 erreicht hast. z.B wenn ich mich 
um 90°drehe, wie weit liegt man dann von den wirklichen 90° weg?

[Sven B. (scummos)]

Andy S. schrieb:
> Sven B. schrieb:
>> Ich
>> hab das Ding auch (funktioniert gut), erinnere mich aber, dass es ein
>> bisschen knifflig in Betrieb zu nehmen war.
>
> Wenn du denn schon mal in Gebrauch hattest, würd mich interresieren
> welche Genauigkeit du mit dem MAG3110 erreicht hast. z.B wenn ich mich
> um 90°drehe, wie weit liegt man dann von den wirklichen 90° weg?

Kann ich Dir nicht sagen, weil ich bisher nicht in der Lage (bzw. eher 
zu faul) war, die Werte in Neigungswinkel umzurechnen. Das ist nicht 
ganz trivial, weil du ja sowas bekommst wie "Projektion des 
Magnetfeldvektors auf x, y, und z-Achse des Geräts", und der 
Magnetfeldvektor zeigt irgendwie schräg nach unten und nach Norden. Du 
bekommst also nichtmal Winkel raus, sondern eben die Projektionen dieses 
Vektors auf das Koordinatensystem, und daraus müsste man die Winkel 
erstmal errechnen, und dann noch richtig hindrehen (bzw. andersrum). *
Wenn man ein paar Werte mittelt, ist der Jitter aber ~1 Grad. Ich hab 
mal ein paar Objekte in Blender damit gedreht, das geht recht flüssig 
(bis darauf, dass die Winkel halt alle total komisch und falsch sind).

Zum eigentlichen Problem: Sendest Du denn keine Konfiguration an das 
Ding? Ich weiß nicht, was das tut, wenn Du alle Steuer-Register nicht 
initialisierst. Hier ist jedenfalls mal das, was ich mache (auf dem 
Raspberry Pi, deshalb ein bisschen mehr High-Level):

#include <errno.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <i2c-dev.h>
#include <i2cbusses.h>
#include <util.h>

int main()
{
    int res, file;
    char filename[20] = "/dev/i2c-0";
    int axis = 0, byte = 0, count = 0;
    
    file = open_i2c_dev(0, filename, 0);
    set_slave_addr(file, 0x0e, 0);
    
    //                   DR(3)             OS(2)         FR(1)
    unsigned char reg0 = (0b000 << 5) + (0b00 << 3) +   (0 << 2)
    //                   TRIG(1)    ACT(1)
                        + (0 << 1) + (1 << 0);
    //                   ARST(1)   Res(1)  RAW(1)      RST(1)   Res(4)
    unsigned char reg1 = (0b1 << 7) +     (0b0 << 5) + (0b0 << 4);
    i2c_smbus_write_byte_data(file, 0x10, reg0);
    i2c_smbus_write_byte_data(file, 0x11, reg1);
    
    // x, y, z offset
    i2c_smbus_write_byte_data(file, 0x09, 0);
    i2c_smbus_write_byte_data(file, 0x0A, 0);
    i2c_smbus_write_byte_data(file, 0x0B, 0);
    i2c_smbus_write_byte_data(file, 0x0C, 0);
    i2c_smbus_write_byte_data(file, 0x0D, 0b11110110);
    i2c_smbus_write_byte_data(file, 0x0E, 0b11111111);
    
    float fullScale = 925.0;
    
    while ( 1 ) {
        count++;
        res = i2c_smbus_read_byte_data(file, 0x00);
        if ( res != 0xff )
            continue;
        for ( axis = 0; axis < 3; axis++ ) {
            int value = 0;
            for ( byte = 0; byte <= 1; byte++ ) {
                value += i2c_smbus_read_byte_data(file, axis*2 + 1 + byte) << (1-byte)*8;
            }
            if ( value >= (1 << 15) ) {
                value -= 1 << 16;
            }
            printf("%i ", (int) ( value / fullScale ));
        }
        printf("\n");
        fflush(stdout);
    }
    exit(0);
}

Als Slave Address habe ich irgendwie 0x0e, das ist anders als bei Dir, 
oder?

Grüße,
Sven

_______

* P.S.: Wenn jemand Code dafür hat, den nehme ich gern! :D

[Andy (Gast)]

Hab auch schon probiert, vorher die register zu konfigurieren, leider 
kann ich ja ned mit dem Baustein sprechen, was die sache erschwert;:).

Die Adresse ist 0x0E, hab ich auch. Du betreibst den baustein alleine am 
bus oder?

Ich werds morgen auch mal mitn raspberry pi ausprobieren, vielleicht 
gehts so.

Aber weshalb mein ACK bei halb Vcc liegt weiss keiner oder?
Deshalb funzt die kommunikation leider nicht.

[Sven B. (scummos)]

Ah, du hast ein Raspberry Pi? Das ist ja günstig, dann kannst du ja 
einfach mal meinen Code probieren. Wenn's damit funktioniert, wissen wir 
immerhin, ob es an der Software oder an der Hardware liegt.

Der Baustein ist bei mir allein am Bus, ja.

Wegen des ACK habe ich leider überhaupt keine Ahnung.

Im Anhang der Code mit Makefile und so.

[Andy (Gast)]

Jep, werd ich morgen dann mal ausprobieren. Sobald ich mehr weiss, werd 
ich meine Erkenntnise morgen dann posten.

[Andy S. (andy87)]

Also ich hab das Problem gelöst, wobei die Lösung schon sehr komisch 
ist.

Hab jetzt 14,7k Pullups drin, jetzt liegt der Pegel des ACK endlich bei 
<0,3VCC.

Entweder ist auf dem Board ein riesen Serienwiederstand drin, oder der 
Open-Kollektor Transister des MAG3110 kann den Transistor nicht komplett 
durchschalten, wobei ich nicht weiss warum und weshalb er das nicht 
machen sollte.

Mit FAST-I2C wirds dann wahrscheinlich nichts mehr bei den Pullups:).

[Sven B. (scummos)]

Ich hab das Ding genau so aufgebaut wie im Datenblatt beschrieben [1] 
und bei mir funktioniert es anstandslos. Weiß ich dann auch nicht. ;)

___
[1] Foto: 
http://2.bp.blogspot.com/-ymnNCx3JuYI/ULF1COlw4kI/AAAAAAAAAPw/BSSYQvIiNZ4/s1600/magnetometer_front.jpg