SHT4x

最新推荐文章于 2024-04-27 15:55:07 发布
Haiguozhe
最新推荐文章于 2024-04-27 15:55:07 发布
阅读量510
点赞数
分类专栏：传感器驱动文章标签：开发语言单片机 mcu c语言 Powered by 金山文档
本文链接：https://blog.csdn.net/Haiguozhe/article/details/129235095
版权
传感器驱动专栏收录该内容
11 篇文章 1 订阅
订阅专栏
#ifndef SHT4X_CFG_H_
#define SHT4X_CFG_H_
//
#ifdef __cplusplus
extern "C" {
#endif
    //
    #include "ex_sht4x_drivers.h"
    #include "crc_task.h"    
    //

    //===设备通讯地址
    #define SHT4X_I2C_WADDR                            0x88    //0x8A                                                        //---设备的写地址
    #define SHT4X_I2C_RADDR                            0x89    //0x8B

    #define SHT4X_CMD_T_RH_HIGH                        0xFD
    #define SHT4X_CMD_T_RH_MEDIUM                    0xF6
    #define SHT4X_CMD_T_RH_LOW                        0xE0
    #define SHT4X_CMD_READ_SN                        0x89

    #define SHT4X_CMD_RESET                            0x94
    
    #define SHT4X_CMD_200mW_1000MS                    0x39
    #define SHT4X_CMD_200mW_100MS                    0x32

    #define SHT4X_CMD_110mW_1000MS                    0x2F
    #define SHT4X_CMD_110mW_100MS                    0x24

    #define SHT4X_CMD_20mW_1000MS                    0x1E
    #define SHT4X_CMD_20mW_100MS                    0x15

    #define SHT4X_CMD_SAMPLE_PERIOD                    (uint32_t)(120/SHT4X_MIN_PULSE_WIDTH)

    //===结构体定义
    typedef struct _sht4x_i2c_handle_type            sht4x_i2c_handle_type;
    //===指针结构体定义
    typedef struct _sht4x_i2c_handle_type            *psht4x_i2c_handle_type;
    //===内存管理控制器
    struct _sht4x_i2c_handle_type
    {
        uint8_t msg_lock;                            //---锁定
        uint8_t msg_state;                            //---状态
        uint8_t msg_step;                            //---执行步序
        uint8_t msg_err;                            //---错误

        int32_t    msg_temperaturec_x1000;                //---摄氏度温度
        int32_t    msg_temperaturef_x1000;                //---华氏度温度
        int32_t    msg_humidity_x1000;                    //---湿度

        uint32_t msg_interval_time;                    //---轮询时间间隔,单位是ms
        time_span_t msg_interval_tick;
        time_span_t msg_time_tick;

        ex_sht4x_i2c_def_type msg_sht4x_i2c;        //---sht4x结构
        void(*msg_f_delay_ms)(uint32_t );            //---ms延时
        time_span_t(*msg_f_time_ticks)(void);    //---时间节拍
    };

    #define SHT4X_I2C_TASK_ONE                p_sht4x_i2c_one    //---任务1
    #define SHT4X_I2C_TASK_TWO                0                //---任务2
    #define SHT4X_I2C_TASK_THREE            0

    extern sht4x_i2c_handle_type            g_sht4x_i2c_one;
    extern psht4x_i2c_handle_type            p_sht4x_i2c_one;

    //===函数定义
    uint8_t sht4x_i2c_init(sht4x_i2c_handle_type* SHT4Xx,
        void(*func_delay_us)(uint32_t delay),
        void(*func_delay_ms)(uint32_t delay),
        time_span_t(*func_time_ticks)(void), uint8_t ishw);
    uint8_t sht4x_i2c_exinit(sht4x_i2c_handle_type* SHT4Xx,
        void(*func_delay_us)(uint32_t delay),
        void(*func_delay_ms)(uint32_t delay),
        time_span_t(*func_time_ticks)(void), uint8_t ishw);
    uint8_t sht4x_i2c_rst(sht4x_i2c_handle_type* SHT4Xx);
    uint8_t sht4x_i2c_handle(sht4x_i2c_handle_type* SHT4Xx);
    float sht4x_i2c_get_temperaturec_float(sht4x_i2c_handle_type* SHT4Xx);
    float sht4x_i2c_get_temperaturef_float(sht4x_i2c_handle_type* SHT4Xx);
    float sht4x_i2c_get_humidity_float(sht4x_i2c_handle_type* SHT4Xx);

//
#ifdef __cplusplus
}
#endif
//
#endif /* SHT4X_CFG_H_ */

#include "sht4x_cfg.h"

//===全局变量定义
sht4x_i2c_handle_type            g_sht4x_i2c_one = { 0 };
psht4x_i2c_handle_type            p_sht4x_i2c_one = &g_sht4x_i2c_one;

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_init_one(sht4x_i2c_handle_type* SHT4Xx)
{
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT4X_I2C_SCL_PORT_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT4X_I2C_SCL_BIT_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT4X_I2C_SCL_ALTERNATE_ONE;

    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT4X_I2C_SDA_PORT_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT4X_I2C_SDA_BIT_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT4X_I2C_SDA_ALTERNATE_ONE;

    //---使用的硬件I2C接口
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_p_i2cx = SHT4X_I2C_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_addr_id = SHT4X_ADDR_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_clock_speed = SHT4X_I2C_CLK_HZ_ONE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_pulse_width = SHT4X_PULSE_WIDTH_ONE;
    
    //---转换周期
    SHT4Xx->msg_interval_time = SHT4X_SAMPLE_PERIOD;

    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_init_two(sht4x_i2c_handle_type* SHT4Xx)
{
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT4X_I2C_SCL_PORT_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT4X_I2C_SCL_BIT_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT4X_I2C_SCL_ALTERNATE_TWO;

    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT4X_I2C_SDA_PORT_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT4X_I2C_SDA_BIT_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT4X_I2C_SDA_ALTERNATE_TWO;

    //---使用的硬件I2C接口
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_p_i2cx = SHT4X_I2C_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_addr_id = SHT4X_ADDR_TWO;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_clock_speed = 100000;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_pulse_width = 1;

    //---转换周期
    SHT4Xx->msg_interval_time = SHT4X_SAMPLE_PERIOD;
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_init_three(sht4x_i2c_handle_type* SHT4Xx)
{
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT4X_I2C_SCL_PORT_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT4X_I2C_SCL_BIT_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT4X_I2C_SCL_ALTERNATE_THREE;

    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT4X_I2C_SDA_PORT_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT4X_I2C_SDA_BIT_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT4X_I2C_SDA_ALTERNATE_THREE;

    //---使用的硬件I2C接口
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_p_i2cx = SHT4X_I2C_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_addr_id = SHT4X_ADDR_THREE;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_clock_speed = 100000;
    SHT4Xx->msg_sht4x_i2c.msg_i2cx.msg_pulse_width = 1;

    //---转换周期
    SHT4Xx->msg_interval_time = SHT4X_SAMPLE_PERIOD;
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_init(sht4x_i2c_handle_type* SHT4Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    SHT4Xx->msg_f_time_ticks = func_time_ticks;
    SHT4Xx->msg_f_delay_ms = func_delay_ms;

    if ((SHT4Xx != NULL) && (SHT4Xx == SHT4X_I2C_TASK_ONE))
    {
        sht4x_i2c_init_one(SHT4Xx);
    }
    else if ((SHT4Xx != NULL) && (SHT4Xx == SHT4X_I2C_TASK_TWO))
    {
        sht4x_i2c_init_two(SHT4Xx);
    }
    else if ((SHT4Xx != NULL) && (SHT4Xx == SHT4X_I2C_TASK_THREE))
    {
        sht4x_i2c_init_three(SHT4Xx);
    }
    else
    {
        return ERROR_2;
    }
    SHT4Xx->msg_time_tick = SHT4Xx->msg_f_time_ticks();
    SHT4Xx->msg_interval_tick = SHT4Xx->msg_f_time_ticks();
    //---初始化
    ex_sht4x_i2c_init(&(SHT4Xx->msg_sht4x_i2c),
        func_delay_us, func_delay_ms, func_time_ticks, ishw);
    //---初始化配置
    return OK_0;
}

///
//函        数: 
//功        能: 外部初始化定义
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_exinit(sht4x_i2c_handle_type* SHT4Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    SHT4Xx->msg_f_time_ticks = func_time_ticks;
    SHT4Xx->msg_f_delay_ms = func_delay_ms;
    SHT4Xx->msg_time_tick = SHT4Xx->msg_f_time_ticks();
    SHT4Xx->msg_interval_tick = SHT4Xx->msg_f_time_ticks();
    //---初始化
    ex_sht4x_i2c_init(&(SHT4Xx->msg_sht4x_i2c),
        func_delay_us, func_delay_ms, func_time_ticks, ishw);
    //---初始化配置
    return OK_0;
}

///
//函        数: 
//功        能: 读数据
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_read(sht4x_i2c_handle_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    return ex_sht4x_i2c_read(&(SHT4Xx->msg_sht4x_i2c), buffer, length);
}

///
//函        数: 
//功        能: 写数据
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_send(sht4x_i2c_handle_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    return ex_sht4x_i2c_send(&(SHT4Xx->msg_sht4x_i2c), buffer, length);
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//

uint8_t sht4x_i2c_rst(sht4x_i2c_handle_type* SHT4Xx)
{
    uint8_t tempcmd = SHT4X_CMD_RESET;
    return sht4x_i2c_send(SHT4Xx, &tempcmd, 1);
}

///
//函        数: 
//功        能: 读取温湿度信息
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_read_temperature_humidity(sht4x_i2c_handle_type* SHT4Xx)
{
    uint8_t _return = OK_0;
    uint8_t tempres[6] = {0};
    uint8_t tempcrc[2] = { 0 };
    double temptth = 0;
    //---读取采样结果
    _return = sht4x_i2c_read(SHT4Xx, tempres, 6);
    //---crc校验温度
    tempcrc[0] = crc_task_crc8_type(CRC8_TYPE_TABLE_31H_1, tempres, 2);
    //---crc校验湿度
    tempcrc[1] = crc_task_crc8_type(CRC8_TYPE_TABLE_31H_1, tempres + 3, 2);
    //----判断校验信息
    if ((tempres[2]==tempcrc[0])&&
        (tempres[5] == tempcrc[1])&&
        (_return==OK_0))
    {
        //---计算摄氏温度数据
        temptth = tempres[0];
        temptth *= 256;
        temptth +=tempres[1];
        temptth *= 175;
        temptth /= 65535;
        temptth -= 45;
        SHT4Xx->msg_temperaturec_x1000 = (int32_t)(temptth * 1000);

        //---计算华氏温度数据
        temptth = tempres[0];
        temptth *= 256;
        temptth += tempres[1];
        temptth *= 315;
        temptth /= 65535;
        temptth -= 49;
        SHT4Xx->msg_temperaturef_x1000 = (int32_t)(temptth * 1000);

        //---计算湿度
        temptth = tempres[3];
        temptth *= 256;
        temptth += tempres[4];
        temptth *= 125;
        temptth /= 65535;
        temptth -= 6;
        SHT4Xx->msg_humidity_x1000 = (int32_t)(temptth * 1000);
    }
    else
    {
        _return = ERROR_8;
    }
    return _return;
}

///
//函        数: 
//功        能: 温湿度数据进行处理
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht4x_i2c_handle(sht4x_i2c_handle_type* SHT4Xx)
{
    uint8_t _return = OK_0;
    //---判断采集周期是否到达
    if (TIME_SPAN_T(SHT4Xx->msg_f_time_ticks(), SHT4Xx->msg_interval_tick)> SHT4Xx->msg_interval_time)
    {
        switch (SHT4Xx->msg_step)
        {
            //---发送命令
            case 0:
            {
                //---发送配置信息
                _return = SHT4X_CMD_T_RH_HIGH;
                _return = sht4x_i2c_send(SHT4Xx, &_return, 1);
                //---更新时间节点
                SHT4Xx->msg_time_tick=SHT4Xx->msg_f_time_ticks();
                //---下一步
                SHT4Xx->msg_step++;
                break;
            }
            //---命令发送等待100ms
            case 1:
            {
                //---检查采样周期是否到达
                if (TIME_SPAN_T(SHT4Xx->msg_f_time_ticks(),SHT4Xx->msg_time_tick)> SHT4X_CMD_SAMPLE_PERIOD)
                {
                    //---读取温湿度数据
                    _return = sht4x_i2c_read_temperature_humidity(SHT4Xx);
                    //---更新时间节点
                    SHT4Xx->msg_time_tick = SHT4Xx->msg_f_time_ticks();
                    //---下一步
                    SHT4Xx->msg_step++;
                }
                break;
            }
            //---温湿度信息采样完成
            case 2:
            default:
            {
                //---更新周期时间
                SHT4Xx->msg_interval_tick = SHT4Xx->msg_f_time_ticks();
                //---更新时间节点
                SHT4Xx->msg_time_tick = SHT4Xx->msg_f_time_ticks();
                //---下一步
                SHT4Xx->msg_step=0;
                break;
            }
        }
    }
    return _return;
}

///
//函        数: 
//功        能: 摄氏度
//输入参    数: 
//输出参    数: 
//说        明: 
//
float sht4x_i2c_get_temperaturec_float(sht4x_i2c_handle_type* SHT4Xx)
{
    float _return = SHT4Xx->msg_temperaturec_x1000;

    return (_return / 1000.0f);
}

///
//函        数: 
//功        能: 华氏度
//输入参    数: 
//输出参    数: 
//说        明: 
//
float sht4x_i2c_get_temperaturef_float(sht4x_i2c_handle_type* SHT4Xx)
{
    float _return = SHT4Xx->msg_temperaturef_x1000;

    return (_return / 1000.0f);
}

///
//函        数: 
//功        能: 湿度
//输入参    数: 
//输出参    数: 
//说        明: 
//
float sht4x_i2c_get_humidity_float(sht4x_i2c_handle_type* SHT4Xx)
{
    float _return = SHT4Xx->msg_humidity_x1000;

    return (_return / 1000.0f);
}

#ifndef EX_SHT4X_DRIVERS_H_
#define EX_SHT4X_DRIVERS_H_
//
#ifdef __cplusplus
extern "C" {
#endif
    //
    #include "complier_lib.h"
    #include "hw_config.h"
    #include "ex_i2c_drivers.h"
    //
    //===定义结构体    
    typedef struct _ex_sht4x_i2c_def_type            ex_sht4x_i2c_def_type;
    //===定义结构体    
    typedef struct _ex_sht4x_i2c_def_type            ex_sht4x_i2c_def_t;
    //===定义指针结构体
    typedef struct _ex_sht4x_i2c_def_type            * pex_sht4x_i2c_def_type;
    //===结构体定义
    struct _ex_sht4x_i2c_def_type
    {
        ex_i2c_def_type msg_i2cx;
        void(*msg_f_delay_us)(uint32_t );            //---毫秒延时函数,编程结束后需要等待5ms
        void(*msg_f_delay_ms)(uint32_t );            //---ms延时
        time_span_t(*msg_f_time_ticks)(void);        //---时间节拍
    };

    //===函数定义
    uint8_t ex_sht4x_i2c_init(ex_sht4x_i2c_def_type* SHT4Xx,
        void(*func_delay_us)(uint32_t delay),
        void(*func_delay_ms)(uint32_t delay),
        time_span_t(*func_time_ticks)(void), uint8_t ishw);
    uint8_t ex_sht4x_i2c_deinit(ex_sht4x_i2c_def_type* SHT4Xx);
    uint8_t ex_sht4x_i2c_read(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length);
    uint8_t ex_sht4x_i2c_send(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length);
    
    //
#ifdef __cplusplus
}
#endif
//
#endif /* EX_SHT4X_DRIVERS_H_ */

#include "ex_sht4x_drivers.h"


///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_init_hw(ex_sht4x_i2c_def_type* SHT4Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    ex_i2c_master_init_hw(&(SHT4Xx->msg_i2cx), 
        func_delay_us,
        func_time_ticks,ishw);

    //---注册函数
    SHT4Xx->msg_f_delay_us = func_delay_us;
    SHT4Xx->msg_f_delay_ms = func_delay_ms;
    SHT4Xx->msg_f_time_ticks = func_time_ticks;

    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_sw_init(ex_sht4x_i2c_def_type* SHT4Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    ex_i2c_master_init_sw(&(SHT4Xx->msg_i2cx),
        func_delay_us,
        func_time_ticks, ishw);

    //---注册函数
    SHT4Xx->msg_f_delay_us = func_delay_us;
    SHT4Xx->msg_f_delay_ms = func_delay_ms;
    SHT4Xx->msg_f_time_ticks = func_time_ticks;

    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_init(ex_sht4x_i2c_def_type* SHT4Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    //---校验初始化硬件模式还是软件模式
    if (ishw != 0)
    {
        return ex_sht4x_i2c_init_hw(SHT4Xx,
            func_delay_us, func_delay_ms, func_time_ticks,ishw);
    }
    else
    {
        return ex_sht4x_i2c_sw_init(SHT4Xx,
            func_delay_us, func_delay_ms, func_time_ticks, ishw);
    }
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_deinit(ex_sht4x_i2c_def_type* SHT4Xx)
{
    if (SHT4Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_i2c_deinit_hw(&(SHT4Xx->msg_i2cx));
    }
    else
    {
        return ex_i2c_deinit_sw(&(SHT4Xx->msg_i2cx));
    }
}


///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_send_bits8_sw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动信号
    ex_i2c_master_start_sw_poll(&(SHT4Xx->msg_i2cx));
    //---发送从机地址
    ex_i2c_master_send_addr_sw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) & 0xFE);
    //---读取应答信号
    _return = ex_i2c_master_receive_ack_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_3;
        goto GoExit;
    }
    //---数据发送
    ex_i2c_master_send_bits8_sw_poll(&(SHT4Xx->msg_i2cx), val, 1);
    //---读取ACK
    _return = ex_i2c_master_receive_ack_sw_poll(&(SHT4Xx->msg_i2cx));
    //---退出操作入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_sw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_send_bits8_hw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) & 0xFE);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT4Xx->msg_i2cx),
            (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) & 0xFE);
        //---校验状态
        if (_return != OK_0)
        {
            _return = ERROR_3;
            goto GoExit;
        }
    }
    //---发送指定地址的数据
    _return = ex_i2c_master_send_bits8_hw_poll(&(SHT4Xx->msg_i2cx), val, 1);
    //---校验状态
    if (_return != OK_0)
    {
        _return = ERROR_4;
        goto GoExit;
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}
///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_send_sw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_send_hw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_read_bits8_sw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动信号
    ex_i2c_master_start_sw_poll(&(SHT4Xx->msg_i2cx));
    //---发送从机地址
    ex_i2c_master_send_addr_sw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---读取应答信号
    _return = ex_i2c_master_receive_ack_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动读数据失败
        _return = ERROR_3;
        goto GoExit;
    }
    //---读取数据
    (*val) = ex_i2c_master_receive_bits8_sw_poll(&(SHT4Xx->msg_i2cx));
    //---发送不应答信号
    _return = ex_i2c_master_send_ack_sw_poll(&(SHT4Xx->msg_i2cx), 1);
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_sw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_read_bits8_hw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT4Xx->msg_i2cx),
            (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
        //---校验
        if (_return != OK_0)
        {
            _return = ERROR_3;
            goto GoExit;
        }
    }
    //---发送应答
    _return = ex_i2c_master_send_ack_hw_poll(&(SHT4Xx->msg_i2cx), 1);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_4;
        goto GoExit;
    }
    //---数据读取
    _return = ex_i2c_master_receive_bits8_hw_poll(&(SHT4Xx->msg_i2cx), val, 1, 0);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_5;
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_read_sw_poll(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    uint8_t _return = OK_0;
    uint16_t index = 0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动信号
    ex_i2c_master_start_sw_poll(&(SHT4Xx->msg_i2cx));
    //---发送从机地址
    ex_i2c_master_send_addr_sw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---读取应答信号
    _return = ex_i2c_master_receive_ack_sw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动读数据失败
        _return = ERROR_3;
        goto GoExit;
    }
    //---循环读取指定长度的数据
    for (index = 0; index < length; index++)
    {
        //---读取数据
        buffer[index] = ex_i2c_master_receive_bits8_sw_poll(&(SHT4Xx->msg_i2cx));
        //---发送应答信号
        ex_i2c_master_send_ack_sw_poll(&(SHT4Xx->msg_i2cx),
            (index == (length - 1)) ? 1 : 0);
    }
    _return = OK_0;
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_sw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_read_hw_poll(ex_sht4x_i2c_def_type* SHT4Xx,
    uint8_t* buffer, uint16_t length)
{
    uint8_t _return = OK_0;
    uint16_t index = 0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT4Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT4Xx->msg_i2cx),
        (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT4Xx->msg_i2cx),
            (uint8_t)(SHT4Xx->msg_i2cx.msg_addr_id) | 0x01);
        //---校验
        if (_return != OK_0)
        {
            _return = ERROR_5;
            goto GoExit;
        }
    }
    //---发送应答
    _return = ((length > 1) ? 0 : 1);
    //---发送应答
    _return = ex_i2c_master_send_ack_hw_poll(&(SHT4Xx->msg_i2cx), _return);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_6;
        goto GoExit;
    }
    for (index = 0; index < length; index++)
    {
        //---校验发送NACK
        if (((length > 1) && (index == (length - 2))) ||
            (index == (length - 1)))
        {
            _return = 1;
        }
        else
        {
            _return = 0;
        }
        //---数据读取
        _return = ex_i2c_master_receive_bits8_hw_poll(&(SHT4Xx->msg_i2cx),
            &buffer[index],
            _return,
            (index < (length - 1)) ? 1 : 0);
        //---校验
        if (_return != OK_0)
        {
            _return = ERROR_7;
            break;
        }
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT4Xx->msg_i2cx));
    return _return;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_read(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    if (SHT4Xx->msg_i2cx.msg_hw != 0)
    {
        if (length > 1)
        {
            return ex_sht4x_i2c_read_hw_poll(SHT4Xx, buffer, length);
        }
        else
        {
            return ex_sht4x_i2c_read_bits8_hw_poll(SHT4Xx, buffer);
        }
    }
    else
    {
        if (length > 1)
        {
            return ex_sht4x_i2c_read_sw_poll(SHT4Xx, buffer, length);
        }
        else
        {
            return ex_sht4x_i2c_read_bits8_sw_poll(SHT4Xx, buffer);
        }
    }
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht4x_i2c_send(ex_sht4x_i2c_def_type* SHT4Xx, uint8_t* buffer, uint16_t length)
{
    if (SHT4Xx->msg_i2cx.msg_hw != 0)
    {
        if (length > 1)
        {
            return ex_sht4x_i2c_send_hw_poll(SHT4Xx, buffer, length);
        }
        else
        {
            return ex_sht4x_i2c_send_bits8_hw_poll(SHT4Xx, *buffer);
        }
    }
    else
    {
        if (length > 1)
        {
            return ex_sht4x_i2c_send_sw_poll(SHT4Xx, buffer, length);
        }
        else
        {
            return ex_sht4x_i2c_send_bits8_sw_poll(SHT4Xx, *buffer);
        }
    }
}