Cortex M3 I2C timingproblem

[Sylvia H. (sandy)]

Hi Leute, ich habe ein Timingproblem bei der Programmierung des I2C Bus 
des Cortex M3:
Ich flashe das Programm mit Eqlipse im Debugmodus auf meinen Cortex. Das 
Ergebnis schaue ich mir mit Hilfe des ARRDVARK auf meinem Rechner an. 
Wenn ich nun in meinem GoEther() Task über den I2C Bus ein Datenarray 
verschicken möchte, dann funktioniert es nur, wenn ich nach jedem Byte 
eine kleine Wartezeit einbaue. Das verstehe ich schon mal nicht so 
richtig. Das wirkliche seltsame ist aber, dass das Programm nicht läuft, 
sobald ich den Controller "alleine" starte, also mit Reset, oder einfach 
so an die Spannung anschliesse. Es funktioniert nur, direkt nach dem 
Eqlipse flashen.
Hat jemand eine Erklärung dafür?
Zum Code:
ich poste meinen gesammten Code, nicht wundern, ich möchte mit meinem 
Controller später noch  einen ENC28J60 ansteuern, zusätzlich spielt CAN 
auch noch eine Rolle. Deshalb sind da Codefragmente darin, die nichts 
mit I2C zu tun haben, ich dachte mir aber ich lasse mal alles drinn, 
vielleicht spielen sie eine Rolle für das Timing....

Hier die I2C Codes:

/**
  * @brief  Initialize all stuff you need for I2C
  * @retval None.
  */
void I2C_config(void)
{
  I2C_InitTypeDef  I2C_InitStructure1;
  I2C_InitTypeDef  I2C_InitStructure2;

 //zuerste I2C1 initialisieren------------------------------------------------
  I2C_DeInit(I2C1);

  /* I2C configuration */
  I2C_InitStructure1.I2C_Mode = I2C_Mode_I2C;
  I2C_InitStructure1.I2C_DutyCycle = I2C_DutyCycle_2;
  I2C_InitStructure1.I2C_OwnAddress1 = I2C1_SLAVE_ADDRESS7;
  I2C_InitStructure1.I2C_Ack = I2C_Ack_Enable;
  I2C_InitStructure1.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
  I2C_InitStructure1.I2C_ClockSpeed = I2C_Speed;


  /* Apply I2C configuration (war in der vorlage erst nach I2C_Cmd()) */
  I2C_Init(I2C1, &I2C_InitStructure1);
  /* I2C Peripheral Enable */
  I2C_Cmd(I2C1, ENABLE);

  //GPIO Configs
  GPIO_InitTypeDef  GPIO_InitStructure1;

   /* GPIOB clock enable */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE); //??????????????wurde schon bei SPI Init erledigt
    /* I2C1 clock enable */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

   /* Configure I2C1 pins: SCL and SDA to communicate with outside */
   GPIO_InitStructure1.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
   GPIO_InitStructure1.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure1.GPIO_Mode = GPIO_Mode_AF_OD;
   GPIO_Init(GPIOB, &GPIO_InitStructure1);


   //danach I2C2 initialisieren------------------------------------------------
   I2C_DeInit(I2C2);

   // GPIOB clock enable  wurde oben schon erledigt
       // RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB, ENABLE);
       // I2C2 clock enable
       RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C2, ENABLE);

    // I2C configuration
    I2C_InitStructure2.I2C_Mode = I2C_Mode_I2C;
    I2C_InitStructure2.I2C_DutyCycle = I2C_DutyCycle_2;
    I2C_InitStructure2.I2C_OwnAddress1 = I2C2_SLAVE_ADDRESS7;
    I2C_InitStructure2.I2C_Ack = I2C_Ack_Enable;
    I2C_InitStructure2.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
    I2C_InitStructure2.I2C_ClockSpeed = I2C_Speed;

    //Apply I2C configuration (war in der vorlage erst nach I2C_Cmd())
     I2C_Init(I2C2, &I2C_InitStructure2);
     // I2C Peripheral Enable
     I2C_Cmd(I2C2, ENABLE);

     //GPIO Configs
      GPIO_InitTypeDef  GPIO_InitStructure2;



   // Configure I2C2 pins: SCL and SDA for the administrative bus
    GPIO_InitStructure2.GPIO_Pin =  GPIO_Pin_10 | GPIO_Pin_11;
    GPIO_InitStructure2.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure2.GPIO_Mode = GPIO_Mode_AF_OD;
    GPIO_Init(GPIOB, &GPIO_InitStructure2);


}


/**
  * @brief  Transmits one byte to  the  selected slave device.
  * @param  I2Cx: where x can be 1 or 2 to select the I2C peripheral.
  * @param  Address: specifies the slave address to which the data will be transmitted
  * @param  Data: the data byte which will be transmitted
  * @retval None.
  */
void I2C_Master_Transmit_Byte(I2C_TypeDef* I2Cx, uint8_t Adress, uint8_t Data)
{
  if(I2C_GetFlagStatus(I2C1, I2C_FLAG_BUSY))
     I2C_GenerateSTOP(I2C1, ENABLE);

  // I2Cx->CR1 = 0xC01; /* ACK=1, POS =1, PE = 1  */
    /* Send STRAT condition */
      I2C_GenerateSTART(I2Cx, ENABLE);

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

      I2C_Send7bitAddress(I2C1, Adress, I2C_Direction_Transmitter);

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

       /*Send Data*/
       I2C_SendData(I2C1,Data);

       /* Test on EV8 and clear it */
      while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTING));

      /* Test on EV8_2 and clear it */
       //    while(!I2C_CheckEvent(I2C1, I2C_EVENT_MASTER_BYTE_TRANSMITTED));

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

und hier meine main:

#include "stm32f10x.h"
#include "FreeRTOSSource/FreeRTOS.h"
#include "FreeRTOSSource/task.h"
#include "lib/can.h"
#include "lib/outpin.h"
#include "lib/canids.h"
#include "lib/i2c.h"
#include "Std_lib/misc.h"
#include "Std_lib/stm32f10x_it.h"
#include "Std_lib/stm32f10x_rcc.h"
#include "Std_lib/stm32f10x_dma.h"
#include "lib/SPI.H"

#include "lib/enc28j60.h"


const unsigned char enc28j60_MAC[6] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06};
/**
 * FreeRTOS task prototypes.
 */

portTASK_FUNCTION(goEther, param);


portTASK_FUNCTION(vQueryCAN, param);

portTASK_FUNCTION(vBlinkLEDs, param);

/* Private define ------------------------------------------------------------*/


/* Private macro -------------------------------------------------------------*/
/* Private variables ---------------------------------------------------------*/

DMA_InitTypeDef DMA_InitStructure;


volatile portTickType lastErrorTimeStamp;
outpin_t led_ready, led_error, led_3,led_4, ready,sck;


/**
  * @brief  Configures NVIC and Vector Table base location.
  * @param  None
  * @retval : None
  */
void NVIC_Configuration(void)
{

    /* 1 bit for pre-emption priority, 3 bits for subpriority */
  //  NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);

    NVIC_SetPriority(I2C1_EV_IRQn, 0x00);
    NVIC_EnableIRQ(I2C1_EV_IRQn);

    NVIC_SetPriority(I2C1_ER_IRQn, 0x01);
    NVIC_EnableIRQ(I2C1_ER_IRQn);


    NVIC_SetPriority(I2C2_EV_IRQn, 0x00);
    NVIC_EnableIRQ(I2C2_EV_IRQn);

    NVIC_SetPriority(I2C2_ER_IRQn, 0x01);
    NVIC_EnableIRQ(I2C2_ER_IRQn);

}




///////////////////////////////////////////////////////////////////////////////
// MAIN
///////////////////////////////////////////////////////////////////////////////
int main(void) {

  outpin_init(&led_ready, 'C', 0);
  outpin_init(&ready, 'C', 14);
  outpin_init(&led_3, 'C', 2);
  outpin_init(&led_4, 'C', 3);
  outpin_init(&led_error, 'C', 1);


  // this sets up the oscilator
  SystemInit();
  // Initialization
  NVIC_Configuration();
  CAN_inits();
  SPI2_Init();
  I2C_config();


         //zu testzwecken
    outpin_enable(&led_3);
    outpin_enable(&led_4);
    outpin_enable(&led_error);
    

  enc28j60Init((unsigned char *)enc28j60_MAC);

    

  enc_powerdown();

  //initialization terminated
  outpin_enable(&ready);

  // launch CAN query task one priority level below
  xTaskCreate(vQueryCAN, (const int8_t*)"QCAN", 100, NULL, tskIDLE_PRIORITY, NULL);
  // launch blink
  xTaskCreate(vBlinkLEDs, (const int8_t*)"BLINK", 100, NULL, tskIDLE_PRIORITY, NULL);


  xTaskCreate(goEther, (const int8_t*)"Ether", 200, NULL, tskIDLE_PRIORITY, NULL);

  vTaskStartScheduler();
  return 0;
}


portTASK_FUNCTION(goEther, param) {
  outpin_t CS_Ether, MOSI, SCK;
  outpin_init(&CS_Ether, 'B', 12); // SS Ethernetmodul

  uint8_t buffer[16] = {0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D,0x0E,0x0F};

    int i;

  for (i = 0;i<=15;i++)
  {
    int a = 1000;
         while(--a);
    I2C_Master_Transmit_Byte(I2C1,0x00,buffer[i]);
  }

  while (1) {
    

  }

}


/**
 * This task grabs actor messages from the CAN bus and forwards their
 * content.
 * ERROR messages are also evaluated.
 */portTASK_FUNCTION(vQueryCAN, param) {
  // Register all CAN ids that could contain interesting
  // messages.

  CAN_subscribeId(CANID_ERROR);

  uint32_t message;
  static float norm;
  static uint8_t brake;
  static portTickType timeStamp;

  while (1) {
    timeStamp = xTaskGetTickCount();

    if (CAN_receive(CANID_ERROR, &message)) {
      if (message == ERRORID_PWM_FREQUENCY || message
          == ERRORID_PWM_OUTOFBOUNDS || message
          == ERRORID_RECEIVER_NOSIGNAL)
        lastErrorTimeStamp = timeStamp;
    }
    // and sleep for 10ms before trying to fetch new messages again
    vTaskDelay(10 / portTICK_RATE_MS);
  }
}
/**
 * Task to blink the "RUNS" LED
 * Slow blinking for normal operation, fast for indicating some error.
 */portTASK_FUNCTION(vBlinkLEDs, param) {


  //outpin_init(&led_ready, 'C', 0);
  while (1) {
    outpin_toggle(&led_ready);
    if (xTaskGetTickCount() - lastErrorTimeStamp > 1000 / portTICK_RATE_MS) {
      // blink slow if ok
      vTaskDelay(250 / portTICK_RATE_MS);
      //for(int i=0;i<0xffff;i++){


    } else {
      // hectic blink if error present now or in the last second
      //for(int i=0;i<0xffff;i++);
      vTaskDelay(75 / portTICK_RATE_MS);

    }
  }
}