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

ARM_day8：温湿度数据采集应用_主机发送起始信号

作者：羊村懒王 | 2024-05-22 18:58:19

赞

踩

主机发送起始信号

1、IIC通信过程

主机发送起始信号、主机发送8位(7位从机地址+1位传送方向(0W，1R))、从机应答、发数据、应答、数据传输完，主机发送停止信号

2、起始信号和终止信号

SCL时钟线，SDA数据线

SCL高电平，SDA由高到低——起始信号

SCL高电平，SDA由低到高——终止信号

均由主机发出

3、应答信号和非应答信号

8位数据+1位应答位——一帧9位

8位数据传输完，第九个时钟周期，数据线(SDA)低电平，接收方还想接收数据，回复应答信号

                                                       数据线(SDA)高电平，接收方不想接收数据，回复非应信号

4、数据传输时机

时钟信号(SCL)高电平，数据线(SDA)稳定时，读取

时钟信号(SCL)低电平，数据线(SDA)高电平或低电平，写入

5、IIC从机选择及读写选择

传输信号包括地址信号、数据信号

起始信号后必须跟一个8位数据(7位从机地址+1位传送方向位(R/W))(0——W、1——R)

6、IIC读写时序

主机向从机发送：

主机发送起始信号、主机发送8位(7位从机地址+1位写标志)、从机应答、主机发送8位从机寄存器地址、从机应答、主机发送8位数据、从机应答、主机发起终止信号

主机读取从机数据：

主机发送起始信号、主机发送8位(7位从机地址+1位写标志)、从机应答、主机发起重复起始信号、主机发送8位(7位从机地址+1位读标志)、从机应答、从机发送8位数据、主机非应答信号、主机发起终止信号

实验：I2C读取温湿度传感器数据

1、SCL时钟线——PF14，SDA数据线——PF15        引脚连接

        I2C总线引脚初始化：(PF14、PF15共同初始化)使能GPIOF外设时钟、设输出功能、推挽输出、输出速度、上拉下拉、空闲状态下的SCL和SDA状态(拉高)——起始信号要求SCL高，SDA从高到低

2、模拟I2C开始信号时序

        SDA数据线保持输出状态  PF15输出；(PF15管脚设为输出)

        空闲状态SCL、SDA拉高(起始信号要求SCL高，SDA从高到低);(选用ODR(设置)、BSRR(复位)、BRR(清空)使输出高低电平)

        延迟一段时间，保持稳定后，拉低SDA数据线完成起始信号；

        延迟一段时间，拉低SCL时钟线，才能进行写入数据；

3、主机向从机写数据(高位到低位)

        SDA数据线保持输出状态  PF15输出；(PF15管脚设为输出)

        时钟线拉低，才能写数据；

        循环发送数据8位(0-7)，延迟时间，保持时钟线稳定，开始发送数据;(要发送的数据 dat & 0x80(10000000)，判断其真假，真则拉高数据线为高电平1，否则拉低数据线为低电平0)

        每次发送一位数据，延时后拉高时钟线(SCL)，接收器才能读数据；

        延时等待接收器接收数据，再延时后将数据左移一位再&0x80进行循环

4、计算温湿度

        湿度：hem=125*测量值/65536-6

        温度：tem=175.72*测量值/65536-46.85

程序代码：

main.c:

  1. #include "si7006.h"
  2. extern void printf(const char* fmt, ...);
  3. int main()
  4. {
  5.     //si7006初始化
  6.     si7006_init();
  7.     unsigned short hum;
  8.     short tem;
  9.     while(1)
  10.     {
  11.         //读取温湿度
  12.         hum=si70006_read_hum();
  13.         tem=si70006_read_tem();
  14.         //计算温湿度数据
  15.         hum=hum*125/65536-6;
  16.         tem=tem*175.72/65536-46.85;
  17.         printf("hum:%d\n",hum);
  18.         printf("tem:%d\n",tem);
  19.         delay_ms(1000);
  20.         //湿度大于65开启马达
  21.         if(hum>65)
  22.         {
  23.             GPIOF->ODR |= (0x1<<6);
  24.         }
  25.         else if(hum<=60)  //湿度小于60关闭马达
  26.         {
  27.            GPIOF->ODR &= (~(0x1<<6)); 
  28.         }
  29.          //温度大于25开启风扇
  30.         if(tem>=25)
  31.         {
  32.             GPIOE->ODR |= (0x1<<9);
  33.         }
  34.         else if(tem<25)  //湿度小于25关闭风扇
  35.         {
  36.             GPIOE->ODR &= (~(0x1<<9)); 
  37.         }
  38.     }
  39.     return 0;
  40. }

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 si70006_read_hum();
  7. short si70006_read_tem();
  8. #endif

si7006.c:

  1. #include "si7006.h"
  2. extern void printf(const char* fmt, ...);
  3. void delay_ms(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. }
  14. void si7006_init()
  15. {
  16.     //发起起始信号
  17.     i2c_init();//I2C总线引脚初始化
  18.     i2c_start();//模拟i2c开始信号的时序
  19.     //发送7bit从机地址和写标志位 0x80
  20.     i2c_write_byte(0x40<<1|0);//主机向从机写8bit数据
  21.     //等待从机应答
  22.     i2c_wait_ack();//等待接收器应答
  23.     //发送寄存器地址 0XE6
  24.     i2c_write_byte(0xE6);
  25.     //等待从机应答
  26.     i2c_wait_ack();//等待接收器应答
  27.     //向从机发送数据 0x3A
  28.     i2c_write_byte(0x3A);
  29.     //等待从机应答
  30.     i2c_wait_ack();
  31.     //发送终止信号
  32.     i2c_stop();
  33. }
  34. unsigned short si70006_read_hum()//湿度读取
  35. {
  36.     unsigned char hum_l,hum_h;
  37.     unsigned short hum;
  38.     //主机发送起始信号
  39.     i2c_init();
  40.     i2c_start();
  41.     //主机发送7bit从机地址+1bit写标志
  42.     i2c_write_byte(0x40<<1|0);
  43.     //等待从机应答
  44.     i2c_wait_ack();
  45.     //主机发送8bit寄存器地址
  46.     i2c_write_byte(0xE5);
  47.     //等待从机应答
  48.     i2c_wait_ack();
  49.     //主机发起重复起始信号
  50.     i2c_start();
  51.     //主机发送7bit从机地址+1bit 读 0x81
  52.     i2c_write_byte(0x40<<1|1);
  53.     //等待从机应答
  54.     i2c_wait_ack();
  55.     //延时等待从机测量数据
  56.     delay_ms(100);
  57.     //读取湿度的高8bit数据 hum_h
  58.     //发送应答信号
  59.     hum_h=i2c_read_byte(0);
  60.     //读取湿度的低8位数据 hum_l
  61.     //发送非应答信号
  62.     hum_l=i2c_read_byte(1);
  63.     //发送终止信号
  64.     //将读取到的数据的低8位和高8位合成一个完整数据
  65.     hum=hum_h<<8 | hum_l;
  66.     return hum;
  67. }
  68. short si70006_read_tem()//温度读取
  69. {
  70.     unsigned char tem_l,tem_h;
  71.     unsigned short tem;
  72.     //主机发送起始信号
  73.     i2c_init();
  74.     i2c_start();
  75.     //主机发送7bit从机地址+1bit写标志
  76.     i2c_write_byte(0x40<<1|0);
  77.     //等待从机应答
  78.     i2c_wait_ack();
  79.     //主机发送8bit寄存器地址
  80.     i2c_write_byte(0xE3);
  81.     //等待从机应答
  82.     i2c_wait_ack();
  83.     //主机发起重复起始信号
  84.     i2c_start();
  85.     //主机发送7bit从机地址+1bit 读 0x81
  86.     i2c_write_byte(0x40<<1|1);
  87.     //等待从机应答
  88.     i2c_wait_ack();
  89.     //延时等待从机测量数据
  90.     delay_ms(100);
  91.     //读取温度的高8bit数据 tem_h
  92.     //发送应答信号
  93.     tem_h=i2c_read_byte(0);
  94.     //读取温度的低8位数据 tem_l
  95.     //发送非应答信号
  96.     tem_l=i2c_read_byte(1);
  97.     //发送终止信号
  98.     //将读取到的数据的低8位和高8位合成一个完整数据
  99.     tem=tem_h<<8 | tem_l;
  100.     return tem;
  101. }

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.  * */
  12.  
  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

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

运行结果：

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

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

  

闽ICP备14008679号