STM8 I2C Busy Bit bleibt immer gesetzt

[µC8051 (Gast)]

Hallo,

ich arbeite mit dem STM8S105K6 und habe hier schon mehrer Beispiele von 
ST ausprobiert. SDA und SCL haben einen 4,7K Pull up. Die Leitung ist 
aktuell nur mit einem Oszi verbunden.

Manuell kann ich die entsprechenden Pins toggeln lassen aber with I2C 
bleiben die Pins bei 3,3V.

Nach längerem Debuggen bemerkte ich dann das bei allen Beispielen das 
Busy Bit immer durchgehend gesetzt ist.

Da ich den Fehler nicht finden kann würde ich mich über hilfe sehr 
freuen.

Hier ein kleines Beispiel meiner Meinung, müsste ich am Oszi die 
gesendete Adresse sehen können.

int main(void){
  I2C_Init();
  while(1){
  I2C_7BitAdresse();
  }

 void I2C_Init(){
  CLK->CKDIVR = 0x01;
  I2C->CR2 |=1 <<7; 
  I2C->CR2 ^=1 <<7;                //Reset periphial clock
  GPIOB->ODR |= 0x30;             //define SDA, SCL outputs, HiZ, Open drain, Fast
  GPIOB->DDR |= 0x30;              //Bits 4 und 5 als Output,20MHz
  GPIOB->CR2 |= 0x30;

  #ifdef FAST_I2C_MODE
    I2C->FREQR = 16;               // input clock to I2C - 16MHz 
    I2C->CCRL = 15;                // 900/62.5= 15, (SCLhi must be at least 600+300=900ns!)
    I2C->CCRH = 0x80;              // fast mode, duty 2/1 (bus speed 62.5*3*15~356kHz)
    I2C->TRISER = 5;               // 300/62.5 + 1= 5  (maximum 300ns)
  #else
    I2C->FREQR = 8;                // input clock to I2C - 8MHz
    I2C->CCRL = 40;                // CCR= 40 - (SCLhi must be at least 4000+1000=5000ns!)
    I2C->CCRH = 0;                 // standard mode, duty 1/1 bus speed 100kHz
    I2C->TRISER = 9;               // 1000ns/(125ns) + 1  (maximum 1000ns)
  #endif
    I2C->OARL = 0xA0;              // own address A0;
    I2C->OARH |= 0x40;
    //I2C->ITR = 1;                // enable error interrupts
    I2C->CR2 |= 0x04;              // ACK=1, Ack enable
    I2C->CR1 |= 0x01;              // PE=1
}

 void I2C_7BitAdresse(){
   while(I2C->SR3 &1 <<1){ //Busy Bit pollen
    I2C->CR2 |= 2;                              // STOP=1, generate stop
    while((I2C->CR2 & 2));                      // wait until stop is performed
  }
   I2C->SR1 |=1;  //Start Sequenz
   while(!(I2C->SR1 &1));  //warten bis Start Sequenz vorbei
   while(!(I2C->SR1 &1<<7));  
   I2C->DR = (uint8_t)(SlaveAdress << 1); // Adresse Senden
   while(!(I2C->SR1 & 2)); 
 }
}

[12 (Gast)]

Sorry, nur oberflächlich: Hast du auch alle beteiligten Module 
(mindestens aber das I2c-Modul) mit "Takt" versorgt? (Stichwort: 
CLK->PCKENR1 oder peripheral clock gating)? In deinem Code fehlt das.

[public (Gast)]

ST stellt doch massig Bibliotheken zur Verfügung, eine Initialisierung 
des I2C sollte doch auch enthalten sein...

beste grüße

[proethel (Gast)]

Errata sheet "STM8S005xx and STM8S105xx device limitations" und die 
AN3281
(STM8 optimized I2C examples) helfen weiter.

[µC8051 (Gast)]

public schrieb:
> ST stellt doch massig Bibliotheken zur Verfügung, eine Initialisierung
> des I2C sollte doch auch enthalten sein...
>
> beste grüße

Hallo,

Die init aus meinem ersten Post ist dem Beispiel von ST zum I2C 
entnommen und wurde auf meinen µC angepasst.

Natürlich gibt es Bibliotheken von ST. Habe das auch ausprobiert aber 
bin auch zu keinem Ergbeniss gekommen.


Hier z.B das Programm mit den Inits aus den i2C lib das läuft zwar glatt 
durch aber am Ausgnag passiert nichts. Schaut man sich dann die Register 
an sieht man auch hier, dass das Busy Bit durchgehend auf 1 ist.

#include "stm8s.h"
#include "main.h"
#include "stm8s_eval_i2c_ee.h"

int main(void){
  GPIOB->ODR |= 0x30;             //define SDA, SCL outputs, HiZ, Open drain, Fast
  GPIOB->DDR |= 0x30;              //Bits 4 und 5 als Output,20MHz
  GPIOB->CR2 |= 0x30;
  I2C_SoftwareResetCmd(ENABLE);
  I2C_SoftwareResetCmd(DISABLE);
  I2C_DeInit();
  CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C,ENABLE);
  I2C_Init(400000, 0x0000, I2C_DUTYCYCLE_2, I2C_ACK_NONE, I2C_ADDMODE_7BIT , 16);
  I2C->SR3 &=0xFD;
  I2C_Cmd(ENABLE);
  while(1){
    I2C_GenerateSTART(ENABLE);
    I2C_Send7bitAddress(0x04, I2C_DIRECTION_TX);
    I2C_SendData(0x70);
    I2C_GenerateSTOP(ENABLE);
  }
}

Wäre über hilfe sehr dankbar sitze schon einige Tage an dem Problem und 
komme nicht weiter.

[proethel (Gast)]

Die Standard Library hilft dir nicht weiter. Schau dir die AN3281 (pdf 
und zip) an und verwende die dort beschriebenen Funktionen. Die richtige 
Reihenfolge bei der Initialisierung ist z.B. SEHR wichtig.

[µC8051 (Gast)]

proethel schrieb:
> Die Standard Library hilft dir nicht weiter. Schau dir die AN3281 (pdf
> und zip) an und verwende die dort beschriebenen Funktionen. Die richtige
> Reihenfolge bei der Initialisierung ist z.B. SEHR wichtig.

Danke für den Tip die habe ich auch schon gefunden und ausprobiert. Mein 
erster Versuch ist auch von diesen abgeleitet. Aber auch wenn ich driekt 
das Beispiel aus AN3281 verwende und halt den Port entsprechend zu 
meinem µC anpasse bleibt er in der Abfrage vom Bussy Bit hängen und 
springt letztendlich in einen Fehler.

[proethel (Gast)]

Dann schau die deine Initialisierung an, besonders die Clock (und in dem 
Zusammenhang auch die Option Bytes). Anhand deines Codes gehe ich davon 
aus das du den internen Oszillator (HSI) mit 16Mhz verwenden möchtest, 
der STM8 startet aber mit stanardmäßig 2MHz.

[µC8051 (Gast)]

proethel schrieb:
> Dann schau die deine Initialisierung an, besonders die Clock (und in dem
> Zusammenhang auch die Option Bytes). Anhand deines Codes gehe ich davon
> aus das du den internen Oszillator (HSI) mit 16Mhz verwenden möchtest,
> der STM8 startet aber mit stanardmäßig 2MHz.


Ok Ausgehend von dem Code aus Beispiel AN3281.
Ich bin alle Register nochmal durch gegangen und bin der Meinung das 
diese passen. Nur bei der Configurierung der Pins SDA/SCL in der Init 
bin ich mir nicht sicher (Über Rückmeldung würde ich mich freuen).

Es ist immernoch das gleiche Problem in der erste While schleife von 
I2C_WriteRegister bleibt das Programm hängen weil das Busy Bit gesetzt 
bleibt.

/*Main*/
#include "stm8s.h"
#include "i2c_master_poll.h"
#include <string.h>

const u8 DUMMY_INIT[MAX_DUMMY]= { 0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90, 0xa0 };

u8 Dummy[MAX_DUMMY];
volatile u8 err_save;
volatile u16 TIM4_tout;
u16 loop_count;

#ifndef FAST_I2C_MODE
  #define FAST_I2C_MODE
#endif

void main (void) { 
  CLK_FastHaltWakeUpCmd(ENABLE);
  /* peripheral initialization */  
  #ifdef FAST_I2C_MODE
  CLK->CKDIVR = 0x00;             // sys clock / 1
  #else
  CLK->CKDIVR = 0x01;             // sys clock / 2
  #endif
  
  // initialize timer 4 mandatory for timout and tick measurement 
  TIM4_Init();                    
  
  // Initialize I2C for communication
  I2C_Init();                     
  
  // initialization of dummy field for test purpose    
  memcpy(Dummy, DUMMY_INIT, MAX_DUMMY);

  enableInterrupts();
/* main test loop */
  while(1) {
    set_tout_ms(10);
    I2C_WriteRegister(8, 1, &Dummy[8]);
}


/*I2C_Master_poll.c*/

/* flag clearing sequence - uncoment next for peripheral clock under 2MHz */
#define dead_time() { /* _asm("nop"); _asm("nop"); */ }
#define delay(a)          { TIM4_tout= a; while(TIM4_tout); }
#define tout()            (TIM4_tout)
#define set_tout_ms(a)    { TIM4_tout= a; }
extern u16 TIM4_tout;



void I2C_Init(void) {
  GPIOB->ODR |= 0x30;             //define SDA, SCL outputs, HiZ, Open drain, Fast
  GPIOB->DDR |= 0x30;              //Bits 4 und 5 als Output,20MHz
  GPIOB->CR2 |= 0x30;

#ifdef FAST_I2C_MODE
  I2C->FREQR = 16;               // input clock to I2C - 16MHz 
  I2C->CCRL = 15;                // 900/62.5= 15, (SCLhi must be at least 600+300=900ns!)
  I2C->CCRH = 0x80;              // fast mode, duty 2/1 (bus speed 62.5*3*15~356kHz)
  I2C->TRISER = 5;               // 300/62.5 + 1= 5  (maximum 300ns)
#else
  I2C->FREQR = 8;                // input clock to I2C - 8MHz
  I2C->CCRL = 40;                // CCR= 40 - (SCLhi must be at least 4000+1000=5000ns!)
  I2C->CCRH = 0;                 // standard mode, duty 1/1 bus speed 100kHz
  I2C->TRISER = 9;               // 1000ns/(125ns) + 1  (maximum 1000ns)
#endif
  I2C->OARL = 0xA0;              // own address A0;
  I2C->OARH |= 0x40;
  I2C->ITR = 1;                  // enable error interrupts
  I2C->CR2 |= 0x04;              // ACK=1, Ack enable
  I2C->CR1 |= 0x01;              // PE=1
}



void I2C_WriteRegister(u8 u8_regAddr, u8 u8_NumByteToWrite, u8 *u8_DataBuffer)
{
  while((I2C->SR3 & 2))                         // Wait while the bus is busy
  {
    I2C->CR2 |= 2;                                        // STOP=1, generate stop
    while((I2C->CR2 & 2) && tout());                      // wait until stop is performed
  }
  
  I2C->CR2 |= 1;                                          // START=1, generate start
  while(((I2C->SR1 & 1)==0) && tout());                   // Wait for start bit detection (SB)
  dead_time();                                            // SB clearing sequence
  if(tout())
  {
    #ifdef TEN_BITS_ADDRESS                                // TEN_BIT_ADDRESS decalred in I2c_master_poll.h
      I2C->DR = (u8)(((SLAVE_ADDRESS >> 7) & 6) | 0xF0);  // Send header of 10-bit device address (R/W = 0)
      while(!(I2C->SR1 & 8) &&  tout());                  // Wait for header ack (ADD10)
      if(tout())
      {
        I2C->DR = (u8)(SLAVE_ADDRESS);                    // Send lower 8-bit device address & Write 
      }
    #else
      I2C->DR = (u8)(SLAVE_ADDRESS << 1);                 // Send 7-bit device address & Write (R/W = 0)
    #endif
  }
  while(!(I2C->SR1 & 2) && tout());                       // Wait for address ack (ADDR)
  dead_time();                                            // ADDR clearing sequence
  I2C->SR3;
  while(!(I2C->SR1 & 0x80) && tout());                    // Wait for TxE
  if(tout())
  {
    I2C->DR = u8_regAddr;                                 // send Offset command
  }
  if(u8_NumByteToWrite)
  {
    while(u8_NumByteToWrite--)                            
    {                                                      // write data loop start
      while(!(I2C->SR1 & 0x80) && tout());                  // test EV8 - wait for TxE
      I2C->DR = *u8_DataBuffer++;                           // send next data byte
    }                                                      // write data loop end
  }
  while(((I2C->SR1 & 0x84) != 0x84) && tout());           // Wait for TxE & BTF
  dead_time();                                            // clearing sequence
  
  I2C->CR2 |= 2;                                          // generate stop here (STOP=1)
  while((I2C->CR2 & 2) && tout());                        // wait until stop is performed  
}

[proethel (Gast)]

Ich hab mal die Initialisierungssqequenz und die I2C-Funktionen 
angehangen die ich auf einem STM8S-DISCOVERY verwende. Bei dir vermisse 
ich die Initialisierung des Clock Controllers (CLK_ClockSwitchConfig()) 
um von der langsamen Startfrequenz auf die 16MHz zu schalten.

[µC8051 (Gast)]

proethel schrieb:
> Ich hab mal die Initialisierungssqequenz und die I2C-Funktionen
> angehangen die ich auf einem STM8S-DISCOVERY verwende. Bei dir vermisse
> ich die Initialisierung des Clock Controllers (CLK_ClockSwitchConfig())
> um von der langsamen Startfrequenz auf die 16MHz zu schalten.

Vielen Dank für deine Lösung. Ich habe jetzt außer deine Init alles was 
für den I2C wichtig ist raus genommen und in meine Init geschrieben.
Leider tritt auch hier wieder der gleiche Fehler auf, das er in der 
Abfrage vom Busy Bit hängen bleibt und dann in den Fehler springt.

void INIT_Reset(void){
  GPIO_Init(GPIOB, GPIO_PIN_4, GPIO_MODE_OUT_OD_HIZ_FAST);
  GPIO_Init(GPIOB, GPIO_PIN_5, GPIO_MODE_OUT_OD_HIZ_FAST);
  
  CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO,
                        CLK_SOURCE_HSE,
                        DISABLE,
                        CLK_CURRENTCLOCKSTATE_DISABLE);

   // High speed internal clock prescaler: 1
   // CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV1);
  while((CLK->SWCR & CLK_SWCR_SWIF) == 0);
  
  I2C_DeInit();
   I2C_Init(100000,                                                              // uint32_t OutputClockFrequencyHz,
            0xA0,                                                                // uint16_t OwnAddress,
            I2C_DUTYCYCLE_2,                                                     // I2C_DutyCycle_TypeDef I2C_DutyCycle,
            I2C_ACK_NEXT,                                                        // I2C_Ack_TypeDef Ack,
            I2C_ADDMODE_7BIT,                                                    // I2C_AddMode_TypeDef AddMode,
            16);                                                                 // uint8_t InputClockFrequencyMHz

   I2C_ITConfig(I2C_IT_EVT, DISABLE);
   I2C_ITConfig(I2C_IT_BUF, DISABLE);
   
   enableInterrupts();

   I2C_Cmd(ENABLE);
}

[µC8051 (Gast)]

Sollte natürlich "aus" deiner Init heißen

[proethel (Gast)]

Ich verwende den externen Quarz auf dem Discovery-Board (HSE). Wenn du 
den internen Takt (HSI) verwendest (ich gehe weiterhin davon aus) ist 
die Funktion CLK_ClockSwitchConfig() anzupassen, also mindestens 
CLK_SOURCE_HSE wäre dann falsch. Schau dir mal den Abschnitt "9.2 Master 
clock switching, Figure 23. Clock switching flowchart (manual mode 
example)" im Reference Manual an. Ich habe im Augenblick wenig Zeit, 
aber ich werde mich heute abend wieder melden.

[proethel (Gast)]

Versuch doch einfach mal

I2C_Init(1000,
         0xA0,
I2C_DUTYCYCLE_2, 
I2C_ACK_NEXT, 
I2C_ADDMODE_7BIT,
2);

[proethel (Gast)]

(Mist, unbeabsichtigt abgedrückt)
Dann sollte I2C testweise auch mit 2MHz funktionieren.

[µC8051 (Gast)]

proethel schrieb:
> Versuch doch einfach mal
>
> I2C_Init(1000,
>          0xA0,
> I2C_DUTYCYCLE_2,
> I2C_ACK_NEXT,
> I2C_ADDMODE_7BIT,
> 2);

Hallo,

das habe ich auch schon probiert. Gleicher Fehler Busy Bit bleibt 
gesetzt.

Prinzipiell ist es mir ertmal egal ob der µC mit derm Internen oder dem 
externen Tackt läuft. Habe jetzt aber auch mal den Teil des Manuals 
bezüglich des CLK angeschaut. Meiner Ansicht nach muss man eben nur 
CLK_SOURCE_HSE zu CLK_SOURCE_HSI wechseln. Damit er mit dem interenn 
Clock läuft dann bleibt er allerdings in der Schleife

 while((CLK->SWCR & CLK_SWCR_SWIF) == 0);

 hängen da wohl das "Switch done" bit nicht kommt.

Ich saß gestern auch schon 3h mit meinem µC Proffessor dran aber auch 
der konnte mir nicht helfen.

[µC8051 (Gast)]

Hab das Problem gelöst.

Werde morgen kurz die Lösung Posten.

Dank an alle die Versucht haben mir zu helfen.

[µC8051 (Gast)]

Hallo,

etwas verspätet aber hier die Lösung meines Problems.

Einfach im Programm ST Visual Develop Tools-Programmer und dort die 
"Option Bytes" für I2C aktievieren (Siehe Bild1). Anschließend müssen 
die OPtion Bytes noch Programmiert werden (Siehe Bild2).

[Michael K. (Gast)]

proethel schrieb:
> Dann schau die deine Initialisierung an, besonders die Clock (und in dem
> Zusammenhang auch die Option Bytes)