21ic电子技术开发论坛 › 综合技术交流 › 电子技术交流论坛 › stm32wb55使用C++开发驱动程序实践之驱动SGP30传感器 ...
返回列表 发新帖我要提问本帖赏金: 50.00元(功能说明)

[技术讨论] stm32wb55使用C++开发驱动程序实践之驱动SGP30传感器

[复制链接]
 楼主| dql2015 发表于 2023-1-23 10:47 | 显示全部楼层 |阅读模式
<
stm32wb, 驱动程序, STM, STM32, STM32W, gp, p30
本帖最后由 dql2015 于 2023-1-23 10:49 编辑

#申请原创# @21小跑堂
mbed os是ARM以C++为主要开发语言的RTOS，提供Mbed Studio集成开发环境，支持很多开发板，屏蔽了底层驱动，给应用层提供统一的接口。楼主抽空体验了基于mbed os平台使用C++开发驱动程序， 测试使用stm32wb55驱动I2C接口的CO2、TVOC传感器SGP30，使用GPIO模拟I2C和硬件I2C两种方法实现。使用C++更加直观，可读性更强，封装性更强，更方便维护，尤其在多人协同开发优势更明显。
首先设计一个基类GPIO_I2C ，私有成员变量_scl_io和_sda_io用于操作GPIO，提供GPIO输入输出设置、上下拉设置、高低电平输出、读取输入电平等基本操作方法；然后设计一个SGP30类，继承自GPIO_I2C，提供SGP30初始化、序列号获取、传感器数据获取、软复位等方法。关于SGP30的寄存器和驱动时序本帖不再赘述，https://bbs.21ic.com/icview-3273394-1-1.html中有详细描述。头文件设计如下：
复制
  1. #ifndef MBED_SGP30_H
    

  2. #define MBED_SGP30_H
    


  3. 

  4. #include "mbed.h"
    


  5. 

  6. //启用硬件I2C去掉注释，启用GPIO软件模拟模拟I2C保留注释
    

  7. //#define HARD_I2C 1
    


  8. 

  9. //SGP30 I2C设备地址
    

  10. #define SGP30_ADDR 0x58
    

  11. //SGP30 I2C写地址
    

  12. #define SGP30_ADDR_WRITE (SGP30_ADDR << 1)      // 0xb0
    

  13. //SGP30 I2C读地址
    

  14. #define SGP30_ADDR_READ ((SGP30_ADDR << 1) + 1) // 0xb1
    

  15. /* SGP30初始化空气质量测量寄存器 */
    

  16. #deSGP30fine SGP30_CMD_INIT_AIR_QUALITY 0x2003
    

  17. /* 开始空气质量测量寄存器  */
    

  18. #define SGP30_CMD_MEASURE_AIR_QUALITY 0x2008
    

  19. /* SGP30获取串号寄存器  */
    

  20. #define SGP30_CMD_GET_SERIAL_ID 0X3682
    


  21. 

  22. //GPIO基类
    

  23. class GPIO_I2C {
    

  24.         //公有成员
    

  25. public:
    

  26.   GPIO_I2C(PinName scl, PinName sda);//构造函数
    

  27.   ~GPIO_I2C();//析构函数
    

  28.   void SDA_SET_OUT();//设置SDA输出模式方法
    

  29.   void SDA_SET_IN();//设置SDA输入模式方法
    

  30.   void SGP30_SCK_L();//设置SCL输出低电平方法
    

  31.   void SGP30_SCK_H();//设置SCL输出高电平方法
    

  32.   void SGP30_SDA_L();//设置SDA输出低电平方法
    

  33.   void SGP30_SDA_H();//设置SDA输出高电平方法
    

  34.   int SGP30_READ_SDA();//读取SDA输入电平方法
    

  35.   void sgp30_delay_us(uint32_t us);//延时微秒方法
    

  36.   void sgp30_delay_ms(uint32_t nms);//延时毫秒方法
    

  37.   void IIC_Start(void);//I2C开始信号方法
    

  38.   void IIC_Stop(void);//I2C停止信号方法
    

  39.   uint8_t IIC_Wait_Ack(void);//I2C等待应答方法
    

  40.   void IIC_Ack(void);//I2C应答方法
    

  41.   void IIC_NAck(void);//I2C无应答方法
    

  42.   void IIC_Send_Byte(uint8_t txd);//I2C发送1字节数据方法
    

  43.   uint8_t IIC_Read_Byte(uint8_t ack);//I2C接收1字节数据方法
    

  44. //私有成员
    

  45. private:
    

  46.   DigitalOut *_scl_io;//scl操作对象指针成员变量
    

  47.   DigitalInOut *_sda_io;//sda操作对象指针成员变量
    

  48. };
    


  49. 

  50. //SGP30对象继承自GPIO_I2C对象
    

  51. class SGP30 : GPIO_I2C {
    


  52. 

  53. public:
    

  54.   SGP30(PinName scl, PinName sda);//构造函数
    

  55.   ~SGP30();//析构函数
    


  56. 

  57.   int sgp30_init(void);//SGP30初始化方法
    

  58.   int sgp30_read(uint16_t *CO2, uint16_t *TVOC);//SGP30读取传感器数据方法
    

  59.   int sgp30_get_serial_id(uint8_t id[6]);//SGP30读取序列化方法
    

  60.   int sgp30_soft_reset(void);//SGP30软复位方法
    


  61. 

  62. private:
    

  63. #ifdef HARD_I2C
    

  64.   I2C *_i2c;//硬件I2C对象指针
    

  65.   #endif
    

  66.   int sgp30_iic_write(uint8_t addr, const uint8_t* buf, uint32_t len);//SGP30 I2C写数据方法
    

  67.   int sgp30_iic_read(uint8_t addr, uint8_t* buf, uint32_t len);//SGP30 I2C读数据方法
    

  68.   uint8_t sgp30_checksum(const uint8_t* buf, uint32_t len);//SGP30和校验方法
    

  69. };
    


  70. 

  71. #endif
    


  72.

cpp文件实现各个成员函数和构造函数：
复制
  1. #include "SGP30.h"
    


  2. 

  3. void GPIO_I2C::SGP30_SCK_L() { _scl_io->write(0); }
    

  4. void GPIO_I2C::SGP30_SCK_H() { _scl_io->write(1); }
    

  5. void GPIO_I2C::SGP30_SDA_L() { _sda_io->write(0); }
    

  6. void GPIO_I2C::SGP30_SDA_H() { _sda_io->write(1); }
    


  7. 

  8. int GPIO_I2C::SGP30_READ_SDA() {
    

  9.   if (_sda_io->read() == 1)
    

  10.     return 1;
    

  11.   else
    

  12.     return 0;
    

  13. }
    


  14. 

  15. //构造函数
    

  16. GPIO_I2C::GPIO_I2C(PinName scl, PinName sda) {
    

  17. #ifndef HARD_I2C
    

  18.   printf("i2c use %d for scl,%d for sda\r\n", scl, sda);
    

  19.   //scl对象指针实例化
    

  20.   _scl_io = new DigitalOut(scl);
    

  21.   //sda对象指针实例化
    

  22.   _sda_io = new DigitalInOut(sda);
    

  23.   //设置sda输出模式
    

  24.   _sda_io->output();
    


  25. 

  26.   //拉高时钟引脚
    

  27.   _scl_io->write(1);
    

  28.   //拉高数据引脚
    

  29.   _sda_io->write(1);
    

  30. #endif
    

  31. }
    


  32. 

  33. //析构函数
    

  34. GPIO_I2C::~GPIO_I2C() {
    

  35. //释放资源        
    

  36. #ifndef HARD_I2C
    

  37.   delete _scl_io;
    

  38.   delete _sda_io;
    

  39. #endif
    

  40. }
    


  41. 

  42. //设置SDA输出模式方法
    

  43. void GPIO_I2C::SDA_SET_OUT() {
    

  44.   //设置SDA输出模式
    

  45.   _sda_io->output();
    

  46.   //设置SDA输出低电平
    

  47.   _sda_io->write(0);
    

  48. }
    


  49. 

  50. //设置SDA输入模式方法
    

  51. void GPIO_I2C::SDA_SET_IN() {
    

  52.   //设置SDA无上、下拉
    

  53.   _sda_io->mode(PullNone);
    

  54.   //设置SDA输入模式
    

  55.   _sda_io->input();
    

  56. }
    


  57. 

  58. void GPIO_I2C::sgp30_delay_us(uint32_t us) { wait_us(us); }
    

  59. void GPIO_I2C::sgp30_delay_ms(uint32_t nms) { wait_ms(nms); }
    


  60. 

  61. void GPIO_I2C::IIC_Start(void) {
    

  62.   SDA_SET_OUT();
    

  63.   SGP30_SDA_H();
    

  64.   SGP30_SCK_H();
    

  65.   sgp30_delay_us(5);
    

  66.   SGP30_SDA_L(); // START:when CLK is high,DATA change form high to low
    

  67.   sgp30_delay_us(6);
    

  68.   SGP30_SCK_L();
    

  69. }
    


  70. 

  71. void GPIO_I2C::IIC_Stop(void) {
    

  72.   SDA_SET_OUT();
    

  73.   SGP30_SCK_L();
    

  74.   SGP30_SDA_L(); // STOP:when CLK is high DATA change form low to high
    

  75.   SGP30_SCK_H();
    

  76.   sgp30_delay_us(6);
    

  77.   SGP30_SDA_H();
    

  78.   sgp30_delay_us(6);
    

  79. }
    


  80. 

  81. uint8_t GPIO_I2C::IIC_Wait_Ack(void) {
    

  82.   uint16_t tempTime = 0;
    

  83.   SGP30_SDA_H();
    

  84.   sgp30_delay_us(1);
    

  85.   SDA_SET_IN();
    

  86.   SGP30_SCK_H();
    

  87.   sgp30_delay_us(1);
    

  88.   while (SGP30_READ_SDA()) {
    

  89.     tempTime++;
    

  90.     wait_ms(10);
    

  91.     if (tempTime > 250) {
    

  92.       IIC_Stop();
    

  93.       return 1;
    

  94.     }
    

  95.   }
    

  96.   SGP30_SCK_L();
    

  97.   return 0;
    

  98. }
    


  99. 

  100. void GPIO_I2C::IIC_Ack(void) {
    

  101.   SGP30_SCK_L();
    

  102.   SDA_SET_OUT();
    

  103.   SGP30_SDA_L();
    

  104.   sgp30_delay_us(2);
    

  105.   SGP30_SCK_H();
    

  106.   sgp30_delay_us(5);
    

  107.   SGP30_SCK_L();
    

  108. }
    


  109. 

  110. void GPIO_I2C::IIC_NAck(void) {
    

  111.   SGP30_SCK_L();
    

  112.   SDA_SET_OUT();
    

  113.   SGP30_SDA_H();
    

  114.   sgp30_delay_us(2);
    

  115.   SGP30_SCK_H();
    

  116.   sgp30_delay_us(5);
    

  117.   SGP30_SCK_L();
    

  118. }
    


  119. 

  120. void GPIO_I2C::IIC_Send_Byte(uint8_t txd) {
    

  121.   uint8_t t;
    

  122.   SDA_SET_OUT();
    

  123.   SGP30_SCK_L();
    

  124.   for (t = 0; t < 8; t++) {
    

  125.     if ((txd & 0x80) > 0) // 0x80  1000 0000
    

  126.       SGP30_SDA_H();
    

  127.     else
    

  128.       SGP30_SDA_L();
    

  129.     txd <<= 1;
    

  130.     sgp30_delay_us(2);
    

  131.     SGP30_SCK_H();
    

  132.     sgp30_delay_us(2);
    

  133.     SGP30_SCK_L();
    

  134.     sgp30_delay_us(2);
    

  135.   }
    

  136. }
    


  137. 

  138. uint8_t GPIO_I2C::IIC_Read_Byte(uint8_t ack) {
    

  139.   uint8_t i, receive = 0;
    

  140.   SDA_SET_IN();
    

  141.   for (i = 0; i < 8; i++) {
    

  142.     SGP30_SCK_L();
    

  143.     sgp30_delay_us(2);
    

  144.     SGP30_SCK_H();
    

  145.     receive <<= 1;
    

  146.     if (SGP30_READ_SDA())
    

  147.       receive++;
    

  148.     sgp30_delay_us(1);
    

  149.   }
    

  150.   if (!ack)
    

  151.     IIC_NAck();
    

  152.   else
    

  153.     IIC_Ack();
    

  154.   return receive;
    

  155. }
    


  156. 

  157. SGP30::SGP30(PinName scl, PinName sda) : GPIO_I2C(scl, sda) {
    

  158. #ifdef HARD_I2C
    

  159.   _i2c = new I2C(I2C_SDA, I2C_SCL);
    

  160.   _i2c->frequency(100000);
    

  161. #endif
    

  162. }
    

  163. SGP30::~SGP30() {}
    

  164. int SGP30::sgp30_iic_write(uint8_t addr, const uint8_t *buf, uint32_t len) {
    

  165. #ifdef HARD_I2C
    

  166.   //_i2c->write(addr, buf, len,false);
    

  167.   _i2c->write((int)addr, (char *)buf, (int)len, false);
    

  168.   return 0;
    

  169. #else
    

  170.   int i;
    

  171.   IIC_Start();
    

  172.   IIC_Send_Byte(addr);
    

  173.   IIC_Wait_Ack();
    

  174.   for (i = 0; i < len; i++) {
    

  175.     IIC_Send_Byte(buf[i]);
    

  176.     IIC_Wait_Ack();
    

  177.   }
    

  178.   IIC_Stop();
    

  179.   return 0;
    

  180. #endif
    

  181. }
    


  182. 

  183. int SGP30::sgp30_iic_read(uint8_t addr, uint8_t *buf, uint32_t len) {
    

  184. #ifdef HARD_I2C
    

  185.   _i2c->read((int)addr, (char *)buf, (int)len, false);
    

  186. #else
    

  187.   int i;
    

  188.   IIC_Start();
    

  189.   IIC_Send_Byte(addr);
    

  190.   IIC_Wait_Ack();
    

  191.   for (i = 0; i < len - 1; i++) {
    

  192.     buf[i] = IIC_Read_Byte(1);
    

  193.   }
    

  194.   buf[i] = IIC_Read_Byte(0); // SGP30接收数据时候的最后一个字节不需要等待ACK
    

  195.   IIC_Stop();
    

  196. #endif
    

  197.   return 0;
    

  198. }
    


  199. 

  200. int SGP30::sgp30_get_serial_id(uint8_t id[6]) {
    

  201.   uint8_t buf[32];
    

  202.   uint8_t crc[3];
    


  203. 

  204.   buf[0] = (SGP30_CMD_GET_SERIAL_ID & 0XFF00) >> 8;
    

  205.   buf[1] = (SGP30_CMD_GET_SERIAL_ID & 0X00FF);
    


  206. 

  207.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
    

  208.     return -1;
    


  209. 

  210.   if (sgp30_iic_read(SGP30_ADDR_READ, buf, 9) < 0)
    

  211.     return -2;
    


  212. 

  213.   crc[0] = buf[2];
    

  214.   crc[1] = buf[5];
    

  215.   crc[2] = buf[8];
    


  216. 

  217.   id[0] = buf[0];
    

  218.   id[1] = buf[1];
    

  219.   id[2] = buf[3];
    

  220.   id[3] = buf[4];
    

  221.   id[4] = buf[6];
    

  222.   id[5] = buf[7];
    


  223. 

  224.   if (sgp30_checksum(&id[0], 2) != crc[0] ||
    

  225.       sgp30_checksum(&id[2], 2) != crc[1] ||
    

  226.       sgp30_checksum(&id[4], 2) != crc[2])
    

  227.     return -3;
    


  228. 

  229.   return 0;
    

  230. }
    


  231. 

  232. uint8_t SGP30::sgp30_checksum(const uint8_t *buf, uint32_t len) {
    

  233.   const uint8_t Polynomial = 0x31;
    

  234.   uint8_t Initialization = 0XFF;
    

  235.   uint8_t i = 0, k = 0;
    

  236.   while (i < len) {
    

  237.     Initialization ^= buf[i++];
    

  238.     for (k = 0; k < 8; k++) {
    

  239.       if (Initialization & 0X80)
    

  240.         Initialization = (Initialization << 1) ^ Polynomial;
    

  241.       else
    

  242.         Initialization = (Initialization << 1);
    

  243.     }
    

  244.   }
    

  245.   return Initialization;
    

  246. }
    


  247. 

  248. int SGP30::sgp30_soft_reset(void) {
    

  249.   uint8_t cmd = 0X06;
    

  250.   return sgp30_iic_write(0X00, &cmd, 1);
    

  251. }
    


  252. 

  253. int SGP30::sgp30_init(void) {
    

  254.   uint8_t buf[2];
    


  255. 

  256.   // 软件复位
    

  257.   if (sgp30_soft_reset() < 0)
    

  258.     return -2;
    


  259. 

  260.   // 等待复位完成
    

  261.   sgp30_delay_ms(50);
    


  262. 

  263.   buf[0] = (SGP30_CMD_INIT_AIR_QUALITY & 0XFF00) >> 8;
    

  264.   buf[1] = (SGP30_CMD_INIT_AIR_QUALITY & 0X00FF);
    


  265. 

  266.   // 初始化控制测量参数
    

  267.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
    

  268.     return -3;
    

  269.   printf("sgp30 init end\r\n");
    

  270.   return 0;
    

  271. }
    


  272. 

  273. int SGP30::sgp30_read(uint16_t *CO2, uint16_t *TVOC) {
    

  274.   uint8_t buf[8] = {0};
    


  275. 

  276.   buf[0] = (SGP30_CMD_MEASURE_AIR_QUALITY & 0XFF00) >> 8;
    

  277.   buf[1] = (SGP30_CMD_MEASURE_AIR_QUALITY & 0X00FF);
    


  278. 

  279.   // 启动空气质量测量
    

  280.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
    

  281.     return -1;
    


  282. 

  283.   // 等待测量完成
    

  284.   sgp30_delay_ms(1000);
    


  285. 

  286.   // 读取收到的数据
    

  287.   if (sgp30_iic_read(SGP30_ADDR_READ, buf, 6) < 0)
    

  288.     return -2;
    


  289. 

  290.   // 校验CRC
    

  291.   if (sgp30_checksum(&buf[3], 2) != buf[5])
    

  292.     return -3;
    


  293. 

  294.   if (CO2 != NULL)
    

  295.     *CO2 = (buf[0] << 8) | buf[1];
    

  296.   if (TVOC != NULL)
    

  297.     *TVOC = (buf[3] << 8) | buf[4];
    


  298. 

  299.   return 0;
    

  300. }


工作线程sgp30_work_thread设计如下，首先new一个SGP30对象，然后调用初始化方法，读取序列号，读取传感器数据：
复制
  1. void sgp30_work_thread() {
    

  2.   int ret;
    

  3.   SGP30 *sgp30 = new SGP30(I2C_SCL, I2C_SDA);
    

  4.   DigitalOut led1(LED1);
    

  5.   uint16_t TVOC = 0, CO2 = 0;
    

  6.   uint8_t ID[6] = {0};
    

  7.   while (sgp30->sgp30_init() < 0) {
    

  8.     printf(" sgp30 init fail\r\n");
    

  9.     wait_ms(1000);
    

  10.   }
    


  11. 

  12.   if (sgp30->sgp30_get_serial_id(ID) < 0) {
    

  13.     printf(" sgp30 read serial id failed\r\n");
    

  14.   } else {
    

  15.     printf("SGP30 Serial number: ");
    

  16.     for (int i = 0; i < 6; i++)
    

  17.       printf("%02X", ID[i]);
    

  18.     printf("\r\n");
    

  19.   }
    

  20.   printf("sgp30 wait air for init");
    

  21.   fflush(stdout);
    

  22.   do {
    

  23.     ret = sgp30->sgp30_read(&CO2, &TVOC);
    

  24.     if (ret < 0) {
    

  25.       printf("SGP30 read failed,ret=%d\r\n", ret);
    

  26.     } else {
    

  27.       printf("-");
    

  28.       fflush(stdout);
    

  29.     }
    

  30.   } while (TVOC == 0 && CO2 == 400);
    

  31.   printf("\r\n");
    

  32.   while (true) {
    

  33.     ret = sgp30->sgp30_read(&CO2, &TVOC);
    

  34.     if (ret < 0) {
    

  35.       printf(" sgp30 read fail,ret=%d\r\n", ret);
    

  36.     } else {
    

  37.       printf("CO2:%5dppm TVOC:%5dppb\r\n", CO2, TVOC);
    

  38.     }
    

  39.     led1 = !led1;
    

  40.     ThisThread::sleep_for(1000);
    

  41.   }
    

  42. }



编译结果：STM32WB55拥有1 MB flash，256 KB SRAM，运行C++写的RTOS+蓝牙协议栈毫无压力。


Mbed Studio界面类似vscode，智能提示、自动补全等功能十分完善，代码编辑体验吊打自家的KEIL MDK。


连接stm32wb55开发板运行运行结果：

总结：从编译出的二进制文件大小，RAM使用情况，运行速度可以看出，使用C++开发并不会造成资源消耗过大的情况（主要看交叉编译器的性能），且C++能够和C混合编程，能显著的提高C在处理面向对象类问题上开发效率不足的缺点，尤其是在处理复杂一点的通信协议上如加解密，往往能达到事半功倍的效果。
然而主大多数MCU的flash容量在32KB~2MB左右，SRAM通常低于1MB（不考虑外部扩展），这样就限制C++中的STL模板，运行时多态等会造成内存“爆炸”的高级特性无法使用，如果我们只使用支持class的C++，这样就不必利用C结构体+函数指针的写法来实现面向对象的特性。











本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？注册

×
回复 赏

举报

打赏榜单

21小跑堂 打赏了 50.00 元 2023-01-29
理由：恭喜通过原创审核！期待您更多的原创作品~

评论

21小跑堂
以Mbed Studio集成开发环境体验stm32wb55的C++开发体验，完成度较好，但是文章整体代码所占比重较文字描述过重，对代码的分析较少，以后注意扩充文章结构可获得更高打赏。  发表于 2023-1-29 10:52

相关帖子
秦生0303 发表于 2023-1-31 09:27 | 显示全部楼层
路过学习了
回复 赏

举报

Bymyself 发表于 2023-1-31 09:42 | 显示全部楼层
谢谢分享，学习了
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

dql2015

104

主题

384

帖子

8

粉丝
快速回复 在线客服 返回列表 返回顶部