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

IIC总线读取温度湿度传感器数据实验

作者：不正经 | 2024-04-24 00:22:56

赞

踩

IIC总线读取温度湿度传感器数据实验

iic.c

  1. #include "iic.h"
  2.  
  3. extern void printf(const char* fmt, ...);
  4. /*
  5.  * 函数名 ： delay_us
  6.  * 函数功能：延时函数
  7.  * 函数参数：无
  8.  * 函数返回值：无
  9.  * */
  10. void delay_us(void)  //微秒级延时
  11. {
  12.     unsigned int i = 2000;
  13.     while(i--);
  14. }
  15. /*
  16.  * 函数名 ： i2c_init
  17.  * 函数功能： i2C总线引脚的初始化， 通用输出，推挽输出，输出速度，
  18.  * 函数参数：无
  19.  * 函数返回值：无
  20.  * */
  21. void i2c_init(void)
  22. {
  23.     // 使能GPIOF端口的时钟
  24.     RCC->MP_AHB4ENSETR |= (0x1 << 5);
  25.     // 设置PF14，PF15引脚为通用的输出功能
  26.     GPIOF->MODER &= (~(0xF << 28));
  27.     GPIOF->MODER |= (0x5 << 28);
  28.     // 设置PF14, PF15引脚为推挽输出
  29.     GPIOF->OTYPER &= (~(0x3 << 14));
  30.     // 设置PF14, PF15引脚为高速输出
  31.     GPIOF->OSPEEDR |= (0xF << 28);
  32.     // 设置PF14, PF15引脚的禁止上拉和下拉
  33.     GPIOF->PUPDR &= (~(0xF << 28));
  34.     // 空闲状态SDA和SCL拉高 
  35.     I2C_SCL_H;
  36.     I2C_SDA_H;
  37. }
  38.  
  39.  
  40.  
  41. /*
  42.  * 函数名：i2c_start
  43.  * 函数功能：模拟i2c开始信号的时序
  44.  * 函数参数：无
  45.  * 函数返回值：无
  46.  * */
  47. void i2c_start(void)
  48. {
  49.     /*
  50.      * 开始信号：时钟在高电平期间，数据线从高到低的变化
  51.      *     --------
  52.      * SCL         \
  53.      *              --------
  54.      *     ----
  55.      * SDA     \
  56.      *          --------
  57.      * */   
  58.     //确保SDA是输出状态 PF15输出
  59.     SET_SDA_OUT;
  60.     // 空闲状态SDA和SCL拉高 
  61.     I2C_SCL_H;
  62.     I2C_SDA_H;
  63.     delay_us();//延时等待一段时间
  64.     I2C_SDA_L;//数据线拉低
  65.     delay_us();//延时等待一段时间
  66.     I2C_SCL_L;//时钟线拉低，让总线处于占用状态
  67. }
  68.  
  69. /*
  70.  * 函数名：i2c_stop
  71.  * 函数功能：模拟i2c停止信号的时序
  72.  * 函数参数：无
  73.  * 函数返回值：无
  74.  * */
  76. void i2c_stop(void)
  77. {
  78.     /*
  79.      * 停止信号 ： 时钟在高电平期间，数据线从低到高的变化 
  80.      *             ----------
  81.      * SCL        /
  82.      *    --------
  83.      *    ---         -------
  84.      * SDA   X       /
  85.      *    --- -------
  86.      * */
  87.     //确保SDA是输出状态 PF15输出
  88.     SET_SDA_OUT;
  89.     //时钟线拉低
  90.     I2C_SCL_L;//为了修改数据线的电平
  91.     delay_us();//延时等待一段时间
  92.     I2C_SDA_L;//数据线拉低
  93.     delay_us();//延时等待一段时间
  94.     //时钟线拉高
  95.     I2C_SCL_H;
  96.     delay_us();//延时等待一段时间
  97.     I2C_SDA_H;//数据线拉高
  98.  
  99. }
  100.  
  101. /*
  102.  * 函数名： i2c_write_byte
  103.  * 函数功能：主机向i2c总线上的从设备写8bits数据
  104.  * 函数参数：dat : 等待发送的字节数据
  105.  * 函数返回值： 无
  106.  * */
  108. void i2c_write_byte(unsigned char dat)
  109. {  
  110.     /*
  111.      * 数据信号：时钟在低电平期间，发送器向数据线上写入数据
  112.      *          时钟在高电平期间，接收器从数据线上读取数据 
  113.      *      ----          --------
  114.      *  SCL     \        /        \
  115.      *           --------          --------
  116.      *      -------- ------------------ ---
  117.      *  SDA         X                  X
  118.      *      -------- ------------------ ---
  119.      *
  120.      *      先发送高位在发送低位 
  121.      * */
  122.     //确保SDA是输出状态 PF15输出
  123.     SET_SDA_OUT;
  124.     unsigned int i;
  125.     for(i=0;i<8;i++)
  126.     {
  127.         //时钟线拉低
  128.          I2C_SCL_L;
  129.          delay_us();//延时
  130.          //0X3A->0011 1010   0X80->10000000
  131.          if(dat&0X80)//最高位为1
  132.          {
  133.             //发送1
  134.             I2C_SDA_H;
  135.          }
  136.          else  //最高位为0
  137.          {
  138.             I2C_SDA_L;//发送0
  139.          }
  140.          delay_us();//延时
  141.          //时钟线拉高，接收器接收
  142.          I2C_SCL_H;
  143.         delay_us();//延时,用于等待接收器接收数据
  144.         delay_us();//延时
  145.         //将数据左移一位，让原来第6位变为第7位
  146.         dat = dat<<1;
  147.  
  148.     }
  149.     
  150.  
  151. }
  152.  
  153. /*
  154.  * 函数名：i2c_read_byte
  155.  * 函数功能： 主机从i2c总线上的从设备读8bits数据, 
  156.  *          主机发送一个应答或者非应答信号
  157.  * 函数参数： 0 ： 应答信号   1 ： 非应答信号
  158.  * 函数返回值：读到的有效数据
  159.  *
  160.  * */
  161. unsigned char i2c_read_byte(unsigned char ack)
  162. {
  163.     /*
  164.      * 数据信号：时钟在低电平期间，发送器向数据线上写入数据
  165.      *          时钟在高电平期间，接收器从数据线上读取数据 
  166.      *      ----          --------
  167.      *  SCL     \        /        \
  168.      *           --------          --------
  169.      *      -------- ------------------ ---
  170.      *  SDA         X                  X
  171.      *      -------- ------------------ ---
  172.      *
  173.      *      先接收高位， 在接收低位 
  174.      * */
  175.     unsigned int i;
  176.     unsigned char dat;//保存接受的数据
  177.     //将数据线设置为输入
  178.     SET_SDA_IN;
  179.     for(i=0;i<8;i++)
  180.     {
  181.         //先把时钟线拉低，等一段时间，保证发送器发送完毕数据
  182.         I2C_SCL_L;
  183.         delay_us();
  184.         delay_us();//保证发送器发送完数据
  185.         //时钟线拉高，读取数据
  186.         I2C_SCL_H;
  187.         delay_us();
  188.         dat=dat<<1;//数值左移 一定要先左移在赋值，不然数据会溢出
  189.         if(I2C_SDA_READ)//pf15管脚得到了一个高电平输入
  190.         {
  191.             dat |=1; //0000 0110
  192.         }
  193.         else
  194.         {
  195.             dat &=(~0X1);
  196.         }
  197.          delay_us();
  198.     }
  199.         if(ack)
  200.         {
  201.             i2c_nack();//发送非应答信号，不再接收下一次数据
  202.         }
  203.         else
  204.         {
  205.            i2c_ack();//发送应答信号 
  206.         }
  207.     return dat;//将读取到的数据返回
  208. }
  209. /*
  210.  * 函数名： i2c_wait_ack
  211.  * 函数功能： 主机作为发送器时，等待接收器返回的应答信号
  212.  * 函数参数：无
  213.  * 函数返回值：
  214.  *                  0：接收到的应答信号
  215.  *                  1：接收到的非应答信号
  216.  * */
  217. unsigned char i2c_wait_ack(void)
  218. {
  219.     /*
  220.      * 主机发送一个字节之后，从机给主机返回一个应答信号
  221.      *
  222.      *                   -----------
  223.      * SCL              /   M:读    \
  224.      *     -------------             --------
  225.      *     --- ---- --------------------
  226.      * SDA    X    X
  227.      *     ---      --------------------
  228.      *     主  释   从机    主机
  229.      *     机  放   向数据  读数据线
  230.      *         总   线写    上的数据
  231.      *         线   数据
  232.      * */   
  233.     //时钟线拉低，接收器可以发送信号
  234.     I2C_SCL_L;
  235.     I2C_SDA_H;//先把数据线拉高，当接收器回应应答信号时，数据线会拉低
  236.     delay_us();
  237.     SET_SDA_IN;//设置数据线为输入
  238.     delay_us();//等待从机响应
  239.     delay_us();
  240.     I2C_SCL_H;//用于读取数据线数据
  241.     if(I2C_SDA_READ)//PF15得到一个高电平输入，收到非应答信号
  242.         return 1;
  243.     I2C_SCL_L;//时钟线拉低，让数据线处于占用状态
  244.     return 0;
  245.     
  246. } 
  247. /*
  248.  * 函数名： iic_ack
  249.  * 函数功能： 主机作为接收器时，给发送器发送应答信号
  250.  * 函数参数：无
  251.  * 函数返回值：无
  252.  * */
  253. void i2c_ack(void)
  254. {
  255.     /*            --------
  256.      * SCL       /        \
  257.      *    -------          ------
  258.      *    ---
  259.      * SDA   X 
  260.      *    --- -------------
  261.      * */
  262.     //保证数据线是输出
  263.     SET_SDA_OUT;
  264.     I2C_SCL_L;//拉低时钟线
  265.     delay_us();
  266.     I2C_SDA_L;//数据线拉低，表示应答信号
  267.     delay_us();
  268.     I2C_SCL_H;//时钟线拉高，等待发送器读取应答信号
  269.     delay_us();//让从机读取我们当前的回应
  270.     delay_us();
  271.     I2C_SCL_L;//数据线处于占用状态，发送器发送下一次数据
  272.  
  273. }
  274. /*
  275.  * 函数名： iic_nack
  276.  * 函数功能： 主机作为接收器时，给发送器发送非应答信号
  277.  * 函数参数：无
  278.  * 函数返回值：无
  279.  * */
  280. void i2c_nack(void)
  281. {
  282.     /*            --------
  283.      * SCL       /        \
  284.      *    -------          ------
  285.      *    --- ---------------
  286.      * SDA   X 
  287.      *    --- 
  288.      * */   
  289.     //保证数据线是输出
  290.     SET_SDA_OUT;
  291.     I2C_SCL_L;//拉低时钟线
  292.     delay_us();
  293.     I2C_SDA_H;//数据线拉高，表示非应答信号
  294.     delay_us();
  295.     I2C_SCL_H;//时钟线拉高，等待发送器读取应答信号
  296.     delay_us();
  297.     delay_us();
  298.     I2C_SCL_L;//数据线处于占用状态，发送器发送下一次数据
  299. }
  300.  
  301.

iic.h

  1. #ifndef __IIC_H__
  2. #define __IIC_H__
  3. #include "stm32mp1xx_gpio.h"
  4. #include "stm32mp1xx_rcc.h"
  5.  
  6. /* 通过程序模拟实现I2C总线的时序和协议
  7.  * GPIOF ---> AHB4
  8.  * I2C1_SCL ---> PF14
  9.  * I2C1_SDA ---> PF15
  10.  *
  11.  * */
  13. #define SET_SDA_OUT     do{GPIOF->MODER &= (~(0x3 << 30)); \
  14.                             GPIOF->MODER |= (0x1 << 30);}while(0)
  15.  
  16. #define SET_SDA_IN      do{GPIOF->MODER &= (~(0x3 << 30));}while(0)
  17.  
  18. #define I2C_SCL_H       do{GPIOF->BSRR |= (0x1 << 14);}while(0)
  19. #define I2C_SCL_L       do{GPIOF->BRR |= (0x1 << 14);}while(0)
  20.  
  21. #define I2C_SDA_H       do{GPIOF->BSRR |= (0x1 << 15);}while(0)
  22. #define I2C_SDA_L       do{GPIOF->BRR |= (0x1 << 15);}while(0)
  23.  
  24. #define I2C_SDA_READ    (GPIOF->IDR & (0x1 << 15))
  25.  
  26. void delay_us(void);//微秒延时
  27. void delay(int ms);
  28. void i2c_init(void);//初始化
  29. void i2c_start(void);//起始信号
  30. void i2c_stop(void);//终止信号
  31. void i2c_write_byte(unsigned char  dat);//写一个字节数据
  32. unsigned char i2c_read_byte(unsigned char ack);//读取一个字节数据
  33. unsigned char i2c_wait_ack(void);       //等待应答信号
  34. void i2c_ack(void);//发送应答信号
  35. void i2c_nack(void);//发送非应答信号
  36.  
  37. #endif

si7006.c

  1. #include"si7006.h"
  2. //封装延时函数
  3. void delay(int ms)
  4. {
  5.     int i,j;
  6.     for(i=0;i<ms;i++)
  7.     {
  8.         for(j=0;j<2000;j++)
  9.         {}
  10.  
  11.     }
  12. }
  13. void si7006_init()
  14. {
  15.     
  16.     //发起起始信号
  17.     i2c_start();
  18.     //发送从机地址+写标志
  19.     i2c_write_byte(0X40<<1|0);
  20.     //等待从机应答
  21.     i2c_wait_ack();
  22.     //发送寄存器地址 0XE6
  23.     i2c_write_byte(0XE6);
  24.     //等待从机应答
  25.     i2c_wait_ack();
  26.     //传输要写入的数据0X3A、
  27.     i2c_write_byte(0X3A);
  28.     //等待从机应答
  29.     i2c_wait_ack();
  30.     //发送终止信号
  31.     i2c_stop();
  32. }
  33.  
  34. short si7006_read_tem()
  35. {
  36.     short tem;
  37.     char tem_h,tem_l;
  38.     //发起起始信号
  39.     i2c_start();
  40.     //发送从机地址+写标志
  41.     i2c_write_byte(0x40<<1|0);
  42.     //等待从机应答
  43.     i2c_wait_ack();
  44.     //发送寄存器地址  0XE3
  45.     i2c_write_byte(0xe3);
  46.     //等待从机应答
  47.     i2c_wait_ack();
  48.     //重复起始信号
  49.     i2c_start();
  50.     //发送从机地址+读标志
  51.     i2c_write_byte(0x40<<1|1);
  52.     //等待从机应答
  53.     i2c_wait_ack();
  54.     delay(100);//等待从机测量数据
  55.     //接收数据高八位
  56.     //发送应答信号
  57.     tem_h=i2c_read_byte(0);
  58.  
  59.     //接收数据低八位
  60.     //发送非应答信号
  61.     tem_l=i2c_read_byte(1);
  62.     //将高八位和低八位合成一个数据   高八位<<8|低8位
  63.     tem=tem_h<<8|tem_l;
  64.     return  tem;
  65. }
  66.  
  67. unsigned short si7006_read_hum()
  68. {
  69.  
  70.     unsigned short hum;
  71.      unsigned char hum_h,hum_l;
  72.     //发起起始信号
  73.     i2c_start();
  74.     //发送从机地址+写标志
  75.     i2c_write_byte(0x40<<1|0);
  76.     //等待从机应答
  77.     i2c_wait_ack();
  78.     //发送寄存器地址  0XE3
  79.     i2c_write_byte(0xe5);
  80.     //等待从机应答
  81.     i2c_wait_ack();
  82.     //重复起始信号
  83.     i2c_start();
  84.     //发送从机地址+读标志
  85.     i2c_write_byte(0x40<<1|1);
  86.     //等待从机应答
  87.     i2c_wait_ack();
  88.     delay(100);//等待从机测量数据
  89.     //接收数据高八位
  90.     //发送应答信号
  91.     hum_h=i2c_read_byte(0);
  92.  
  93.     //接收数据低八位
  94.     //发送非应答信号
  95.     hum_l=i2c_read_byte(1);
  96.     //将高八位和低八位合成一个数据   高八位<<8|低8位
  97.     hum=hum_h<<8|hum_l;
  98.     return  hum;
  99. }

si7006.h

  1. #ifndef __SI7006_H__
  2. #define __SI7006_H__
  3. #include"iic.h"
  4. void delay_ms(int ms);
  5. void si7006_init();
  6. unsigned short si7006_read_hum();
  7. short si7006_read_tem();
  8.  
  9. #endif

main.c

  1. #include "si7006.h"
  2.  
  3.  
  4.  
  5. int main()
  6.  
  7. {
  8.  
  9.     //si7006初始化
  10.  
  11.     si7006_init();
  12.  
  13.     i2c_init();
  14.  
  15.     unsigned short hum;
  16.  
  17.     short tem;
  18.  
  19.     while(1)
  20.  
  21.     {
  22.  
  23.         //读取温度和湿度
  24.  
  25.         hum=si7006_read_hum();
  26.  
  27.         tem=si7006_read_tem();
  28.  
  29.         //计算温湿度数据
  30.  
  31.         hum=hum*125/65536-6;
  32.  
  33.         tem=tem*175.72/65536-46.85;
  34.  
  35.         printf("hum:%d\n",hum);
  36.  
  37.         printf("tem:%d\n",tem);
  38.  
  39.         delay(1000);
  40.  
  41.     }
  42.  
  43.     return 0;
  44.  
  45. }
  46.

运行结果：

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/不正经/article/detail/476743
推荐阅读
相关标签

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

  

闽ICP备14008679号