STM32F051 I2C slave Problem

[Klaus (Gast)]

Hallo,

ich habe in einem STM32F051k Projekt ein Problem mit dem I2C als Slave.

Ich sende von einem AVR:
Start/Adresse Wr/Befehl/repStart/Adresse RD/ ... lese Informationen / 
Stop)
Wobei die zu lesenden Informationen immer aus Befehl/Anzahl/Daten 
besteht.

Komischerweise wird genau einmal alles sauber gemacht und dann komme ich 
selten mal zum senden der Anzahl, aber nie wieder zum senden der Daten.

#define OUT_STATE_NC       0
#define OUT_STATE_CMD      1
#define OUT_STATE_LENGTH   2
#define OUT_STATE_DATA     3


unsigned char Info[128]; 
unsigned char State[64]; 

__IO unsigned char InputCounter;
__IO unsigned char OutputCounter;
__IO unsigned char Output_State;
__IO unsigned char Data_Out_Max;

__IO unsigned char data_in[MAXBYTES+1]; 
unsigned char *pData_Out;   /* Pointer auf die Ausgabe Daten */

unsigned char Data_Cmd;

TBOOL bRecStart;

volatile TBOOL new_data; /* 1 = neue daten */

__IO uint16_t IIC_Direction;


void I2C1_IRQHandler(void)
{
   if (I2C_GetITStatus(I2C1,I2C_IT_ADDR)) //  meine Adresse erkannt?
   {
      I2C_ClearITPendingBit (I2C1,I2C_IT_ADDR);

      // Start
      IIC_Direction = I2C_GetTransferDirection(I2C1);
      if (IIC_Direction == I2C_Direction_Transmitter) // IIC Write ?   AVR -> ARM
      {
         InputCounter = 0;
         OutputCounter = 0;
         Data_Out_Max = 0;
         Output_State = OUT_STATE_NC;
         bRecStart = TRUE; /* setze flag; System ist am empfangen */
      }
      else // IIC Read ARM -> AVR
      {
         if (InputCounter == 1) /* nur die Register Adresse vorher empfangen?*/
         {
            Output_State = OUT_STATE_CMD;
            Data_Cmd = data_in[0];
            switch (data_in[0])
            {
            case B_GET_INFO:
               pData_Out = (unsigned char *)&Info;
               Data_Out_Max = sizeof (Info);
               break;
            case B_GET_STATUS:
               pData_Out = (unsigned char *)&State;
               Data_Out_Max = sizeof (State);
               break;
            default :
               Data_Out_Max = 0;
               break;
            }
         }
         else
         {
            Output_State = OUT_STATE_NC;
         }
         OutputCounter = 0;
         InputCounter = 0;
      }
   }
   else if (I2C_GetITStatus(I2C1,I2C_IT_STOPF)) // Stopp erkannt?
   {
      I2C_ClearITPendingBit (I2C1,I2C_IT_STOPF);

      // Stop
      Data_Out_Max = 0;
      OutputCounter = 0;
      Output_State = OUT_STATE_NC;

      if (bRecStart != FALSE)
      {
         if (InputCounter == MAXBYTES) /*   alle daten empfangen ?*/
         {
            new_data = TRUE;
         }
      } /* else ->> komme aus nicht def. zustand */

      bRecStart = FALSE; /* loesche flag, Daten Empfang laeuft */
   }
   else  if (I2C_GetITStatus(I2C1,I2C_IT_RXNE)) //  was empfangen?
   {
      uint8_t In_Datum;

      In_Datum = I2C_ReceiveData(I2C1);

      if (InputCounter >= MAXBYTES) /* zu viele Daten empfangen ? */
      {
         bRecStart = FALSE; /* loesche flag, Daten Empfang laeuft */
      }
      else /* Kann noch Daten empfangen ! */
      {
         if (bRecStart == TRUE) /* laeuft Daten Empfang ? */
         {
            data_in[InputCounter] = In_Datum; // das sind die Daten -> also speichern
            InputCounter++;
         }
      }
      Data_Out_Max = 0;
      Output_State = OUT_STATE_NC;

      //I2C_ClearITPendingBit (I2C1,I2C_IT_RXNE); // macht das auslesen schon
   }   
   else   if (I2C_GetITStatus(I2C1,I2C_IT_TXIS)) //  gesendet ?
   {
      I2C_ClearITPendingBit (I2C1,I2C_IT_TXIS);

      switch(Output_State)
      {
      case OUT_STATE_CMD:
         I2C_SendData(I2C1, Data_Cmd);    // 1. Byte ist der Befehl zu dem die Daten passen
         Output_State = OUT_STATE_LENGTH;
         break;
      case OUT_STATE_LENGTH:
         I2C_SendData(I2C1, Data_Out_Max); // 2. Byte ist die Laenge
         Output_State = OUT_STATE_DATA;
         break;
      case OUT_STATE_DATA:
         if (OutputCounter < Data_Out_Max)  // Kann ich noch Daten senden?
         {
            I2C_SendData(I2C1, (*pData_Out));
            pData_Out++;
            OutputCounter++;

            if (OutputCounter >= Data_Out_Max)  // Kann ich noch Daten senden?
            {
                Output_State = OUT_STATE_NC;
            }
         }
         else
         {
            Output_State = OUT_STATE_NC;
            I2C_SendData(I2C1, 0); // sende NULL -> es wird zu viel abgefragt!
         }
         break;
      case OUT_STATE_NC:
      default:
          I2C_SendData(I2C1, 0); // sende NULL -> es wird mist abgefragt!
         break;
      }
   }
    else  if (I2C_GetITStatus(I2C1,I2C_IT_NACKF)) //  erkannt?
   {
      I2C_ClearITPendingBit (I2C1,I2C_IT_NACKF);
   }
   else   if (  (I2C_GetITStatus(I2C1,I2C_IT_BERR)) //  Fehler erkannt?
      || (I2C_GetITStatus(I2C1,I2C_IT_ARLO)) //  Fehler erkannt?
      )
   {
      // Sollte nicht passieren
      InputCounter = 0;
      OutputCounter = 0;
      Data_Out_Max = 0;

      I2C_ClearITPendingBit (I2C1,I2C_IT_BERR);
      I2C_ClearITPendingBit (I2C1,I2C_IT_ARLO);
   }
}



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

   InputCounter = 0x00;
   Data_Cmd = B_GET_NC;
   bRecStart = FALSE; /* loesche flag, daten empfang laeuft */

   // Ausgabe blockieren
   Data_Out_Max = 0;
   OutputCounter = 0;
   Output_State = OUT_STATE_NC;

   I2C_DeInit(I2C1);
   
  /*!< I2C Periph clock enable */
   RCC_APB1PeriphClockCmd(RCC_APB1Periph_I2C1, ENABLE);

   /*!<  GPIO clock enable */
   RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOB, ENABLE);

   RCC_I2CCLKConfig(RCC_I2C1CLK_SYSCLK);

   GPIO_PinAFConfig(GPIOB, GPIO_PinSource6, GPIO_AF_1);
   GPIO_PinAFConfig(GPIOB, GPIO_PinSource7, GPIO_AF_1);

     /* Configure I2C pins:  SDA & SCL  ----------------------------*/
   GPIO_InitStructure.GPIO_Pin =  GPIO_Pin_6 | GPIO_Pin_7;
   GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
   GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
   GPIO_InitStructure.GPIO_OType = GPIO_OType_OD;
   GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
   GPIO_Init(GPIOB, &GPIO_InitStructure);

   /*!< I2C Init */
   I2C_InitStructure.I2C_Mode = I2C_Mode_I2C;
   I2C_InitStructure.I2C_Timing = 100000;
   I2C_InitStructure.I2C_DigitalFilter = 0;
   I2C_InitStructure.I2C_AnalogFilter = I2C_AnalogFilter_Enable;
   I2C_InitStructure.I2C_AcknowledgedAddress = I2C_AcknowledgedAddress_7bit;
   I2C_InitStructure.I2C_Ack = I2C_Ack_Enable;
   I2C_InitStructure.I2C_OwnAddress1 = MYADDR;
   I2C_Init(I2C1, &I2C_InitStructure);

   /* Enable I2C event interrupt */
   I2C_ITConfig(I2C1, (I2C_IT_ERRI | I2C_IT_STOPI | I2C_IT_ADDRI | I2C_IT_RXI  | I2C_IT_TXI), ENABLE); // I2C_IT_NACKI 

  /* Configure the I2C event priority */
   NVIC_InitStructure.NVIC_IRQChannel = I2C1_IRQn;
   NVIC_InitStructure.NVIC_IRQChannelPriority = 0;
   NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
   NVIC_Init(&NVIC_InitStructure);

  I2C_Cmd(I2C1, ENABLE);/* I2C ENABLE */
}

Ich hoffe mir kann jemand helfen,
Klaus

[Peter (Gast)]

Kann mir wirklich keiner Helfen?

[Dennis (Gast)]

Du glaubst jetzt nicht ernsthaft, dass einer jetzt deinen Code nimmt, 
deine Hardware nachbaut, den Fehler nachstellt, die Lösung debuggt und 
zum Schluss dir alles auf den Präsentierteller legt..... ODER???

Es ist eher so, wie im normalen Programmieralltag: Breakpoints setzen, 
Registerinhalte analysieren, LA anschliessen, Hirn in Gang setzen und 
selber den Fehler eingrenzen. Dazu braucht man übrigens auch nicht in 
einem Forum zu Fragen....

Natürlich könnte ich dir jetzt mindestens 20 mögliche Fehlerursachen 
nennen, aber weder habe ich dazu die Zeit, noch ist es erkennbar dass du 
dich mit dem Problem intensiv beschäftigt hast. Sorry, aber das ist 
nicht der Grundgedanke dieses Forums - zumindest nicht in meinen Augen.

[Klaus (Gast)]

Immer diese trolle.

Ist kein Code dabei wird gemeckert und ist mal was dabei wird auch 
gleich dumm herrum Gelaber.

Kannst mir ja mal ein Beispiel Code oder eine top doku zeigen, ich habe 
bis jetzt nichts gefunden.
Für die anderen stm gibt es was aber für die f0 Serie nichts.

Der Debugger hilft hier übrigens nicht viel. Den habe ich schon bis zum 
Unfällen benutzt.

[Klaus-Peter (Gast)]

Trolle?

Erst Klaus, dann Peter, dann wieder Klaus. Offensichtlich heißt du 
anders. Vielleicht nennst du deinen Namen nicht, damit niemand deine 
Fähigkeiten mit dir assoziiert.

Und wenn du es mit einem Debugger nicht hinkriegst, lass jemand mit 
einem höheren IQ ran. Debugger, Oszi und LA dürften erfolgsversprechend 
sein.

[Klaus (Gast)]

Mein Name spielt keine rolle.

Da du ja anscheinend intelligenter bist kannst du ja mal eine gute tat 
vollbringen und einem dummen mal helfen.

Übrigens ist der Fehler nicht im ankommenden Signal. Vor dem f0 hatte 
ich einen avr dran der lief perfekt. Auch alle anderen ic's arbeiten.
nur der stm32f051 will nicht.
Und weder die Doku noch im www finde ich eine Erklärung.

[Klaus (Gast)]

So jetzt trolle ich mal.

Wie sieht es aus?
Keine Antwort?
Ist wohl doch zu kompliziert für Dich oder?
Versteckst Dich dann auch unter einem Gast Post.

Immer diese Nörgler die einem dann doch nicht helfen.
Ist echt Schade.

Bei solchen Antworten fragt man sich dann doch, warum helfe ich, wenn 
ich kann, eigentlich immer wieder.
Ist wohl mein Verständnis für ein Forum, man hilft einander.

[Dennis (Gast)]

Klaus schrieb:
> Wie sieht es aus?
> Keine Antwort?

Doch, siehe in meinem vorherigen Post:

Dennis schrieb:
> Es ist eher so, wie im normalen Programmieralltag: Breakpoints setzen,
> Registerinhalte analysieren, LA anschliessen, Hirn in Gang setzen und
> selber den Fehler eingrenzen. Dazu braucht man übrigens auch nicht in
> einem Forum zu Fragen....

den selben Tipp hast du auch von Klaus-Peter bekommen:

Klaus-Peter schrieb:
> Debugger, Oszi und LA dürften erfolgsversprechend
> sein.

Klaus schrieb:
> Ist wohl doch zu kompliziert für Dich oder?

Wenn ich es auf dem Tisch habe, so vermutlich nicht :-) So aus der Ferne 
mit einem beratungsresistenten Fragesteller: ja!

Klaus schrieb:
> Immer diese Nörgler die einem dann doch nicht helfen.

Mehr kann man (sinnvoll) auch nicht helfen. Programmieren heisst nun mal 
auch Debuggen. Ein guter Programmierer kann daher
a) Code schreiben (idealerweise so, dass es schon an sich fehlerarm ist)
b) vollständig debuggen bis der Code EXAKT das macht, was der 
Programmierer will. Nicht mehr, nicht weniger.

Das kann dir kein Forum abnehmen. Bei spezifischen Problemen wird man 
hier auch geholfen, aber bei einem "Hier ist mein Gesamtcode, findet mal 
den Fehler" darfst du vermutlich lange auf die Lösung warten. Da hilft 
auch nicht das Rumgemeckere mit "hier sind alle so böse und keiner 
hilft".

Übrigens: Es ist wesentlich einfacher den Fehler zu finden, wenn man 
direkt in alt bewährter Weise die Register beschreibt. Da verschleiert 
einem kein Peripheal-Lib die Sicht...

[klaus (Gast)]

Mal abgesehen davon das ich den Fehler längst gefunden habe.
Schon vor meinem vorletzten post.
Aber wenn man mich so reizt dann werde ich immer etwas genervt 
Antworten.

Der Fehler ist nicht mit einem Debugger zu finden.
Man musste schon mit 2 ran und von beiden Seiten debuggen.
Nur wenn der Sender (AVR) das Schritt für Schritt sendet kann man 
erkennen wo der F0 sich verhaspelt. Da würde man mit einem OSZI oder LA 
absolut nichts erkennen, wie auch der Sender ist ja nicht das Problem 
gewesen.

Wenn man die Lösung hat ist auch das eine oder andere, in der DOKU 
schlecht beschriebene, besser verständlich. Aber das was da drin steht 
funktioniert bei mir SO übrigens nicht richtig.
Aber auch hier gibt es wie so oft mehr als eine Lösung.

Verraten werde ich die Lösung nicht, steht alles in der DOKU und wie 
haben hier schlaue Leute gesagt "Debugger benutzen und Hirn an".
Es fehlt nur eine Zeile Code!


Klaus

[Klaus-Peter (Gast)]

Jetzt zerlegst du dich aber selbst.

Klaus schrieb:
> Der Debugger hilft hier übrigens nicht viel. Den habe ich schon bis zum
> Unfällen benutzt.

Klaus schrieb:
> Man musste schon mit 2 ran und von beiden Seiten debuggen.

Da hast du also das gemacht, was dir zwei mal geraten wurde.

Und

> Ich hoffe mir kann jemand helfen.
vs.
> Verraten werde ich die Lösung nicht.

Bei mir fällst du in die Rubrik asoziales Bastelkiddie. Das du die 
Lösung nicht nennst, stört echte Ingenieure wenig. Aber die Googler in 
einen halben Jahr werden sich fühlen, wie es Gunnery Sgt. Hartman 
beschreibt:

"Sie sind doch garantiert diese Art von Typ, der f**kt jemand in den 
Arsch und hat dann nicht mal das bisschen Anstand, dem wenigstens auch 
einen runterzuholen. Sie merk ich mir vor!"