STM32: Busy-Flag wird nach I2C-Initialisierung gesetzt

Meiner Meinung nach sollte STM32CubeMX-Code nicht als fertiger Code betrachtet werden, sondern als Beispiel, mit dem Sie beginnen können. Bei den meisten Mikrocontrollern funktioniert es, aber es gibt einige seltene Fälle, in denen es nicht so ist.

Wenn Sie wissen, dass es nicht funktioniert und Sie die Lösung auch gefunden haben, müssen Sie sich nicht an den ursprünglichen Code halten. In Ihrem Fall können Sie den __HAL_RCC_I2C1_CLK_ENABLE()Aufruf nach der GPIO-Initialisierung weglassen und den davor belassen. Wenn es funktioniert und Sie gesagt haben, dass es funktioniert, dann verwenden Sie den funktionierenden Weg. Auch die Software von ST kann Fehler enthalten.

Sie verwenden ein offizielles Board, daher sollte die Hardware in Ordnung sein, aber Sie können überprüfen, ob die Pull-up-Widerstandswerte korrekt sind. Oder wenn ein Slave-Gerät während der Initialisierung etwas tut.

Am besten führen Sie Ihren Code so aus, dass alles von der Discovery getrennt ist (abgesehen von den Pullups), und überprüfen Sie, ob er immer noch beschäftigt ist. Wenn ja, ist es in Ordnung, wenn Sie diese Zeile im generierten Code ersetzen. Es ist keine so große Modifikation.

Leider gibt es kein I2C-Beispiel im STM32CubeF1- Beispielpaket (dies ist nicht der Codegenerator) unter STM32Cube_FW_F1_V1.4.0\Projects\STM32VL-Discovery\Examples. Aber wenn Sie die MspInitFunktionen des UART oder SPI überprüfen. Die Uhren werden in beiden vor dem GPIO init aktiviert .

void HAL_SPI_MspInit(SPI_HandleTypeDef *hspi)
{
  GPIO_InitTypeDef  GPIO_InitStruct;

  if (hspi->Instance == SPIx)
  {
    /*##-1- Enable peripherals and GPIO Clocks #################################*/
    /* Enable GPIO TX/RX clock */
    SPIx_SCK_GPIO_CLK_ENABLE();
    SPIx_MISO_GPIO_CLK_ENABLE();
    SPIx_MOSI_GPIO_CLK_ENABLE();
    /* Enable SPI clock */
    SPIx_CLK_ENABLE();

    /*##-2- Configure peripheral GPIO ##########################################*/
    /* SPI SCK GPIO pin configuration  */
    GPIO_InitStruct.Pin       = SPIx_SCK_PIN;
    GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
    GPIO_InitStruct.Pull      = GPIO_PULLDOWN;
    GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(SPIx_SCK_GPIO_PORT, &GPIO_InitStruct);

void HAL_UART_MspInit(UART_HandleTypeDef *huart)
{  
  GPIO_InitTypeDef  GPIO_InitStruct;

  /*##-1- Enable peripherals and GPIO Clocks #################################*/
  /* Enable GPIO TX/RX clock */
  USARTx_TX_GPIO_CLK_ENABLE();
  USARTx_RX_GPIO_CLK_ENABLE();


  /* Enable USARTx clock */
  USARTx_CLK_ENABLE(); 

  /*##-2- Configure peripheral GPIO ##########################################*/  
  /* UART TX GPIO pin configuration  */
  GPIO_InitStruct.Pin       = USARTx_TX_PIN;
  GPIO_InitStruct.Mode      = GPIO_MODE_AF_PP;
  GPIO_InitStruct.Pull      = GPIO_PULLUP;
  GPIO_InitStruct.Speed     = GPIO_SPEED_FREQ_HIGH;

  HAL_GPIO_Init(USARTx_TX_GPIO_PORT, &GPIO_InitStruct);

Also ich finde deine Lösung völlig in Ordnung.

Hier ist ein Code, der Ihnen helfen könnte. Im Grunde ist es eine Realisierung des Errata-Blatts (Abschnitt 2.14.7), das in einer früheren Antwort erwähnt wurde. Ich verwende die HAL-Bibliothek, und es gibt einige Verweise auf die Header-Definitionen des IKS01A1-Treibers (mein Peripheriegerät mit dem Problem war der Kreisel auf dieser Platine).

/* USER CODE BEGIN 1 */
/**
1. Disable the I2C peripheral by clearing the PE bit in I2Cx_CR1 register.
2. Configure the SCL and SDA I/Os as General Purpose Output Open-Drain, High level
(Write 1 to GPIOx_ODR).
3. Check SCL and SDA High level in GPIOx_IDR.
4. Configure the SDA I/O as General Purpose Output Open-Drain, Low level (Write 0 to
GPIOx_ODR).
5. Check SDA Low level in GPIOx_IDR.
6. Configure the SCL I/O as General Purpose Output Open-Drain, Low level (Write 0 to
GPIOx_ODR).
7. Check SCL Low level in GPIOx_IDR.
8. Configure the SCL I/O as General Purpose Output Open-Drain, High level (Write 1 to
GPIOx_ODR).
9. Check SCL High level in GPIOx_IDR.
10. Configure the SDA I/O as General Purpose Output Open-Drain , High level (Write 1 to
GPIOx_ODR).
11. Check SDA High level in GPIOx_IDR.
12. Configure the SCL and SDA I/Os as Alternate function Open-Drain.
13. Set SWRST bit in I2Cx_CR1 register.
14. Clear SWRST bit in I2Cx_CR1 register.
15. Enable the I2C peripheral by setting the PE bit in I2Cx_CR1 register.
**/
void HAL_I2C_ClearBusyFlagErrata_2_14_7(I2C_HandleTypeDef *hi2c) {

    static uint8_t resetTried = 0;
    if (resetTried == 1) {
        return ;
    }
    uint32_t SDA_PIN = NUCLEO_I2C_EXPBD_SDA_PIN;
    uint32_t SCL_PIN = NUCLEO_I2C_EXPBD_SCL_PIN;
    GPIO_InitTypeDef GPIO_InitStruct;

    // 1
    __HAL_I2C_DISABLE(hi2c);

    // 2
    GPIO_InitStruct.Pin = SDA_PIN|SCL_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Speed = GPIO_SPEED_FAST;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    HAL_GPIO_WRITE_ODR(GPIOB, SDA_PIN);
    HAL_GPIO_WRITE_ODR(GPIOB, SCL_PIN);

    // 3
    GPIO_PinState pinState;
    if (HAL_GPIO_ReadPin(GPIOB, SDA_PIN) == GPIO_PIN_RESET) {
        for(;;){}
    }
    if (HAL_GPIO_ReadPin(GPIOB, SCL_PIN) == GPIO_PIN_RESET) {
        for(;;){}
    }

    // 4
    GPIO_InitStruct.Pin = SDA_PIN;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    HAL_GPIO_TogglePin(GPIOB, SDA_PIN);

    // 5
    if (HAL_GPIO_ReadPin(GPIOB, SDA_PIN) == GPIO_PIN_SET) {
        for(;;){}
    }

    // 6
    GPIO_InitStruct.Pin = SCL_PIN;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    HAL_GPIO_TogglePin(GPIOB, SCL_PIN);

    // 7
    if (HAL_GPIO_ReadPin(GPIOB, SCL_PIN) == GPIO_PIN_SET) {
        for(;;){}
    }

    // 8
    GPIO_InitStruct.Pin = SDA_PIN;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    HAL_GPIO_WRITE_ODR(GPIOB, SDA_PIN);

    // 9
    if (HAL_GPIO_ReadPin(GPIOB, SDA_PIN) == GPIO_PIN_RESET) {
        for(;;){}
    }

    // 10
    GPIO_InitStruct.Pin = SCL_PIN;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

    HAL_GPIO_WRITE_ODR(GPIOB, SCL_PIN);

    // 11
    if (HAL_GPIO_ReadPin(GPIOB, SCL_PIN) == GPIO_PIN_RESET) {
        for(;;){}
    }

    // 12
    GPIO_InitStruct.Pin = SDA_PIN|SCL_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
    GPIO_InitStruct.Alternate = NUCLEO_I2C_EXPBD_SCL_SDA_AF;
    HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);

   // 13
   hi2c->Instance->CR1 |= I2C_CR1_SWRST;

   // 14
   hi2c->Instance->CR1 ^= I2C_CR1_SWRST;

   // 15
   __HAL_I2C_ENABLE(hi2c);

   resetTried = 1;
}

void HAL_GPIO_WRITE_ODR(GPIO_TypeDef* GPIOx, uint16_t GPIO_Pin)
{
  /* Check the parameters */
  assert_param(IS_GPIO_PIN(GPIO_Pin));

  GPIOx->ODR |= GPIO_Pin;
}

Nur noch etwas zu beachten: In diesem ERRATA- Dokument (Seite 24) finden Sie einen Fehler im I2C-Analogfilter, der zum BUSYHängen des Flags führen kann. Es gibt auch eine Problemumgehung, die Sie ausprobieren können - bei mir funktioniert es.

Siehe Eratta-Blatt: Eratta-Blatt

Problemumgehung: Die SCL- und SDA-Analogfilterausgabe wird aktualisiert, nachdem ein Übergang auf der SCL- bzw. SDA-Leitung auftritt. Der SCL- und SDA-Übergang kann durch Software erzwungen werden, indem die I2C-I/Os im Ausgangsmodus konfiguriert werden. Sobald die analogen Filter entsperrt sind und die SCL- und SDA-Leitungspegel ausgeben, kann das BUSY-Flag mit einem Software-Reset zurückgesetzt werden, und der I2C kann in den Master-Modus wechseln. Daher ist folgende Reihenfolge einzuhalten:

1. Deaktivieren Sie das I2C-Peripheriegerät, indem Sie das PE-Bit im I2Cx_CR1-Register löschen.

2. Konfigurieren Sie die SCL- und SDA-I/Os als Mehrzweck-Ausgang Open-Drain, High-Pegel (Schreiben Sie 1 in GPIOx_ODR).

3. Überprüfen Sie den SCL- und SDA-High-Pegel in GPIOx_IDR.

4. Konfigurieren Sie den SDA I/O als Allzweckausgang Open-Drain, Low-Pegel (schreiben Sie 0 in GPIOx_ODR).
5. Überprüfen Sie den niedrigen SDA-Pegel in GPIOx_IDR.
6. Konfigurieren Sie die SCL-E/A als Allzweckausgang Open-Drain, Low-Pegel (0 in GPIOx_ODR schreiben).
7. Überprüfen Sie den SCL-Low-Pegel in GPIOx_IDR.
8. Konfigurieren Sie die SCL-E/A als Allzweckausgang Open-Drain, High-Pegel (Schreiben Sie 1 in GPIOx_ODR).
9. Überprüfen Sie den SCL-High-Pegel in GPIOx_IDR.
10. Konfigurieren Sie den SDA I/O als Allzweckausgang Open-Drain, High-Pegel (Schreiben Sie 1 in GPIOx_ODR).
11. Überprüfen Sie den hohen SDA-Pegel in GPIOx_IDR.
12. Konfigurieren Sie die SCL- und SDA-I/Os als Alternativfunktion Open-Drain.
13. Setzen Sie das SWRST-Bit im I2Cx_CR1-Register.
14. SWRST-Bit im I2Cx_CR1-Register löschen.
15. Aktivieren Sie die I2C-Peripherie durch Setzen des PE-Bits im I2Cx_CR1-Register.

Ich habe das gleiche Problem bei STM32F429 mit Cube V1.15.0.

Trotzdem ist mir aufgefallen, dass SCL beim Soft-Reset (z. B. beim Debuggen) unmittelbar nach der Initialisierung des HAL_GPIO_Init()Anrufs auf LOW geht.

Ich habe einen Bus-Reset versucht, indem ich gemäß der Empfehlung von i2c-bus.org 16 Uhr an init gesendet habe .

Aber es half nichts. Das Hinzufügen des "Reset" -Codes löste den Trick:

__HAL_RCC_I2C1_FORCE_RESET();
HAL_Delay(2);
__HAL_RCC_I2C1_RELEASE_RESET();

Nach einigen Tests fand ich heraus, dass eine Verzögerung von 2 ms ausreicht. Ich habe die manuelle Neuinitialisierung der Uhr beibehalten, da eine Übertragung beim Zurücksetzen der CPU hängen bleiben kann.

Ich hatte das gleiche Problem mit dem STM32F411 Discovery Board. Als ich die Schaltpläne der Platine überprüfte (vergessen Sie nicht, die Version der Platine anzupassen), stellte ich fest, dass es keinen Pull-up-Widerstand auf den SDA- und SCL-Leitungen gibt. Also habe ich einen internen Pull-Widerstand an SCL- und SDA-Pins verwendet (CubeMX aktiviert den Pull-up-Widerstand bei der automatischen Codegenerierung nicht) und das Problem ist für mich gelöst.