There is some uncertainty regarding the correct usage of i2c

[berkut0]

The examples you've provided use SPI, but don't include i2c. I've managed to get my head around the basics of initialising and using i2c, but I'm still a bit stuck as there isn't much in the way of comprehensive documentation. I've connected an oscilloscope and, in a few cases, I've noticed some fluctuations on the CLK and SDA lines during the boot-up process.

the code:

void i2c_write_data(uint8_t addr, uint8_t data)
{
    //I2C_SetFunc(I2cStart_En);
    stc_i2c_addr_t slaveAddr = {addr << 1, 1};
    I2C_WriteSlaveAddr(&slaveAddr);

    I2C_WriteByte(data);
    //I2C_ClearFunc(I2cStart_En);
}

en_result_t Gpio_InitIOExtForI2C() {
    CLK_EnablePeripheralClk(ClkPeripheralI2c);
    //CLK_EnablePeripheralClk(ClkPeripheralGpio);
    Gpio_SetFunc_I2C_SCL_P14();
    Gpio_SetFunc_I2C_DAT_P15();
    return Ok;
}

int main(void) {
    Clk_Init(ClkFreq24Mhz, ClkDiv1, ClkDiv1);
    Gpio_InitIOExt(0, 1, GpioDirOut, FALSE, FALSE, FALSE, TRUE);

    Gpio_InitIOExtForI2C();
    //I2C_SetFunc(I2cBaud_En);
    //I2C_SetFunc(I2cHlm_En);

    stc_i2c_config_t i2c_config;
    i2c_config.u8Tm = 32; // << how to figure out?
    i2c_config.pfnI2cCb = NULL;
    i2c_config.bTouchNvic = FALSE;
    i2c_config.enFunc = I2cMode_En;
    i2c_config.stcSlaveAddr = (stc_i2c_addr_t){0x1A,1}; // << in case {0x1A,0} SDA / SCL doesn't change on boot 

    if (I2C_Init(&i2c_config) != Ok) {
        SET_RGB(RGB(255,255,0));
        delay1ms(1000);
    }

    // I2C_SetFunc(I2cStart_En); << change nothing

    while (1)
    {
        i2c_write_data(0x1A,0x1A);
        SET_RGB(RGB(32,160,255));
        delay1ms(10);

        
        SET_RGB(0);
        delay1ms(990);
        
    }
}

I found a reference manual for this chip which describes in detail how to work with I2c.
Need to delve into it to understand how to configure it.
http://holosense.cn/uploads/position/1693185730491519.pdf

[berkut0]

After understanding the reference manual a little bit, I realised what I was doing wrong and was finally able to initialise i2c correctly. Now I am stuck at writing bytes, but the oscilloscope is already showing data being sent.

en_result_t InitI2C() {
    WRITE_BIT(&M0P_CLOCK->PERI_CLKEN, ClkPeripheralI2c, 1);
    M0P_RESET->PREI_RESET_f.I2C = 0;
    M0P_RESET->PREI_RESET_f.I2C = 1;

    WRITE_BIT((uint32_t)&M0P_GPIO->P1OD, 4, 1); // Open Drain
    WRITE_BIT((uint32_t)&M0P_GPIO->P1OD, 5, 1); // Open Drain

    Gpio_SetFunc_I2C_SCL_P14();
    Gpio_SetFunc_I2C_DAT_P15();
    
    M0P_I2C->TM = 29; // probably 24000 khz / 8 / (29+1) = 100 khz
    //M0P_I2C->TM = 7; // probably 24000 khz / 8 / (7+1) = 375 khz
    //M0P_I2C->CR_f.H1M = 1; // in case M0P_I2C->TM < 9
    M0P_I2C->TMRUN = 0x01; // enable SCL clock generator
    M0P_I2C->CR_f.ENS = 1; // enable i2c module
    M0P_I2C->CR_f.STA = 1; // send start signal

    while (M0P_I2C->CR_f.SI != 1) {}; // wait

    if (M0P_I2C->STAT == 0x08 || M0P_I2C->STAT == 0x10) {
        return Ok;
    } else {
        return Error;
    }
}

[berkut0]

I finally managed to write a driver that works with I2C. I use it to communicate with sensors. Everything works. There are a few potential problems as no error timeouts are used. But so far there have been no significant problems.

You could probably replace much of what is written here with something from the supplied library (include i2c.h), but at some point it became easier to write directly to registers.

en_result_t InitI2C() {
    WRITE_BIT(&M0P_CLOCK->PERI_CLKEN, ClkPeripheralI2c, 1);
    M0P_RESET->PREI_RESET_f.I2C = 0;
    M0P_RESET->PREI_RESET_f.I2C = 1;

    WRITE_BIT((uint32_t)&M0P_GPIO->P1OD, 4, 1); // Open Drain P14
    WRITE_BIT((uint32_t)&M0P_GPIO->P1OD, 5, 1); // Open Drain P15

    Gpio_SetFunc_I2C_SCL_P14();
    Gpio_SetFunc_I2C_DAT_P15();
    
    M0P_I2C->TM = 29; // probably 24000 khz / 8 / (29+1) = 100 khz
    //M0P_I2C->TM = 7; // probably 24000 khz / 8 / (7+1) = 375 khz
    //M0P_I2C->CR_f.H1M = 1; // in case M0P_I2C->TM < 9
    M0P_I2C->TMRUN = 0x01; // enable SCL clock generator
    M0P_I2C->CR_f.ENS = 1; // enable i2c module

    return Ok;
}

en_result_t ScanI2C(uint8_t addr){
    M0P_I2C->CR_f.STA = 1;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait
    if ((M0P_I2C->STAT == 0x08 || M0P_I2C->STAT == 0x10) != TRUE) {
        return Error;
    }
    M0P_I2C->CR_f.SI = 0;

    M0P_I2C->DATA = addr << 1; // SLA+W
    M0P_I2C->CR_f.SI = 0;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait

    en_result_t result = Error;
    if (M0P_I2C->STAT == 0x18) {
        result = Ok;
    }
    M0P_I2C->CR_f.STO = 1;
    M0P_I2C->CR_f.SI = 0;
    return result;
}

en_result_t ReadI2C(uint8_t addr, uint8_t* data, uint16_t len){
    M0P_I2C->CR_f.STA = 1;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait
    if ((M0P_I2C->STAT == 0x08 || M0P_I2C->STAT == 0x10) != TRUE) {
        return Error;
    }

    M0P_I2C->DATA = (addr << 1 | 1); // SLA+R
    M0P_I2C->CR_f.STA = 0;
    M0P_I2C->CR_f.SI = 0;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait
    if (M0P_I2C->STAT != 0x40) {
        return Error;
    }

    for (uint16_t i = 0; i < len; i++){
        if (i < len - 1) {
            M0P_I2C->CR_f.AA = 1; // ACK
        } else {
            M0P_I2C->CR_f.AA = 0; // NACK
        }
        M0P_I2C->CR_f.SI = 0;
        while (M0P_I2C->CR_f.SI != 1) {}; // wait
        if ((M0P_I2C->STAT == 0x50 || M0P_I2C->STAT == 0x58) != TRUE) {
            M0P_I2C->CR_f.AA = 0;
            M0P_I2C->CR_f.STO = 1;
            M0P_I2C->CR_f.SI = 0;
            return Error;
        }
        *(data + i) = M0P_I2C->DATA;
    }

    M0P_I2C->CR_f.STO = 1;
    M0P_I2C->CR_f.SI = 0;
    return Ok;
}

en_result_t WriteI2C(uint8_t addr, uint8_t* data, uint16_t len, boolean_t stop) {
    M0P_I2C->CR_f.STA = 1;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait
    if ((M0P_I2C->STAT == 0x08 || M0P_I2C->STAT == 0x10) != TRUE) {
        return Error;
    }
    
    M0P_I2C->DATA = addr << 1; //SLA+W
    M0P_I2C->CR_f.STA = 0;
    M0P_I2C->CR_f.SI = 0;
    while (M0P_I2C->CR_f.SI != 1) {}; // wait

    if (M0P_I2C->STAT != 0x18) {
        M0P_I2C->CR_f.STO = 1;
        M0P_I2C->CR_f.SI = 0;
        return Error;
    };

    for (uint16_t i = 0; i < len; i++){
        M0P_I2C->DATA = *(data+i);
        M0P_I2C->CR_f.SI = 0;
        while (M0P_I2C->CR_f.SI != 1) {}; // wait
        if (M0P_I2C->STAT != 0x28) {
            M0P_I2C->CR_f.STO = 1;
            M0P_I2C->CR_f.SI = 0;
            return Error;
        };
    }

    M0P_I2C->CR_f.STO = stop;
    M0P_I2C->CR_f.SI = 0;
    return Ok;
}

/* be careful that you can send a lot of bytes as a register.
HAL usually uses a 16 bit value - this eliminates the need to supply an array of bytes and specify their length.
Since the driver was written from scratch, it is left as is.
*/

en_result_t I2C_MemRead(uint8_t addr, uint8_t* reg, uint16_t reg_len, uint8_t* data, uint16_t data_len) {
    WriteI2C(addr, reg, reg_len, FALSE);
    ReadI2C(addr, data, data_len);
}

en_result_t I2C_MemWrite(uint8_t addr, uint8_t* reg, uint16_t reg_len, uint8_t* data, uint16_t data_len) {\
    uint8_t buf[256];
    for (int i=0; i<reg_len;i++){
        buf[i]=reg[i];
    }
    for (int i=0; i<data_len;i++){
        buf[i+reg_len]=data[i];
    }
    WriteI2C(addr, buf, reg_len + data_len, TRUE);
}

interrupt codes

Status Code Description

Master Transmit Mode
08H Transmitted start condition
10H Repeat start condition sent
18H SLA+W sent, ACK received
20H SLA+W sent, non-ACK received
28H Data in I2C_DATA sent, ACK received
30H Data in I2C_DATA sent, non-ACK received
38H Arbitration lost on SLA+ read/write or write data byte

Master receive mode
08H Start condition sent
10H Repeat start condition sent
38H Arbitration lost in non-ACK
40H SLA+R sent, ACK received
48H SLA+R sent, non-ACK received
50H Data byte received, ACK returned
58H Data byte received, non-ACK returned

From receive mode
60H Received own SLA+W, ACK returned
68H Lost arbitration at SLA+ read/write when mastering, have received own SLA+W, have returned ACK
80H Used its own slave address for previous addressing, received data byte, returned ACK
88H Previous addressing used its own slave address, has received data bytes, has returned non-ACK
A0H Static addressing, received stop condition or repeat start condition from transmit mode
A8H Received own SLA+R, returned ACK
B0H Lost arbitration when host, have received own SLA+R, have returned ACK
B8H Data has been sent, ACK has been received
C0H Data byte sent, non-ACK received
C8H Loaded data byte sent, received ACK

Broadcast call mode
70H Broadcast address (0x00) received, ACK returned
78H Read/write loss arbitration at SLA+ while mastering, broadcast address has been received, ACK has been returned
90H Previous addressing used broadcast address, received data byte, returned ACK
98H Previous addressing used broadcast address, received data byte, returned non-ACK
A0H Stop condition or repeat start condition received during static addressing Remaining miscellaneous statuses
F8H No available related status information, si=0
00H Bus error during transmission, or external interference caused I2C to enter an undefined state