I2C mit dem STM32: Nach Stop-Enable direkt ein Disable notwendig?

[mh (Gast)]

Hallo,

ich kämpfe nun schon seit geraumer Zeit mit dem I2C-Modul des STM32 
unter Verwendung der Standard-Lib.
Mir ist aufgefallen, dass bei TX nach einem

I2C_GenerateSTOP(I2C2, ENABLE);

direkt ein

I2C_GenerateSTOP(I2C2, DISABLE);

eingefügt werden muss, falls dies nach dem letzten gesendeten Byte 
erfolgt. Macht man dies nicht, so wird direkt nach dem nächsten Start, 
was man sendet ein Stop gesendet.

Bei RX wird Stop vor Empfang des letzten Bytes gesetzt, es ist kein 
DISABLE notwendig, alles funktioniert.

Weiß jemand woran das liegt, bzw. hat jemand die gleichen Erfahrungen 
gemacht?

Viele Grüße!

[mh (Gast)]

Achja, was mir noch aufgefallen ist:
Falls der I2C mit 100 kHz betrieben wird braucht man das DISABLE, für 
400 kHz funktionierts auch so.

[aSma>> (Gast)]

Servus,
welchen stm32 hast du genau???

Generell ist der i2c bus beim stm32f1x etwas vermurkst. Ich empfehle 
dafür folgende Appnote: AN2824. Weiterhin empfehle ich dir DMA zu 
nutzen, weil man sonst bei den zeitkritischen bus ohne ein LA/Oszi 
aufgeschmissen ist!

Außerdem würde ich mir in der Appnote genannten I2CRoutines.c mal 
anschauen. Diese hält sich strickt an das Reference Manual/AN2824.

Damit müssest du schnell etwas zum blinken bringen :)

PS: Pullup bei 400khz und 3,3V sollte 1k und bei 5V 1,7k betragen!

mfg

[mh (Gast)]

Hallo,
ich hab nen STM32F103. Das mit dem vermurkst hab ich auch schon 
festgestellt...
Danke für den Tipp mit der Appnote, werd mir die mal angucken.

Also einmal senden geht. Falls ich danach noch was mit dem I2C machen 
will, so geht nix mehr. Auf dem Oszi sieht man wie nach dem Start direkt 
ein Stop gesendet wird und das wars dann.
Falls ich z.B. ein Register eines Slaves lesen will, also:
Addresse+W, Registeradresse, RepStart, Addresse+R, Registerinhalt, ... , 
Nack, Stop
So kann ich auch danach dasselbe nochmal machen, ohne dass irgendwas 
hängt.

[mh (Gast)]

Hab glaub ich meinen Fehler gefunden.
Man sollte sich peinlichst genau an das Diagramm auf Seite 752 des 
Reference Manual (RM0008) halten.
Man sollte immer beim Senden bei einem TXE-Flag Daten in das 
Sende-Register laden und nur falls zusätzlich ein BTF-Flag auftritt, ein 
Stop senden.

[mh (Gast)]

Habs damit doch nicht gelöst, aber folgendes festgestellt.
Der Fehler tritt nur bei exakt 100 kHz auf.
Stell ich eine Bus-Frequenz von 99 kHz, 101 kHz oder 400 kHz ein, so 
funktioniert alles wunderbar.
Hat jemand schonmal etwas ähnliches festgestellt?

[mh (Gast)]

Hier noch mein Programm-Code, falls es jemand nachvollziehen will.
Init-Funktion:

void i2c2_init(void)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  I2C_InitTypeDef I2C_InitStructure;

  RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB | RCC_APB2Periph_AFIO, ENABLE);

  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10 | GPIO_Pin_11;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
  GPIO_Init(GPIOB, &GPIO_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = I2C2_EV_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  NVIC_InitStructure.NVIC_IRQChannel = I2C2_ER_IRQn;
  NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
  NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
  NVIC_Init(&NVIC_InitStructure);

  I2C_DeInit(I2C2);

  I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
  I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure.I2C_ClockSpeed = 400000;
  I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
  I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
  I2C_InitStructure.I2C_OwnAddress1 = 0;
  I2C_Init(I2C2, &I2C_InitStructure);

  I2C_ITConfig(I2C2, I2C_IT_EVT, ENABLE);
  I2C_ITConfig(I2C2, I2C_IT_BUF, ENABLE);
  I2C_ITConfig(I2C2, I2C_IT_ERR, ENABLE);

  I2C_Cmd(I2C2, ENABLE);

  i2c_BusyFlag = 0;
}

Funktionen um auf Slave-Register zugreifen zu können:

/*
 * Schreibt Daten in ein Register des Slaves.
 * Zuerst wird die Addresse+W geschickt, dann die Registeraddresse,
 * gefolgt vom Daten-Byte.
 * Parameter 1: Slaveaddresse links ausgerichtet
 * Parameter 2: Registeraddresse
 * Parameter 3: Daten
 */
void i2c2_write_register(uint8_t address, uint8_t registeraddress, uint8_t data)
{
  while(i2c_BusyFlag);
  i2c_BusyFlag = 1;

  i2c_deviceAddress = address;
  i2c_tx_buffer[0] = registeraddress;
  i2c_tx_buffer[1] = data;

  i2c_DirectionWrite = 1;
  i2c_rx_MsgSize = 0;
  i2c_tx_MsgSize = 2;
  I2C_GenerateSTART(I2C2, ENABLE);
}


/*
 * Liest Daten aus einem Register des Slaves.
 * Zuerst wird die Addresse+W geschickt, dann die Registeraddresse,
 * als naechstes ein Repeated-Start und die Addresse+R.
 * Nun sendet der Slave den Registerinhalt.
 * Parameter 1: Slaveaddresse links ausgerichtet
 * Parameter 2: Registeraddresse
 * Parameter 3: Anzahl der zu lesenden Bytes
 */
void i2c2_read_register(uint8_t address, uint8_t reg_address, uint8_t size)
{
  while(i2c_BusyFlag);
  i2c_BusyFlag = 1;

  i2c_deviceAddress = address;
  i2c_tx_buffer[0] = reg_address;

  i2c_DirectionWrite = 1;
  i2c_rx_MsgSize = size;
  i2c_tx_MsgSize = 1;
  I2C_GenerateSTART(I2C2, ENABLE);
}

IRQs:

void I2C2_EV_IRQHandler(void)
{
  // STM32 Transmitter
  if(i2c_DirectionWrite)
  {
    if(I2C_GetFlagStatus(I2C2, I2C_FLAG_SB) == SET)      // Start bit gesendet
    {
      I2C_ReadRegister(I2C2, I2C_Register_SR1);
      I2C_Send7bitAddress(I2C2, i2c_deviceAddress, I2C_Direction_Transmitter);
      i2c_ByteCounter = 0;
    }
    else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_ADDR) == SET)  // Address sent
    {
      I2C_ReadRegister(I2C2, I2C_Register_SR1);
      I2C_ReadRegister(I2C2, I2C_Register_SR2);

      I2C_SendData(I2C2, i2c_tx_buffer[i2c_ByteCounter++]);
    }
    else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXE) == SET)  // Data register empty
    {
      if(I2C_GetFlagStatus(I2C2, I2C_FLAG_BTF) == SET)  // Byte transfer finished
      {
        if(i2c_rx_MsgSize == 0)
        {
          I2C_GenerateSTOP(I2C2, ENABLE);
          i2c_BusyFlag = 0;
        }
        else
        {
          I2C_GenerateSTART(I2C2, ENABLE);      // Repeated Start
          i2c_DirectionWrite = 0;
        }
      }
      else
      {
        if(i2c_ByteCounter < i2c_tx_MsgSize)
          I2C_SendData(I2C2, i2c_tx_buffer[i2c_ByteCounter++]);
      }
    }
  }

  // STM32 Receiver
  else
  {
    if(I2C_GetFlagStatus(I2C2, I2C_FLAG_SB) == SET)      // Start bit gesendet
    {
      I2C_ReadRegister(I2C2, I2C_Register_SR1);
      I2C_Send7bitAddress(I2C2, i2c_deviceAddress, I2C_Direction_Receiver);
      i2c_ByteCounter = 0;
    }
    else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_ADDR) == SET)  // Address sent
    {
      I2C_ReadRegister(I2C2, I2C_Register_SR1);
      I2C_ReadRegister(I2C2, I2C_Register_SR2);

      if (i2c_rx_MsgSize == 1)
      {
        I2C_AcknowledgeConfig(I2C2, DISABLE);
        I2C_GenerateSTOP(I2C2, ENABLE);
      }
      else
      {
        I2C_AcknowledgeConfig(I2C2, ENABLE);
      }
    }
    else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_RXNE) == SET)  // Data register not empty
    {
      if (i2c_ByteCounter + 2 < i2c_rx_MsgSize)
      {
        i2c_rx_buffer[i2c_ByteCounter++] = I2C_ReceiveData(I2C2);
      }
      else if (i2c_ByteCounter + 2 == i2c_rx_MsgSize)    // bei vorletztem Byte NACK und STOP aktivieren
      {
        i2c_rx_buffer[i2c_ByteCounter++] = I2C_ReceiveData(I2C2);
        I2C_AcknowledgeConfig(I2C2, DISABLE);
        I2C_GenerateSTOP(I2C2, ENABLE);
      }
      else                        // letztes Byte empfangen
      {
        i2c_rx_buffer[i2c_ByteCounter] = I2C_ReceiveData(I2C2);
        i2c_BusyFlag = 0;
      }
    }
  }
}


/*
 * Error-ISR
 */
void I2C2_ER_IRQHandler(void)
{
  I2C_GenerateSTOP(I2C2, ENABLE);

  I2C_ClearFlag(I2C2, I2C_FLAG_AF);
  I2C_ClearFlag(I2C2, I2C_FLAG_ARLO);
  I2C_ClearFlag(I2C2, I2C_FLAG_BERR);

  i2c_BusyFlag = 0;
}

[aSma>> (Gast)]

Servus,
also ohne dir zu nahe zu treten, bitte benutze die DMA. Sonst empfehle 
ich dir den "Diller STM32 Tutorial", da hat er es ganz elegant gelösst.

Beim stm32 sollte man die Flags sofort nach dem Eintritt in den Interupt 
löschen, da der nächste Interrupt zur Störung führt. Wo ist es bei dir. 
Nicht gut. Auch in der Appnote/.c Datei wird geschildert, dass zum Teil 
ein Delay erstellt werden muss, da sonst alles sich aufhängt.

Mein Tipp:
-DMA nutzen,
-STM32 Tutorial
-Timeout erstellen

hier siehst du den Vorteil:
http://letanphuc.net/2014/06/stm32-mpu6050-dma-i2c/

Ich dachte anfangs auch scheiß auf DMA, aber net beim i2c bus!!! Der 
Code halbiert sich. Garantiert!

mfg

[mh (Gast)]

aSma>> schrieb:
> Servus,
> also ohne dir zu nahe zu treten, bitte benutze die DMA. Sonst empfehle
> ich dir den "Diller STM32 Tutorial", da hat er es ganz elegant gelösst.
>
> Beim stm32 sollte man die Flags sofort nach dem Eintritt in den Interupt
> löschen, da der nächste Interrupt zur Störung führt. Wo ist es bei dir.
> Nicht gut. Auch in der Appnote/.c Datei wird geschildert, dass zum Teil
> ein Delay erstellt werden muss, da sonst alles sich aufhängt.
>
> Mein Tipp:
> -DMA nutzen,
> -STM32 Tutorial
> -Timeout erstellen
>
> hier siehst du den Vorteil:
> http://letanphuc.net/2014/06/stm32-mpu6050-dma-i2c/
>
> Ich dachte anfangs auch scheiß auf DMA, aber net beim i2c bus!!! Der
> Code halbiert sich. Garantiert!
>
> mfg


Danke für die konstruktive Kritik!
Hab mir das mit DMA mal angeschaut, sieht wirklich wesentlich einfacher 
aus. Werde das bei Gelegenheit dann so umsetzen.

Viele Grüße!

[mh (Gast)]

Habs nun in DMA umgebaut.
Ich hab den Code aus dem genannten STM32-Tutorial, bzw. leicht 
angepasst. Ich brauch Funktionen um einmal in ein Slave-Register zu 
schreiben (Adr+W, 2 Bytes) und zu lesen (Adr+W, Reg-Adr., Adr+R, Daten).
Der Code aus dem Tutorial hat im Prinzip letzteres fertig implementiert 
gehabt.
Habs nun so erweitert, dass auch reines schreiben gehen soll.
Nur ist mir da was komisches aufgefallen. Bei der Schreibfunktion will 
ich insgesamt 2 Bytes schreiben. Es werden bei:

DMA_SetCurrDataCounter(DMA1_Channel4, 2);

aber nur 1 Byte gesendet, also Adr+W und 1 Byte.
Setz ich:

DMA_SetCurrDataCounter(DMA1_Channel4, 3);

so werden Adr+W und 2 Bytes gesendet. Weiß jemand woran das liegt??
Das würde sich ja mit dem Lesebefehl widersprechen (dieser funktioniert 
wie er soll).

Hier noch der Code (die Init hab ich mal wegelassen, hier wurde einfach 
ergänzt, dass durch DMA1_Channel4 IRQs ausgelöst werden können):

Slave-Zugriffsfunktionen:

/*
 * Schreibt Daten in ein Register des Slaves.
 * Zuerst wird die Addresse+W geschickt, dann die Registeraddresse,
 * gefolgt vom Daten-Byte.
 * Parameter 1: Slaveaddresse links ausgerichtet
 * Parameter 2: Registeraddresse
 * Parameter 3: Daten
 */
/*static*/ void i2c2_write_register(uint8_t address, uint8_t registeraddress, uint8_t data)
{
  while(i2c_BusyFlag);
  i2c_BusyFlag = 1;

  i2c_deviceAddress = address;
  i2c_tx_buffer[0] = registeraddress;
  i2c_tx_buffer[1] = data;

  i2c_DirectionWrite = 1;
  i2c_read_enable = 0;
  DMA_SetCurrDataCounter(DMA1_Channel4, 3);    // TX
  DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, ENABLE);
  I2C_GenerateSTART(I2C2, ENABLE);
}


/*
 * Liest Daten aus einem Register des Slaves.
 * Zuerst wird die Addresse+W geschickt, dann die Registeraddresse,
 * als naechstes ein Repeated-Start und die Addresse+R.
 * Nun sendet der Slave den Registerinhalt.
 * Parameter 1: Slaveaddresse links ausgerichtet
 * Parameter 2: Registeraddresse
 * Parameter 3: Anzahl der zu lesenden Bytes
 */
/*static*/ void i2c2_read_register(uint8_t address, uint8_t reg_address, uint8_t size)
{
  while(i2c_BusyFlag);
  i2c_BusyFlag = 1;

  i2c_deviceAddress = address;
  i2c_tx_buffer[0] = reg_address;

  i2c_DirectionWrite = 1;
  i2c_read_enable = 1;
  DMA_SetCurrDataCounter(DMA1_Channel4, 1);    // TX
  DMA_SetCurrDataCounter(DMA1_Channel5, size);  // RX
  I2C_GenerateSTART(I2C2, ENABLE);
}

IRQ-Routinen:

void I2C2_EV_IRQHandler(void)
{
  if (I2C_GetFlagStatus(I2C2, I2C_FLAG_SB) == SET)
  {
    if(i2c_DirectionWrite)    // STM32 Transmitter
      I2C_Send7bitAddress(I2C2, i2c_deviceAddress, I2C_Direction_Transmitter);
    else            // STM32 Receiver
      I2C_Send7bitAddress(I2C2, i2c_deviceAddress, I2C_Direction_Receiver);
  }
  else if(I2C_CheckEvent(I2C2, I2C_EVENT_MASTER_TRANSMITTER_MODE_SELECTED) == SUCCESS)
  {
    if (i2c_DirectionWrite)    // STM32 Transmitter
      DMA_Cmd(DMA1_Channel4, ENABLE);
  }
  else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_BTF))
  {
    if(i2c_DirectionWrite)    // STM32 Transmitter
    {
      I2C_ClearFlag(I2C2, I2C_FLAG_BTF);

      if(i2c_read_enable)
      {
        I2C_DMALastTransferCmd(I2C2, ENABLE);
        DMA_Cmd(DMA1_Channel5, ENABLE);
        I2C_GenerateSTART(I2C2, ENABLE);
        i2c_DirectionWrite = 0;
      }
    }
  }
}


void DMA1_Channel4_IRQHandler(void)
{
  DMA_ClearFlag(DMA1_FLAG_TC4);
  I2C_GenerateSTOP(I2C2, ENABLE);
  DMA_Cmd(DMA1_Channel4, DISABLE);
  DMA_ITConfig(DMA1_Channel4, DMA_IT_TC, DISABLE);

  i2c_BusyFlag = 0;

  if(imu_communication_enable)
    imu_communication_flow();
}


void DMA1_Channel5_IRQHandler(void)
{
  DMA_ClearFlag(DMA1_FLAG_TC5);
  I2C_GenerateSTOP(I2C2, ENABLE);
  DMA_Cmd(DMA1_Channel4, DISABLE);
  DMA_Cmd(DMA1_Channel5, DISABLE);

  i2c_BusyFlag = 0;

  if(imu_communication_enable)
    imu_communication_flow();
}

[mh (Gast)]

Hab eine Erklärung für das verloren gegangen Byte gefunden.
DMA löst einen IRQ aus, falls alles an die Peripherie übergeben wurde, 
was logischerweise vor dem letzten über I2C versendeten Byte der Fall 
ist.

[aSma>> (Gast)]

mh schrieb:
> Hab eine Erklärung für das verloren gegangen Byte gefunden.
> DMA löst einen IRQ aus, falls alles an die Peripherie übergeben wurde,
> was logischerweise vor dem letzten über I2C versendeten Byte der Fall
> ist.

Ja, also die slave_addr zählt man nicht mit. Nur, bei dir "Registerdata 
und Data".

mh schrieb:
> void i2c2_write_register(uint8_t address, uint8_t registeraddress,
> uint8_t data)

Ich würde das lieber als Buffer versenden oder wenigstens als Pointer.

uint8_t *buffer_p = {0xaa, 0xff};
void i2c2_write(uint8_t address, uint8_t *buffer_p, uint8_t num2write)

//Aufruf 
i2c2_write(address, *buffer_p, num2write){
...
memcpy( &i2c_tx_buffer, buffer_p,  num2write);
...
}

Das Problem ist, es gibt z.B LCD Bildschirme, PCF8574, HD44780, da 
sprichst du den slave_addr + Data an.

Viel Spaß mit DMA :)

mfg