devbox
笔触狂放9
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

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

作者：笔触狂放9 | 2024-05-21 18:40:25

赞

踩

sgp30传感器程序

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.  
  3. #define MBED_SGP30_H
  4.  
  5.  
  6.  
  7. #include "mbed.h"
  8.  
  9.  
  10.  
  11. //启用硬件I2C去掉注释，启用GPIO软件模拟模拟I2C保留注释
  12.  
  13. //#define HARD_I2C 1
  14.  
  15.  
  16.  
  17. //SGP30 I2C设备地址
  18.  
  19. #define SGP30_ADDR 0x58
  20.  
  21. //SGP30 I2C写地址
  22.  
  23. #define SGP30_ADDR_WRITE (SGP30_ADDR << 1)      // 0xb0
  24.  
  25. //SGP30 I2C读地址
  26.  
  27. #define SGP30_ADDR_READ ((SGP30_ADDR << 1) + 1) // 0xb1
  28.  
  29. /* SGP30初始化空气质量测量寄存器 */
  30.  
  31. #deSGP30fine SGP30_CMD_INIT_AIR_QUALITY 0x2003
  32.  
  33. /* 开始空气质量测量寄存器  */
  34.  
  35. #define SGP30_CMD_MEASURE_AIR_QUALITY 0x2008
  36.  
  37. /* SGP30获取串号寄存器  */
  38.  
  39. #define SGP30_CMD_GET_SERIAL_ID 0X3682
  40.  
  41.  
  42.  
  43. //GPIO基类
  44.  
  45. class GPIO_I2C {
  46.  
  47.         //公有成员
  48.  
  49. public:
  50.  
  51.   GPIO_I2C(PinName scl, PinName sda);//构造函数
  52.  
  53.   ~GPIO_I2C();//析构函数
  54.  
  55.   void SDA_SET_OUT();//设置SDA输出模式方法
  56.  
  57.   void SDA_SET_IN();//设置SDA输入模式方法
  58.  
  59.   void SGP30_SCK_L();//设置SCL输出低电平方法
  60.  
  61.   void SGP30_SCK_H();//设置SCL输出高电平方法
  62.  
  63.   void SGP30_SDA_L();//设置SDA输出低电平方法
  64.  
  65.   void SGP30_SDA_H();//设置SDA输出高电平方法
  66.  
  67.   int SGP30_READ_SDA();//读取SDA输入电平方法
  68.  
  69.   void sgp30_delay_us(uint32_t us);//延时微秒方法
  70.  
  71.   void sgp30_delay_ms(uint32_t nms);//延时毫秒方法
  72.  
  73.   void IIC_Start(void);//I2C开始信号方法
  74.  
  75.   void IIC_Stop(void);//I2C停止信号方法
  76.  
  77.   uint8_t IIC_Wait_Ack(void);//I2C等待应答方法
  78.  
  79.   void IIC_Ack(void);//I2C应答方法
  80.  
  81.   void IIC_NAck(void);//I2C无应答方法
  82.  
  83.   void IIC_Send_Byte(uint8_t txd);//I2C发送1字节数据方法
  84.  
  85.   uint8_t IIC_Read_Byte(uint8_t ack);//I2C接收1字节数据方法
  86.  
  87. //私有成员
  88.  
  89. private:
  90.  
  91.   DigitalOut *_scl_io;//scl操作对象指针成员变量
  92.  
  93.   DigitalInOut *_sda_io;//sda操作对象指针成员变量
  94.  
  95. };
  96.  
  97.  
  98.  
  99. //SGP30对象继承自GPIO_I2C对象
  100.  
  101. class SGP30 : GPIO_I2C {
  102.  
  103.  
  104.  
  105. public:
  106.  
  107.   SGP30(PinName scl, PinName sda);//构造函数
  108.  
  109.   ~SGP30();//析构函数
  110.  
  111.  
  112.  
  113.   int sgp30_init(void);//SGP30初始化方法
  114.  
  115.   int sgp30_read(uint16_t *CO2, uint16_t *TVOC);//SGP30读取传感器数据方法
  116.  
  117.   int sgp30_get_serial_id(uint8_t id[6]);//SGP30读取序列化方法
  118.  
  119.   int sgp30_soft_reset(void);//SGP30软复位方法
  120.  
  121.  
  122.  
  123. private:
  124.  
  125. #ifdef HARD_I2C
  126.  
  127.   I2C *_i2c;//硬件I2C对象指针
  128.  
  129.   #endif
  130.  
  131.   int sgp30_iic_write(uint8_t addr, const uint8_t* buf, uint32_t len);//SGP30 I2C写数据方法
  132.  
  133.   int sgp30_iic_read(uint8_t addr, uint8_t* buf, uint32_t len);//SGP30 I2C读数据方法
  134.  
  135.   uint8_t sgp30_checksum(const uint8_t* buf, uint32_t len);//SGP30和校验方法
  136.  
  137. };
  138.  
  139.  
  140.  
  141. #endif
  142.  
  143.  
  144.


cpp文件实现各个成员函数和构造函数：

  1. #include "SGP30.h"
  2.  
  3.  
  4.  
  5. void GPIO_I2C::SGP30_SCK_L() { _scl_io->write(0); }
  6.  
  7. void GPIO_I2C::SGP30_SCK_H() { _scl_io->write(1); }
  8.  
  9. void GPIO_I2C::SGP30_SDA_L() { _sda_io->write(0); }
  10.  
  11. void GPIO_I2C::SGP30_SDA_H() { _sda_io->write(1); }
  12.  
  13.  
  14.  
  15. int GPIO_I2C::SGP30_READ_SDA() {
  16.  
  17.   if (_sda_io->read() == 1)
  18.  
  19.     return 1;
  20.  
  21.   else
  22.  
  23.     return 0;
  24.  
  25. }
  26.  
  27.  
  28.  
  29. //构造函数
  30.  
  31. GPIO_I2C::GPIO_I2C(PinName scl, PinName sda) {
  32.  
  33. #ifndef HARD_I2C
  34.  
  35.   printf("i2c use %d for scl,%d for sda\r\n", scl, sda);
  36.  
  37.   //scl对象指针实例化
  38.  
  39.   _scl_io = new DigitalOut(scl);
  40.  
  41.   //sda对象指针实例化
  42.  
  43.   _sda_io = new DigitalInOut(sda);
  44.  
  45.   //设置sda输出模式
  46.  
  47.   _sda_io->output();
  48.  
  49.  
  50.  
  51.   //拉高时钟引脚
  52.  
  53.   _scl_io->write(1);
  54.  
  55.   //拉高数据引脚
  56.  
  57.   _sda_io->write(1);
  58.  
  59. #endif
  60.  
  61. }
  62.  
  63.  
  64.  
  65. //析构函数
  66.  
  67. GPIO_I2C::~GPIO_I2C() {
  68.  
  69. //释放资源        
  70.  
  71. #ifndef HARD_I2C
  72.  
  73.   delete _scl_io;
  74.  
  75.   delete _sda_io;
  76.  
  77. #endif
  78.  
  79. }
  80.  
  81.  
  82.  
  83. //设置SDA输出模式方法
  84.  
  85. void GPIO_I2C::SDA_SET_OUT() {
  86.  
  87.   //设置SDA输出模式
  88.  
  89.   _sda_io->output();
  90.  
  91.   //设置SDA输出低电平
  92.  
  93.   _sda_io->write(0);
  94.  
  95. }
  96.  
  97.  
  98.  
  99. //设置SDA输入模式方法
  100.  
  101. void GPIO_I2C::SDA_SET_IN() {
  102.  
  103.   //设置SDA无上、下拉
  104.  
  105.   _sda_io->mode(PullNone);
  106.  
  107.   //设置SDA输入模式
  108.  
  109.   _sda_io->input();
  110.  
  111. }
  112.  
  113.  
  114.  
  115. void GPIO_I2C::sgp30_delay_us(uint32_t us) { wait_us(us); }
  116.  
  117. void GPIO_I2C::sgp30_delay_ms(uint32_t nms) { wait_ms(nms); }
  118.  
  119.  
  120.  
  121. void GPIO_I2C::IIC_Start(void) {
  122.  
  123.   SDA_SET_OUT();
  124.  
  125.   SGP30_SDA_H();
  126.  
  127.   SGP30_SCK_H();
  128.  
  129.   sgp30_delay_us(5);
  130.  
  131.   SGP30_SDA_L(); // START:when CLK is high,DATA change form high to low
  132.  
  133.   sgp30_delay_us(6);
  134.  
  135.   SGP30_SCK_L();
  136.  
  137. }
  138.  
  139.  
  140.  
  141. void GPIO_I2C::IIC_Stop(void) {
  142.  
  143.   SDA_SET_OUT();
  144.  
  145.   SGP30_SCK_L();
  146.  
  147.   SGP30_SDA_L(); // STOP:when CLK is high DATA change form low to high
  148.  
  149.   SGP30_SCK_H();
  150.  
  151.   sgp30_delay_us(6);
  152.  
  153.   SGP30_SDA_H();
  154.  
  155.   sgp30_delay_us(6);
  156.  
  157. }
  158.  
  159.  
  160.  
  161. uint8_t GPIO_I2C::IIC_Wait_Ack(void) {
  162.  
  163.   uint16_t tempTime = 0;
  164.  
  165.   SGP30_SDA_H();
  166.  
  167.   sgp30_delay_us(1);
  168.  
  169.   SDA_SET_IN();
  170.  
  171.   SGP30_SCK_H();
  172.  
  173.   sgp30_delay_us(1);
  174.  
  175.   while (SGP30_READ_SDA()) {
  176.  
  177.     tempTime++;
  178.  
  179.     wait_ms(10);
  180.  
  181.     if (tempTime > 250) {
  182.  
  183.       IIC_Stop();
  184.  
  185.       return 1;
  186.  
  187.     }
  188.  
  189.   }
  190.  
  191.   SGP30_SCK_L();
  192.  
  193.   return 0;
  194.  
  195. }
  196.  
  197.  
  198.  
  199. void GPIO_I2C::IIC_Ack(void) {
  200.  
  201.   SGP30_SCK_L();
  202.  
  203.   SDA_SET_OUT();
  204.  
  205.   SGP30_SDA_L();
  206.  
  207.   sgp30_delay_us(2);
  208.  
  209.   SGP30_SCK_H();
  210.  
  211.   sgp30_delay_us(5);
  212.  
  213.   SGP30_SCK_L();
  214.  
  215. }
  216.  
  217.  
  218.  
  219. void GPIO_I2C::IIC_NAck(void) {
  220.  
  221.   SGP30_SCK_L();
  222.  
  223.   SDA_SET_OUT();
  224.  
  225.   SGP30_SDA_H();
  226.  
  227.   sgp30_delay_us(2);
  228.  
  229.   SGP30_SCK_H();
  230.  
  231.   sgp30_delay_us(5);
  232.  
  233.   SGP30_SCK_L();
  234.  
  235. }
  236.  
  237.  
  238.  
  239. void GPIO_I2C::IIC_Send_Byte(uint8_t txd) {
  240.  
  241.   uint8_t t;
  242.  
  243.   SDA_SET_OUT();
  244.  
  245.   SGP30_SCK_L();
  246.  
  247.   for (t = 0; t < 8; t++) {
  248.  
  249.     if ((txd & 0x80) > 0) // 0x80  1000 0000
  250.  
  251.       SGP30_SDA_H();
  252.  
  253.     else
  254.  
  255.       SGP30_SDA_L();
  256.  
  257.     txd <<= 1;
  258.  
  259.     sgp30_delay_us(2);
  260.  
  261.     SGP30_SCK_H();
  262.  
  263.     sgp30_delay_us(2);
  264.  
  265.     SGP30_SCK_L();
  266.  
  267.     sgp30_delay_us(2);
  268.  
  269.   }
  270.  
  271. }
  272.  
  273.  
  274.  
  275. uint8_t GPIO_I2C::IIC_Read_Byte(uint8_t ack) {
  276.  
  277.   uint8_t i, receive = 0;
  278.  
  279.   SDA_SET_IN();
  280.  
  281.   for (i = 0; i < 8; i++) {
  282.  
  283.     SGP30_SCK_L();
  284.  
  285.     sgp30_delay_us(2);
  286.  
  287.     SGP30_SCK_H();
  288.  
  289.     receive <<= 1;
  290.  
  291.     if (SGP30_READ_SDA())
  292.  
  293.       receive++;
  294.  
  295.     sgp30_delay_us(1);
  296.  
  297.   }
  298.  
  299.   if (!ack)
  300.  
  301.     IIC_NAck();
  302.  
  303.   else
  304.  
  305.     IIC_Ack();
  306.  
  307.   return receive;
  308.  
  309. }
  310.  
  311.  
  312.  
  313. SGP30::SGP30(PinName scl, PinName sda) : GPIO_I2C(scl, sda) {
  314.  
  315. #ifdef HARD_I2C
  316.  
  317.   _i2c = new I2C(I2C_SDA, I2C_SCL);
  318.  
  319.   _i2c->frequency(100000);
  320.  
  321. #endif
  322.  
  323. }
  324.  
  325. SGP30::~SGP30() {}
  326.  
  327. int SGP30::sgp30_iic_write(uint8_t addr, const uint8_t *buf, uint32_t len) {
  328.  
  329. #ifdef HARD_I2C
  330.  
  331.   //_i2c->write(addr, buf, len,false);
  332.  
  333.   _i2c->write((int)addr, (char *)buf, (int)len, false);
  334.  
  335.   return 0;
  336.  
  337. #else
  338.  
  339.   int i;
  340.  
  341.   IIC_Start();
  342.  
  343.   IIC_Send_Byte(addr);
  344.  
  345.   IIC_Wait_Ack();
  346.  
  347.   for (i = 0; i < len; i++) {
  348.  
  349.     IIC_Send_Byte(buf[i]);
  350.  
  351.     IIC_Wait_Ack();
  352.  
  353.   }
  354.  
  355.   IIC_Stop();
  356.  
  357.   return 0;
  358.  
  359. #endif
  360.  
  361. }
  362.  
  363.  
  364.  
  365. int SGP30::sgp30_iic_read(uint8_t addr, uint8_t *buf, uint32_t len) {
  366.  
  367. #ifdef HARD_I2C
  368.  
  369.   _i2c->read((int)addr, (char *)buf, (int)len, false);
  370.  
  371. #else
  372.  
  373.   int i;
  374.  
  375.   IIC_Start();
  376.  
  377.   IIC_Send_Byte(addr);
  378.  
  379.   IIC_Wait_Ack();
  380.  
  381.   for (i = 0; i < len - 1; i++) {
  382.  
  383.     buf[i] = IIC_Read_Byte(1);
  384.  
  385.   }
  386.  
  387.   buf[i] = IIC_Read_Byte(0); // SGP30接收数据时候的最后一个字节不需要等待ACK
  388.  
  389.   IIC_Stop();
  390.  
  391. #endif
  392.  
  393.   return 0;
  394.  
  395. }
  396.  
  397.  
  398.  
  399. int SGP30::sgp30_get_serial_id(uint8_t id[6]) {
  400.  
  401.   uint8_t buf[32];
  402.  
  403.   uint8_t crc[3];
  404.  
  405.  
  406.  
  407.   buf[0] = (SGP30_CMD_GET_SERIAL_ID & 0XFF00) >> 8;
  409.   buf[1] = (SGP30_CMD_GET_SERIAL_ID & 0X00FF);
  410.  
  411.  
  412.  
  413.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
  414.  
  415.     return -1;
  416.  
  417.  
  418.  
  419.   if (sgp30_iic_read(SGP30_ADDR_READ, buf, 9) < 0)
  420.  
  421.     return -2;
  422.  
  423.  
  424.  
  425.   crc[0] = buf[2];
  426.  
  427.   crc[1] = buf[5];
  428.  
  429.   crc[2] = buf[8];
  430.  
  431.  
  432.  
  433.   id[0] = buf[0];
  434.  
  435.   id[1] = buf[1];
  436.  
  437.   id[2] = buf[3];
  438.  
  439.   id[3] = buf[4];
  440.  
  441.   id[4] = buf[6];
  442.  
  443.   id[5] = buf[7];
  444.  
  445.  
  446.  
  447.   if (sgp30_checksum(&id[0], 2) != crc[0] ||
  448.  
  449.       sgp30_checksum(&id[2], 2) != crc[1] ||
  450.  
  451.       sgp30_checksum(&id[4], 2) != crc[2])
  452.  
  453.     return -3;
  454.  
  455.  
  456.  
  457.   return 0;
  458.  
  459. }
  460.  
  461.  
  462.  
  463. uint8_t SGP30::sgp30_checksum(const uint8_t *buf, uint32_t len) {
  464.  
  465.   const uint8_t Polynomial = 0x31;
  466.  
  467.   uint8_t Initialization = 0XFF;
  468.  
  469.   uint8_t i = 0, k = 0;
  470.  
  471.   while (i < len) {
  472.  
  473.     Initialization ^= buf[i++];
  474.  
  475.     for (k = 0; k < 8; k++) {
  476.  
  477.       if (Initialization & 0X80)
  478.  
  479.         Initialization = (Initialization << 1) ^ Polynomial;
  480.  
  481.       else
  482.  
  483.         Initialization = (Initialization << 1);
  484.  
  485.     }
  486.  
  487.   }
  488.  
  489.   return Initialization;
  490.  
  491. }
  492.  
  493.  
  494.  
  495. int SGP30::sgp30_soft_reset(void) {
  496.  
  497.   uint8_t cmd = 0X06;
  498.  
  499.   return sgp30_iic_write(0X00, &cmd, 1);
  500.  
  501. }
  502.  
  503.  
  504.  
  505. int SGP30::sgp30_init(void) {
  506.  
  507.   uint8_t buf[2];
  508.  
  509.  
  510.  
  511.   // 软件复位
  512.  
  513.   if (sgp30_soft_reset() < 0)
  514.  
  515.     return -2;
  516.  
  517.  
  518.  
  519.   // 等待复位完成
  520.  
  521.   sgp30_delay_ms(50);
  522.  
  523.  
  524.  
  525.   buf[0] = (SGP30_CMD_INIT_AIR_QUALITY & 0XFF00) >> 8;
  527.   buf[1] = (SGP30_CMD_INIT_AIR_QUALITY & 0X00FF);
  528.  
  529.  
  530.  
  531.   // 初始化控制测量参数
  532.  
  533.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
  534.  
  535.     return -3;
  536.  
  537.   printf("sgp30 init end\r\n");
  538.  
  539.   return 0;
  540.  
  541. }
  542.  
  543.  
  544.  
  545. int SGP30::sgp30_read(uint16_t *CO2, uint16_t *TVOC) {
  546.  
  547.   uint8_t buf[8] = {0};
  548.  
  549.  
  550.  
  551.   buf[0] = (SGP30_CMD_MEASURE_AIR_QUALITY & 0XFF00) >> 8;
  553.   buf[1] = (SGP30_CMD_MEASURE_AIR_QUALITY & 0X00FF);
  554.  
  555.  
  556.  
  557.   // 启动空气质量测量
  558.  
  559.   if (sgp30_iic_write(SGP30_ADDR_WRITE, buf, 2) < 0)
  560.  
  561.     return -1;
  562.  
  563.  
  564.  
  565.   // 等待测量完成
  566.  
  567.   sgp30_delay_ms(1000);
  568.  
  569.  
  570.  
  571.   // 读取收到的数据
  572.  
  573.   if (sgp30_iic_read(SGP30_ADDR_READ, buf, 6) < 0)
  574.  
  575.     return -2;
  576.  
  577.  
  578.  
  579.   // 校验CRC
  580.  
  581.   if (sgp30_checksum(&buf[3], 2) != buf[5])
  582.  
  583.     return -3;
  584.  
  585.  
  586.  
  587.   if (CO2 != NULL)
  588.  
  589.     *CO2 = (buf[0] << 8) | buf[1];
  590.  
  591.   if (TVOC != NULL)
  592.  
  593.     *TVOC = (buf[3] << 8) | buf[4];
  594.  
  595.  
  596.  
  597.   return 0;
  598.  
  599. }
  600.



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

  1. void sgp30_work_thread() {
  2.  
  3.   int ret;
  4.  
  5.   SGP30 *sgp30 = new SGP30(I2C_SCL, I2C_SDA);
  6.  
  7.   DigitalOut led1(LED1);
  8.  
  9.   uint16_t TVOC = 0, CO2 = 0;
  10.  
  11.   uint8_t ID[6] = {0};
  12.  
  13.   while (sgp30->sgp30_init() < 0) {
  14.  
  15.     printf(" sgp30 init fail\r\n");
  16.  
  17.     wait_ms(1000);
  18.  
  19.   }
  20.  
  21.  
  22.  
  23.   if (sgp30->sgp30_get_serial_id(ID) < 0) {
  24.  
  25.     printf(" sgp30 read serial id failed\r\n");
  26.  
  27.   } else {
  28.  
  29.     printf("SGP30 Serial number: ");
  30.  
  31.     for (int i = 0; i < 6; i++)
  32.  
  33.       printf("%02X", ID[i]);
  34.  
  35.     printf("\r\n");
  36.  
  37.   }
  38.  
  39.   printf("sgp30 wait air for init");
  40.  
  41.   fflush(stdout);
  42.  
  43.   do {
  44.  
  45.     ret = sgp30->sgp30_read(&CO2, &TVOC);
  46.  
  47.     if (ret < 0) {
  48.  
  49.       printf("SGP30 read failed,ret=%d\r\n", ret);
  50.  
  51.     } else {
  52.  
  53.       printf("-");
  54.  
  55.       fflush(stdout);
  56.  
  57.     }
  58.  
  59.   } while (TVOC == 0 && CO2 == 400);
  60.  
  61.   printf("\r\n");
  62.  
  63.   while (true) {
  64.  
  65.     ret = sgp30->sgp30_read(&CO2, &TVOC);
  66.  
  67.     if (ret < 0) {
  68.  
  69.       printf(" sgp30 read fail,ret=%d\r\n", ret);
  70.  
  71.     } else {
  72.  
  73.       printf("CO2:%5dppm TVOC:%5dppb\r\n", CO2, TVOC);
  74.  
  75.     }
  76.  
  77.     led1 = !led1;
  78.  
  79.     ThisThread::sleep_for(1000);
  80.  
  81.   }
  82.  
  83. }

编译结果：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结构体+函数指针的写法来实现面向对象的特性。：
---------------------
作者：dql2015
链接：https://bbs.21ic.com/icview-3278652-1-1.html
来源：21ic.com
此文章已获得原创/原创奖标签，著作权归21ic所有，任何人未经允许禁止转载。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号