14. IIC host control–pin software simulation

Timing diagram:

The software is based on the STM32 HAL library
Version 2 is recommended

IIC – Timer Accurate Delay

The use of software involves the use of timers for precise delays, you can refer to my article – “CubeMx Timer High Precision Delay”
Files for delayed use:
tim.c

/**
  ***************************************************** *****************************
  * @file tim.c
  * @brief This file provides code for the configuration
  * of the TIM instances.
  ***************************************************** *****************************
  * @attention
  *
  * <h2><center> & amp;copy; Copyright (c) 2023 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  * opensource.org/licenses/BSD-3-Clause
  *
  ***************************************************** *****************************
  */

/* Includes ----------------------------------------------- -------------------*/
#include "tim.h"

/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

TIM_HandleTypeDef htim17;

/* TIM17 init function */
void MX_TIM17_Init(void)
{<!-- -->

  /* USER CODE BEGIN TIM17_Init 0 */

  /* USER CODE END TIM17_Init 0 */

  /* USER CODE BEGIN TIM17_Init 1 */

  /* USER CODE END TIM17_Init 1 */
  htim17.Instance = TIM17;
  htim17.Init.Prescaler = 24-1;
  htim17.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim17.Init.Period = 65535;
  htim17.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
  htim17.Init.RepetitionCounter = 0;
  htim17.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
  if (HAL_TIM_Base_Init( &htim17) != HAL_OK)
  {<!-- -->
    Error_Handler();
  }
  /* USER CODE BEGIN TIM17_Init 2 */

  /* USER CODE END TIM17_Init 2 */

}

void HAL_TIM_Base_MspInit(TIM_HandleTypeDef* tim_baseHandle)
{<!-- -->

  if(tim_baseHandle->Instance==TIM17)
  {<!-- -->
  /* USER CODE BEGIN TIM17_MspInit 0 */

  /* USER CODE END TIM17_MspInit 0 */
    /* TIM17 clock enable */
    __HAL_RCC_TIM17_CLK_ENABLE();
  /* USER CODE BEGIN TIM17_MspInit 1 */

  /* USER CODE END TIM17_MspInit 1 */
  }
}

void HAL_TIM_Base_MspDeInit(TIM_HandleTypeDef* tim_baseHandle)
{<!-- -->

  if(tim_baseHandle->Instance==TIM17)
  {<!-- -->
  /* USER CODE BEGIN TIM17_MspDeInit 0 */

  /* USER CODE END TIM17_MspDeInit 0 */
    /* Peripheral clock disable */
    __HAL_RCC_TIM17_CLK_DISABLE();
  /* USER CODE BEGIN TIM17_MspDeInit 1 */

  /* USER CODE END TIM17_MspDeInit 1 */
  }
}

/* USER CODE BEGIN 1 */

/* USER CODE END 1 */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

Delay_Driver.c

/********************************************** *************************
*file: timer high precision delay
*author:remnant dream
*date:2022.9.26
*note: Note: Users are prohibited from using and changing
    The timer configuration:
Frequency division factor -- 24, period -- 65535
No need to enable interrupt
***************************************************** *********************/
#include "Delay_Driver.h"

/******************************
@function:us delay
@param:us--time to be delayed
@return: void
@date:2022.9.26
@remark:
*******************************/
void Delay_us(unsigned int us)
{<!-- -->
    if(!us){<!-- -->return;}
    us = (us > 6553)?6553:us;
    us *= 10;//Basic is 100ns
    _DelayTIM_Handle.Instance->CNT = 0;
HAL_TIM_Base_Start( & amp;_DelayTIM_Handle);
while(_DelayTIM_Handle.Instance->CNT < us);
HAL_TIM_Base_Stop( & amp;_DelayTIM_Handle);
}

/******************************
@function:ms delay
@param:ms--time to be delayed
@return: void
@date:2022.9.26
@remark:
*******************************/
void Delay_ms(unsigned int ms)
{<!-- -->
    unsigned int i = 0;
    if(!ms){<!-- -->return;}
    while(ms)
    {<!-- -->
        i = (ms < 6)?(ms):6;
        Delay_us(i*1000);
        ms -= i;
    }
}

/******************************
@function:s delay
@param:s--time to be delayed
@return: void
@date:2022.9.26
@remark:
*******************************/
void Delay_s(unsigned int s)
{<!-- -->
    unsigned int i = 0;
    if(!s){<!-- -->return;}
    while(s)
    {<!-- -->
        i = (s < 60)?(s):60;
        Delay_ms(i*1000);
        s -= i;
    }
}

Delay_Driver.h

#ifndef _Delay_Driver_H_
#define _Delay_Driver_H_
#include "tim.h"

#define _DelayTIM_Handle htim17

extern void Delay_us(unsigned int us);
extern void Delay_ms(unsigned int ms);
extern void Delay_s(unsigned int s);

#endif

Simulated IIC host: Version 1

In this version, SDA pin and SCK pin use macro definition
IIC_simulate.c

/********************************************** *************************
*file: Simulate IIC file
*author:remnant dream
*date:2023.5.20
*note: V1.0
***************************************************** *********************/
#include "IIC_simulate.h"
#include "stdio.h"
#include "gpio.h"
#include "Delay_Driver.h"

#define _SET_PIN(GPIOx,Pin) GPIOx->BSRR = Pin //pin set 1
#define _RESET_PIN(GPIOx,Pin) GPIOx->BSRR = ((uint32_t)Pin << 16u) //pin set 0
#define _READ_PIN(GPIOx,Pin) (GPIOx->IDR & Pin)?1:0

#define dIIC_DELAY() Delay_us(1)//IIC delay function, set IIC communication speed: 500KHz
#define dIIC_SDA_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dIIC_SDA_PORT GPIOB
#define dIIC_SDA_PIN GPIO_PIN_3
#define dIIC_SCK_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dIIC_SCK_PORT GPIOB
#define dIIC_SCK_PIN GPIO_PIN_4

#define dIIC_SDA(x) if(x){<!-- -->_SET_PIN(dIIC_SDA_PORT,dIIC_SDA_PIN);}else _RESET_PIN(dIIC_SDA_PORT,dIIC_SDA_PIN)
#define dIIC_SCL(x) if(x){<!-- -->_SET_PIN(dIIC_SCK_PORT,dIIC_SCK_PIN);}else _RESET_PIN(dIIC_SCK_PORT,dIIC_SCK_PIN)

//IO direction setting
#define dIIC_SDA_IN {<!-- -->GPIOB->MODER & amp;= ~(3<<(dIIC_SDA_PIN*2));GPIOB->MODER |= 0<<(dIIC_SDA_PIN*2);}//input model
#define dIIC_SDA_OUT {<!-- -->GPIOB->MODER & amp;= ~(3<<(dIIC_SDA_PIN*2));GPIOB->MODER |= 1<<(dIIC_SDA_PIN*2);}//Output model
#define dIIC_SDA_READ_READ_PIN(dIIC_SDA_PORT,dIIC_SDA_PIN)
#define dIIC_SCK_READ_READ_PIN(dIIC_SCK_PORT,dIIC_SCK_PIN)

/******************************
@function: Simulate IIC initialization
@param: void
@return: void
@note:
*******************************/
void simIIC_Init(void)
{<!-- -->
    GPIO_InitTypeDef GPIO_InitStruct = {<!-- -->0};

    dIIC_SDA_CLOCK;dIIC_SCK_CLOCK;

    GPIO_InitStruct.Pin = dIIC_SDA_PIN;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct. Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(dIIC_SDA_PORT, &GPIO_InitStruct);
    GPIO_InitStruct.Pin = dIIC_SCK_PIN;
    HAL_GPIO_Init(dIIC_SCK_PORT, & GPIO_InitStruct);
    dIIC_SCL(1);
    dIIC_SDA(1);
}

/******************************
@function: IIC start signal
@param: void
@return: void
@note:
*******************************/
void simIIC_Start(void)
{<!-- -->
    dIIC_SDA_OUT;
    dIIC_SDA(1);
    dIIC_SCL(1);
    dIIC_DELAY();

    dIIC_SDA(0);
    dIIC_DELAY();
    dIIC_SCL(0);
}

/******************************
@function: IIC end signal
@param: void
@return: void
@note:
*******************************/
void simIIC_Stop(void)
{<!-- -->
    dIIC_SCL(0);
    dIIC_SDA(0);
    dIIC_DELAY();

    dIIC_SCL(1);
    dIIC_DELAY();
    dIIC_SDA(1);
    dIIC_DELAY();
}

/******************************
@function: IIC write data (do not use it otherwise)
@param: data--data to be sent
@return: 0--write success, -1--write failure (slave address does not exist)
@note: Does not contain IIC start, IIC end
*******************************/
signed int simIIC_WriteOneByte(unsigned char data)
{<!-- -->
    unsigned char ack = 0, mask = 0;

    dIIC_SDA_OUT;
    for(mask=0x80;mask != 0;mask >>= 1)
    {<!-- -->
        dIIC_SDA(((mask & amp; data) ? 1 : 0));
        dIIC_DELAY();
        dIIC_SCL(1);
        dIIC_DELAY();
        dIIC_SCL(0);
    }
    dIIC_SDA(1);
    dIIC_SDA_IN;
    dIIC_DELAY();
    dIIC_SCL(1);
    dIIC_DELAY();
    ack = dIIC_SDA_READ;
    dIIC_SCL(0);
    dIIC_SDA_OUT;

    return (ack? -1:0);
}

/******************************
@function: IIC read data (do not use it otherwise)
@param: ack: 0--answer, 1--no answer
@return: the data read
@note: Does not contain IIC start, IIC end
*******************************/
unsigned char simIIC_ReadOneByte(unsigned char ack)
{<!-- -->
    unsigned char mask = 0, data = 0;

    dIIC_SDA(1);
    dIIC_SDA_IN;
    for(mask=0x80;mask != 0;mask >>= 1)
    {<!-- -->
        dIIC_DELAY();
        dIIC_SCL(1);
        dIIC_DELAY();
        data |= ((dIIC_SDA_READ)?mask:0);
        dIIC_SCL(0);
    }
    dIIC_SDA_OUT;
    dIIC_SDA((ack?1:0));
    dIIC_DELAY();
    dIIC_SCL(1);
    dIIC_DELAY();
    dIIC_SCL(0);

    return data;
}

/******************************
@function: IIC write data
@param: data--data to be sent
        byteNum - the number of data bytes, excluding address bytes
        address--slave address
@return: 0--write success, -1--write failure (slave address does not exist | data bytes 0)
@note:
*******************************/
signed int simIIC_Write(unsigned char *data, unsigned int byteNum, unsigned char address)
{<!-- -->
    unsigned int pos = 0;
    if(byteNum == 0) return -1;

    simIIC_Start();
    if(simIIC_WriteOneByte(address << 1) < 0){<!-- -->simIIC_Stop();return -1;}//address access: write
    for(pos=0;pos < byteNum;pos + + ){<!-- -->if(simIIC_WriteOneByte(data[pos]) < 0){<!-- -->simIIC_Stop();return -1; }}
    simIIC_Stop();
    return 0;
}

/******************************
@function: IIC read data
@param: data-- the read data
        byteNum--the number of data bytes to be read, excluding address bytes
        address--slave address
@return: 0--read successfully, -1--read failed (slave address does not exist | read error)
@note:
*******************************/
signed int simIIC_Read(unsigned char *data, unsigned int byteNum, unsigned char address)
{<!-- -->
    unsigned int pos = 0;
    if(byteNum == 0) return -1;
    address = (address << 1) | 0x01;

    simIIC_Start();
    if(simIIC_WriteOneByte(address) < 0){<!-- -->simIIC_Stop();return -1;}//address access: read
    for(pos=0;pos < byteNum;pos ++ ){<!-- -->data[pos] = simIIC_ReadOneByte((pos == (byteNum-1))?1:0);}
    simIIC_Stop();
    return 0;
}

IIC_simulate.h

#ifndef _IIC_simulate_H_
#define _IIC_simulate_H_

void simIIC_Init(void);
void simIIC_Start(void);
void simIIC_Stop(void);
signed int simIIC_WriteOneByte(unsigned char data);
unsigned char simIIC_ReadOneByte(unsigned char ack);
signed int simIIC_Write(unsigned char *data, unsigned int byteNum, unsigned char address);
signed int simIIC_Read(unsigned char *data, unsigned int byteNum, unsigned char address);

#endif

Simple example

/******************************
@function: Send two bytes of data
@param: MSB high 8 bits; LSB low 8 bits
@return: -1--write failed, 0--success
@note:
*******************************/
int SHT3x_WriteByte(uint8_t MSB, uint8_t LSB)
{<!-- -->
  uint8_t data[2] = {<!-- -->0};
  data[0] = MSB; data[1] = LSB;
  return (simIIC_Write(data,2,dSHT3X_IIC_ADDRESS) < 0) ? -1 : 0;
}

uint8_t data[6] = {<!-- -->0};
if(simIIC_Read(data,6,dSHT3X_IIC_ADDRESS) < 0) return -1;

Tested using

Simulated IIC host: Version 2

This file simulates the IIC host, and the functions use the simIIC_StructDef structure entity, which is convenient for multiple peripherals
IIC_simulate.c

/********************************************** *************************
*file: Simulate IIC file
*author:remnant dream
*date:2023.5.20
*note:V2.0
This file simulates the IIC host, and the functions use the simIIC_StructDef structure entity, which is convenient for multiple peripherals to use
eg:
#define dSHT3X_SDA_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dSHT3X_SDA_PORT GPIOB
#define dSHT3X_SDA_PIN GPIO_PIN_3
#define dSHT3X_SCL_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dSHT3X_SCL_PORT GPIOB
#define dSHT3X_SCL_PIN GPIO_PIN_4
#define dSHT3X_IIC_ADDRESS 0x44

void SHT3x_GPIO_EnableColock(void)//sht3x initializes the GPIO clock enable function of SDA|SCL of IIC
{
  dSHT3X_SDA_CLOCK;
  dSHT3X_SCL_CLOCK;
}

simIIC_StructDef SHT3X_IIC;//Initialize the IIC structure variable
SHT3X_IIC.SDA_Pin = dSHT3X_SDA_PIN;
SHT3X_IIC.SCL_Pin = dSHT3X_SCL_PIN;
SHT3X_IIC.SDA_GPIO = dSHT3X_SDA_PORT;
SHT3X_IIC.SCL_GPIO = dSHT3X_SCL_PORT;
SHT3X_IIC.GPIO_EnableColock = &SHT3x_GPIO_EnableColock;
SHT3X_IIC.DelayMicrosecond = 1;//IIC speed: 500KHz
SHT3X_IIC.Delay_us = & amp;Delay_us;//External us delay precise function
simIIC_Init(SHT3X_IIC);//Initialize IIC

uint8_t data[6] = {0};
if(simIIC_Read(SHT3X_IIC,data,6,dSHT3X_IIC_ADDRESS) < 0)return -1;//Read 6 bytes of data
if(simIIC_Write(SHT3X_IIC,data,2,dSHT3X_IIC_ADDRESS) < 0) return -1;//write 6 bytes of data
***************************************************** *********************/
#include "IIC_simulate.h"

#define dxSET_PIN(GPIOx,Pin) GPIOx->BSRR = Pin //pin set 1
#define dxRESET_PIN(GPIOx,Pin) GPIOx->BSRR = ((uint32_t)Pin << 16u) //pin set 0
#define dxREAD_PIN(GPIOx,Pin) (GPIOx->IDR & Pin)?1:0
#define dxSET_LEVEL_PIN(gpio,pin,level) if(level){<!-- -->dxSET_PIN(gpio,pin);}else dxRESET_PIN(gpio,pin)

//IO direction setting
#define dxPIN_MODE_IN(gpio,pin) {<!-- -->gpio->MODER & amp;= ~(3<<(pin*2));gpio->MODER |= 0<<(pin*2) ;}//input mode
#define dxPIN_MODE_OUT(gpio,pin) {<!-- -->gpio->MODER & amp;= ~(3<<(pin*2));gpio->MODER |= 1<<(pin*2) ;}//output mode

#define dIIC_SCL(simIIC,x) dxSET_LEVEL_PIN(simIIC.SCL_GPIO,simIIC.SCL_Pin,x)
#define dIIC_SDA(simIIC,x) dxSET_LEVEL_PIN(simIIC.SDA_GPIO,simIIC.SDA_Pin,x)
#define dIIC_SDA_IN(simIIC) dxPIN_MODE_IN(simIIC.SDA_GPIO,simIIC.SDA_Pin)
#define dIIC_SDA_OUT(simIIC) dxPIN_MODE_OUT(simIIC.SDA_GPIO,simIIC.SDA_Pin)
#define dIIC_SDA_READ(simIIC) dxREAD_PIN(simIIC.SDA_GPIO,simIIC.SDA_Pin)

static void simIIC_DelayUs(simIIC_StructDef simIIC);

/******************************
@function: Simulate IIC delay function
@param:
@return: void
@note:
*******************************/
static void simIIC_DelayUs(simIIC_StructDef simIIC)
{<!-- -->
    if(simIIC. DelayMicrosecond == 0) return;
    simIIC.Delay_us(simIIC.DelayMicrosecond);
}

/******************************
@function: Simulate IIC initialization
@param: simIIC-- simIIC_StructDef to be initialized
@return: void
@note:
*******************************/
void simIIC_Init(simIIC_StructDef simIIC)
{<!-- -->
    GPIO_InitTypeDef GPIO_InitStruct = {<!-- -->0};

    simIIC.GPIO_EnableColock();
    GPIO_InitStruct.Pin = simIIC.SDA_Pin;
    GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_OD;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct. Speed = GPIO_SPEED_FREQ_LOW;
    HAL_GPIO_Init(simIIC.SDA_GPIO, &GPIO_InitStruct);
    GPIO_InitStruct.Pin = simIIC.SCL_Pin;
    HAL_GPIO_Init(simIIC.SCL_GPIO, &GPIO_InitStruct);
    dIIC_SCL(simIIC,1);
    dIIC_SDA(simIIC,1);
}

/******************************
@function: IIC start signal
@param: simIIC-- simIIC_StructDef to be initialized
@return: void
@note:
*******************************/
void simIIC_Start(simIIC_StructDef simIIC)
{<!-- -->
    dIIC_SDA_OUT(simIIC);
    dIIC_SDA(simIIC,1);
    dIIC_SCL(simIIC,1);
    simIIC_DelayUs(simIIC);
    dIIC_SDA(simIIC,0);
    simIIC_DelayUs(simIIC);
    dIIC_SCL(simIIC,0);
}

/******************************
@function: IIC end signal
@param: simIIC-- simIIC_StructDef to be initialized
@return: void
@note:
*******************************/
void simIIC_Stop(simIIC_StructDef simIIC)
{<!-- -->
    dIIC_SCL(simIIC,0);
    dIIC_SDA(simIIC,0);
    simIIC_DelayUs(simIIC);

    dIIC_SCL(simIIC,1);
    simIIC_DelayUs(simIIC);
    dIIC_SDA(simIIC,1);
    simIIC_DelayUs(simIIC);
}

/******************************
@function: IIC write data (do not use it otherwise)
@param: data--data to be sent
@return: 0--write success, -1--write failure (slave address does not exist)
@note: Does not contain IIC start, IIC end
*******************************/
signed int simIIC_WriteOneByte(simIIC_StructDef simIIC, unsigned char data)
{<!-- -->
    unsigned char ack = 0, mask = 0;

    dIIC_SDA_OUT(simIIC);
    for(mask=0x80;mask != 0;mask >>= 1)
    {<!-- -->
        dIIC_SDA(simIIC,((mask & amp; data) ? 1 : 0));
        simIIC_DelayUs(simIIC);
        dIIC_SCL(simIIC,1);
        simIIC_DelayUs(simIIC);
        dIIC_SCL(simIIC,0);
    }
    dIIC_SDA(simIIC,1);
    dIIC_SDA_IN(simIIC);
    simIIC_DelayUs(simIIC);
    dIIC_SCL(simIIC,1);
    simIIC_DelayUs(simIIC);
    ack = dIIC_SDA_READ(simIIC);
    dIIC_SCL(simIIC,0);
    dIIC_SDA_OUT(simIIC);

    return (ack? -1:0);
}

/******************************
@function: IIC read data (do not use it otherwise)
@param: ack: 0--answer, 1--no answer
@return: the data read
@note: Does not contain IIC start, IIC end
*******************************/
unsigned char simIIC_ReadOneByte(simIIC_StructDef simIIC, simIIC_xACK_EnumDef ack)
{<!-- -->
    unsigned char mask = 0, data = 0;

    dIIC_SDA(simIIC,1);
    dIIC_SDA_IN(simIIC);
    for(mask=0x80;mask != 0;mask >>= 1)
    {<!-- -->
        simIIC_DelayUs(simIIC);
        dIIC_SCL(simIIC,1);
        simIIC_DelayUs(simIIC);
        data |= ((dIIC_SDA_READ(simIIC))?mask:0);
        dIIC_SCL(simIIC,0);
    }
    dIIC_SDA_OUT(simIIC);
    dIIC_SDA(simIIC,ack);
    simIIC_DelayUs(simIIC);
    dIIC_SCL(simIIC,1);
    simIIC_DelayUs(simIIC);
    dIIC_SCL(simIIC,0);

    return data;
}

/******************************
@function: IIC write data
@param: data--data to be sent
        byteNum - the number of data bytes, excluding address bytes
        address--slave address
@return: 0--write success, -1--write failure (slave address does not exist | data bytes 0)
@note:
*******************************/
signed int simIIC_Write(simIIC_StructDef simIIC, unsigned char *data, unsigned int byteNum, unsigned char address)
{<!-- -->
    unsigned int pos = 0;
    if(byteNum == 0) return -1;

    simIIC_Start(simIIC);
    if(simIIC_WriteOneByte(simIIC,address << 1) < 0){<!-- -->simIIC_Stop(simIIC);return -1;}//address access: write
    for(pos=0;pos < byteNum;pos + + ){<!-- -->if(simIIC_WriteOneByte(simIIC,data[pos]) < 0){<!-- -->simIIC_Stop(simIIC);return -1;}}
    simIIC_Stop(simIIC);
    return 0;
}

/******************************
@function: IIC read data
@param: data-- the read data
        byteNum--the number of data bytes to be read, excluding address bytes
        address--slave address
@return: 0--read successfully, -1--read failed (slave address does not exist | read error)
@note:
*******************************/
signed int simIIC_Read(simIIC_StructDef simIIC, unsigned char *data, unsigned int byteNum, unsigned char address)
{<!-- -->
    unsigned int pos = 0;
    if(byteNum == 0) return -1;
    address = (address << 1) | 0x01;

    simIIC_Start(simIIC);
    if(simIIC_WriteOneByte(simIIC,address) < 0){<!-- -->simIIC_Stop(simIIC);return -1;}//address access: read
    for(pos=0;pos < byteNum;pos + + ){<!-- -->data[pos] = simIIC_ReadOneByte(simIIC,(pos == (byteNum-1))?simIIC_NACK:simIIC_ACK);}
    simIIC_Stop(simIIC);
    return 0;
}

IIC_simulate.h

#ifndef _IIC_simulate_H_
#define _IIC_simulate_H_
#include "gpio.h"

typedef struct
{<!-- -->
    uint32_t SDA_Pin;//SDA pin
    uint32_t SCL_Pin;//SCL pin
    GPIO_TypeDef *SDA_GPIO;//SDA port
    GPIO_TypeDef *SCL_GPIO;//SCL port
    void (*GPIO_EnableColock)(void);//Enable the GPIO clock function of SDA and SCL, user-defined: eg:void SHT3x_GPIO_EnableColock(void)
    unsigned short int DelayMicrosecond;//IIC delay time, the frequency is close to 1/(2*DelayMicrosecond) * 1000000; when it is 0, there is no delay; note that the actual delay of IIC will be slightly longer than this time, because there is still a pin flip time consume
    void (*Delay_us)(unsigned int us);//microsecond delay precise function, user-defined: eg:void Delay_us(unsigned int us)
} simIIC_StructDef;

typedef enum
{<!-- -->
    simIIC_ACK = 0, //IIC response
    simIIC_NACK = 1 //IIC does not respond
} simIIC_xACK_EnumDef;

void simIIC_Init(simIIC_StructDef simIIC);
void simIIC_Start(simIIC_StructDef simIIC);
void simIIC_Stop(simIIC_StructDef simIIC);
signed int simIIC_WriteOneByte(simIIC_StructDef simIIC, unsigned char data);
unsigned char simIIC_ReadOneByte(simIIC_StructDef simIIC,simIIC_xACK_EnumDef ack);
signed int simIIC_Write(simIIC_StructDef simIIC, unsigned char *data, unsigned int byteNum, unsigned char address);
signed int simIIC_Read(simIIC_StructDef simIIC, unsigned char *data, unsigned int byteNum, unsigned char address);

#endif

Example:

eg:
#define dSHT3X_SDA_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dSHT3X_SDA_PORT GPIOB
#define dSHT3X_SDA_PIN GPIO_PIN_3
#define dSHT3X_SCL_CLOCK __HAL_RCC_GPIOB_CLK_ENABLE()
#define dSHT3X_SCL_PORT GPIOB
#define dSHT3X_SCL_PIN GPIO_PIN_4
#define dSHT3X_IIC_ADDRESS 0x44

void SHT3x_GPIO_EnableColock(void)//sht3x initializes the GPIO clock enable function of SDA|SCL of IIC
{<!-- -->
  dSHT3X_SDA_CLOCK;
  dSHT3X_SCL_CLOCK;
}

simIIC_StructDef SHT3X_IIC;//Initialize the IIC structure variable
SHT3X_IIC.SDA_Pin = dSHT3X_SDA_PIN;
SHT3X_IIC.SCL_Pin = dSHT3X_SCL_PIN;
SHT3X_IIC.SDA_GPIO = dSHT3X_SDA_PORT;
SHT3X_IIC.SCL_GPIO = dSHT3X_SCL_PORT;
SHT3X_IIC.GPIO_EnableColock = &SHT3x_GPIO_EnableColock;
SHT3X_IIC.DelayMicrosecond = 1;//IIC speed: 500KHz
SHT3X_IIC.Delay_us = & amp;Delay_us;//External us delay precise function
simIIC_Init(SHT3X_IIC);//Initialize IIC

uint8_t data[6] = {<!-- -->0};
if(simIIC_Read(SHT3X_IIC,data,6,dSHT3X_IIC_ADDRESS) < 0)return -1;//Read 6 bytes of data
if(simIIC_Write(SHT3X_IIC,data,2,dSHT3X_IIC_ADDRESS) < 0) return -1;//write 6 bytes of data

have been tested using