STM32F4 I2C immer busy

[Patrick B. (p51d)]

Hallo miteinander

Ich möchte ein wenig mit dem I2C der STM-Familie herumspielen, aber 
bisher leider ohne Erfolg. Beim Versuch etwas zu senden oder Empfangen 
ist das Modul immer busy, ohne das etwas gemacht wird.
Ich habe mich nun schon seit 3 Tagen an diesem ding generft. Vieleicht 
fällt einem ja auf, was falsch ist:

void HMC5883L_init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    I2C_InitTypeDef I2C_InitStructure;

    // write CONFIG_A register
    uint8_t tmp = (HMC5883L_AVERAGING_8 << (HMC5883L_CRA_AVERAGE_BIT - HMC5883L_CRA_AVERAGE_LENGTH + 1)) |
                  (HMC5883L_RATE_15 << (HMC5883L_CRA_RATE_BIT - HMC5883L_CRA_RATE_LENGTH + 1)) |
                  (HMC5883L_BIAS_NORMAL << (HMC5883L_CRA_BIAS_BIT - HMC5883L_CRA_BIAS_LENGTH + 1)) ;

    // Enable clock
    RCC_APB1PeriphClockCmd(HMC5883L_I2C_RCC_Periph, ENABLE);
    RCC_AHB1PeriphClockCmd(HMC5883L_I2C_RCC_Port, ENABLE);

    // Performing a Reset
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
    RCC_APB1PeriphResetCmd(HMC5883L_I2C_RCC_Periph, ENABLE);
    RCC_APB1PeriphResetCmd(HMC5883L_I2C_RCC_Periph, DISABLE);

    // Connect Pins to AF function
    GPIO_PinAFConfig(HMC5883L_I2C_Port, HMC5883L_I2C_SCL_Pin, HMC5883L_I2C_SCL_AF);
    GPIO_PinAFConfig(HMC5883L_I2C_Port, HMC5883L_I2C_SDA_Pin, HMC5883L_I2C_SDA_AF);

    // Configure I2C SCL Pin(Pin10), SDA Pin (pin11)
    GPIO_InitStructure.GPIO_Pin = HMC5883L_I2C_SCL_Pin | HMC5883L_I2C_SDA_Pin;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
    GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
    GPIO_Init(HMC5883L_I2C_Port, &GPIO_InitStructure);

    // Configure I2C
    I2C_DeInit(HMC5883L_I2C);
    I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;                  // I2C mode
    I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;              // 50% duty cycle -> standard
    I2C_InitStructure.I2C_OwnAddress1 = 0;                    // not relevant in master mode
    I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
    I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;  // Set address length to 7 bit addresses
    I2C_InitStructure.I2C_ClockSpeed = I2C_SPEED;
    I2C_Init(HMC5883L_I2C, &I2C_InitStructure);

    /*ENABLE*/
    I2C_Cmd(HMC5883L_I2C, ENABLE);

    HMC5883L_I2C_ByteWrite(HMC5883L_DEFAULT_ADDRESS, &tmp ,HMC5883L_RA_CONFIG_A); // <== Hier hängt er sich auf
}

void HMC5883L_I2C_ByteWrite(uint8_t slaveAddr, uint8_t* pBuffer, uint8_t WriteAddr)
{
// Diese Schlaufe wird nie verlassen
  while(I2C_GetFlagStatus(HMC5883L_I2C, I2C_FLAG_BUSY));      // wait until I2C is not busy anymore

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

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

  /* Send HMC5883 address for write */
  I2C_Send7bitAddress(HMC5883L_I2C, slaveAddr, I2C_Direction_Transmitter);

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

  /* Send the HMC5883L internal address to write to */
  I2C_SendData(HMC5883L_I2C, WriteAddr);

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

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

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

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

Testweise habe ich die I2C-Lib etwas angepasst:

FlagStatus I2C_GetFlagStatus(I2C_TypeDef* I2Cx, uint32_t I2C_FLAG)
{
  FlagStatus bitstatus = RESET;
  __IO uint32_t i2creg = 0, i2cxbase = 0;
uint32_t SR1 = 0, SR2 = 0;
  /* Check the parameters */
  assert_param(IS_I2C_ALL_PERIPH(I2Cx));
  assert_param(IS_I2C_GET_FLAG(I2C_FLAG));

  /* Get the I2Cx peripheral base address */
  i2cxbase = (uint32_t)I2Cx;
  
  /* Read flag register index */
  i2creg = I2C_FLAG >> 28;
  
  /* Get bit[23:0] of the flag */
  I2C_FLAG &= FLAG_MASK;
  
  if(i2creg != 0)
  {
    /* Get the I2Cx SR1 register address */
    i2cxbase += 0x14;
  }
  else
  {
    /* Flag in I2Cx SR2 Register */
    I2C_FLAG = (uint32_t)(I2C_FLAG >> 16);
    /* Get the I2Cx SR2 register address */
    i2cxbase += 0x18;
  }
SR1 = (*(__IO uint32_t *) (i2cxbase - 0x18 + 0x14));
SR2 = (*(__IO uint32_t *)i2cxbase);
  if(((*(__IO uint32_t *)i2cxbase) & I2C_FLAG) != (uint32_t)RESET)
  {
    /* I2C_FLAG is set */
    bitstatus = SET;
  }
  else
  {
    /* I2C_FLAG is reset */
    bitstatus = RESET;
  }
  
  /* Return the I2C_FLAG status */
  return  bitstatus;
}

SR1 = 0;
SR2 = 2; -> Busy Flag ist gesetzt

Was habe ich falsch gemacht?

Besten Dank für die Hilfe
MFG
Patrick

[dein Lehrer (Gast)]

Patrick B. schrieb:
> ding generft. Vieleicht
> fällt einem ja auf, was falsch ist:

richtig wäre
Ding genervt. Vielleicht

[frame (Gast)]

Hast du schon einmal nachgemessen, was auf dem Bus passiert ?
Ein Oszilloskop ist hier sehr hilfreich.

Zumindest statisch sollten die Pegel stimmen. I2C ist ein Open-Drain 
Bus, das ist dir schon bewußt. Sprich, du brauchst einen 
Pullup-Widerstand. Fehlt der, ist der Bus auch immer "busy".
Und wenn das alles in Ordnung ist: manchmal starten diverse I2C-Slaves 
nicht korrekt, weil sie irgendeine Störung als Bussignal bewerten. Dann 
kann es helfen, auf SCL 9 Taktimpulse auszugeben, damit der Slave SDA 
wieder freigibt. Dazu müßtest du die I2C-Pins als GPIO betreiben.