I2C-Bus mit STM32F100 bleibt stecken (AF, BERR)

[David K. (dave_k)]

Hallo liebe Community,

Ich versuche schon seit einigen Tagen eine Kommunikation zwischen dem 
STM32F100 Discovery Board und dem Gyrosensor L3G4200D mittels I2C-Bus 
aufzubauen. Jedoch scheiterte ich bis jetzt. Daher bitte ich um 
dringende Hilfe.

Ich verwende das Modul PmodGYRO von Digilent, um das testen zu 
vereinfachen.

Zur Verdrahtung:
STM32 - PmodGYRO
PB6   -  J2_1   (SCL)
PB7   -  J2_3   (SDA)
GND   -  J2_5
3V3   -  J2_7

Die CS-Leitung ist bereits mit einem Pull-Up Widerstand auf Versorgung 
gesetzt und die SDO/SA0 auch - somit ist die Slave-Adresse: 1101001b

Zum Code:

#include "stm32f10x.h"

//Konfig fuer Firmware Lib:
#include "Firmware Lib\stm32f10x_conf.h"

void rcc_config (void)
{
        /* Enable AlternativFunktion */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
  /* Enable GPIOB */
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);
}

/*=============================================================*/

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

GPIO_InitStructure.GPIO_Pin = GPIO_Pin_6 | GPIO_Pin_7;
GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_OD;
GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
GPIO_Init(GPIOB, &GPIO_InitStructure);
 
NVIC_InitStructure.NVIC_IRQChannel = I2C1_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 = I2C1_ER_IRQn;
NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
NVIC_Init(&NVIC_InitStructure);
 
I2C_DeInit(I2C1);
  
I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
I2C_InitStructure.I2C_ClockSpeed = 100000;
I2C_InitStructure.I2C_DutyCycle = I2C_DutyCycle_2;
I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
I2C_InitStructure.I2C_OwnAddress1 = 0;
I2C_Init(I2C1, &I2C_InitStructure);
 
I2C_ITConfig(I2C1, I2C_IT_EVT, ENABLE);
I2C_ITConfig(I2C1, I2C_IT_BUF, ENABLE);
I2C_ITConfig(I2C1, I2C_IT_ERR, ENABLE);

I2C_Cmd(I2C1, ENABLE);
}


/*===============*/

I2C_TypeDef * I2C_Module = I2C1;
volatile uint8_t deviceAddress;
volatile uint8_t i2cBusyFlag=0;
volatile uint8_t dataByte0;
volatile uint8_t receivedDataByte0;
volatile uint8_t i2cDirectionWrite;

void i2c_writeByte(uint8_t address, uint8_t byte)
{
  while(i2cBusyFlag){}
  while(I2C_GetFlagStatus(I2C_Module,I2C_FLAG_BUSY)){}
  
  deviceAddress = address;
  dataByte0 = byte;
  i2cDirectionWrite = 1;
  i2cBusyFlag = 1;
  I2C_GenerateSTART(I2C_Module, ENABLE);
}


void i2c_readByte(uint8_t address)
{
  while(i2cBusyFlag){}
  while(I2C_GetFlagStatus(I2C_Module,I2C_FLAG_BUSY)){}

  deviceAddress = address;
  i2cDirectionWrite = 0;
  i2cBusyFlag = 1;
  I2C_AcknowledgeConfig(I2C_Module, ENABLE);
  I2C_GenerateSTART(I2C_Module, ENABLE);
}


// ISR
void i2c_handleEventInterrupt(void){
  
if(I2C_GetFlagStatus(I2C_Module, I2C_FLAG_SB) == SET)
  {
    if(i2cDirectionWrite){
      // STM32 Transmitter
    I2C_Send7bitAddress(I2C_Module, deviceAddress << 1, I2C_Direction_Transmitter);   // !!DAS SCHICKT ER NOCH WEG

    }else{
      // STM32 Receiver
      I2C_Send7bitAddress(I2C_Module, deviceAddress << 1, I2C_Direction_Receiver);
      I2C_AcknowledgeConfig(I2C_Module, DISABLE);
      I2C_GenerateSTOP(I2C_Module, ENABLE);    
    }
  }
  
else if(I2C_GetFlagStatus(I2C_Module, I2C_FLAG_ADDR) == SET || I2C_GetFlagStatus(I2C_Module, I2C_FLAG_BTF) == SET)
  {
    I2C_ReadRegister(I2C_Module, I2C_Register_SR1);
    I2C_ReadRegister(I2C_Module, I2C_Register_SR2);
    
    if(i2cDirectionWrite==1)
    {
      // STM32 Transmitter
        I2C_SendData(I2C_Module, dataByte0);
        i2cBusyFlag = 0;
        i2cDirectionWrite=0;
     }  
     else
     {
        I2C_GenerateSTOP(I2C_Module, ENABLE);
        i2cBusyFlag = 0;
      }
   }
   
else if(I2C_GetFlagStatus(I2C_Module, I2C_FLAG_RXNE) == SET){
    // STM32 Receiver
    I2C_ReadRegister(I2C_Module, I2C_Register_SR1);
    I2C_ReadRegister(I2C_Module, I2C_Register_SR2);

     receivedDataByte0 = I2C_ReceiveData(I2C_Module);
     i2cBusyFlag = 0;
  }
}



// ISR
void i2c_handleErrorInterrupt(void){
  I2C_GenerateSTOP(I2C_Module, ENABLE);
  i2cBusyFlag = 0;
 
  I2C_ReadRegister(I2C_Module, I2C_Register_SR1);
  I2C_ReadRegister(I2C_Module, I2C_Register_SR2);
  I2C_ClearFlag(I2C_Module, I2C_FLAG_AF);
  I2C_ClearFlag(I2C_Module, I2C_FLAG_ARLO);
  I2C_ClearFlag(I2C_Module, I2C_FLAG_BERR);
  I2C_GenerateSTOP(I2C_Module, DISABLE);
}


void I2C1_EV_IRQHandler(void){
  i2c_handleEventInterrupt();
}
 
void I2C1_ER_IRQHandler(void){
  i2c_handleErrorInterrupt();
}



void read (uint8_t gyro, uint8_t SUB)
{ 
  i2c_writeByte(gyro, SUB);   //Schreiben - welches Register gelesen werden soll
  
  i2c_readByte(gyro);       //Lesen - Byte vom Register auslesen
}
  
  
/*======================== MAIN =======================*/
int main (void)
{
  rcc_config();
  I2C_config();

        read (0x69,0x0F);  //Test - Anfrage: Who_am_i

  while(1)
  {}
}

Im Prinzip sollte es ja so ausschauen, dass er nach dem Generieren des 
Starts das SB-Flag gesetzt wird (was auch getan wird) und er in seine 
Event-ISR springt und die Adresse wegschickt. Das funktioniert auch 
alles gut.
Nur dann wartet er (BUSY-Flag ist gesetzt) und auf einmal ist das 
AF-Flag oder das BERR-Flag gesetzt (in letzter Zeit bleibt setzt er nur 
mehr das AF-Flag) und er springt in die Error-ISR.

Im Bestfall sollte er ja bei erfolgreicher Übermittlung der Adresse 
nochmal in die Event-ISR springen und das ADDR-Flag bzw. das BTF-Flag 
gesetzt sein. Dann kann er die Registeradresse, die ich lesen will, 
abschicken.
Nach dem muss nochmales ein Start-Signal  ausgelöst werden, aber nun mit 
dem Zeichen, dass der STM32 lesen will (readByte-Funktion) 
(I2C_Direction_Receiver).
Dann sollte der Gyrosensor aktiv werden und das Byte schicken und somit 
das RXNE-Flag setzten. Dadurch wird wieder die Event-ISR ausgelöst und 
das Byte eingelesen.
So sollte es sein oder irr ich mich?

Kurz gesagt, er bleibt nach dem Abschicken der Adresse immer hängen und 
setzt das AF- oder BERR-Flag.
Ich bitte, um dringende Hilfe.
Vielen vielen Dank im Voraus

[Jim M. (turboj)]

Hast Du auch Pullups an SDA und SCL? Ohne diese tut I²C nicht.

[David K. (dave_k)]

Vielen Dank für die Antwort, im Prinzip dachte ich, dass das eh vom STM 
32 generiert wird, da dieser vor jedem Pin Pullup Widerstände hat. Aber 
ein echt guter Hinweis, wenn ich wieder vorm Schreibtisch sitze, probier 
ichs gleich aus.
An der Software kann es nicht liegen?

[Martin (Gast)]

Das ist zwar jetzt schon etwas älter, aber es könnte vielleicht noch 
jemand interessieren, der das hier liest.
Ich denke, das Problem liegt darin, dass das Interrupt Flag nicht 
zurückgesetzt wurde. Somit führt er die ISR einmal aus und kommt dann 
nicht mehr rein, das sie durch das Flag gesperrt ist.

[David K. (dave_k)]

vielen dank für die Antwort.

Guter Ansatz mit dem Flag, aber die werden bei dem Aufruf der Registern 
zurückgesetzt.
Ich muss sagen, ich bin bei dieser Variante nicht weitergekommen. Ich 
hab das ganze ohne Interrupts gelöst. Ist zwar von der 
Prozessorauslastung nicht ideal, aber einfacherer und kontrollierter.

Aja, übrigens haben damals die Pull-up-Widerstände auch gefehlt :)
Hat aber leider auch mit denen nicht funktioniert.

[Michael (Gast)]

Wie sieht denn dein Programm aus?
Wo hast du die Firmware Lib für I2C her?
Ich muss mich komplett neu in den I2C Bus einarbeiten. Einen guten Tipp 
für mich?

Ich soll binnen 1 Woche als Studiprojekt zwei Sensoren, die über einen 
I2C Bus an STM32F100RB angeschlossen sind, auswerten und die Auswertung 
auf einem Display ausgeben. Die Auswertung und die Ausgabe ist nicht das 
Problem. Aber alleine schon eine funktionsfähige I2C Konfiguration zu 
schreiben..

Wäre nett, wenn mir jemand weiterhelfen könnte.

[David K. (dave_k)]

Grüß dich,

Arbeitest du mit der Std-Lib. (Funktion wie in meinen ersten Code) oder 
mit der HAL-Lib.?

Ist das Display ein alphanumerisches? Da könnt ich dir einen fertigen 
Code geben

LG

[Michael (Gast)]

Wenn dann würde ich mit der STD Lib arbeiten.
Display ist alphanummerisch. Habe damit aber schon Erfahrung.

Ist folgendes erlaubt?
USART3 darf nicht auf Remap sein, oder?

void Init_GPIOs(void)
{
  /* Enable the AFIO, GPIO_A and B  */
   RCC->APB2ENR |= RCC_APB2ENR_AFIOEN;
   RCC->APB2ENR |= RCC_APB2ENR_IOPAEN;
   RCC->APB2ENR |= RCC_APB2ENR_IOPBEN;

  /* Enable the I2C1 and I2C2 function */
  RCC->APB1ENR |= RCC_APB1ENR_I2C1EN;
  RCC->APB1ENR |= RCC_APB1ENR_I2C2EN;

  //Enable SWD, but Disable JTAG and UART3 is PC10,PC11
  AFIO->MAPR=AFIO_MAPR_SWJ_CFG_JTAGDISABLE|AFIO_MAPR_USART3_REMAP_PARTIALR 
EMAP  ;

  GPIOB->CRL   = 0x33333333;                  // B0..B7 Output PP
  GPIOB->CRH   = 0x33333333;                  // B8..B15 Output PP
  GPIOC->CRL   = 0x33333333;                  // C0..C7 Output PP
  GPIOD->CRL   = 0x44444448;                  // D2 Keys Input with 
Pullup

  // Enable additonal pins on board
  GPIOA->CRH   = 0x344334b3;                  // A9 Alternate 
Function_PP, A10 Input Floating
                        // A8, A11, A12 and A15 are connected to LEDs
  GPIOC->CRH   = 0x44884b44;                  // C12,C13 Keys (Input 
with PullUps),
                        // C10 Alternate Function_PP, C11 Input Floating
  GPIOC->ODR   = 0x3C00;

}