stm32f100 I2C bricht nach 2. Startsignal ab

[Martin (Gast)]

Hi
Ich versuche gerade eine i2c Verbindung aufzubauen, was an sich auch 
schon was tut.
Wenn ich mein Programm starte, macht es das, was es soll. Es generiert 
ein Startsignal, überträgt die Adresse und sendet Daten.
Sobald aber das zweite Startsignal erzeugt wird, springt mein Programm 
einmal in den Interrupt, liest das SR1 und schreibt die Adresse in das 
Datenregister. Danach passiert nichts mehr. Also er sendet die Adresse 
nicht und springt auch nicht mehr in mein Interrupt. Statt dessen wird 
gleich wieder ein Stoppsignal generiert.
Im angehängten Bild sieht man was ich meine.

Ich hoffe mir kann jemand helfen, ich bin nämlich schon am verzweifeln!
Wer noch mehr Infos braucht, einfach sagen.


Mein Code:

#include "i2c.h"


static uint8_t i2c_slave_address_buffer = 0;
static uint8_t* i2c_data_buffer;
static uint8_t data_length = 0;
static uint8_t i2c_direction = I2C_Direction_Receiver;


void i2c_init(){
  GPIO_InitTypeDef GPIO_InitStructure;
  NVIC_InitTypeDef NVIC_InitStructure;
  I2C_InitTypeDef I2C_InitStructure;
  
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE);
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, 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 = 100000;
  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);
}


void i2c_transmitt_data(uint8_t slave_address, uint8_t* data, uint8_t length, uint8_t direction){
  while(I2C_GetFlagStatus(I2C2, I2C_FLAG_BUSY));
  i2c_slave_address_buffer = slave_address;
  i2c_data_buffer = data;
  i2c_direction = direction;
  data_length = length;
  I2C_AcknowledgeConfig(I2C2, ENABLE);
  I2C_GenerateSTART(I2C2, ENABLE);
}


void show_error(){
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_BERR)) send_display(2, 1, "BEER");
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_ARLO)) send_display(2, 6, "ARLO");
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_AF)) send_display(2, 11, "AF");
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_OVR)) send_display(2, 14, "OVR");
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_PECERR)) send_display(3, 1, "PECERR");
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_TIMEOUT)) send_display(3, 8, "TIMEOUT");
}


void I2C2_EV_IRQHandler(void){
  if(I2C_GetFlagStatus(I2C2, I2C_FLAG_SB)){
    I2C2->DR = (i2c_slave_address_buffer << 1) | i2c_direction;
    if(data_length == 1 && !I2C_GetFlagStatus(I2C2, I2C_FLAG_TRA)){
      //I2C_AcknowledgeConfig(I2C2, DISABLE);
      //I2C_GenerateSTOP(I2C2, ENABLE); 
    }
  }
  else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_RXNE) && !I2C_GetFlagStatus(I2C2, I2C_FLAG_TRA)){
    *i2c_data_buffer++ = I2C2->DR;
    if(data_length == 0){
      I2C_AcknowledgeConfig(I2C2, DISABLE);
      I2C_GenerateSTOP(I2C2, ENABLE);    
    }
    --data_length;
  }
  //else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_ADDR)){
  else if(I2C_GetFlagStatus(I2C2, I2C_FLAG_TXE) && I2C_GetFlagStatus(I2C2, I2C_FLAG_TRA)){
    if(data_length > 0){
      I2C2->DR = *i2c_data_buffer++;
      //++i2c_data_buffer;
      --data_length;
    }
    else I2C_GenerateSTOP(I2C2, ENABLE);
  }
  else{
    //I2C_GenerateSTOP(I2C2, ENABLE);
  }
  //if((I2C2->SR1&0x0DF00)>0){
    //show_error();
  //}

}


void I2C2_ER_IRQHandler(void){
  show_error();
}




int main() {
  display_init();
  i2c_init();
  
  data_buffer[0] = 0x00;
  data_buffer[1] = 0x19;
  data_buffer[2] = 0xee;
  data_buffer[3] = 0x0a;
  data_buffer[4] = 0x05;
  i2c_transmitt_data(0x29, data_buffer, 5, I2C_Direction_Transmitter);
  i2c_transmitt_data(0x29, data_buffer, 5, I2C_Direction_Transmitter);
  //i2c_transmitt_data(0x29, data_buffer, 1, I2C_Direction_Receiver);
  
  send_display(1, 1, "wert:");
  delay_ms(1);
  to_array(data_buffer[0]);
  send_display(1, 7, display_buffer);
}

[Martin (Gast)]

Ich hab mein Problem mittlerweile gelöst.
Die Lösung:
Ich hab mein Programm einfach mal meinem Vater gezeigt, dann hat es 
spontan entschieden zumindest im Debugger das zu tun, was ich wollte.
Naja, ich hab dann in dem Interrupt noch eine Verzögerung eingebaut und 
jetzt funktioniert es wunderbar. Wieso ich die brauch, ist mir 
allerdings schleierhaft.
Hatte das aber schon mal im Studium. Da hab ich (auf dem gleichen Chip) 
einen Timer programmiert und musste noch eine sinnlose Wert Zuweisung 
einbauen, weil es sonst nicht funktioniert hat. Selbst mein Prof hatte 
keine Ahnung, was das war...
Wer also weis, wieso das so ist, möge doch bitte sein Wissen Teilen ;)