AI 助理
备案控制台
开发者社区 开发与运维 文章 正文

ESP32-C3入门教程 基础篇（四、I2C总线 — 与SHT21温湿度传感器通讯）

2022-09-15 966
版权
版权声明：
本文内容由阿里云实名注册用户自发贡献，版权归原作者所有，阿里云开发者社区不拥有其著作权，亦不承担相应法律责任。具体规则请查看《 阿里云开发者社区用户服务协议》和 《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容，填写 侵权投诉表单进行举报，一经查实，本社区将立刻删除涉嫌侵权内容。
简介： 测试第四课，了解ESP32-C3的 I2C 总线使用，与SHT21 温湿度传感器通讯这一课把基础介绍放在前面，先看基本流程，再去修改代码 
测试第四课，了解ESP32-C3的 I2C 总线使用，与SHT21 温湿度传感器通讯
这一课把基础介绍放在前面，先看基本流程，再去修改代码

前言

接下来的ESP32-C3 功能测试都是基于自己设计的开发板：

自己画一块ESP32-C3 的开发板（第一次使用立创EDA）（PCB到手）

开发环境是乐鑫官方的 ESP-IDF， 基于VScode插件搭建好的：

ESP32-C3 VScode开发环境搭建（基于乐鑫官方ESP-IDF——Windows和Ubuntu双环境）

在开发板上面，我画了一个 HTU21D I2C温湿度传感器（和 SHT21 pin to pin，驱动也一样），使用的是 GPIO3 （SDA）和GPIO10 （SCL）：
在这里插入图片描述

示例程序我们选用i2c_self_test，要注意这个示例的说明，下图中右边介绍这一部分，好好看看：
在这里插入图片描述

1、 ESP32-C3 I2C基础介绍

对于ESP32-C3 I2C的介绍，乐鑫的官网的说明链接如下：

乐鑫官方ESP32-C3 I2C部分说明

国产的芯片终于遇到个中文资料了，呵呵~

ESP32-C3 只有一个 I2C接口，可做主机也可以做从机。

本文的测试以及说明是以 ESP23-C3 作为主机来说明

1.1 I2C初始化

根据官方文档，ESP32-C3 UART使用步骤如下：

  1. 设置参数，使用i2c_config_t结构体可以统一设置：

在这里插入图片描述
例如示例中：
在这里插入图片描述
示例中，最后使用了i2c_param_config配置好I2C的所有参数，除了自己定义的，其他的参数会被配置成 I2C 总线协议规范中定义的默认值。
和 UART 一样，I2C的这些默认值 也可以使用一些函数对某些参数单独进行设置：
在这里插入图片描述

  1. 使用i2c_driver_install函数进行 I2C 设备的初始化，其中包括 端口好、通讯模式，发送接收缓存区， 中断标志：

在这里插入图片描述
以示例中的主机初始化为例：
在这里插入图片描述

1.2 I2C读写

  1. 完成，上述步骤以后，下面就可以发起通讯，在官方文档中的说明有一张流程图：

在这里插入图片描述
流程说明如下：
在这里插入图片描述
通过示例说明一下上述流程：
在这里插入图片描述
最后放一张官方介绍的 I2C 工作的整体流程图：
在这里插入图片描述

2、 I2C 示例测试 — SHT21驱动移植

通过示例工程i2c_self_test创建好工程，通过上面的基础介绍和分析，基本上知道了I2C通讯的步骤和方式了，因为示例代码是与 BH1750 传感器进行的 通讯，所以这里示例代码是无法测试的，直接修改 SHT21 的代码。

2.1 驱动移植修改

因为SHT21驱动函数以前在 STM32上用过，这里就相当于移植过来，先把sht21.c 和sht21.h文件放进来，当然得注意包含关系，宏定义等一些东西：
在这里插入图片描述
既然增加了驱动，所以代码就放在驱这两个文件里面，对于sht21.h 文件，宏定义放在此文件中，函数在sht21.c文件中实现（下面会放源码），在此处声明 ：

在这里插入图片描述

在 sht21.c 中的温湿度读取函数是如何实现的呢， 先来看一张 STH21 读取的时序图，是我在另一篇博文中写好的：
在这里插入图片描述
上图出自：nRF52832学习记录（十一、TWI总线的应用 SHT21程序移植）

这里我就直接上源码 ：

#include "sht21.h"

struct {
      sint16 value;
      uint16 raw;
      uint8  crc;
} aTemperature, aHumidity;


esp_err_t i2c_master_init(void)
{
    int i2c_master_port = I2C_MASTER_NUM;
    i2c_config_t conf = {
        .mode = I2C_MODE_MASTER,
        .sda_io_num = I2C_MASTER_SDA_IO,
        .sda_pullup_en = GPIO_PULLUP_ENABLE,
        .scl_io_num = I2C_MASTER_SCL_IO,
        .scl_pullup_en = GPIO_PULLUP_ENABLE,
        .master.clk_speed = I2C_MASTER_FREQ_HZ,
        // .clk_flags = 0,          /*!< Optional, you can use I2C_SCLK_SRC_FLAG_* flags to choose i2c source clock here. */
    };
    esp_err_t err = i2c_param_config(i2c_master_port, &conf);
    if (err != ESP_OK) {
        return err;
    }
    return i2c_driver_install(i2c_master_port, conf.mode, I2C_MASTER_RX_BUF_DISABLE, I2C_MASTER_TX_BUF_DISABLE, 0);
}


//    fT  = 175.72*u16T/65536.0 - 46.85;
//    fRH = 125.0*u16RH/65536.0 - 6.0;

// -------------------------------------------------------------------
sint16 sht21_calcRH(uint16 u16RH)
{
  sint16 humidityRH;              // variable for result

  u16RH &= ~0x0003;          // clear bits [1..0] (status bits)
  //-- calculate relative humidity [%RH] --

  humidityRH = (sint16)(-600 + (12500*(sint32)u16RH)/65536 ); // RH = -6 + 125 * SRH/2^16
  return humidityRH;                                          // Return RH*100
}

// -------------------------------------------------------------------
sint16 sht21_calcTemperature(uint16 u16T)
{
  sint16 temperature;            // variable for result

  u16T &= ~0x0003;           // clear bits [1..0] (status bits)

  //-- calculate temperature [癈] --
  temperature= (sint16)(-4685 + (17572*(sint32)u16T)/65536); //T = -46.85 + 175.72 * ST/2^16
  return temperature;                                        //return T*100
}


// i2c_cmd_handle_t cmd = i2c_cmd_link_create();
// i2c_master_start(cmd);
// i2c_master_write_byte(cmd, BH1750_SENSOR_ADDR << 1 | WRITE_BIT, ACK_CHECK_EN);
// i2c_master_write_byte(cmd, BH1750_CMD_START, ACK_CHECK_EN);
// i2c_master_stop(cmd);
// ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_RATE_MS);
// i2c_cmd_link_delete(cmd);
// if (ret != ESP_OK) {
//     return ret;
// }
// vTaskDelay(30 / portTICK_RATE_MS);
// cmd = i2c_cmd_link_create();
// i2c_master_start(cmd);
// i2c_master_write_byte(cmd, BH1750_SENSOR_ADDR << 1 | READ_BIT, ACK_CHECK_EN);
// i2c_master_read_byte(cmd, data_h, ACK_VAL);
// i2c_master_read_byte(cmd, data_l, NACK_VAL);
// i2c_master_stop(cmd);
// ret = i2c_master_cmd_begin(i2c_num, cmd, 1000 / portTICK_RATE_MS);
// i2c_cmd_link_delete(cmd);

esp_err_t SHT2X_THMeasure(i2c_port_t i2c_num){
        // uint8 u8Ack;
    int ret;
    uint8 t_value[3];
    uint8 h_value[3];

#if (SHT2X_RESOLUTION != 0x00)                                              // only needed if used resolution other than default
    // i2c_start();                                                        // send start sequence (S)
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_WRITE);               // write to slave 0x40
    // u8Ack = (u8Ack<<1)|i2c_write(SHT2X_CMD_RD_REG);                     // request to read from user register  
      
    // i2c_start();                                                          // send start sequence (S)
    // u8Ack = (u8Ack<<1)|i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_READ);     // read from slave 0x40
    // u8UserReg = i2c_read(I2C_NACK);                                       // read user register       
      
    // i2c_start();                                                          // send start sequence (S)  
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_WRITE);               // write to slave 0x40
    // u8Ack = (u8Ack<<1)|i2c_write(SHT2X_CMD_WR_REG);                     // request to write user register
    // u8Ack = (u8Ack<<1)|i2c_write(SHT2X_RESOLUTION | (u8UserReg & ~0x81)); // write new user register data
    i2c_cmd_handle_t cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    i2c_master_write_byte(cmd, SHT2X_SLAVEADDRESS<<1 | WRITE_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd, SHT2X_CMD_WR_REG, ACK_CHECK_EN);
    i2c_master_stop(cmd);
    ret = i2c_master_cmd_begin(i2c_num, cmd, 500 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);
    if (ret != ESP_OK) {
        return ret;
    }
#endif//(SHT2X_RESOLUTION != 0x00)
    
    // --------------------
    // measure temperature
    // --------------------
    // i2c_start();     // send start sequence (S)
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_WRITE);//----IIC???(8?)???7??IIC????0x80(???HT2X_SLAVEADDRESS=0x40)???DATA???(?R:1 ,?WRITE?0) //a write to slave 0x40 
    // u8Ack = (u8Ack<<1)|i2c_write(SHT2X_CMD_MEAS_T);      //----SHT2X_CMD_MEAS_T=0xF3(??????,???)//request to measure temperature          
    // i2c_stop();

    i2c_cmd_handle_t  cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    i2c_master_write_byte(cmd, SHT2X_SLAVEADDRESS<<1 | WRITE_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd, SHT2X_CMD_MEAS_T, ACK_CHECK_EN);
    i2c_master_stop(cmd);
    ret = i2c_master_cmd_begin(i2c_num, cmd, 500 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);
    if (ret != ESP_OK) {
        return ret;
    }

    vTaskDelay(SHT2X_TEMP_MEAS_TIME / portTICK_RATE_MS);

    // shortTermSleep(SHT2X_TEMP_MEAS_TIME);  
    // HAL_Delay(SHT2X_TEMP_MEAS_TIME);
    // time_wait(SHT2X_TEMP_MEAS_TIME);
            
    // i2c_start();                 // send start sequence (SR)
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_READ); //----IIC???(8?)???7??IIC????0x80(???HT2X_SLAVEADDRESS=0x40)???DATA???(?R:1 ,?WRITE?0)  // a read from slave 0x40
    
    cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    i2c_master_write_byte(cmd, SHT2X_SLAVEADDRESS << 1 | READ_BIT, ACK_CHECK_EN);
    i2c_master_read_byte(cmd, &t_value[0], ACK_VAL);
    i2c_master_read_byte(cmd, &t_value[1], ACK_VAL);
    i2c_master_read_byte(cmd, &t_value[2], NACK_VAL);
    i2c_master_stop(cmd);
    ret = i2c_master_cmd_begin(i2c_num, cmd, 500 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);

    // if(u8Ack==I2C_ACK)  {
    //     aTemperature.raw = i2c_read(I2C_ACK)<<8;                        // read hi byte 
    //     aTemperature.raw |= i2c_read(I2C_ACK);                          // read lo byte
    //     aTemperature.crc = i2c_read(I2C_NACK);                          // read check sum and finish transfere
    // }else {
    //     aTemperature.raw = 0;                       
    // }
    // i2c_stop();
    aTemperature.raw = t_value[0]<<8;
    aTemperature.raw |= t_value[1];
    aTemperature.crc = t_value[2]; 

    // -------------------------
// Humidity Measure 
// -------------------------
    // i2c_start();                                                      // send start sequence (S)
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_WRITE);             // a write to slave 0x40               1000 0000
    // u8Ack = (u8Ack<<1)|i2c_write(SHT2X_CMD_MEAS_RH);                  // request to measure humidity F5  1110 0101
      // i2c_stop();
                
        cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    i2c_master_write_byte(cmd, SHT2X_SLAVEADDRESS<<1 | WRITE_BIT, ACK_CHECK_EN);
    i2c_master_write_byte(cmd, SHT2X_CMD_MEAS_RH, ACK_CHECK_EN);
    i2c_master_stop(cmd);
    ret = i2c_master_cmd_begin(i2c_num, cmd, 500 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);
    if (ret != ESP_OK) {
        return ret;
    }
        // shortTermSleep(SHT2X_HUMI_MEAS_TIME);
    // HAL_Delay(SHT2X_HUMI_MEAS_TIME);
    vTaskDelay(SHT2X_HUMI_MEAS_TIME / portTICK_RATE_MS);

        
    // i2c_start();                                                      // send start sequence (SR)
    // u8Ack = i2c_write((SHT2X_SLAVEADDRESS<<1)|I2C_READ);              // read from slave 0x40                  1000 0001

    cmd = i2c_cmd_link_create();
    i2c_master_start(cmd);
    i2c_master_write_byte(cmd, SHT2X_SLAVEADDRESS << 1 | READ_BIT, ACK_CHECK_EN);
    i2c_master_read_byte(cmd, &h_value[0], ACK_VAL);
    i2c_master_read_byte(cmd, &h_value[1], ACK_VAL);
    i2c_master_read_byte(cmd, &h_value[2], NACK_VAL);
    i2c_master_stop(cmd);
    ret = i2c_master_cmd_begin(i2c_num, cmd, 500 / portTICK_RATE_MS);
    i2c_cmd_link_delete(cmd);

    // if(u8Ack==I2C_ACK)  {                                             // timeout
    //     aHumidity.raw = i2c_read(I2C_ACK)<<8;                           // read hi byte 
    //     aHumidity.raw |= i2c_read(I2C_ACK);                             // read lo byte
    //     aHumidity.crc = i2c_read(I2C_NACK);                           // read check sum and finish transfere
    // }else{
    //     aHumidity.raw = 0;
    // }
        // i2c_stop();
      // PowerOff();
    aHumidity.raw = h_value[0] <<8;                           // read hi byte 
    aHumidity.raw |= h_value[1];                             // read lo byte
    aHumidity.crc = h_value[2];                           // read check sum and finish transfere 

                       
    aTemperature.value = sht21_calcTemperature(aTemperature.raw);
    aHumidity.value = sht21_calcRH(aHumidity.raw);      // signed value, temperature = aTemperature.value * 0.01?
    if(aTemperature.crc!= sht21_CRC((uint8*)&aTemperature.raw, 2))  {}
    if(aHumidity.crc!= sht21_CRC((uint8*)&aHumidity.raw, 2))  {}
    if(aTemperature.value>5100) aTemperature.value=5100;              //prevent temperature over-/underflow
    else if(aTemperature.value<0) aTemperature.value=0;
    if(aHumidity.value>10000) aTemperature.value=10000;              //prevent temperature over-/underflow
    else if(aTemperature.value<0) aTemperature.value=0;

    return ret;
}

uint16_t getTemperature() {
  return aTemperature.value;
}

uint16_t getHumidity() {
  return aHumidity.value;
}

//==============================================================================
uint8 sht21_CRC(uint8 value[], uint8 u8Bytes) {
//  CRC
    const uint16 POLYNOMIAL = 0x131;  //P(x)=x^8+x^5+x^4+1 = 100110001
    uint8 crc = 0;    
    uint8 byteCtr;
    uint8 bitCtr;

    //calculates 8-Bit checksum with given polynomial
    for (byteCtr = 0; byteCtr < u8Bytes; ++byteCtr) { 
        crc ^= (value[byteCtr]);
        for (bitCtr = 8; bitCtr > 0; --bitCtr)
        { 
          if (crc & 0x80) crc = (crc << 1) ^ POLYNOMIAL;
          else crc = (crc << 1);
        }
    }
    return crc;
}

2.2 测试

最后只需要在任务中调用SHT2X_THMeasure 函数即可：
在这里插入图片描述
可以看一下整体，i2c_example_main.c文件简单明了多了：
在这里插入图片描述
测试结果如下，正常：

在这里插入图片描述

文章标签：
容器服务Kubernetes版
测试技术
Ubuntu
Windows
传感器
芯片
缓存
相关实践学习
通过Ingress进行灰度发布
本场景您将运行一个简单的应用，部署一个新的应用用于新的发布，并通过Ingress能力实现灰度发布。
容器应用与集群管理
欢迎来到《容器应用与集群管理》课程，本课程是“云原生容器Clouder认证“系列中的第二阶段。课程将向您介绍与容器集群相关的概念和技术，这些概念和技术可以帮助您了解阿里云容器服务ACK/ACK Serverless的使用。同时，本课程也会向您介绍可以采取的工具、方法和可操作步骤，以帮助您了解如何基于容器服务ACK Serverless构建和管理企业级应用。 学习完本课程后，您将能够： 掌握容器集群、容器编排的基本概念 掌握Kubernetes的基础概念及核心思想 掌握阿里云容器服务ACK/ACK Serverless概念及使用方法 基于容器服务ACK Serverless搭建和管理企业级网站应用
矜辰所致
目录
相关文章
囚徒冇困境
|
6月前
|
网络协议 数据处理 数据格式
51单片机ESP8266云端通信的实现
51单片机ESP8266云端通信的实现
囚徒冇困境
422 1
是Yu欸
|
存储 开发框架 前端开发
单片机与HC-05蓝牙模块通信
单片机与HC-05蓝牙模块通信
是Yu欸
161 0
丘比特惩罚陆
|
传感器 安全
嵌入式 STM32 SHT31温湿度传感器
嵌入式 STM32 SHT31温湿度传感器
丘比特惩罚陆
220 0
风正豪
|
物联网
zigbee DL-20无线串口收发模块使用（双车通讯，电赛模块推荐）
zigbee DL-20无线串口收发模块使用（双车通讯，电赛模块推荐）
风正豪
472 0
ST小智
|
传感器 C语言 芯片
单片机中利用SHT11实现温湿度实验
单片机中利用SHT11实现温湿度实验
ST小智
218 0
单片机中利用SHT11实现温湿度实验
Vuko-wxh
|
传感器 开发工具
ZYNQ-实现外设驱动开发-iic接口的温湿度传感器si7021
ZYNQ-实现外设驱动开发-iic接口的温湿度传感器si7021
Vuko-wxh
282 0
ZYNQ-实现外设驱动开发-iic接口的温湿度传感器si7021
Vuko-wxh
|
传感器 API 开发工具
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30（一）
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30
Vuko-wxh
247 0
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30（一）
Vuko-wxh
|
传感器 API 开发工具
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30（二）
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30
Vuko-wxh
443 0
ZYNQ-实现外设驱动开发-iic接口的光强度传感器GY-30（二）
河北稳控科技
|
传感器 芯片
可编程 USB 转串口适配器开发板 SHT3x-DIS 温湿度传感器芯片
SHT3x-DIS 是 IIC 接口的温度、湿度传感器芯片，可工作于单次测量或连续自动测量模式。USB2S 已有 1 片 SHT31-DIS 芯片，芯片地址为 0x88。 SHT3X-DIS 的输出温度和湿度均为 3 字节，前两字节是温湿度值，第 3 字节是校验字节。转换 公式如下：（数值=第 1 个字节*256+第 2 个字节）。
河北稳控科技
164 0
可编程 USB 转串口适配器开发板 SHT3x-DIS 温湿度传感器芯片
老汉憨憨Kobe
|
传感器 芯片 内存技术
STM32与测温芯片ADT7410通过模拟IIC通信
STM32与测温芯片ADT7410通过模拟IIC通信
老汉憨憨Kobe
459 1
STM32与测温芯片ADT7410通过模拟IIC通信