I2C mit STM32 und ITG3200 Sensor will nicht loslegen

[Cell85 (Gast)]

Hi,

ich hab einen STM32 F103ZE mit 16mhz quarz statt 8 - ist aber alles 
eigentlich soweit richtig beachtet und konfiguriert (siehe screenshot 
"clocks").

Ich versuche gerade via I2C einen ITG3200 auszulesen.

Leider hängt es beim debuggen bzw. ausführen immer bei

/* Test on EV5 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_MODE_SELECT));

(siehe screenshot 1.jpg)

Ich weiß nicht woran das liegen mag. Ehrlich gesagt, ist es auch das 
erste mal das ich mit dem I2C an einem STM32 arbeite.

Hier mein Code für den I2C

/******************************************************************************/
/* IRG3200_1.C: GYRO                                     */
/*Info: Gyro1 und 2 an I2C-1 und I2C-2; Accel1 und 2 an SPI1 und SP2;       */
/*Gyro I2C Adresse: bin: 1101000  hex: 0x68                                   */
/******************************************************************************/

/* Includes */
#include "ITG3200_1.h"
#include "stm32f10x.h"
#include "misc.h"


float gyr_adj[3]={0};//ITG 0-bias

/**
* @defgroup ITG
* @{
*/

/** @defgroup ITG_I2C_Function
* @{
*/

/**
* @brief  Initializes the I2C peripheral used to drive the ITG
* @param  None
* @retval None
*/
void ITG_I2C_Init(void)
{
  I2C_InitTypeDef  I2C_InitStructure;
  GPIO_InitTypeDef GPIO_InitStructure;

  /* Enable I2C and GPIO clocks */
  RCC_APB1PeriphClockCmd(ITG_I2C_RCC_Periph, ENABLE);
  RCC_APB2PeriphClockCmd(ITG_I2C_RCC_Port, ENABLE);

  /* Configure I2C pins: SCL and SDA */
  GPIO_InitStructure.GPIO_Pin =  ITG_I2C_SCL_Pin | ITG_I2C_SDA_Pin;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
  GPIO_Init(ITG_I2C_Port, &GPIO_InitStructure);

  /* I2C configuration */
  I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  I2C_InitStructure.I2C_OwnAddress1 = 0x00;
  I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure.I2C_ClockSpeed = ITG_I2C_Speed;

  /* Apply I2C configuration after enabling it */
  I2C_Init(ITG_I2C, &I2C_InitStructure);

  /* I2C Peripheral Enable */
  I2C_Cmd(ITG_I2C, ENABLE);
}

/**
* @brief  Writes one byte to the  ITG.
* @param  slAddr : slave address ITG_A_I2C_ADDRESS or ITG_M_I2C_ADDRESS
* @param  pBuffer : pointer to the buffer  containing the data to be written to the ITG.
* @param  WriteAddr : address of the register in which the data will be written
* @retval None
*/
void ITG_I2C_ByteWrite(u8 slAddr, u8* pBuffer, u8 WriteAddr)
{
  /* Send START condition */
  I2C_GenerateSTART(ITG_I2C, ENABLE);

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_MODE_SELECT));

  /* Send ITG address for write */
  I2C_Send7bitAddress(ITG_I2C, slAddr, I2C_Direction_Transmitter);

  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));

  /* Send the ITG internal address to write to */
  I2C_SendData(ITG_I2C, WriteAddr);

  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));

  /* Send the byte to be written */
  I2C_SendData(ITG_I2C, *pBuffer);

  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));

  /* Send STOP condition */
  I2C_GenerateSTOP(ITG_I2C, ENABLE);
 
}

/**
* @brief  Reads a block of data from the ITG.
* @param  slAddr  : slave address ITG_A_I2C_ADDRESS or ITG_M_I2C_ADDRESS
* @param  pBuffer : pointer to the buffer that receives the data read from the ITG.
* @param  ReadAddr : ITG's internal address to read from.
* @param  NumByteToRead : number of bytes to read from the ITG ( NumByteToRead >1  only for the gyro readinf).
* @retval None
*/

void ITG_I2C_BufferRead(u8 slAddr, u8* pBuffer, u8 ReadAddr, u16 NumByteToRead)
{

  /* While the bus is busy */
  while(I2C_GetFlagStatus(ITG_I2C, I2C_FLAG_BUSY));

  /* Send START condition */
  I2C_GenerateSTART(ITG_I2C, ENABLE);

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_MODE_SELECT));

  /* Send ITG_Magn address for write */
  I2C_Send7bitAddress(ITG_I2C, slAddr, I2C_Direction_Transmitter);

  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED));

  /* Clear EV6 by setting again the PE bit */
  I2C_Cmd(ITG_I2C, ENABLE);

  /* Send the ITG_Magn's internal address to write to */
  I2C_SendData(ITG_I2C, ReadAddr);

  /* Test on EV8 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_BYTE_TRANSMITTED));

  /* Send STRAT condition a second time */
  I2C_GenerateSTART(ITG_I2C, ENABLE);

  /* Test on EV5 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_MODE_SELECT));

  /* Send ITG address for read */
  I2C_Send7bitAddress(ITG_I2C, slAddr, I2C_Direction_Receiver);

  /* Test on EV6 and clear it */
  while(!I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_RECEIVER_MODE_SELECTED));

  /* While there is data to be read */
  while(NumByteToRead)
  {
    if(NumByteToRead == 1)
    {
      /* Disable Acknowledgement */
      I2C_AcknowledgeConfig(ITG_I2C, DISABLE);

      /* Send STOP Condition */
      I2C_GenerateSTOP(ITG_I2C, ENABLE);
    }

    /* Test on EV7 and clear it */
    if(I2C_CheckEvent(ITG_I2C, I2C_EVENT_MASTER_BYTE_RECEIVED))
    {
      /* Read a byte from the ITG */
      *pBuffer = I2C_ReceiveData(ITG_I2C);

      /* Point to the next location where the byte read will be saved */
      pBuffer++;

      /* Decrement the read bytes counter */
      NumByteToRead--;
    }
  }

  /* Enable Acknowledgement to be ready for another reception */
  I2C_AcknowledgeConfig(ITG_I2C, ENABLE);

}

void ITG_Init(ITG_ConfigTypeDef *ITG_Config_Struct)
{
  u32 i=100000;
  GPIO_InitTypeDef GPIO_InitStructure;

  u8 FS_LPF=ITG_Config_Struct->FS | ITG_Config_Struct->LPFBandwidth;
    ITG_I2C_ByteWrite(ITG_I2C_ADDRESS,&(ITG_Config_Struct->ClkSel),ITG_POWERMANAGE_REG_ADDR);
  ITG_I2C_ByteWrite(ITG_I2C_ADDRESS,&(ITG_Config_Struct->SamRate),ITG_SR_DIVIDER_REG_ADDR);
  ITG_I2C_ByteWrite(ITG_I2C_ADDRESS,&FS_LPF,ITG_FULL_SCALE_REG_ADDR);
  ITG_I2C_ByteWrite(ITG_I2C_ADDRESS,&(ITG_Config_Struct->IntMode),ITG_INT_CONFIG_ADDR);
  while(i--);
//  RCC_APB2PeriphClockCmd(ITG_DRDY_RCC_Port, ENABLE);    //GPIOE
  GPIO_InitStructure.GPIO_Pin = ITG_DRDY_Pin ;     
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(ITG_DRDY_Port, &GPIO_InitStructure);

}

void ITG_Read_RawData(s16* out)
{
  u8 buffer[6];
  u8 testReady;
  u8 intStatus;
  u8 i;
  
  testReady = GPIO_ReadInputDataBit(ITG_DRDY_Port , ITG_DRDY_Pin);
  if(testReady == 0)
  {
    ITG_I2C_BufferRead(ITG_I2C_ADDRESS, &intStatus, ITG_INT_STATUS_REG_ADDR, 1);
    if(intStatus==0x01)
    {    
      ITG_I2C_BufferRead(ITG_I2C_ADDRESS, buffer, ITG_XOUT_H_ADDR, 6);
      for(i=0;i<3;i++)
      {
        out[i] = buffer[2*i] & 0x00ff;
        out[i] <<= 8;
        out[i] |= buffer[2*i+1];
      }
    }
  }
}

void ITG_Cali(void)
{
  s16 rawData[3];
  u16 i;
  u32 delay;
  for(i=0;i<500;i++)
  {
    ITG_Read_RawData(rawData);
    gyr_adj[0] += rawData[0];
    gyr_adj[1] += rawData[1];
    gyr_adj[2] += rawData[2];
    delay=1000;
    while(delay--);
  }
  for(i=0;i<3;i++)
  {
     gyr_adj[i] /= 500.0;
  }
}
/**
* @brief   Read ITG output register
* @param  out : buffer to store data
* @retval None
*/

void ITG_Read_GyroRate(float* out)
{
  s16 rawData[3];
  u8 i;
  float temp;
  ITG_Read_RawData(rawData);
  for(i=0;i<3;i++)
  {
    out[i]=-(float)(rawData[i]-gyr_adj[i])/5868.0;
  } 
   temp=out[0];
   out[0]=out[1];
   out[1]=temp;   
}

Hier die Defines für das I2C

/* Define to prevent recursive inclusion*/
#ifndef __HAL_ITG3200_1_H_
#define __HAL_ITG3200_1_H_

#ifdef __cplusplus
 extern "C" {
#endif 
  
/* Includes */
#include "stm32f10x.h"
#include "misc.h"

/**
* @addtogroup ITG3200 
* @{
*/

/**
* @addtogroup  ITG3200_I2C_Define
* @{
*/

#define ITG_I2C                  I2C2
#define ITG_I2C_RCC_Periph       RCC_APB1Periph_I2C2
#define ITG_I2C_Port             GPIOB
#define ITG_I2C_SCL_Pin          GPIO_Pin_10
#define ITG_I2C_SDA_Pin          GPIO_Pin_11
#define ITG_I2C_RCC_Port         RCC_APB2Periph_GPIOB
#define ITG_I2C_Speed            200000

/**
*@}
*/ /* end of group ITG3200_I2C_Define */ 

/**
* @addtogroup Gyro_DRDY_Pin_Define
* @{
*/

//#ifdef  ITG_DRDY_ENABLE
#define ITG_DRDY_Pin                   GPIO_Pin_3
#define ITG_DRDY_Port                  GPIOE
#define ITG_DRDY_RCC_Port              RCC_APB2Periph_GPIOE
#define ITG_DRDY_Port_Source           GPIO_PortSourceGPIOE
#define ITG_DRDY_Pin_Source            GPIO_PinSource3
#define ITG_DRDY_EXTI_Line             EXTI_Line3
#define ITG_DRDY_Edge                  EXTI_Trigger_Falling
#define ITG_DRDY_EXTI_IRQCHANNEL       EXTI3_5_IRQChannel
#define ITG_DRDY_Preemption_Priority   3    
#define ITG_DRDY_Sub_Priority          3    
//#endif

/**
* @}
*/ /* end of group ITG_DRDY_Pin_Define */

/**
 * @}
 */ /* end of group ITG */


#endif /* __HAL_ITG3200_H */

und die main

/**
  * IMU200 Basic Firmware Rednd-Sensors Only
  * 
  */  

/* Includes ------------------------------------------------------------------*/
#include "stm32f10x.h"
#include <stdio.h>
#include "setup.h"
#include "ITG3200_1.h"



int main (void)
{
  s16 gyroRate[3];
  SetupClock();
  SetupLED  ();
  IMU_Led1_Off();
  IMU_Led2_Off();
  
  //Gyro1
  
  ITG_I2C_Init();
  ITG_Config();
  IMU_Led1_On();   //IMU_Led2_On();
     
       
    while(1)    
    {                        
             ITG_Read_RawData(gyroRate); //Read Gyro
    }
    
   
}




#ifdef  USE_FULL_ASSERT

void assert_failed(uint8_t* file, uint32_t line)
{ 
/
  while (1)
  {
  }
}
#endif

[Cell85 (Gast)]

Vielleicht könnt ihr mir weiterhelfen.

Viele Grüße
Sven!

[holger (Gast)]

Versuchs mal so:

  RCC_APB2PeriphClockCmd(ITG_I2C_RCC_Port | RCC_APB2Periph_AFIO, 
ENABLE);

Und schau mal nach ob dein I2C evtl. remapped ist.

[Cell85 (Gast)]

Hi, danke für die Antwort.

Leider hat das nichts gebracht. Ich hab mal die Registerübersicht vom 
I2C angehängt.

Wenn ich Schritt für Schritt Debugge hab ich oft einen Fehler 
Errorstatus Flag vom SR1 und SR2
gemeldet aus der STM32 Std. Periph. Library.

Hmm. Remapped habe ich eigentlich nichts, es ist alles auf Standardt.


Viele Grüße
Sven

[holger (Gast)]

>Wenn ich Schritt für Schritt Debugge hab ich oft einen Fehler
>Errorstatus Flag vom SR1 und SR2
>gemeldet aus der STM32 Std. Periph. Library.

Das solltest du besser lassen mit dem debuggen. Schau mal ins
Errata Sheet von deinem STM32. Das I2C Modul
ist sowas von vergurkt;)

[Cell85 (Gast)]

schlecht ... aber irgendwie muss ich das hinbekommen :((

[holger (Gast)]

>schlecht ... aber irgendwie muss ich das hinbekommen :((

Mach Software I2C. Und das ist kein Witz.

[Cell85 (Gast)]

ich hab auch gerade bei CHR etwas mit dem itg3200 gesehen, die machen 
das tatsächlich. Hast du vielleicht ein Beispiel oder ein Link parat?

ansonsten versuch ich mal das hier:

was hällst du davon ?

http://um6firmware.svn.sourceforge.net/viewvc/um6firmware/trunk/UM6%20Firmware/CHR_i2c.c?revision=28&view=markup

[Cell85 (Gast)]

Ich hab auf meiner Platine keine Pullups für die I2C Leitung ist das 
sehr schlimm? Kann das Problem deswegen sein?

[Oliver J. (skriptkiddy)]

Cell85 schrieb:
> Ich hab auf meiner Platine keine Pullups für die I2C Leitung ist das
> sehr schlimm? Kann das Problem deswegen sein?
Die Pullups gehören bei I2C immer hin.

So 4,7k...10k

Gruß Oliver

[Cell85 (Gast)]

also die beim Application note von invensense haben 2,2k benutzt. um 
400khz zu schaffen, was jetzt nicht mein Ziel ist.
Jedenfalls kann ich mit bissl Geschick, den da dran löten :D

[Gerhard O. (gerhard_)]

holger schrieb:
>>Wenn ich Schritt für Schritt Debugge hab ich oft einen Fehler
>>Errorstatus Flag vom SR1 und SR2
>>gemeldet aus der STM32 Std. Periph. Library.
>
> Das solltest du besser lassen mit dem debuggen. Schau mal ins
> Errata Sheet von deinem STM32. Das I2C Modul
> ist sowas von vergurkt;)

Bei mir funktionieren beide I2C Peripherien auf einem STM32F103RB und 
VE6 einwandfrei. Hatte aber Anfangs wie Cell85 tolle Probleme damit.

Das Geheimnis ist dass man sich gewissenhaft an die "CheckEvent" EVn 
Zugriffe in der richtigen Reihenfolge wie im Referenz Manual beschrieben 
hält. Wenn man sich nicht genau daran hält dann benimmt sich der STM32 
ganz gemein.;-)

Für Experimentierzwecke habe ich mir eine einfache I2C Ueber-Library 
aufgebaut die z. T. auf Grundfunktionen der ST-Peripheral Lib Library 
3.5.0 zugreift.

Es stehen nun einfache I2C Baustein Funktionen zur Verfügung mit der es 
sich genauso leicht wie beim AVR oder PIC arbeiten lässt. Hier ein paar 
Beispiele:

i2c_start(I2Cx)

return_status = i2c_write7bitAddress(I2Cx, address, I2C_DIR_TX)

// I2C_DIR_TX steuert das SLAVE Address READ/WRITE bit
return_status = i2c_write7bitAddress(I2Cx, address, I2C_DIR_RX)

i2c_write(I2Cx, data);

data = i2c_read(I2Cx, ACK)

data = i2c_read(I2Cx, NO_ACK)

i2c_stop(I2Cx)


Hier ein Beispiel zum Lesen eines TMP101 Temperatursensor:

/**
 * @brief  Reads current TMP101 temperature value
 * @param  pointer to I2C bus, TMP101 slave address
 * @retval signed 16-bit tmp101 result
 */
s16 read_TMP101(I2C_TypeDef* I2Cx, u8 address)
{

u8 msb_data, lsb_data;
u16 temp=0;
s16 result = -15984; // Error value for sensor communications problem 
(-62.4 DEG C)

i2c_start(I2Cx); // Set I2C Start condition
// Check for timeout to detect missing or malfunctioning sensor
if(!i2c_write7bitAddress(I2Cx, address, I2C_DIR_TX))
{
    i2c_write(I2Cx, 0x00);  // Configuration register = read temperature
    i2c_start(I2Cx);        // Start Read sequence
    i2c_write7bitAddress(I2Cx, address, I2C_DIR_RX);
    // Read MSB/LSB data from TMP101 and assemble output word
    result = (s16) i2c_read(I2Cx, ACK) << 8;
    result += (s16) i2c_read(I2Cx, ACK);
    i2c_stop(I2Cx);
}
else
{
   i2c_stop(I2Cx);
}
return(result);
}


Aufruf Beispiel:

#define TMP101_SLAVE_ADR 0x94

temperature = read_TMP101(I2C1, TMP101_SLAVE_ADR)

I2C1 oder I2C2 ist in der ST Library definiert

Bei EEPROMs steht mir auch noch eine spezielle "Acknowledgement Poll" 
Funktion zur Verfuegung die nach Setzen des STOP bits periodisch (1ms) 
die ACK Antwort vom EEPROM pollt um auf das Ende des Schreibvorgangs zu 
warten. Dabei muss man aufpassen weil sich sonst die Peripherie 
aufhängt.

Man könnte das auch mit einem Interrupt machen. Zum Experimentieren mit 
I2C Bausteinen reicht der Funktionsumfang.

(Die ST I2C EEPROM Beispiele funktionieren zumindest bei mir nicht)

Mit "I2Cx" wird mit I2C1 oder I2C2 der entsprechende I2C Bus 
spezifiziert welche in den ST Libs definiert sind.

Bis jetzt habe ich damit erfolgreich bei 400kHz auf beiden I2C Bussen 
mit den folgenden I2C Bausteinen gearbeitet:

24C08, 24C1024, TMP101, LM75, AD5245, AD5243


mfg,
Gerhrad

[Cell85 (Gast)]

Das hört sich cool an!

Meinst du, du könntest mir deine "über-Lib" zur Verfügung stellen ? :-D

Ich werde jetzt erstmal versuchen Pullups dran zu löten, das wird eine 
Friemelarbeit  :((

Gruß
Sven

[Gerhard O. (gerhard_)]

Hallo Sven,

im Anhang findest Du eine funktionierende I2C Test Version mit einem 
TMP101 als externen Baustein.

Beide I2C Peripheren sind aktiv und sofort verwendbar.

Wenn Du einen andere Tool Chain verwendest wirst Du gewisse Sachen 
selber anpassen müssen.

Hoffe es hilf Dir. Viel Erfolg mit Deinem Projekt.!

mfg,
Gerhard


Cell85 schrieb:
> Das hört sich cool an!
>
> Meinst du, du könntest mir deine "über-Lib" zur Verfügung stellen ? :-D
>
> Ich werde jetzt erstmal versuchen Pullups dran zu löten, das wird eine
> Friemelarbeit  :((
>
> Gruß
> Sven

[Cell85 (Gast)]

Vielen Dank Gerhard!

Ich habe jetzt auch mall den Pull up von einem Sensor angelötet und er 
scheint zu funktionieren.

Das was sich da aber ST mit dem I2C geleistet hat ist echt eine heftige 
Wurst!

[Gerhard O. (gerhard_)]

Cell85 schrieb:
> Vielen Dank Gerhard!
>
> Ich habe jetzt auch mal den Pull up von einem Sensor angelötet und er
> scheint zu funktionieren.
>
Bei mir habe ich 2K dran weil 5 verschiedene I2C Bausteine am Bus 
haengen. Mit 3.9K dauert die Vorderflanke deutlich länger. Bei 400kHz 
habe ich allerdings noch keine Probleme gehabt.

> Das was sich da aber ST mit dem I2C geleistet hat ist echt eine heftige
> Wurst!

Ja, da gebe ich Dir recht. Die Errata sind tatsächlich 
"katastrophfuerchterbar";-) Bin nur froh dass die I2C Schnittstelle 
trotzdem brauchbar ist.

Gruß,
Gerhard