SHT2x

最新推荐文章于 2024-09-16 11:29:33 发布
最新推荐文章于 2024-09-16 11:29:33 发布
阅读量200 收藏
点赞数
分类专栏： 传感器驱动 文章标签： 开发语言 c语言 mcu 单片机 Powered by 金山文档
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Haiguozhe/article/details/129235284
版权 
#ifndef EX_SHT2X_DRIVERS_H_
#define EX_SHT2X_DRIVERS_H_
//
#ifdef __cplusplus
extern "C" {
#endif
    //
    #include "complier_lib.h"
    #include "hw_config.h"
    #include "ex_i2c_drivers.h"
    //
    //===定义结构体    
    typedef struct _ex_sht2x_i2c_def_type            ex_sht2x_i2c_def_type;
    //===定义结构体    
    typedef struct _ex_sht2x_i2c_def_type            ex_sht2x_i2c_def_t;
    //===定义指针结构体
    typedef struct _ex_sht2x_i2c_def_type            * pex_sht2x_i2c_def_type;
    //===结构体定义
    struct _ex_sht2x_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_sht2x_i2c_init(ex_sht2x_i2c_def_type* SHT2Xx,
        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_sht2x_i2c_deinit(ex_sht2x_i2c_def_type* SHT2Xx);
    uint8_t ex_sht2x_i2c_rst(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd);
    uint8_t ex_sht2x_i2c_read_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t* val);
    uint8_t ex_sht2x_i2c_send_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t  val);

    uint8_t ex_sht2x_i2c_poll_cmd(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd);
    uint8_t ex_sht2x_i2c_poll_data(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t* dat);

    //
#ifdef __cplusplus
}
#endif
//
#endif /* EX_SHT2X_DRIVERS_H_ */

#include "ex_sht2x_drivers.h"


///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_init_hw(ex_sht2x_i2c_def_type* SHT2Xx,
    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(&(SHT2Xx->msg_i2cx),
        func_delay_us, 
        func_time_ticks,
        ishw);
    //---注册函数
    SHT2Xx->msg_f_delay_us = func_delay_us;
    SHT2Xx->msg_f_delay_ms = func_delay_ms;
    SHT2Xx->msg_f_time_ticks = func_time_ticks;
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_sw_init(ex_sht2x_i2c_def_type* SHT2Xx,
    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(&(SHT2Xx->msg_i2cx),
        func_delay_us,
        func_time_ticks, ishw);

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

    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_init(ex_sht2x_i2c_def_type* SHT2Xx,
    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_sht2x_i2c_init_hw(SHT2Xx,
            func_delay_us, func_delay_ms, func_time_ticks,ishw);
    }
    else
    {
        return ex_sht2x_i2c_sw_init(SHT2Xx,
            func_delay_us, func_delay_ms, func_time_ticks, ishw);
    }
}

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

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

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

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_rst(ex_sht2x_i2c_def_type* SHT2Xx,uint8_t cmd)
{
    if (SHT2Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_sht2x_i2c_hw_rst(SHT2Xx, cmd);
    }
    else
    {
        return ex_sht2x_i2c_sw_rst(SHT2Xx, cmd);
    }
}


///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_hw_read_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t* val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT2Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) & 0xFE);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT2Xx->msg_i2cx),
            (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) & 0xFE);
        //---校验状态
        if (_return != OK_0)
        {
            _return = ERROR_3;
            goto GoExit;
        }
    }
    //---发送寄存器地址,低地址
    _return = ex_i2c_master_send_bits8_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(cmd & 0xFF), 0);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_4;
        goto GoExit;
    }
    //---发送重新启动命令
    ex_i2c_master_restart_hw_poll(&(SHT2Xx->msg_i2cx));
    //---发送i2c设备地址,读地址
    _return = ex_i2c_master_send_addr_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_5;
        goto GoExit;
    }
    //---发送应答
    _return = ex_i2c_master_send_ack_hw_poll(&(SHT2Xx->msg_i2cx), 1);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_6;
        goto GoExit;
    }
    //---数据读取
    _return = ex_i2c_master_receive_bits8_hw_poll(&(SHT2Xx->msg_i2cx), val, 1, 0);
    //---校验
    if (_return != OK_0)
    {
        _return = ERROR_7;
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT2Xx->msg_i2cx));
    return _return;
}

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

///
//函        数: 
//功        能: 读取寄存器
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_read_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t* val)
{
    if (SHT2Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_sht2x_i2c_hw_read_reg(SHT2Xx, cmd,val);
    }
    else
    {
        return ex_sht2x_i2c_sw_read_reg(SHT2Xx, cmd,val);
    }
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_hw_send_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t  val)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT2Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    ex_i2c_master_start_hw_poll(&(SHT2Xx->msg_i2cx));
    //---发送i2c设备地址
    _return = ex_i2c_master_send_addr_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) & 0xFE);
    //---校验状态
    if (_return != OK_0)
    {
        _return = ERROR_3;
        goto GoExit;
    }
    //---发送寄存器地址,低地址
    _return = ex_i2c_master_send_bits8_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(cmd & 0xFF), 0);
    //---校验状态
    if (_return != OK_0)
    {
        _return = ERROR_4;
        goto GoExit;
    }
    //---读取指定地址的数据
    _return = ex_i2c_master_send_bits8_hw_poll(&(SHT2Xx->msg_i2cx), val, 0);
    //---校验状态
    if (_return != OK_0)
    {
        _return = ERROR_5;
        goto GoExit;
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT2Xx->msg_i2cx));
    return _return;
}

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

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_send_reg(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd, uint8_t  val)
{
    if (SHT2Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_sht2x_i2c_hw_send_reg(SHT2Xx, cmd, val);
    }
    else
    {
        return ex_sht2x_i2c_send_sw_reg(SHT2Xx, cmd, val);
    }
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_hw_poll_cmd(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd)
{
    uint8_t _return = OK_0;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT2Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) & 0xFE);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT2Xx->msg_i2cx),
            (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) & 0xFE);
        //---校验状态
        if (_return != OK_0)
        {
            _return = ERROR_3;
            goto GoExit;
        }
    }
    //---发送指定地址的数据
    _return = ex_i2c_master_send_bits8_hw_poll(&(SHT2Xx->msg_i2cx), cmd, 1);
    //---校验状态
    if (_return != OK_0)
    {
        _return = ERROR_2;
        goto GoExit;
    }
    //---延时等待20us
    SHT2Xx->msg_f_delay_us(22);
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT2Xx->msg_i2cx));
    return _return;
}

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

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_poll_cmd(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t cmd)
{
    if (SHT2Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_sht2x_i2c_hw_poll_cmd(SHT2Xx, cmd);
    }
    else
    {
        return ex_sht2x_i2c_sw_poll_cmd(SHT2Xx, cmd);
    }
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_hw_poll_data(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t *dat)
{
    uint8_t _return = OK_0;
    uint16_t index = 0,length=3;
    //---检查空闲
    _return = ex_i2c_master_check_busy_hw_poll(&(SHT2Xx->msg_i2cx));
    if (_return != OK_0)
    {
        //---启动写数据失败
        _return = ERROR_2;
        goto GoExit;
    }
    //---发送启动命令
    _return = ex_i2c_master_start_addr_hw_poll(&(SHT2Xx->msg_i2cx),
        (uint8_t)(SHT2Xx->msg_i2cx.msg_addr_id) | 0x01);
    //---判断发送结果
    if (_return != OK_0)
    {
        //---发送重新启动命令
        _return = ex_i2c_master_restart_addr_hw_poll(&(SHT2Xx->msg_i2cx),
            (uint8_t)(SHT2Xx->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(&(SHT2Xx->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(&(SHT2Xx->msg_i2cx),
            &dat[index],
            _return,
            (index < (length - 1)) ? 1 : 0);
        //---校验
        if (_return != OK_0)
        {
            _return = ERROR_7;
            break;
        }
    }
    //---退出函数入口
GoExit:
    //---发送停止信号
    ex_i2c_master_stop_hw_poll(&(SHT2Xx->msg_i2cx));
    return _return;
}

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

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t ex_sht2x_i2c_poll_data(ex_sht2x_i2c_def_type* SHT2Xx, uint8_t* dat)
{
    if (SHT2Xx->msg_i2cx.msg_hw != 0)
    {
        return ex_sht2x_i2c_hw_poll_data(SHT2Xx, dat);
    }
    else
    {
        return ex_sht2x_i2c_sw_poll_data(SHT2Xx, dat);
    }
}



#ifndef SHT2X_CFG_H_
#define SHT2X_CFG_H_
//
#ifdef __cplusplus
extern "C" {
#endif
    //
    #include "ex_sht2x_drivers.h"
    #include "crc_task.h"
    //

    #define SHT2X_CMD_HOLD_T        0xE3
    #define SHT2X_CMD_HOLD_TH        0xE5

    #define SHT2X_CMD_POLL_T        0xF3
    #define SHT2X_CMD_POLL_TH        0xF5

    #define SHT2X_CMD_REG_READ        0xE7
    #define SHT2X_CMD_REG_SEND        0xE6

    #define SHT2X_CMD_RST            0xFE

    #define SHT2X_RH12BIT_T14BIT    0x00
    #define SHT2X_RH8BIT_T12BIT        0x01
    #define SHT2X_RH10BIT_T13BIT    0x80
    #define SHT2X_RH11BIT_T11BIT    0x81
    #define SHT2X_RHBIT_TBIT_MASK    0x81

    #define SHT2X_HEATER_ON            0x04
    #define SHT2X_HEATER_OFF        0x00
    #define SHT2X_HEATER_MASK        0x04

    #define SHT2X_EOB_ON            0x40
    #define SHT2X_EOB_MASK            0x40

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

        uint8_t    msg_reg;                            //---配置寄存器
        uint8_t    msg_reserve[3];                        //---保留

        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_sht2x_i2c_def_type msg_sht2x_i2c;        //---sht2x结构
        void(*msg_f_delay_ms)(uint32_t );        //---ms延时
        time_span_t(*msg_f_time_ticks)(void);            //---时间节拍
    };

    #define SHT2X_I2C_TASK_ONE                p_sht2x_i2c_one    //---任务1
    #define SHT2X_I2C_TASK_TWO                0                //---任务2
    #define SHT2X_I2C_TASK_THREE            0

    extern sht2x_i2c_handle_type            g_sht2x_i2c_one;
    extern psht2x_i2c_handle_type            p_sht2x_i2c_one;

    //===函数定义
    uint8_t sht2x_i2c_init(sht2x_i2c_handle_type* SHT2Xx,
        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 sht2x_i2c_exinit(sht2x_i2c_handle_type* SHT2Xx,
        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 sht2x_i2c_rst(sht2x_i2c_handle_type* SHT2Xx);
    uint8_t sht2x_i2c_poll_handle(sht2x_i2c_handle_type* SHT2Xx);
    float sht2x_i2c_get_temperaturec_float(sht2x_i2c_handle_type* SHT2Xx);
    float sht2x_i2c_get_temperaturef_float(sht2x_i2c_handle_type* SHT2Xx);
    float sht2x_i2c_get_humidity_float(sht2x_i2c_handle_type* SHT2Xx);

//
#ifdef __cplusplus
}
#endif
//
#endif /* SHT2X_CFG_H_ */

#include "sht2x_cfg.h"


//===全局变量定义
sht2x_i2c_handle_type            g_sht2x_i2c_one = { 0 };
psht2x_i2c_handle_type            p_sht2x_i2c_one = &g_sht2x_i2c_one;

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_init_one(sht2x_i2c_handle_type* SHT2Xx)
{
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT2X_I2C_SCL_PORT_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT2X_I2C_SCL_BIT_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT2X_I2C_SCL_ALTERNATE_ONE;

    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT2X_I2C_SDA_PORT_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT2X_I2C_SDA_BIT_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT2X_I2C_SDA_ALTERNATE_ONE;

    //---使用的硬件I2C接口
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_p_i2cx = SHT2X_I2C_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_addr_id = SHT2X_ADDR_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_clock_speed = SHT2X_I2C_CLK_HZ_ONE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_pulse_width = SHT2X_PULSE_WIDTH_ONE;

    //---转换周期
    SHT2Xx->msg_interval_time = 100;
    //---寄存器默认值
    SHT2Xx->msg_reg = 0x02;

    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_init_two(sht2x_i2c_handle_type* SHT2Xx)
{
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT2X_I2C_SCL_PORT_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT2X_I2C_SCL_BIT_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT2X_I2C_SCL_ALTERNATE_TWO;

    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT2X_I2C_SDA_PORT_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT2X_I2C_SDA_BIT_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT2X_I2C_SDA_ALTERNATE_TWO;

    //---使用的硬件I2C接口
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_p_i2cx = SHT2X_I2C_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_addr_id = SHT2X_ADDR_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_clock_speed = SHT2X_I2C_CLK_HZ_TWO;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_pulse_width = SHT2X_PULSE_WIDTH_TWO;

    //---转换周期
    SHT2Xx->msg_interval_time = 100;
    //---寄存器默认值
    SHT2Xx->msg_reg = 0x02;
    return OK_0;
}

///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_init_three(sht2x_i2c_handle_type* SHT2Xx)
{
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_p_portx = SHT2X_I2C_SCL_PORT_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_bit = SHT2X_I2C_SCL_BIT_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sclx.msg_alternate = SHT2X_I2C_SCL_ALTERNATE_THREE;

    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_p_portx = SHT2X_I2C_SDA_PORT_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_bit = SHT2X_I2C_SDA_BIT_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_gpio_sdax.msg_alternate = SHT2X_I2C_SDA_ALTERNATE_THREE;

    //---使用的硬件I2C接口
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_p_i2cx = SHT2X_I2C_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_addr_id = SHT2X_ADDR_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_clock_speed = SHT2X_I2C_CLK_HZ_THREE;
    SHT2Xx->msg_sht2x_i2c.msg_i2cx.msg_pulse_width = SHT2X_PULSE_WIDTH_THREE;

    //---转换周期
    SHT2Xx->msg_interval_time = 100;
    //---寄存器默认值
    SHT2Xx->msg_reg = 0x02;
    return OK_0;
}

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

    if ((SHT2Xx != NULL) && (SHT2Xx == SHT2X_I2C_TASK_ONE))
    {
        sht2x_i2c_init_one(SHT2Xx);
    }
    else if ((SHT2Xx != NULL) && (SHT2Xx == SHT2X_I2C_TASK_TWO))
    {
        sht2x_i2c_init_two(SHT2Xx);
    }
    else if ((SHT2Xx != NULL) && (SHT2Xx == SHT2X_I2C_TASK_THREE))
    {
        sht2x_i2c_init_three(SHT2Xx);
    }
    else
    {
        return ERROR_2;
    }
    SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
    SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
    //---初始化
    ex_sht2x_i2c_init(&(SHT2Xx->msg_sht2x_i2c),
        func_delay_us, func_delay_ms, func_time_ticks, ishw);
    //---初始化配置
    SHT2Xx->msg_step = 0;
    return OK_0;
}

///
//函        数: 
//功        能: 外部拓展定义
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_exinit(sht2x_i2c_handle_type* SHT2Xx,
    void(*func_delay_us)(uint32_t delay),
    void(*func_delay_ms)(uint32_t delay),
    time_span_t(*func_time_ticks)(void), uint8_t ishw)
{
    SHT2Xx->msg_f_time_ticks = func_time_ticks;
    SHT2Xx->msg_f_delay_ms = func_delay_ms;
    SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
    SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
    //---初始化
    ex_sht2x_i2c_init(&(SHT2Xx->msg_sht2x_i2c),
        func_delay_us, func_delay_ms, func_time_ticks, ishw);
    //---初始化配置
    SHT2Xx->msg_step = 0;
    return OK_0;
}


///
//函        数: 
//功        能: 
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_rst(sht2x_i2c_handle_type* SHT2Xx)
{
    uint8_t _return = ERROR_1;
    //---发送复位命令
    _return= ex_sht2x_i2c_rst(&(SHT2Xx->msg_sht2x_i2c), SHT2X_CMD_RST);
    //---校验指令发送结果
    if (_return==OK_0)
    {
        //---寄存器默认值
        SHT2Xx->msg_reg = 0x02;
    }
    return _return;
}

///
//函        数: 
//功        能: 设置测量时间
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_set_measure_time(sht2x_i2c_handle_type* SHT2Xx, uint8_t reg, uint8_t ishumi)
{
    switch ((reg & SHT2X_RHBIT_TBIT_MASK))
    {
        case SHT2X_RH8BIT_T12BIT:
        {
            if (ishumi != 0)
            {
                SHT2Xx->msg_interval_time = 5 / SHT2X_MIN_PULSE_WIDTH;
            }
            else
            {
                SHT2Xx->msg_interval_time = 24 / SHT2X_MIN_PULSE_WIDTH;
            }
            break;
        }
        case SHT2X_RH10BIT_T13BIT:
        {
            if (ishumi != 0)
            {
                SHT2Xx->msg_interval_time = 10 / SHT2X_MIN_PULSE_WIDTH;
            }
            else
            {
                SHT2Xx->msg_interval_time = 45 / SHT2X_MIN_PULSE_WIDTH;
            }
            break;
        }
        case SHT2X_RH11BIT_T11BIT:
        {
            if (ishumi != 0)
            {
                SHT2Xx->msg_interval_time = 15 / SHT2X_MIN_PULSE_WIDTH;
            }
            else
            {
                SHT2Xx->msg_interval_time = 12 / SHT2X_MIN_PULSE_WIDTH;
            }
            break;
        }
        case SHT2X_RH12BIT_T14BIT:
        default:
        {
            if (ishumi != 0)
            {
                SHT2Xx->msg_interval_time = 30 / SHT2X_MIN_PULSE_WIDTH;
            }
            else
            {
                SHT2Xx->msg_interval_time = 90 / SHT2X_MIN_PULSE_WIDTH;
            }
            break;
        }
    }
    return OK_0;
}


///
//函        数: 
//功        能: 读取用户寄存器
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_read_reg(sht2x_i2c_handle_type* SHT2Xx)
{
    return ex_sht2x_i2c_read_reg(&(SHT2Xx->msg_sht2x_i2c), SHT2X_CMD_REG_READ, &(SHT2Xx->msg_reg));
}

///
//函        数: 
//功        能: 写用户寄存器
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_send_reg(sht2x_i2c_handle_type* SHT2Xx, uint8_t reg)
{
    SHT2Xx->msg_reg &= ~reg;
    SHT2Xx->msg_reg |= reg;
    sht2x_i2c_set_measure_time(SHT2Xx, SHT2Xx->msg_reg, 0);
    return ex_sht2x_i2c_send_reg(&(SHT2Xx->msg_sht2x_i2c), SHT2X_CMD_REG_SEND, SHT2Xx->msg_reg);
}


///
//函        数: 
//功        能: 轮训处理
//输入参    数: 
//输出参    数: 
//说        明: 
//
uint8_t sht2x_i2c_poll_handle(sht2x_i2c_handle_type* SHT2Xx)
{
    uint8_t _return =OK_0;
    double temptth = 0;
    switch (SHT2Xx->msg_step)
    {
        //---初始化
        case 0:
        {
            SHT2Xx->msg_step += 1;
            //---更新时间节点
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
        //---温度测试 1
        case 1:
        {
            //---发送温度测试命令
            _return = ex_sht2x_i2c_poll_cmd(&(SHT2Xx->msg_sht2x_i2c), SHT2X_CMD_POLL_T);
            //---设置轮训时间
            sht2x_i2c_set_measure_time(SHT2Xx, SHT2Xx->msg_reg, 0);
            //---下一步
            SHT2Xx->msg_step += 1;
            //---更新轮训节点
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            //---更新时间节点
            SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
        //---温度测试 2
        case 2:
        {
            //---检查时间间隔是否到达
            if (TIME_SPAN_T(SHT2Xx->msg_f_time_ticks(), SHT2Xx->msg_interval_tick)>
                SHT2Xx->msg_interval_time)
            {
                //---更新轮训节点
                SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
                //---读取温度数据
                _return = ex_sht2x_i2c_poll_data(&(SHT2Xx->msg_sht2x_i2c), SHT2Xx->msg_reserve);
                //---校验温度的读取结果
                if (_return==OK_0)
                {
                    //---下一步
                    SHT2Xx->msg_step += 1;
                    //---更新时间节点
                    SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
                }
                else
                {
                    if (TIME_SPAN_T(SHT2Xx->msg_f_time_ticks(), SHT2Xx->msg_time_tick) >
                        (SHT2Xx->msg_interval_time>>1))
                    {
                        //---下一步
                        SHT2Xx->msg_step += 2;
                        //---更新时间节点
                        SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
                    }
                }
            }
            break;
        }
        //---温度测试 3
        case 3:
        {
            //---计算crc
            _return = crc_task_crc8_type(CRC8_TYPE_TABLE_31H_0, SHT2Xx->msg_reserve, 2);
            //---校验crc
            if (_return== SHT2Xx->msg_reserve[2])
            {
                //---将数据装换为温度数据
                temptth = SHT2Xx->msg_reserve[0];
                temptth *= 256;
                temptth += (SHT2Xx->msg_reserve[1]&0xFC);
                temptth *= 175.72;
                temptth /= 65536.0f;
                temptth -= 46.85;
                SHT2Xx->msg_temperaturec_x1000 = (int32_t)(temptth * 1000);
                //---将摄氏度转换为华氏度
                temptth *= 1.8;
                temptth += 32;
                SHT2Xx->msg_temperaturef_x1000 = (int32_t)(temptth * 1000);
            }
            //---下一步
            SHT2Xx->msg_step += 1;
            //---更新轮训节点
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            //---更新时间节点
            SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
        //---湿度测试 1
        case 4:
        {
            //---发送温度测试命令
            _return = ex_sht2x_i2c_poll_cmd(&(SHT2Xx->msg_sht2x_i2c), SHT2X_CMD_POLL_TH);
            //---设置轮训时间
            sht2x_i2c_set_measure_time(SHT2Xx, SHT2Xx->msg_reg, 1);
            //---下一步
            SHT2Xx->msg_step += 1;
            //---更新轮训节点
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            //---更新时间节点
            SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
        //---湿度测试 2
        case 5:
        {
            //---检查时间间隔是否到达
            if (TIME_SPAN_T(SHT2Xx->msg_f_time_ticks(), SHT2Xx->msg_interval_tick) >
                SHT2Xx->msg_interval_time)
            {
                //---更新轮训节点
                SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
                //---读取温度数据
                _return = ex_sht2x_i2c_poll_data(&(SHT2Xx->msg_sht2x_i2c), SHT2Xx->msg_reserve);
                //---校验温度的读取结果
                if (_return == OK_0)
                {
                    //---下一步
                    SHT2Xx->msg_step += 1;
                    //---更新时间节点
                    SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
                }
                else
                {
                    if (TIME_SPAN_T(SHT2Xx->msg_f_time_ticks(), SHT2Xx->msg_time_tick) >
                        (SHT2Xx->msg_interval_time >> 1))
                    {
                        //---下一步
                        SHT2Xx->msg_step += 2;
                        //---更新时间节点
                        SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
                    }
                }
            }
            break;
        }
        //---湿度测试 3
        case 6:
        {
            //---计算crc
            _return = crc_task_crc8_type(CRC8_TYPE_TABLE_31H_0, SHT2Xx->msg_reserve, 2);
            //---校验crc
            if (_return == SHT2Xx->msg_reserve[2])
            {
                //---将数据装换为湿度数据
                temptth = SHT2Xx->msg_reserve[0];
                temptth *= 256;
                temptth += (SHT2Xx->msg_reserve[1] & 0xFC);
                temptth *= 125.0f;
                temptth /= 65536.0f;
                temptth -= 6.0f;
                SHT2Xx->msg_humidity_x1000 = (int32_t)(temptth * 1000);
            }
            //---下一步
            SHT2Xx->msg_step += 1;
            //---更新轮训节点
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            //---更新时间节点
            SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
        //---结束
        case 7:
        default:
        {
            SHT2Xx->msg_step = 0;
            //---设置轮训时间
            sht2x_i2c_set_measure_time(SHT2Xx, SHT2Xx->msg_reg, 0);
            SHT2Xx->msg_time_tick = SHT2Xx->msg_f_time_ticks();
            SHT2Xx->msg_interval_tick = SHT2Xx->msg_f_time_ticks();
            break;
        }
    }
    return _return;
}


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

    return (_return / 1000.0f);
}

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

    return (_return / 1000.0f);
}

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

    return (_return / 1000.0f);
}
Haiguozhe
关注
专栏目录
Arduino驱动防水型SHT2x温湿传感器（温湿度传感器）
不脱发的程序猿
11-23 551
SHT2x防水型温湿传感器，配有电容式相对湿度传感器和能隙温度传感器外，该芯片包含一个放大器、A/D转换器、OTP内存和数字处理单元，可精确测量周边环境温度和空气相对湿度。
Arduino与Proteus仿真实例-SHT2x温度湿度传感器驱动仿真
视觉与物联智能
11-24 1052
SHT2x温度湿度传感器驱动仿真 1、SHT2x介绍 SHT2x系列包括低成本版本SHT20、标准版本SHT21，以及高端版本SHT25。除需与空气接触的湿度敏感区域之外,整个芯片完全包覆成型——可使电容式湿度传感器免受外界影响，具有良好的长期稳定性，适合各类应用。 SHT2x嵌入在3 × 3 × 1.1 mm3可回流焊双扁平无引线（DFN）封装中，提供经校准的线性传感器信号,并以数字I2C格式输出。SHT2x湿度传感器系列将电容式湿度传感器、带隙温度传感器和专用模拟和数字集成电路——都集成在一个CMOSe
SHT2x温湿度传感器驱动
u011052048的博客
04-21 716
文章目录I2C驱动头文件I2C驱动源码SHT2x驱动头文件SHT2x驱动源码 I2C驱动头文件 I2C.h #ifndef I2C_H #define I2C_H //---------- Includes ---------------------------------------------------------- #include "system.h" //---------- D...
温湿度传感器SHT2X代码
07-27
温湿度传感器代码 sht20 sht2x 经测试可以用
Sensirion温湿度传感器SHT2X驱动--基于STM32F103
05-31
Sensirion温湿度传感器SHT2X驱动--基于STM32F103，成功上板验证，标准IIC接口时序，通过串口打印温湿度数据。
STM32 使用 SHT2x 温湿度传感器
小马哔哔
04-27 2005
简介 这TM的是个超级坑的通讯过程，虽然符合SPI通讯流程，但要是你直接用SPI通讯会发现完全不是这么回事。这个是在STM32F0系列单片机上使用的范例，可以正常读取温度和湿度，只写了主机模式。 database.h 里面没啥东西，可以直接用#include "stm32f0xx.h"代替 代码 SHT2x.h #ifndef SHT2x_H #define SHT2x_H //-------...
外设驱动库开发笔记10：SHT2x系列温湿度传感器驱动
木南创智
07-19 1661
温湿度检测是嵌入式编程中经常应用到的一项功能。在我们的产品中亦经常使用。SHT2x系列温湿度传感器作为一种高精度低成本的集成模块，一直应用于我们的产品中。在这里我们讨论如何封装SHT2x系列温湿度传感器的驱动。 1、功能概述 SHT20配有一个全新设计的CMOSens芯片、一个经过改进的电容式湿度传感元件和一个标准的能隙温度传感元件，其性能已经大大提升甚至超出了前一代传感器（SHT1x和SHT7x）的可靠性水平。 1.1、硬件描述 SHT2x湿度和温度传感器采用了新的封装模式和数字接口，每一个传感器
sht2x驱动_sht2x驱动程序_
09-30
《STM32驱动SHT2X高精度温湿度传感器详解》 SHT2X系列传感器是瑞士Sensirion公司推出的一款高精度温湿度传感器，广泛应用于环境监测、智能家居、医疗设备等领域。本文将深入探讨如何在STM32微控制器上开发并驱动SHT...
SHT2X_温湿度传感器_SHT2X驱动_
10-04
SHT2X是一款由瑞士公司Sensirion生产的高精度温湿度传感器，广泛应用于环境监测、智能家居、工业自动化等领域。SHT2X系列包括SHT20、SHT21和SHT25等型号，它们都具备低功耗、高精度和快速响应的特点。 在嵌入式系统...
温度传感器SHT1x和SHT2x代码
08-27
温度传感器SHT1x和SHT2x的iic通信代码，这都是从网上找的代码，sht1x亲测可用，sht2x时序也是准确的
SHT2x温湿度传感器官方源代码以及相关文档
06-01
SHT2x温湿度传感器官方源代码以及相关文档
sht2x_flash源码_SHT2x_sht2x代码_
09-28
《SHT2x Flash源码解析与应用》 SHT2x系列传感器是瑞士Sensirion公司生产的一款高精度温湿度传感器，广泛应用于环境监测、智能家居、医疗设备等领域。其内部集成了温度和湿度传感器，并提供了易于使用的I2C通信接口...
SHT2X温湿度传感器驱动
04-02
【SHT2X温湿度传感器驱动】是一种专用于检测环境温度和湿度的硬件设备的软件接口。SHT2X系列传感器是由瑞士Sensirion公司生产的高精度、低功耗的传感器模块，常用于物联网设备、智能家居、气象监测、农业环境控制等...
Adafruit_GFX.zip_Adafruit_GFX.cpp_SHT2x-master_Sodaq SHT2x ardui
09-21
《Adafruit GFX与SHT2x温湿度传感器在Arduino平台的应用》 在 Arduino 开发过程中，集成图形显示和环境参数监测是常见的需求。本篇将详细介绍如何利用Adafruit GFX库和SHT2x系列温湿度传感器，特别是SHT20，进行...
温湿度模块 SHT2x 使用手册
lrlv5的博客
03-31 5861
一、SHT2X 概况 1、1.8%校准后的精度 2、数字输出型，I2C接口 3、超低功耗 4、超长时间稳定性 5、DFN封装，可回流焊接 二、Sensor分析 DFN封装，3*3MM高1.1mm 注：Center Pad连接到地，NC脚一定要悬空，还要远离热源。在90%相对湿度时，每增加1度热量，造成的误差可达%5. Sensor Chip 本传感器除了具有电容
I2C总线驱动框架详解
u014426028的博客
03-12 1549
一、I2C子系统总体架构 1、三大组成部分 (1)I2C核心(i2c-core)：I2C核心提供了I2C总线驱动（适配器）和设备驱动的注册、注销方法，I2C通信方法(”algorithm”)上层的，与具体硬件无关的代码以及探测设备 检测设备地址的上层代码等。。 (2)I2C总线驱动(I2Cadapter)：I2C总线驱动是I2C适配器的软件实现，提供I2C适配器与从设备间完成数...
I2C通信的实践，学习笔记
DNFM的博客
09-20 2708
本文是我自己实际工作中，对I2C通信协议的学习，实现过程的一个总结。它记录了我从对I2C一无所知到最终能够熟练实现I2C协议的一个过程。希望能够帮到不了解I2C通信协议却正好要使用I2C的一些小伙伴们。叙述的方式还是一点一点来，尽量简单，用到哪儿再详细说哪儿。 一提到通信我们自然会想到要有两个设备，在它们之间相互传递数据的过程就叫通信。那么它们怎么传递数据呢？硬件上怎么连接？什么时候开始发送数据...
【开发语言】写程序的两大基本原则（PO和NT原则）
最新发布
weixin_56334307的博客
09-16 212
PO和NT原则是软件开发过程中不可或缺的基础。通过遵循这些原则，可以确保程序具备基本的可运行性和无威胁性，为后续的优化、普世性和维护性打下坚实的基础。在实际编程中，我们应该始终将这两个原则放在首位，并在整个开发周期中持续关注和优化。
SHT2X温湿度传感器C语言编程指南
"SHT2X温湿度传感器的官方C语言程序提供了详细的示例代码，适用于SHT21传感器，支持通信软件1的结构和代码层次。代码结构清晰，包括了system.h、system.c、I2C_HAL.h、I2C_HAL.c等多个头文件和源文件，以及显示模块...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值