ARM GPIO模拟IIC获取温湿度

最新推荐文章于 2024-04-28 14:49:48 发布
最新推荐文章于 2024-04-28 14:49:48 发布
阅读量326 收藏 1
点赞数 2
文章标签： arm开发 单片机 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_52238362/article/details/137888277
版权

IIC.c

#include "iic.h"
extern void printf(const char *fmt, ...);
/*
 * 函数名 ： delay_us
 * 函数功能：延时函数
 * 函数参数：无
 * 函数返回值：无
 * */
void delay_us(void)
{
    unsigned int i = 2000;
    while (i--);
}
/*
 * 函数名 ： i2c_init
 * 函数功能： i2C总线引脚的初始化， 通用输出，推挽输出，输出速度，
 * 函数参数：无
 * 函数返回值：无
 * */
void i2c_init(void)
{
    // 使能GPIOF端口的时钟
    RCC->MP_AHB4ENSETR |= (0x1 << 5);
    // 设置PF14，PF15引脚为通用的输出功能
    GPIOF->MODER &= (~(0xF << 28));
    GPIOF->MODER |= (0x5 << 28);
    // 设置PF14, PF15引脚为推挽输出
    GPIOF->OTYPER &= (~(0x3 << 14));
    // 设置PF14, PF15引脚为高速输出
    GPIOF->OSPEEDR |= (0xF << 28);
    // 设置PF14, PF15引脚的禁止上拉和下拉
    GPIOF->PUPDR &= (~(0xF << 28));
    // 空闲状态SDA和SCL拉高
    I2C_SCL_H;
    I2C_SDA_H;
}

/*
 * 函数名：i2c_start
 * 函数功能：模拟i2c开始信号的时序
 * 函数参数：无
 * 函数返回值：无
 * */
void i2c_start(void)
{
    /*
     * 开始信号：时钟在高电平期间，数据线从高到低的变化
     *     --------
     * SCL         \
     *              --------
     *     ----
     * SDA     \
     *          --------
     * */
    // 确保SDA是输出状态 PF15输出
    SET_SDA_OUT;
    // 空闲状态SDA和SCL拉高
    I2C_SCL_H;
    I2C_SDA_H;
    delay_us(); // 延时等待一段时间
    I2C_SDA_L;  // 数据线拉低
    delay_us(); // 延时等待一段时间
    I2C_SCL_L;  // 时钟线拉低，让总线处于占用状态
}

/*
 * 函数名：i2c_stop
 * 函数功能：模拟i2c停止信号的时序
 * 函数参数：无
 * 函数返回值：无
 * */

void i2c_stop(void)
{
    /*
     * 停止信号 ： 时钟在高电平期间，数据线从低到高的变化
     *             ----------
     * SCL        /
     *    --------
     *    ---         -------
     * SDA   X       /
     *    --- -------
     * */
    // 确保SDA是输出状态 PF15输出
    SET_SDA_OUT;
    // 时钟线拉低，为了修改数据线
    I2C_SCL_L;  
    delay_us(); // 延时等待一段时间
    I2C_SDA_L;  // 数据线拉低
    delay_us(); // 延时等待一段时间
    // 时钟线拉高
    I2C_SCL_H;
    delay_us(); // 延时等待一段时间
    I2C_SDA_H;  // 数据线拉高
}

/*
 * 函数名： i2c_write_byte
 * 函数功能：主机向i2c总线上的从设备写8bits数据
 * 函数参数：dat : 等待发送的字节数据
 * 函数返回值： 无
 * */

void i2c_write_byte(unsigned char dat)
{
    /*
     * 数据信号：时钟在低电平期间，发送器向数据线上写入数据
     *          时钟在高电平期间，接收器从数据线上读取数据
     *      ----          --------
     *  SCL     \        /        \
     *           --------          --------
     *      -------- ------------------ ---
     *  SDA         X                  X
     *      -------- ------------------ ---
     *
     *      先发送高位在发送低位
     * */
    // 确保SDA是输出状态 PF15输出
    SET_SDA_OUT;
    unsigned int i;
    for (i = 0; i < 8; i++)
    {
        // 时钟线拉低
        I2C_SCL_L;
        delay_us(); // 延时
        // 0X3A->0011 1010   0X80->10000000
        if (dat & 0X80) // 最高位为1
        {
            // 发送1
            I2C_SDA_H;
        }
        else // 最高位为0
        {
            I2C_SDA_L; // 发送0
        }
        delay_us(); // 延时
        // 时钟线拉高，接收器接收
        I2C_SCL_H;
        delay_us(); // 延时,用于等待接收器接收数据
        delay_us(); // 延时
        // 将数据左移一位，让原来第6位变为第7位
        dat = dat << 1;
    }
}

/*
 * 函数名：i2c_read_byte
 * 函数功能： 主机从i2c总线上的从设备读8bits数据,
 *          主机发送一个应答或者非应答信号
 * 函数参数： 0 ： 应答信号   1 ： 非应答信号
 * 函数返回值：读到的有效数据
 *
 * */
unsigned char i2c_read_byte(unsigned char ack)
{
    /*
     * 数据信号：时钟在低电平期间，发送器向数据线上写入数据
     *          时钟在高电平期间，接收器从数据线上读取数据
     *      ----          --------
     *  SCL     \        /        \
     *           --------          --------
     *      -------- ------------------ ---
     *  SDA         X                  X
     *      -------- ------------------ ---
     *
     *      先接收高位， 在接收低位
     * */
    unsigned int i;
    unsigned char dat; // 保存接受的数据
    // 将数据线设置为输入
    SET_SDA_IN;
    for (i = 0; i < 8; i++)
    {
        // 先把时钟线拉低，等一段时间，保证发送器发送完毕数据
        I2C_SCL_L;
        delay_us();
        delay_us(); // 保证发送器发送完数据
        // 时钟线拉高，读取数据
        I2C_SCL_H;
        delay_us();
        dat = dat << 1;   // 数值左移 一定要先左移在赋值，不然数据会溢出
        if (I2C_SDA_READ) // pf15管脚得到了一个高电平输入
        {
            dat |= 1; // 0000 0110
        }
        else
        {
            dat &= (~0X1);
        }
        delay_us();
    }
    if (ack)
    {
        i2c_nack(); // 发送非应答信号，不再接收下一次数据
    }
    else
    {
        i2c_ack(); // 发送应答信号
    }
    return dat; // 将读取到的数据返回
}
/*
 * 函数名： i2c_wait_ack
 * 函数功能： 主机作为发送器时，等待接收器返回的应答信号
 * 函数参数：无
 * 函数返回值：
 *                  0：接收到的应答信号
 *                  1：接收到的非应答信号
 * */
unsigned char i2c_wait_ack(void)
{
    /*
     * 主机发送一个字节之后，从机给主机返回一个应答信号
     *
     *                   -----------
     * SCL              /   M:读    \
     *     -------------             --------
     *     --- ---- --------------------
     * SDA    X    X
     *     ---      --------------------
     *     主  释   从机    主机
     *     机  放   向数据  读数据线
     *         总   线写    上的数据
     *         线   数据
     * */
    // 时钟线拉低，接收器可以发送信号
    I2C_SCL_L;
    I2C_SDA_H; // 先把数据线拉高，当接收器回应应答信号时，数据线会拉低
    delay_us();
    SET_SDA_IN; // 设置数据线为输入
    delay_us(); // 等待从机响应
    delay_us();
    I2C_SCL_H;        // 用于读取数据线数据
    if (I2C_SDA_READ) // PF15得到一个高电平输入，收到非应答信号
        return 1;
    I2C_SCL_L; // 时钟线拉低，让数据线处于占用状态
    return 0;
}
/*
 * 函数名： iic_ack
 * 函数功能： 主机作为接收器时，给发送器发送应答信号
 * 函数参数：无
 * 函数返回值：无
 * */
void i2c_ack(void)
{
    /*            --------
     * SCL       /        \
     *    -------          ------
     *    ---
     * SDA   X
     *    --- -------------
     * */
    // 保证数据线是输出
    SET_SDA_OUT;
    I2C_SCL_L; // 拉低时钟线
    delay_us();
    I2C_SDA_L; // 数据线拉低，表示应答信号
    delay_us();
    I2C_SCL_H;  // 时钟线拉高，等待发送器读取应答信号
    delay_us(); // 让从机读取我们当前的回应
    delay_us();
    I2C_SCL_L; // 数据线处于占用状态，发送器发送下一次数据
}
/*
 * 函数名： iic_nack
 * 函数功能： 主机作为接收器时，给发送器发送非应答信号
 * 函数参数：无
 * 函数返回值：无
 * */
void i2c_nack(void)
{
    /*            --------
     * SCL       /        \
     *    -------          ------
     *    --- ---------------
     * SDA   X
     *    ---
     * */
    // 保证数据线是输出
    SET_SDA_OUT;
    I2C_SCL_L; // 拉低时钟线
    delay_us();
    I2C_SDA_H; // 数据线拉高，表示非应答信号
    delay_us();
    I2C_SCL_H; // 时钟线拉高，等待发送器读取应答信号
    delay_us();
    delay_us();
    I2C_SCL_L; // 数据线处于占用状态，发送器发送下一次数据
}

IIC.h

#ifndef __IIC_H__
#define __IIC_H__
#include "stm32mp1xx_gpio.h"
#include "stm32mp1xx_rcc.h"

/* 通过程序模拟实现I2C总线的时序和协议
 * GPIOF ---> AHB4
 * I2C1_SCL ---> PF14
 * I2C1_SDA ---> PF15
 *
 * */

#define SET_SDA_OUT                     \
    do                                  \
    {                                   \
        GPIOF->MODER &= (~(0x3 << 30)); \
        GPIOF->MODER |= (0x1 << 30);    \
    } while (0)

#define SET_SDA_IN                      \
    do                                  \
    {                                   \
        GPIOF->MODER &= (~(0x3 << 30)); \
    } while (0)

#define I2C_SCL_H                   \
    do                              \
    {                               \
        GPIOF->BSRR |= (0x1 << 14); \
    } while (0)

#define I2C_SCL_L                  \
    do                             \
    {                              \
        GPIOF->BRR |= (0x1 << 14); \
    } while (0)

#define I2C_SDA_H                   \
    do                              \
    {                               \
        GPIOF->BSRR |= (0x1 << 15); \
    } while (0)

#define I2C_SDA_L                  \
    do                             \
    {                              \
        GPIOF->BRR |= (0x1 << 15); \
    } while (0)

#define I2C_SDA_READ (GPIOF->IDR & (0x1 << 15))

void delay_us(void);                            // 微秒延时
void delay(int ms);                             // 毫秒延时
void i2c_init(void);                            // 初始化
void i2c_start(void);                           // 起始信号
void i2c_stop(void);                            // 终止信号
void i2c_write_byte(unsigned char dat);         // 写一个字节数据
unsigned char i2c_read_byte(unsigned char ack); // 读取一个字节数据
unsigned char i2c_wait_ack(void);               // 等待应答信号
void i2c_ack(void);                             // 发送应答信号
void i2c_nack(void);                            // 发送非应答信号

#endif

si7006.c

#include "si7006.h"
void delay1(int ms)
{
	int i, j;
	for (i = 0; i < ms; i++)
	{
		for (j = 0; j < 2000; j++);
	}
}
/*
 * 函数名：si7006_init
 * 函数功能：SI7006芯片的初始化
 * 函数参数：无
 * 函数返回值：无
 */
void si7006_init(void)
{
	// 1.发起起始信号
	i2c_start();
	// 2.发送7bit从机地址和写标志位   0X80
	i2c_write_byte(0x40 << 1 | 0);
	// 3.等待从机应答
	i2c_wait_ack();
	// 4.发送寄存器地址 0XE6
	i2c_write_byte(0xE6);
	// 5.等待从机应答
	i2c_wait_ack();
	// 6.向从机发送数据  0X3A
	i2c_write_byte(0x3A);
	// 7.等待从机应答
	i2c_wait_ack();
	// 8.发送终止信号
	i2c_stop();
}
/*
 * 函数名：si7006_read_hum_data
 * 函数功能：读取SI7006的湿度转换结果
 * 函数参数：
 *     slave_addr ： 从机地址
 *     cmd_code ： 命令码
 * 函数返回值：湿度测量的数字量
 */
unsigned short si7006_read_hum_data()
{
	unsigned char hum_l = 0, hum_h = 0; //
	unsigned short hum = 0;
	// 1.主机发起起始信号
	i2c_start();
	// 2.主机发送7bit从机地址+1bit写标志
	i2c_write_byte(0x40 << 1 | 0);
	// 3.等待从机应答
	i2c_wait_ack();
	// 4.主机发送8bit寄存器地址
	i2c_write_byte(0xE5);
	// 5.等待从机应答
	i2c_wait_ack();
	// 6.主机发起重复起始信号
	i2c_start();
	// 7.主机发送7bit从机地址+1bit 读  0X81
	i2c_write_byte(0x40 << 1 | 1);
	// 8.等待从机应答
	i2c_wait_ack();
	// 9.延时等待从机测量数据
	delay1(100);
	// 10.读取湿度的高8bit数据  hum_h
	// 11.发送应答信号
	hum_h = i2c_read_byte(0);
	// 12.读取湿度的低8位数据  hum_l
	// 13.发送非应答信号
	hum_l = i2c_read_byte(1);
	// 14.发起终止信号
	i2c_stop();
	// 15.将读取到的数据的低8位和高8bit合成一个完整的数据
	hum = (hum_h << 8) | hum_l; // 将高位左移八位，与低位组合成一个2B的湿度测量数据
	return hum;
}
/*
 * 函数名：si7006_read_temp_data
 * 函数功能：读取SI7006的温度转换结果
 * 函数参数：
 *     slave_addr ： 从机地址
 *     cmd_code ： 命令码
 * 函数返回值：温度测量的数字量
 */
short si7006_read_temp_data()
{
	char tem_l = 0, tem_h = 0;
	short tem = 0;
	// 1.主机发起起始信号
	i2c_start();
	// 2.主机发送7bit从机地址+1bit写标志
	i2c_write_byte(0x80);
	// 3.等待从机应答
	i2c_wait_ack();
	// 4.主机发送8bit寄存器地址
	i2c_write_byte(0xE3);
	// 5.等待从机应答
	i2c_wait_ack();
	// 6.主机发起重复起始信号
	i2c_start();
	// 7.主机发送7bit从机地址+1bit 读  0X81
	i2c_write_byte(0X81);
	// 8.等待从机应答
	i2c_wait_ack();
	// 9.延时等待从机测量数据
	delay1(100);
	// 10.读取湿度的高8bit数据  tem_h
	// 11.发送应答信号
	tem_h = i2c_read_byte(0);
	// 12.读取湿度的低8位数据  tem_l
	// 13.发送非应答信号
	tem_l = i2c_read_byte(1);
	// 14.发起终止信号
	i2c_stop();
	// 15.将读取到的数据的低8位和高8bit合成一个完整的数据
	tem = (tem_h << 8) | tem_l; // 将高位左移八位，与低位组合成一个2B的温度测量数据
	return tem;
}

si7006.h

#ifndef __SI7006_H__
#define __SI7006_H__
#include "iic.h"
#define     SI7006_SLAVE   0x40
void delay1(int ms);
void si7006_init(void);
unsigned short si7006_read_hum_data();
short si7006_read_temp_data();
#endif //__SI7006_H__

 main.c

#include "si7006.h"
#include "iic.h"
#include "led.h"
extern void printf(const char *fmt, ...);
int main()
{
    //si7006初始化
    si7006_init();
    i2c_init();
    led_start();
    unsigned short hum;
    short tem;
    while(1)
    {
        //读取温度和湿度
        hum=si7006_read_hum_data();
        tem=si7006_read_temp_data();
        //计算温湿度数据
        hum=hum*125/65536-6;
        tem=tem*175.72/65536-46.85;
        if (tem > 26)
        {
            LED1_CTRL(1);
            LED2_CTRL(1);
            LED3_CTRL(1);
            fan(1);
            buzzer(1);
        }
        
        printf("hum:%d\n",hum);
        printf("tem:%d\n",tem);
        delay1(1000);
    }
    return 0;
}

开始时要保证时钟线和数据线都是高电平状态。时钟线保持高电平，数据线产生下降沿时是启动信号。当时钟线保持低电平时，可以像数据线中写入数据，高电平时可以从数据线中读取数据。时钟线保持高电平，数据线产生上升沿时是停止信号。

IIC是一种串行、半双工、同步的通信方式。

小憩一下马上回来
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
ESP32C3 GPIO模拟IIC协议实现驱动mpu6500
07-27
直接用GPIO引脚模拟IIC协议的各个功能模块，根据MPU6500数据手册实现读写寄存器数据
STM32F103通过IIC协议实现温湿度（AHT20）的采集
qq_53088119的博客
11-16 1129
STM32F103通过IIC协议实现温湿度（AHT20）的采集
STM32基于IIC协议的温湿度（AHT20）采集
jynyyhd的博客
11-13 1402
IIC通讯协议(Inter－Integrated Circuit)是由 Phiilps 公司开发的，由于它引脚少，硬件实现简单，可扩展性强，不需要 USART、CAN 等通讯协议的外部收发设备，现在被广泛地使用在系统内多个集成电路(IC)间的通讯。了解学习了IIC协议进行通信，对AHT20芯片读取数据的过程也要有一个比较清晰的认识，知道如何通过AHT20读取采集到的温湿度。
STM32F103ZET6+IIC+SHT20温湿度传感
weixin_52411606的博客
06-08 5161
STM32F103ZET6+IIC+SHT20温湿度传感 IIC概述 IIC：两线式串行总线，它是由数据线SDA和时钟线SCL构成的串行总线，可发送和接收数据。 在CPU与被控IIC之间、IIC与IIC之间进行双向传送，高速IIC总线一般可达400kbs以上。总线上可以接多个从设备，从设备的地址必须不同。也可也接多个主设备，但同一时刻只能有一个主设备控制总线。最大设备数量受总线的最大负载电容400pf限制。每个从设备有自己的设备地址，主设备发送START信号后，紧跟着发送想要通信的从设备地址字节，7位器件地
STM32 软件IIC OLED温湿度显示
qq_44610809的博客
01-16 395
目录oled.coled.hdelay.cdelay.hmain.cDHT11.hDHT11.c 用的板子是STM32最小系统板STM32F103C8T6 原理之前再硬件IIC那篇文章中写过，就不写了，直接附上代码了 oled.c #include "stm32f10x.h" #include "oled.h" #include "oledfont.h" #include "delay.h" //static void delay_u(unsigned char num) //{ // uint8_
gpio模拟iic drivers
03-17
gpio模拟iic驱动，基于stm8寄存器版，移植方便，只需要修改io即可
GPIO模拟IIC，通信AT24C02
08-17
STM32F7GPIO模拟IIC，用EEPROM_AT24C02
GT911 GPIO模拟IIC
03-07
通过GPIO模拟IIC进行通讯，访问gt911寄存器
GPIO模拟IIC的参考程序
01-17
GPIO模拟IIC的参考程序
鸿蒙OpenHarmony【轻量系统 运行】 （基于Hi3861开发板）
m0_62167422的博客
04-27 1083
由于Hi3861为WLAN模组，您可以在版本编译及烧录后，通过如下操作，使开发板实现联网功能。复位Hi3861 WLAN模组，终端界面显示“ready to OS start”，则启动成功。Hi3861 WLAN模组复位成功示意图依次执行如下AT命令，启动STA模式，连接指定AP热点，并开启DHCP功能。查看Hi3861 WLAN模组与网关联通是否正常，如下图所示。Hi3861 WLAN模组联网成功示意图。
初学者如何选择ARM开发硬件？
单片机一哥的博客
04-21 864
配置中断句柄，连接到C语言入口。也许你看到给你的一些示例程序当中，bootloader会有很多东西，但是不要被这些复杂的程序所困扰，因为你不是做开发板的，你的任务就是做段小程序，让你的应用程序能够运行下去刚好，我总结了一些嵌入式资料放在视频结尾。1． 如果你有做硬件和单片机的经验,建议自己做个最小系统板：假如你从没有做过ARM的开发，建议你一开始不要贪大求全，把所有的应用都做好，因为ARM的启动方式和dsp或单片机有所不同，往往会碰到各种问题，所以建议先布一个仅有Flash,SRAM或SDRAM、CPU、
正点原子[第二期]Linux之ARM（MX6U）裸机篇学习笔记-5
weixin_40289409的博客
04-24 550
本文是根据哔哩哔哩网站上“正点原子[第二期]Linux之ARM（MX6U）裸机篇”视频的学习笔记，在这里会记录下正点原子 I.MX6ULL 开发板的配套视频教程所作的实验和学习笔记内容。本文大量引用了正点原子教学视频和链接中的内容。
全志ARM-超声波测距
长路漫漫，平平无奇
04-27 667
【代码】全志ARM-超声波测距。
【ARM 裸机】NXP 官方 SDK 使用
我的博客
04-27 562
ARM 裸机，NXP 官方 SDK 使用，移植官方的文件，参考正点原子给出的修改之后文件，已成功移植
基于ARM深入分析C程序
小pp的博客
04-27 396
c语言深度学习
鸿蒙OpenHarmony【小型系统 烧录】（基于Hi3516开发板）
最新发布
m0_62167422的博客
04-28 873
鸿蒙—作为国家主力推送的国产操作系统。部分的高校已经取消了安卓课程，从而开设鸿蒙课程；企业纷纷跟进启动了鸿蒙研发。并且鸿蒙是完全具备无与伦比的机遇和潜力的；预计到年底将有 5,000 款的应用完成原生鸿蒙开发，未来将会支持 50 万款的应用。那么这么多的应用需要开发，也就意味着需要有更多的鸿蒙人才。鸿蒙开发工程师也将会迎来爆发式的增长，学习鸿蒙势在必行！
OpenHarmony语言基础类库【@ohos.url (URL字符串解析)】
2301_76813281的博客
04-24 931
本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。
MCU功耗测量
qq_42301955的博客
04-24 1077
功耗测量
rtthread用gpio模拟iic
03-29
在RT-Thread中，可以利用GPIO模拟IIC总线。以下是一个简单的例子： ```c #include <rtthread.h> #include <rtdevice.h> #define IIC_SCL_PIN GET_PIN(B, 10) #define IIC_SDA_PIN GET_PIN(B, 11) static void iic_gpio_delay(void) { rt_thread_mdelay(1); } static void iic_gpio_set_sda(rt_bool_t value) { rt_pin_write(IIC_SDA_PIN, value); } static void iic_gpio_set_scl(rt_bool_t value) { rt_pin_write(IIC_SCL_PIN, value); } static rt_bool_t iic_gpio_get_sda(void) { return rt_pin_read(IIC_SDA_PIN); } static void iic_gpio_start(void) { iic_gpio_set_sda(RT_TRUE); iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); iic_gpio_set_sda(RT_FALSE); iic_gpio_delay(); iic_gpio_set_scl(RT_FALSE); } static void iic_gpio_stop(void) { iic_gpio_set_sda(RT_FALSE); iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); iic_gpio_set_sda(RT_TRUE); iic_gpio_delay(); } static rt_bool_t iic_gpio_write_byte(rt_uint8_t data) { rt_uint8_t i; for (i = 0; i < 8; i++) { iic_gpio_set_sda((data & 0x80) ? RT_TRUE : RT_FALSE); iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); iic_gpio_set_scl(RT_FALSE); iic_gpio_delay(); data <<= 1; } iic_gpio_set_sda(RT_TRUE); iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); if (iic_gpio_get_sda()) { return RT_FALSE; } iic_gpio_set_scl(RT_FALSE); return RT_TRUE; } static rt_uint8_t iic_gpio_read_byte(rt_bool_t ack) { rt_uint8_t i; rt_uint8_t data = 0; iic_gpio_set_sda(RT_TRUE); for (i = 0; i < 8; i++) { iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); data <<= 1; data |= iic_gpio_get_sda() ? 0x01 : 0x00; iic_gpio_set_scl(RT_FALSE); iic_gpio_delay(); } if (ack) { iic_gpio_set_sda(RT_FALSE); } iic_gpio_set_scl(RT_TRUE); iic_gpio_delay(); iic_gpio_set_scl(RT_FALSE); iic_gpio_delay(); if (ack) { iic_gpio_set_sda(RT_TRUE); } return data; } static rt_err_t iic_gpio_transfer(rt_uint8_t addr, rt_uint8_t *buf, rt_uint16_t len, rt_bool_t read) { rt_uint8_t i; rt_err_t result = RT_EOK; iic_gpio_start(); if (!iic_gpio_write_byte(addr)) { result = -RT_EIO; goto __exit; } if (read) { for (i = 0; i < len - 1; i++) { buf[i] = iic_gpio_read_byte(RT_TRUE); } buf[len - 1] = iic_gpio_read_byte(RT_FALSE); } else { for (i = 0; i < len; i++) { if (!iic_gpio_write_byte(buf[i])) { result = -RT_EIO; goto __exit; } } } __exit: iic_gpio_stop(); return result; } rt_err_t iic_gpio_init(void) { rt_pin_mode(IIC_SCL_PIN, PIN_MODE_OUTPUT_OD); rt_pin_mode(IIC_SDA_PIN, PIN_MODE_OUTPUT_OD); rt_pin_write(IIC_SCL_PIN, RT_TRUE); rt_pin_write(IIC_SDA_PIN, RT_TRUE); return RT_EOK; } #ifdef RT_USING_FINSH #include <finsh.h> static void iic_gpio_test(void) { rt_uint8_t buf[8]; rt_memset(buf, 0, sizeof(buf)); iic_gpio_transfer(0x50, buf, sizeof(buf), RT_FALSE); rt_kprintf("write: "); for (int i = 0; i < sizeof(buf); i++) { rt_kprintf("%02X ", buf[i]); } rt_kprintf("\n"); rt_kprintf("read: "); rt_memset(buf, 0, sizeof(buf)); iic_gpio_transfer(0x50, buf, sizeof(buf), RT_TRUE); for (int i = 0; i < sizeof(buf); i++) { rt_kprintf("%02X ", buf[i]); } rt_kprintf("\n"); } FINSH_FUNCTION_EXPORT(iic_gpio_test, iic gpio test) #endif /* RT_USING_FINSH */ ``` 在这个例子中，我们使用GPIO B10和B11作为IIC总线的SCL和SDA引脚。我们定义了一个iic_gpio_transfer函数来实现IIC总线的读写操作。我们还定义了一些辅助函数来模拟IIC总线的信号，如iic_gpio_start、iic_gpio_stop、iic_gpio_write_byte和iic_gpio_read_byte函数。最后，我们在FINSH shell中定义了一个iic_gpio_test函数来测试我们的IIC模拟代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值