通过普通IO模拟I2C主机

已于 2022-02-23 00:13:21 修改
阅读量8.9k 收藏 12
点赞数
分类专栏： 嵌入式 文章标签： 单片机 stm32 物联网
于 2022-02-23 00:12:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/songdawww/article/details/123080499
版权

文章目录

 I2C协议是嵌入式开发中常用的一种总线协议，使用方便占用IO少，多个从设备可以挂在同一个主机总线上。在一些特殊的情况下，需要多个I2C接口，硬件模块不够用；或者硬件设计原因无法使用硬件I2C，这时候就需要使用普通IO模拟I2C，通常模拟为主机。使用GPIO模拟I2C方便灵活，不受硬件资源限制，移植方便。

1. 模拟I2C主机代码

 这里使用的是Stm32L4的开发板，基于HAL库实现了GPIO模拟I2C主机，可以支持模拟多个I2C接口，不同接口可以有不同的SCL频率。

 头文件为：

#ifndef __IIC_SIMU_H
#define __IIC_SIMU_H

#ifdef __cplusplus
extern "C" {
#endif /*_cplusplus*/

/* Includes */
#include "stm32l4xx_hal.h"
#include "common_def.h"
#include "user_config.h"

typedef struct
{
    uint32_t        I2C_Timing;
    GPIO_TypeDef*   SCL_GPIOx;
    uint32_t        SCL_Pin;
    GPIO_TypeDef*   SDA_GPIOx;
    uint32_t        SDA_Pin;
} I2C_PortDef;

#define I2C_TIMING_100K      4
#define I2C_TIMING_200K      2

#define I2C_WRITE            0u
#define I2C_READ             1u

#define I2C_BYTE_TIMEOUT      10u

#define I2C_PIN_MODE          GPIO_MODE_OUTPUT_OD

#define ENTER_CRITICAL()
#define EXIT_CRITICAL()

/* Exported functions */
void I2C_SimInit(I2C_PortDef* port);

HAL_StatusTypeDef I2C_SimWrite(I2C_PortDef* port, uint8_t addr, 
                               uint8_t *data, uint32_t len, uint32_t Timeout);

HAL_StatusTypeDef I2C_SimRead(I2C_PortDef* port, uint8_t addr, 
                              uint8_t *data, uint32_t len, uint32_t Timeout);

HAL_StatusTypeDef I2C_SimMemWrite(I2C_PortDef* port, uint8_t addr, 
                                  uint8_t *memAddr, uint32_t memAddrLen,
                                  uint8_t *data, uint32_t len, uint32_t Timeout);

HAL_StatusTypeDef I2C_SimMemRead(I2C_PortDef* port, uint8_t addr, 
                                 uint8_t *memAddr, uint32_t memAddrLen,
                                 uint8_t *data, uint32_t len, uint32_t Timeout);
#ifdef __cplusplus
}
#endif /*_cplusplus*/

#endif /* __IIC_SIMU_H */

 实现文件为：

#include "iic_sim.h"

void SysCtlDelay(uint32_t ulCount)
{
    __asm("    subs    r0, #1\n"
          "    bne.n   SysCtlDelay\n"
          "    bx      lr");
}

void _I2C_DelayUs(uint32_t us)
{
    SysCtlDelay(us*(SystemCoreClock/3000000));
}

void _I2C_RCC_ENABLE(GPIO_TypeDef* GPIOx)
{
    if (GPIOx == GPIOA)
    {
        __HAL_RCC_GPIOA_CLK_ENABLE();
    } else if (GPIOx == GPIOB) {
        __HAL_RCC_GPIOB_CLK_ENABLE();
    } else if (GPIOx == GPIOC) {
        __HAL_RCC_GPIOC_CLK_ENABLE();
    }
    #if defined(GPIOD)
    else if (GPIOx == GPIOD) {
        __HAL_RCC_GPIOD_CLK_ENABLE();
    }
    #endif
    #if defined(GPIOE)
    else if (GPIOx == GPIOE) {
        __HAL_RCC_GPIOE_CLK_ENABLE();
    }
    #endif
    #if defined(GPIOF)
    else if (GPIOx == GPIOF) {
        __HAL_RCC_GPIOF_CLK_ENABLE();
    }
    #endif
    #if defined(GPIOG)
    else if (GPIOx == GPIOG) {
        __HAL_RCC_GPIOG_CLK_ENABLE();
    }
    #endif
}

void _I2C_PinOutPut(GPIO_TypeDef *GPIOx, uint32_t Pin)
{
    GPIO_InitTypeDef  GPIO_InitStruct;

    GPIO_InitStruct.Mode  = I2C_PIN_MODE;
    GPIO_InitStruct.Pull  = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pin = Pin;
    HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
}

void _I2C_PinInPut(GPIO_TypeDef *GPIOx, uint32_t Pin)
{
    GPIO_InitTypeDef  GPIO_InitStruct;

    GPIO_InitStruct.Mode  = GPIO_MODE_INPUT;
    GPIO_InitStruct.Pull  = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pin = Pin;
    HAL_GPIO_Init(GPIOx, &GPIO_InitStruct);
}

void I2C_SimInit(I2C_PortDef* port)
{
    GPIO_InitTypeDef  GPIO_InitStruct;

    _I2C_RCC_ENABLE(port->SCL_GPIOx);
    _I2C_RCC_ENABLE(port->SDA_GPIOx);

    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);

    GPIO_InitStruct.Mode  = I2C_PIN_MODE;
    GPIO_InitStruct.Pull  = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pin = port->SDA_Pin;
    HAL_GPIO_Init(port->SDA_GPIOx, &GPIO_InitStruct);

    GPIO_InitStruct.Mode  = I2C_PIN_MODE;
    GPIO_InitStruct.Pull  = GPIO_PULLUP;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_VERY_HIGH;
    GPIO_InitStruct.Pin = port->SCL_Pin;
    HAL_GPIO_Init(port->SCL_GPIOx, &GPIO_InitStruct);
}

/*
* Start: SDA High->Low, when SCL High
*/
void I2C_SimStart(I2C_PortDef* port)
{
    _I2C_PinOutPut(port->SDA_GPIOx, port->SDA_Pin);

    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
    _I2C_DelayUs(port->I2C_Timing);
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_RESET);
    _I2C_DelayUs(port->I2C_Timing);

    /* Drive bus */
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
}

/*
* Stop: SDA Low->High, when SCL High
*/
void I2C_SimStop(I2C_PortDef* port)
{
    _I2C_PinOutPut(port->SDA_GPIOx, port->SDA_Pin);

    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
    _I2C_DelayUs(port->I2C_Timing);
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    _I2C_DelayUs(port->I2C_Timing);
}

HAL_StatusTypeDef I2C_SimWaitAck(I2C_PortDef* port, uint32_t WaitMs)
{
    uint32_t start;
  
    _I2C_PinInPut(port->SDA_GPIOx, port->SDA_Pin);
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
    
    start = HAL_GetTick();
    _I2C_DelayUs(port->I2C_Timing>>1u);
    while(HAL_GPIO_ReadPin(port->SDA_GPIOx, port->SDA_Pin) != GPIO_PIN_RESET)
    {
        if((HAL_GetTick()-start) > WaitMs)
        {
            I2C_SimStop(port);
            return HAL_TIMEOUT;
        }
    }
    
    _I2C_DelayUs(port->I2C_Timing>>1u);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
    return HAL_OK;
}

/*
* ACK: SDA Low, when SCL Low->High->Low
*/
void I2C_SimSendAck(I2C_PortDef* port)
{
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
    _I2C_PinOutPut(port->SDA_GPIOx, port->SDA_Pin);
    
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_RESET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
    _I2C_DelayUs(port->I2C_Timing);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
}

/*
* NACK: SDA High, when SCL Low->High->Low
*/
void I2C_SimSendNack(I2C_PortDef* port)
{
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
    _I2C_PinOutPut(port->SDA_GPIOx, port->SDA_Pin);
    
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
    _I2C_DelayUs(port->I2C_Timing);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
}

void I2C_SimSendByte(I2C_PortDef* port, uint8_t chr)
{
    uint8_t i;
    
    ENTER_CRITICAL();
    
    _I2C_PinOutPut(port->SDA_GPIOx, port->SDA_Pin);
    HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
    
    for (i=0;i<8u;i++)
    {
        if (chr & 0x80)
        {
            HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
        } else {
            HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_RESET);
        }

        _I2C_DelayUs(port->I2C_Timing>>1u);
        HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
        _I2C_DelayUs(port->I2C_Timing);
        HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
        _I2C_DelayUs(port->I2C_Timing>>1u);

        chr <<= 1u;
    }
    
    EXIT_CRITICAL();
}

uint8_t I2C_SimGetByte(I2C_PortDef* port)
{
    uint8_t i;
    uint8_t chr = 0u;
    
    ENTER_CRITICAL();

    _I2C_PinInPut(port->SDA_GPIOx, port->SDA_Pin);
    HAL_GPIO_WritePin(port->SDA_GPIOx, port->SDA_Pin, GPIO_PIN_SET);
    
    for (i=0;i<8u;i++)
    {
        HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
        _I2C_DelayUs(port->I2C_Timing>>1u);
        HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_SET);
        _I2C_DelayUs(port->I2C_Timing>>1u);

        chr <<= 1u;
        if (HAL_GPIO_ReadPin(port->SDA_GPIOx, port->SDA_Pin) == GPIO_PIN_SET)
        {
            chr |= 1u;
        }

        _I2C_DelayUs(port->I2C_Timing>>1u);
        HAL_GPIO_WritePin(port->SCL_GPIOx, port->SCL_Pin, GPIO_PIN_RESET);
        _I2C_DelayUs(port->I2C_Timing>>1u);
    } 
    EXIT_CRITICAL();

    return chr;
}

HAL_StatusTypeDef I2C_WaitTill(I2C_PortDef* port, uint32_t start, uint32_t Timeout)
{
    if ((HAL_GetTick()-start) > Timeout)
    {
        I2C_SimStop(port);
        return HAL_TIMEOUT;
    }
    
    return HAL_OK;
}

/*
* I2c write data
* addr: slave address
* Timeout: timeout(ms)
*/
HAL_StatusTypeDef I2C_SimWrite(I2C_PortDef* port, uint8_t addr, 
                               uint8_t *data, uint32_t len, uint32_t Timeout)
{
    uint32_t i;
    uint32_t start;
    
    start = HAL_GetTick();

    I2C_SimStart(port);
    I2C_SimSendByte(port, (addr<<1u)|I2C_WRITE);
    if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
    {
        return HAL_TIMEOUT;
    }

    for (i=0;i<len;i++)
    {
        I2C_SimSendByte(port, data[i]);
        if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }
    I2C_SimStop(port);

    return HAL_OK;
}

HAL_StatusTypeDef I2C_SimRead(I2C_PortDef* port, uint8_t addr, 
                              uint8_t *data, uint32_t len, uint32_t Timeout)
{
    uint32_t i;
    uint32_t start;

    start = HAL_GetTick();

    I2C_SimStart(port);
    I2C_SimSendByte(port, (addr<<1u)|I2C_READ);
    if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
    {
        return HAL_TIMEOUT;
    }

    for (i=0;i<len;i++)
    {
        data[i] = I2C_SimGetByte(port);
        if (i == (len-1))
        {
            I2C_SimSendNack(port);
        } else {
            I2C_SimSendAck(port);
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }
    I2C_SimStop(port);

    return HAL_OK;
}

HAL_StatusTypeDef I2C_SimMemWrite(I2C_PortDef* port, uint8_t addr, 
                                  uint8_t *memAddr, uint32_t memAddrLen,
                                  uint8_t *data, uint32_t len, uint32_t Timeout)
{
    uint32_t i;
    uint32_t start;

    start = HAL_GetTick();

    I2C_SimStart(port);
    I2C_SimSendByte(port, (addr<<1u)|I2C_WRITE);
    if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
    {
        return HAL_TIMEOUT;
    }
    
    /* Send register addrss */
    for (i=0;i<memAddrLen;i++)
    {
        I2C_SimSendByte(port, memAddr[i]);
        if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }
    
    /* Send data */
    for (i=0;i<len;i++)
    {
        I2C_SimSendByte(port, data[i]);
        if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }
    I2C_SimStop(port);

    return HAL_OK;
}

HAL_StatusTypeDef I2C_SimMemRead(I2C_PortDef* port, uint8_t addr, 
                                 uint8_t *memAddr, uint32_t memAddrLen,
                                 uint8_t *data, uint32_t len, uint32_t Timeout)
{
    uint32_t i;
    uint32_t start;

    start = HAL_GetTick();

    I2C_SimStart(port);
    I2C_SimSendByte(port, (addr<<1u)|I2C_WRITE);
    if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
    {
        return HAL_TIMEOUT;
    }
    
    /* Send register addrss */
    for (i=0;i<memAddrLen;i++)
    {
        I2C_SimSendByte(port, memAddr[i]);
        if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }

    I2C_SimStart(port);
    I2C_SimSendByte(port, (addr<<1u)|I2C_READ);
    if (I2C_SimWaitAck(port, I2C_BYTE_TIMEOUT) != HAL_OK)
    {
        return HAL_TIMEOUT;
    }

    /* Get data */
    for (i=0;i<len;i++)
    {
        data[i] = I2C_SimGetByte(port);
        if (i == (len-1))
        {
            I2C_SimSendNack(port);
        } else {
            I2C_SimSendAck(port);
        }

        if (I2C_WaitTill(port, start, Timeout) != HAL_OK)
        {
            return HAL_TIMEOUT;
        }
    }
    I2C_SimStop(port);

    return HAL_OK;
}

2.测试代码

 这里使用24C08模块作为从设备，通过模拟I2C进行数据读写，通过逻辑分析仪分析数据正确性。测试代码为：

I2C_PortDef i2c_port;

i2c_port.I2C_Timing = I2C_TIMING_100K;
i2c_port.SCL_GPIOx = GPIOC;
i2c_port.SCL_Pin = GPIO_PIN_8;
i2c_port.SDA_GPIOx = GPIOC;
i2c_port.SDA_Pin = GPIO_PIN_9;
I2C_SimInit(&i2c_port);

uint8_t aa[4] = {0x55, 0xaa, 0x5a, 0xa5};
uint8_t memaddr = 0;
I2C_SimMemWrite(&i2c_port, 0x50, 
                   &memaddr, 1,
                   aa, 4, 30);
HAL_Delay(100);
    
uint8_t bb[4];
memaddr = 2;
I2C_SimMemRead(&i2c_port, 0x50, 
                   &memaddr, 1,
                   bb, 4, 30);

 通过逻辑分析仪抓到的数据可以看到I2C的时序是正确的：

 写EEPROM

 读EEPROM

3.总结

 通过GPIO模拟I2C主机灵活方便，可以同时模拟多个I2C端口，缺点是相较硬件实现容易受到其他代码的影响，无法使用DMA等高级功能。然而由于I2C使用的场景大部分情况下速度都比较慢，GPIO模拟I2C仍是一种比较实用的方式。

songdawww
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
普通IO口模拟I2C及应用（EEPROM 24C04）
08-20
普通IO口模拟实现I2C通信及应用解析，包含I2C通信模拟驱动IICDrv.c，IICDrv.h，EEPROM 24C04相关函数EEApp.C，EEApp.h
GPIO模拟I2C通信协议（一）
热门推荐
Chen_Tianyang的博客
11-07 3万+
本博客是GPIO模拟I2C通信协议系列的第1篇，本文将首先介绍I2C协议的基本时序，然后给出用GPIO模拟实现I2C功能的C代码，最后介绍驱动开发的一些思路。本文的主要内容包括I2C协议简介和I2C协议的C代码实现两个部分，每个部分中又包含很多细节内容，都有代码实现。
IO口软件模拟IIC
zhejfl的博客
09-28 2万+
  一、IIC时序 IIC(Inter-Integrated Circuit, 内部集成电路)总线是飞利浦公司开发的两线式串行总线，用于短距离传输，常用语微控制器及其外围设备。它是由数据线SDA和时钟线SCL构成的串行总线，可发送和接收数据。 I2C总线通过上拉电阻接正电源。即当总线空闲时，两根线均为高电平。如此，连在总线上的任一器件输出的低电平，都可以使得总线的信号变低，也就是说各器件...
单片机IO管脚模拟I2C从机通信
dear_Wally的博客
05-28 5281
1、思路：需要使用SDA管脚下降沿中断，通过I2C的通信协议可知，主机发送开始信号时，会先把SDA管脚拉低，所以从机在SDA下降沿会进入中断，然后做相关的操作。 2、优点：可以让没有硬件I2C的单片机通过此方式模拟通信；实测从机收发数据正常，无丢包现象；90%的代码都注释，避免初学者看不明白。 3、缺点：由于是模拟的方式，所以主机的速度不能太快，否则单片机处理不过来；SDA管脚的中断优先级尽量调到最高，避免接收数据时进入其它中断，导致丢包；接收过程在中断里面处理，所以占用中断的时间受传输速度和数据长..
笔记四：linux下IO口模拟实现I2C协议
peng_fp的博客
10-25 2355
一、i2c总线、模拟
模拟IIC——关于模拟IIC的IO口的配置选取推挽输出还是开漏输出，以及是否需要更改IO口输入输出模式和是否需要对IO配置上拉
m0_62243928的博客
07-14 1万+
关于模拟IIC的IO口的配置选取推挽输出还是开漏输出，以及是否需要更改I口输入输出模式
I2C总线原理与IO模拟时序实现
ic2121的博客
03-29 963
而I2C的总从通讯主要由判断I2C总线上的每个设备的唯一的地址，来确保不同设备之间访问的准确性，也就是说挂在总线上的每个I2C设备，都由一个属于自己的固定地址，并且I2C总线规范规定，标准模式I2C，从机地址为7位长，其次是1个读/写位。现在的很多单片机都内置了I2C外设，在使用上只需要配置好对应的管脚、模式、速率以及地址等参数就可以进行通讯，但是由于硬件I2C设计的固定，对于应答等方面有了固定的要求，并不便于调整，还有很多单片机本身就没有I2C，所以现在很多设计都喜欢采用IO口模拟时序的方式来实现。
STM32-I2C --- 通过IO口模拟
weixin_43980926的博客
03-27 8566
I2C — 通过IO口模拟 1.I2C介绍 I2C两根线，一根时钟线（SCL）一根信号线（SDA）。 数据传输时：时钟线信号为低电平时，数据线电平才允许变化。 起始和停止位控制时：时钟线信号为高电平，数据线由高向低变化为起始信号，数据线由低向高变化为停止信号。 应答ACK：发送器件传输完成一个字节后，应答器回应ACK，发送器发送下一字节。应答器不回应ACK，发送器不发送下一字节。ACK为低电平脉冲。 软件模拟I2C移植性及稳定性更好。 2.I2C应用方法 2.1 I2C初始化 /**************
超详细！新手必看！STM32基础-IIC串行通信协议-IO口模拟IIC操作AT24C02
最新发布
qq_48361010的博客
09-30 907
STM32 --IIC串行通信协议
C语言27-I2C从机中断模式与IO口模拟I2C主机进行自发自收（STC32G-DEMO-CODE-220311kw）
06-14
C语言27-I2C从机中断模式与IO口模拟I2C主机进行自发自收（STC32G-DEMO-CODE-220311kw）C语言27-I2C从机中断模式与IO口模拟I2C主机进行自发自收（STC32G-DEMO-CODE-220311kw）C语言27-I2C从机中断模式与IO口模拟I2C...
电子-STM32的IO模拟I2C主机硬件I2C从机.zip
09-05
电子-STM32的IO模拟I2C主机硬件I2C从机.zip,单片机/嵌入式STM32-F0/F1/F2
STM32的IO模拟I2C主机_硬件I2C从机.rar_STM32 I2C_STM32 IO_i2c 32 io_stm32 i
07-15
stm32作为主机从机进行I2C通信的程序。
电子-STM32的IO模拟I2C主机硬件I2C从机.rar
09-05
电子-STM32的IO模拟I2C主机硬件I2C从机.rar,单片机/嵌入式STM32-F0/F1/F2
51单片机模拟I2C从机
11-12
利用普通IO口模拟I2C从机，解决UART不够用的问题。TEST.c为主机部分代码，I2C_UART.C为转换器部分代码。主机为89C52，转换器为STC12LE5608
Python实现SM4算法
songdawww的博客
01-20 1万+
Python实现SM4算法 SM4算法：SM4分组密码算法是我国自主设计的分组对称密码算法，用于实现数据的加密/解密运算，以保证数据和信息的机密性。要保证一个对称密码算法的安全性的基本条件是其具备足够的密钥长度，SM4算法与AES算法具有相同的密钥长度分组长度128比特，因此在安全性上高于3DES算法。 　　最近在写Python脚本时，需要用到SM4算法，通过百度查找SM4算法实现基本
Stm32+STemWin+LCD
songdawww的博客
06-15 1万+
Stm32+STemWin+LCD 手里有块STM32F4Discovery的板子，最近拿出来玩玩，移植了STemWin配上4.6寸触摸屏，效果还是不错的。 Stm32STemWinLCD 简介 效果图 QA 1LCD驱动移植问题 2STemWin移植 3触摸屏驱动触点会跳问题 4emWin在模拟器调试简介    STemWin、emWin& ucGui都差不多，可以当作一个东西，STemWin
嵌入式开发输出调试信息的几种方法
songdawww的博客
06-23 4569
嵌入式开发输出调试信息的几种方法 嵌入式开发输出调试信息的几种方法 1、输出log信息到SRAM 2、通过SWO输出log 2.1 通过IDE输出 2.2 通过STM32 ST-LINK Utility输出 3、通过串口输出log 4、使用IO模拟串口输出log 总结 《论语》有云：“工欲善其事,必先利其器”。输出调试信息是软件开发中必不可少的调试利器，在出现b...
个io模拟i2c从机的代码
07-14
这段代码模拟了一个简单的I2C从机，它接收来自主机的数据，并将接收到的数据存储在缓冲区中。然后，当主机请求读取数据时，从机将缓冲区中的数据发送给主机。 请注意，这只是一个简单的示例代码，实际应用中可能...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值