STM32F446 Problem mit I2CSlave SDA

[I2CSlave (Gast)]

Hi,
Ich habe ein Problem mit dem FMPI2C des STM32F446.
Der STM ist als I2C slave (NOSTRETCH = 1) an einen anderen µC (RL78) 
angeschlossen. Scheiben vom RL78 zum STM geht.
Beim Lesen gibt es in Abhängigkeit von den vom STM gesendeten Daten ein 
Problem mit der Freigabe der SDA-Leitung.
Im TXIS Interrupt wird das nächste zu sendene Byte eingestellt (da ich 
nicht weiß wieviele Daten vom RL78 abgeholt werden, muss ich das TXDR 
immer befüllen, auch wenn der RL78 kurz darauf ein Stop senden kann).
Ist das bit7 = 1 (Bild I2CSlave_8a.png) und der RL78 möchte die 
Transmission abbrechen, wird das Stop korrekt erzeugt und ich bekomme 
einen Interrupt mit STOPF).
Ist dagegen bit7 = 0 (Bild I2CSlave_4a.png) scheitert das Ausgeben der 
Stop-Sequenz.
Offensichtlich gibt der STM das Bit7 des nächsten Datenbytes schon auf 
den Bus, wodurch die SDA-Leitung auf 0 gehalten wird (ist Bit7 = 1, dann 
stört es SDA nicht). Der STM gibt irgendwann die Leitung durch die in 
Folge gesendeten SCL Takte wieder frei. Diese Takte gehören aber 
eigentlich zur nächsten Transmission (nächste I2C-Adresse), welche 
dadurch verloren geht.

In den Abbildung im RM0390-Reference manual kann man nicht sehen, wann 
der STM die Ausgabe des nächsten Datenbits beginnt.

Ist jemanden so etwas schon mal vorgekommen und kann einen Tipp geben?

Anbei meine STM Interrupt Routine:
Da ist jetzt auch jede Menge Müll drin, um das Problem zu lösen.

Beste Grüße,
Tom

void I2CScheduler::EV_IRQHandler_FMPI2C()
{
  static bool prefilled = false;
    bool Ackn=true;
    uint8_t sentdata = 0xaa;
    uint8_t recdata = 0xaa;
    uint16_t stages = prefilled? 0x8000:0x0;

    if (64 <= IsrBufferIdx) {
      IsrBufferIdx = 0;
    }
    ITFlags   = READ_REG(fmpi2c.Instance->ISR);

    if (ITFlags & (FMPI2C_FLAG_STOPF | FMPI2C_ISR_NACKF)) {
      stages |= 0x1000;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c,FMPI2C_FLAG_STOPF | FMPI2C_ISR_NACKF);
         I2C_Slave_STOPF();
         if (nullptr != pActiveSlave) {
             pActiveSlave->HandleI2cEvent(II2CSlave::eStopReceived, m_Address, 0U);
         }
         pActiveSlave = nullptr;
    }

    if (ITFlags & FMPI2C_FLAG_TCR) {
      stages |= 0x2000;
        fmpi2c.Instance->CR2 |= 1 << FMPI2C_CR2_NBYTES_Pos;
    }

    if (ITFlags & FMPI2C_FLAG_ADDR) {
      stages |= 0x04;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c,FMPI2C_FLAG_ADDR);
        m_Address = (ITFlags & FMPI2C_ISR_ADDCODE_Msk) >> FMPI2C_ISR_ADDCODE_Pos;
        recdata = m_Address;
        pActiveSlave = nullptr;
      uint16_t stages;
      datacount = 2;
      prefilled = false;
        for (uint8_t i = 0; cMaxSlaves > i; ++i) {
            if ( m_Address == Slaves[i].Address) {
                pActiveSlave = Slaves[i].pSlave;
            }
        }
        if (nullptr != pActiveSlave) {
            Ackn = pActiveSlave->HandleI2cEvent(II2CSlave::eCheckAddress, m_Address, 0U);
            Ackn = true;
        if (Ackn) {
        if(ITFlags & FMPI2C_ISR_DIR) {
            stages |= 0x08;
           m_I2cState = eTransmit;
           if (1 || !prefilled) {
             //fmpi2c.Instance->ISR |= FMPI2C_FLAG_TXE;
             //__HAL_FMPI2C_CLEAR_FLAG(&fmpi2c, FMPI2C_FLAG_TXE);
             __HAL_FMPI2C_ENABLE_IT(&fmpi2c, FMPI2C_IT_TXI );
             uint8_t SendData = 0;//pActiveSlave->HandleI2cEvent(II2CSlave::eByteToSend, m_Address, 0U);
             SendData = 0x80 | DataGen();
             fmpi2c.Instance->TXDR = SendData;
             sentdata = SendData;
           }
        }
        else {
            stages |= 0x10;
           m_I2cState = eReceive;
           __HAL_FMPI2C_ENABLE_IT(&fmpi2c, FMPI2C_IT_RXI);
             (void)READ_REG(fmpi2c.Instance->RXDR);  // clear rx
        }
        }
       else {
          stages |= 0x20;
         __HAL_FMPI2C_GENERATE_NACK(&fmpi2c);
       }
       }
       else {
           __HAL_FMPI2C_GENERATE_NACK(&fmpi2c);
       }
    }

    if (ITFlags & FMPI2C_FLAG_RXNE) {
      stages |= 0x40;
        uint8_t RecData = READ_REG(fmpi2c.Instance->RXDR);
        recdata = RecData;
        //if (eReceive == m_I2cState) {
        if (nullptr != pActiveSlave) {
            Ackn = 1; //pActiveSlave->HandleI2cEvent(II2CSlave::eByteReceived, m_Address, RecData);
         // prefill data
            prefilled = true;
       uint8_t SendData = 0;//pActiveSlave->HandleI2cEvent(II2CSlave::eByteToSend, m_Address, 0U);
       SendData = 0x40 | DataGen();
       sentdata = SendData;
       fmpi2c.Instance->TXDR = SendData;
            if (!Ackn) {
              __HAL_FMPI2C_GENERATE_NACK(&fmpi2c);
            }
        }
    }
    if (ITFlags & (FMPI2C_FLAG_TXIS)) {
        uint8_t SendData = 0;
//        --datacount;
        if (datacount) {
      if (eTransmit == m_I2cState) {
        if (nullptr != pActiveSlave) {
          stages |= 0x82;
          //SendData = pActiveSlave->HandleI2cEvent(II2CSlave::eByteToSend, m_Address, 0U);
          SendData = DataGen();
          fmpi2c.Instance->TXDR = SendData;
          sentdata = SendData;
        }
        else {
          stages |= 0x81;
          fmpi2c.Instance->TXDR = 0xC0 | DataGen();
        }
      }
      else {
        stages |= 0x80;
        fmpi2c.Instance->TXDR = 0xB3;
      }
        }
        else {
          fmpi2c.Instance->TXDR = 0x12;
        }
    }

    if (ITFlags & FMPI2C_ISR_NACKF) {
      stages |= 0x100;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c, FMPI2C_ISR_NACKF);
    }
    if (ITFlags & FMPI2C_FLAG_BERR) {
      stages |= 0x200;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c, FMPI2C_FLAG_BERR);
    }
    if (ITFlags & FMPI2C_FLAG_ARLO) {
      stages |= 0x400;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c, FMPI2C_FLAG_ARLO);
    }
    if (ITFlags & FMPI2C_FLAG_OVR) {
      stages |= 0x800;
        __HAL_FMPI2C_CLEAR_FLAG(&fmpi2c, FMPI2C_FLAG_OVR);
    }
    IsrBuffer[IsrBufferIdx].Isr  = ITFlags;
    IsrBuffer[IsrBufferIdx].Data = sentdata;
    IsrBuffer[IsrBufferIdx].stages = stages;
    IsrBuffer[IsrBufferIdx].Rec = recdata;
    ++IsrBufferIdx;
    // SMBus only: FMPI2C_FLAG_PECERR, FMPI2C_FLAG_TIMEOUT, FMPI2C_FLAG_ALERT
}