Sensorkommunikation I2C - Atmega32

[JP (Gast)]

Hallo Leute :)

Ich beschäftige mich zurzeit damit, über TWI (I2C) mit einem Sensor zu 
kommunizieren. Jedoch komme ich nicht so wirklich klar damit. Die 
gesamte Kommunikation soll später über 3 Funktionen (TWI_initTWI, 
TWI_ReceiveData und TWI_SendData) erfolgen. Hierfür möchte ich gerne die 
Nebenfunktionen in die Receive und Send Funktion einbauen, jedoch klappt 
das nicht so recht. Könnt Ihr mir evtl weiterhelfen und sagen, wo meine 
Fehler liegen?

Hier der Code:
/*********************************************************************** 
********
*Funktion       void TWI_InitTWI_v(uint8_t BitRate, uint8_t 
PrescalerHighBit, uint8_t PrescalerLowBit)
*
*Beschreibung   Initialiesiert das TWI-Modul des Mikrocontrollers
*
*Parameter    BitRate: Bitrate die im Register TWBR eingestellt werden 
soll
*        PrescalerHighBit:  Wert der fuer TWPS1 eingestellt werden soll
*        PrescalerLowBit:  Wert der fuer TWPS0 eingestellt werden soll
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_InitTWI(uint8_t BitRate, uint8_t PrescalerHighBit, uint8_t 
PrescalerLowBit)
{
  // TWIFrequenz auswaehlen freq= F_CPU/(16+2(TWBR)*4^TWPS)
  TWBR=BitRate;                        //Bitrate setzen
  TWSR=(PrescalerHighBit<<TWPS1)|(PrescalerLowBit<<TWPS0);    // Setzen 
der prescalar bits
}


/*********************************************************************** 
********
*Funktion       void TWI_StartCondition(void)
*
*Beschreibung   Sendet eine Startbedingung fuer eine TWI Kommunikation
*
*Parameter    keine
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_StartCondition(void)
{
  // Setzt TWI interrupt flag zurueck, legt Startbedingung an SDA, 
Enable TWI
  TWCR= (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  while(!(TWCR & (1<<TWINT))); // wartet bis die Startbedingung gesendet 
ist
  while((TWSR & 0xF8)!= 0x08); // prueft acknowledgement
}

/*********************************************************************** 
********
*Funktion       void TWI_RepeatedStartCondition(void)
*
*Beschreibung   Sendet eine erneute Startbedingung
*
*Parameter    keine
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_RepeatedStartCondition(void)
{
  // Setzt TWI interrupt flag zurueck, legt Startbedingung an SDA, 
Enable TWI
  TWCR= (1<<TWINT)|(1<<TWSTA)|(1<<TWEN);
  while(!(TWCR & (1<<TWINT))); // wartet bis die Startbedingung gesendet 
ist
  while((TWSR & 0xF8)!= 0x10); // prueft acknowledgement
}


/*********************************************************************** 
********
*Funktion       void TWI_SendAddress(uint8_t Adress, uint8_t Direction)
*
*Beschreibung   Sendet die Slave Adresse, ob anschließend gelesen oder 
geschriben werden soll und wartet ACK ab
*
*Parameter    Adress:  Adresse des Slaves im 8-Bit Format (letztes Bit 
egal)
*        Direction: Read=1; Write=0
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_SendAddress(uint8_t Adress, uint8_t Direction)
{
  if (Direction==0)
  {
    Adress&=0xFE;
  }
  else
  {
    Adress|=0x01;
  }
  TWDR=Adress;          // Addresse and Richtung senden
  TWCR=(1<<TWINT)|(1<<TWEN);    // Setzt TWI interrupt flag zurueck, 
Enable TWI
  while (!(TWCR & (1<<TWINT)));  // wartet bis TWDR uebertragen ist
  if (Direction==0)
  {
    while((TWSR & 0xF8)!= 0x18);  // prueft acknoledgement fuer lesen
  }
  else
  {
    while((TWSR & 0xF8)!= 0x40);  // prueft acknoledgement fuer 
schreiben
  }

}


/*********************************************************************** 
********
*Funktion       void TWI_WriteData(uint8_t char Data)
*
*Beschreibung   Sendet 8-Bit Daten und wartet auf ACK
*
*Parameter    Data: 8-Bit Daten, die gesendet werden sollen
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_WriteData(uint8_t Data)
{
  TWDR=Data;            // legt Data ins Senderegister
  TWCR=(1<<TWINT)|(1<<TWEN);    // Setzt TWI interrupt flag zurueck, 
Enable TWI
  while (!(TWCR & (1<<TWINT)));  // wartet bis TWDR uebertragen ist
  while((TWSR & 0xF8) != 0x28);  // prueft acknoledgement
}

/*********************************************************************** 
********
*Funktion       uint8_t TWI_ReadData(void)
*
*Beschreibung   Empfaengt 8-Bit Daten ueber TWI
*
*Parameter    keine
*
*Rueckgabe      8Bit Daten
*
************************************************************************ 
*******/
uint8_t TWI_ReadData(void)
{
  uint8_t ReciveData;        //Variable fuer die empfangenden Daten
  TWCR=(1<<TWINT)|(1<<TWEN);    // Setzt TWI interrupt flag zurueck, 
Enable TWI
  while (!(TWCR & (1<<TWINT)));  // wartet bis das TWDR-Byte 
uebermittelt wurde
  while((TWSR & 0xF8) != 0x58);  // prueft acknoledgement
  ReciveData=TWDR;        // liest TWDR-Byte aus
  return (ReciveData);      // Rueckgabe der Daten
}

/*********************************************************************** 
********
*Funktion       void TWI_StopCondition(void)
*
*Beschreibung   Sendet Stopp-Bedingung nach TWI-Kommunikation
*
*Parameter    keine
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_StopCondition(void)
{
  // Setzt TWI interrupt flag zurueck, legt Stoppbedingung an SDA, 
Enable TWI
  TWCR= (1<<TWINT)|(1<<TWEN)|(1<<TWSTO);
  while(!(TWCR & (1<<TWSTO)));  // wartet bis Stoppbedingung 
uebermittelt wurde
}

/*********************************************************************** 
********
*Funktion       void TWI_SendData(uint8_t SlaveAdress, uint8_t 
RegisterAdress, uint8_t Data)
*
*Beschreibung   Schreibt Daten ins das abgegebene Register des Slaves 
mit der angegebenen Adresse
*
*Parameter    SlaveAdress:  Adresse des Slaves, der angesprochen werden 
soll
*        Registeradress:  Register, in das geschrieben werden soll
*        Data:      Daten, die in das Register geschrieben werden sollen
*
*Rueckgabe      keine
*
************************************************************************ 
*******/
void TWI_SendData(uint8_t SlaveAdress, uint8_t RegisterAdress, uint8_t 
Data)
{
  /*Funktion mit Hilfe der oben gegeben Funktionen schreiben*/
  TWI_StartCondition();
  TWI_SendAddress(SlaveAdress, RegisterAdress);
  TWI_WriteData(Data);
  TWI_WriteData(Data);
  TWI_StopCondition();
}

/*********************************************************************** 
********
*Funktion       uint8_t TWI_ReciveData(uint8_t SlaveAdress, uint8_t 
RegisterAdress)
*
*Beschreibung   Empfaengt Daten des Slaves, welche unter der angebenen 
Registeradresse zu finden sind
*
*Parameter    SlaveAdresse:  Adresse des angeschlossenen Slaves im 8-Bit 
Format
*        RegisterAdress: Adresse des Registers, das gelesen werden soll
*
*Rueckgabe      8-Bit Daten
*
************************************************************************ 
*******/
uint8_t TWI_ReciveData(uint8_t SlaveAdress, uint8_t RegisterAdress)
{
  /*Funktion mit Hilfe der oben gegeben Funktionen schreiben*/
  TWI_StartCondition();
  TWI_SendAddress(SlaveAdress, RegisterAdress);
  TWI_ReadData();
  TWI_RepeatedStartCondition();
  TWI_StopCondition();
}

Ich hoffe, dass mir jemand weiterhelfen kann :)
LG

[spess53 (Gast)]

Hi

Du solltest dich mal über I2C schlau machen:

http://www.nxp.com/documents/user_manual/UM10204.pdf

uint8_t TWI_ReciveData(uint8_t SlaveAdress, uint8_t RegisterAdress)
{
  /*Funktion mit Hilfe der oben gegeben Funktionen schreiben*/
  TWI_StartCondition();
  TWI_SendAddress(SlaveAdress, RegisterAdress);
  TWI_ReadData();
  TWI_RepeatedStartCondition();
  TWI_StopCondition();
}

Wie passt z.B.

TWI_SendAddress(SlaveAdress, RegisterAdress);

mit

void TWI_SendAddress(uint8_t Adress, uint8_t Direction)

zusammen?

Und was soll das TWI_RepeatedStartCondition(); in dem Code?

...


MfG Spess

[Stefan F. (Gast)]

Ich mach das alles mit einer einzigen Funktion. Diese Idee habe ich von 
einer Java implementierung (Lejos) abgeguckt. Dort wird sie im Bereich 
Robotics verwendet und hat sich bewährt:

//========================================================================
// I2C Bus
//========================================================================
// Wenn der I2C Bus nicht verwendet wird, stehen dessen Pins als reguläre
// I/O Pins zur Verfügung. Pull-Up Widerstände nicht vergessen!

// Sendet beliebig viele Bytes an den adressierten Slave und empfängt
// anschließend beliebig viele Bytes von dem Slave. 

// slave_address ist die Adresse des Slave in 7bit Schreibweise (0-127).
// send_data zeigt auf die zu sendenden Daten, z.B. ein Array von Bytes. 
// send_bytes gibt an, wieviele Bytes gesendet werden sollen.
// rcv_data zeigt auf einen Puffer, wo die empfangenen Daten abgelegt 
// werden sollen, z.B. ein Array von Bytes. 
// rcv_Bytes gibt an, wieviele Bytes empfangen werden sollen.
// Der Rückgabewert zeigt an, wie viele Bytes tatsächlich empfangen wurden.

// Wenn man nur senden will, gibt man rcv_data=0 und rcv_bytes=0 an.
// Wenn man nur empfangen will, gibt man send_data=0 und send_bytes=0 an.
// Es ist erlaubt, bei send_bytes und rcv_bytes Zeiger auf den selben 
// Puffer zu übergeben.

uint8_t i2c_communicate(uint8_t slave_address, void* send_data, uint8_t send_bytes, void* rcv_data, uint8_t rcv_bytes) {
    uint8_t rcv_count=0;
            
    // Adresse ein Bit nach links verschieben, um Platz für das r/w Flag zu schaffen
    slave_address=slave_address<<1;
           
    if (send_bytes>0) {
        // Sende Start 
        TWCR=(1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
        while (!(TWCR & (1<<TWINT)));
        uint8_t status=TWSR & 0xf8;
        if (status != 0x08 && status != 0x10) goto error;
    
        // Sende Adresse (write mode)
        TWDR=slave_address;
        TWCR=(1<<TWINT) | (1<<TWEN);
        while (!(TWCR & (1<<TWINT)));
        if ((TWSR & 0xf8) != 0x18) goto error;
        
        // Sende Daten
        while (send_bytes>0) {
            TWDR=*((uint8_t*)send_data);
            TWCR=(1<<TWINT) | (1<<TWEN);
            while (!(TWCR & (1<<TWINT)));
            if ((TWSR & 0xf8) != 0x28) goto error;
            send_data++;
            send_bytes--;
        }
    }
    
    if (rcv_bytes>0) { 
        // Sende START
        TWCR=(1<<TWINT) | (1<<TWEN) | (1<<TWSTA);
        while (!(TWCR & (1<<TWINT)));
        uint8_t status=TWSR & 0xf8;
        if (status != 0x08 && status != 0x10) goto error;
        
        // Sende Adresse (read mode)
        TWDR=slave_address + 1;
        TWCR=(1<<TWINT) | (1<<TWEN);
        while (!(TWCR & (1<<TWINT)));
        if ((TWSR & 0xf8) != 0x40) goto error;
    
        // Empfange Daten
        while (rcv_bytes>0) {    
            if (rcv_bytes==1) {
                // das letzte Byte nicht mit ACK quittieren
                TWCR=(1<<TWINT) | (1<<TWEN); 
            } 
            else {   
                // alle anderen Bytes mit ACK quittieren
                TWCR=(1<<TWINT) | (1<<TWEN) | (1<<TWEA);
            }
            while (!(TWCR & (1<<TWINT)));
            uint8_t status=TWSR & 0xf8;
            if (status!=0x50 && status != 0x58) goto error;
            *((uint8_t*)rcv_data)=TWDR;
            rcv_data++;
            rcv_bytes--;
            rcv_count++;
        }

    }
    
    // Sende STOP
    TWCR=(1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
    return rcv_count;

    error:
    // Sende STOP
    TWCR=(1<<TWINT) | (1<<TWEN) | (1<<TWSTO);
    return 0;
}

Was da noch fehlt, ist die Initialisierung der Bitrate:

    // TWI Interface ungefähr 100kbit/section, bei 15Mhz
    TWBR=75;

[JP (Gast)]

ich werde es mal so probieren vielen Dank :)