外设驱动库开发笔记43：GPIO模拟SPI驱动

已于 2022-07-03 18:25:42 修改
阅读量3.5k 收藏 68
点赞数 15
分类专栏： 外设驱动库开发 文章标签： SPI 软件模拟
于 2022-07-03 17:58:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/foxclever/article/details/125586266
版权

  SPI总线是我们常用的串行设备接口，一般情况下我们都会适应硬件SPI接口，但有些时候当硬件端口不足时，我们也希望可以使用软件来模拟SPI硬件接口，特别是要求不是很高的时候。在这一篇中我们将来讨论如何使用GPIO和软件来模拟SPI通讯接口。

1、功能概述

  SPI即串行外设接口，是一种同步串行通讯接口，用于微处理器及控制器和外围扩展芯片之间的串行连接，现已发展成为一种工业标准。

1.1、物理层

  SPI总线在物理层通常使用3条总线及1条片选线，3条总线分别为 SCK、 MOSI、 MISO，片选线为NSS，它们的作用介绍如下：
  NSS( Slave Select)，从设备选择信号线，常称为片选信号线。在SPI协议中没有设备地址，所以需要使用NSS信号线来寻址，当主机要选择从设备时，把该从设备的NSS信号线设置为低电平，该从设备即被选中，即片选有效，接着主机开始与被选中的从设备进行SPI通讯。所以SPI通讯以NSS线置低电平为开始信号，以NSS线被拉高作为结束信号。
  SCK (Serial Clock)，时钟信号线，用于通讯数据同步。它由通讯主机产生，决定了通讯的速率，不同的设备支持的最高时钟频率不一样，如 STM32 的 SPI 时钟频率最大为fpclk/2，两个设备之间通讯时，通讯速率受限于低速设备。
  MOSI (Master Output， Slave Input)，主设备输出/从设备输入引脚。主机的数据从这条信号线输出，从机由这条信号线读入主机发送的数据，即这条线上数据的方向为主机到从机。
  MISO(Master Input,， Slave Output)，主设备输入/从设备输出引脚。主机从这条信号线读入数据，从机的数据由这条信号线输出到主机，即在这条线上数据的方向为从机到主机。
  对于使用SPI总线来进行通讯的设备，一台主机可以与多台从机进行通讯，时钟与数据总线为公用，片选线每台从机都是独立的，具体连接方式如下图所示：

  也就是说，有多个SPI从设备与SPI主机通讯时，设备的时钟线和总线数据线 SCK、MOSI及MISO同时并联到相同的SPI总线上，即无论有多少个从设备，都共同只使用这 3 条总线。而每个从设备都拥有独立的一条NSS信号线，即有多少个从设备，就有多少条片选信号线。

1.2、协议层

  我们已经简述了SPI总线的物理连接方式，接下来我们再来了解一下具体的通讯协议。在了解协议前，我们需要清楚两个概念，即时钟的极性和时钟的相位。
  所谓时钟极性，通常称作CPOL，即是指在空闲状态下，时钟所处的电平状态。如果SCLK在数据发送之前和之后的空闲状态是高电平，那么就是CPOL=1；如果空闲状态SCLK是低电平，那么就是 CPOL=0。
  而时钟的相位，通常称作CPHA，就是指数据采样是在时钟脉冲的第1个跳变沿还是在第2个跳变沿。如果在SCK的第1个跳变沿进行数据采样，则CPHA=0；如果在SCK的第2个跳变沿采样，则CPHA=1。
  在通讯协议中，根据CPOL和CPHA的取值不同存在4种不同的配置方式，不同的配置方式对应不同的通讯模式。
  （1）当CPOL=0，CPHA=0时，空闲状态时钟SCK的电平要保持在低电平，而数据的采样时刻在时钟脉冲的奇数跳变边沿，其时序图如下：

  （2）当CPOL=0，CPHA=1时，空闲状态时钟SCK的电平要保持在低电平，而数据的采样时刻在时钟脉冲的偶数跳变边沿，其时序图如下：

  （3）当CPOL=1，CPHA=0时，空闲状态时钟SCK的电平要保持在高电平，而数据的采样时刻在时钟脉冲的奇数跳变边沿，其时序图如下：

  （4）当CPOL=1，CPHA=1时，空闲状态时钟SCK的电平要保持在高电平，而数据的采样时刻在时钟脉冲的偶数跳变边沿，其时序图如下：

  根据这时钟情况，将SPI总线的工作模式分为4种，如下图所示：

  而只有主机与从机拥有相同的工作模式时，主从机之间才可以正常通讯。在实际应用中，“模式 0”与“模式 3”是比较常见的工作模式，但在我们的驱动设计中应该兼顾这4种模式，以具备更广泛的适应性。

2、驱动设计与实现

  我们已经简要的描述了SPI通讯总线的物理连接和通讯协议，接下来我们将根据其协议的特性设计并实现基于GPIO模拟的SPI总线驱动。

2.1、对象定义

  我们依然使用基于对象的思想来实现基于GPIO模拟的SPI总线驱动。既然是基于对象，那么在使用一个对象之前我们需要先获得这个对象。所以我们必须先定义一个基于GPIO模拟的SPI总线的对象。

2.1.1、对象的抽象

  我们要得到基于GPIO模拟的SPI总线的对象，需要先分析其基本特性。一般来说，一个对象至少包含属性与操作两方面的特性。接下来我们就来从这两个方面思考一下基于GPIO模拟的SPI总线的对象。
  我们首先来考虑对象的属性，作为属性肯定是用于标识或记录对象特征的东西。我们在前面已经了解到SPI总线的一些特点和独特设定，那么这些特点和设定是否能成为对象的属性呢？
  我们考虑到作为同步总线，SPI总线的控制需要时钟，这关系到SPI总线的通讯速率，这一通讯速率不仅配置SPI总线的工作方式也标识当前的工作状态，所以我们将工作速率作为模拟SPI总线对象的一个属性。在前面我们讨论过SPI总线的工作模式，工作模式由CPOL和CPHA决定，所以在初始化总线时就会确定工作模式，所以我们需要记录CPOL和CPHA，我们将CPOL和CPHA也作为对象的属性。
  接下来我们考虑GPIO模拟SPI总线的操作问题。我们将那些对象要实现的，并且依赖于具体的平台的行为实现定义为对象的操作。对于GPIO模拟SPI总线来说，我们需要通过总线发送数据和接收数据，而接收和发送的实现都依赖于具体的软硬件平台，所以我们将发送数据和接收数据定义为对象的操作。SPI总线作为同步总线需要时钟，而时钟操作也是依赖于具体的软硬件平台来实现，所以我们将始终的控制也作为对象的操作。
  根据上述我们对GPIO模拟SPI总线的分析，我们可以定义GPIO模拟SPI总线对象类型如下：

/*定义GPIO模拟SPI接口对象*/
typedef struct SimuSPIObject{
  uint16_t CPOL:1;
  uint16_t CPHA:1;
  uint16_t period:14;   //确定速度为大于0K小于等于400K的整数，默认为100K
  void (*SetSCKPin)(SimuSPIPinValueType op);        //设置SCL引脚
  void (*SetMOSIPin)(SimuSPIPinValueType op);        //设置SDA引脚
  uint8_t (*ReadMISOPin)(void);                  //读取SDA引脚位
  void (*Delayus)(volatile uint32_t period);    //速度延时函数
}SimuSPIObjectType;

2.1.2、对象初始化

  我们知道，在使用一个对象之前需要先对其进行初始化，所以这里我们来考虑GPIO模拟SPI对象的初始化函数。一般来说，初始化函数需要处理几个方面的问题。一是检查输入参数是否合理；二是为对象的属性赋初值；三是对对象做必要的初始化配置。据此我们设计GPIO模拟SPI对象的初始化函数如下：

/* GPIO模拟SPI通讯初始化 */
void SimuSPIInitialization(SimuSPIObjectType *simuSPIInstance,//初始化的模拟SPI对象
                           uint32_t speed,      //时钟频率
                           SimuSPICPOLType CPOL,        //时钟极性
                           SimuSPICPHAType CPHA,        //时钟频率
                           SimuSPISetSCKPin setSCK,     //SCK时钟操作函数指针
                           SimuSPISetMOSIPin setMOSI,   //MOSI操作函数指针
                           SimuSPIReadMISOPin getMISO,  //MISO操作函数指针
                           SimuSPIDelayus delayus       //微秒延时操作函数指针
                               )
{
    if((simuSPIInstance==NULL)||(setSCK==NULL)||(setMOSI==NULL)||(getMISO==NULL)||(delayus==NULL))
    {
        return;
    }
    
    simuSPIInstance->SetSCKPin=setSCK;
    simuSPIInstance->SetMOSIPin=setMOSI;
    simuSPIInstance->ReadMISOPin=getMISO;
    simuSPIInstance->Delayus=delayus;
    
    /*初始化速度,默认100K*/
    if((speed>0)&&(speed<=500))
    {
        simuSPIInstance->period=500/speed;
    }
    else
    {
        simuSPIInstance->period=5;
    }
    
    simuSPIInstance->CPOL=CPOL;
    simuSPIInstance->CPHA=CPHA;
    
    /*拉高总线，使处于空闲状态*/
    
    if(simuSPIInstance->CPOL==SimuSPI_POLARITY_LOW)
    {
        simuSPIInstance->SetSCKPin(SimuSPI_Reset);
    }
    else
    {
        simuSPIInstance->SetSCKPin(SimuSPI_Set);
    }
}

2.2、对象操作

  我们已经定义了对象类型，也实现了对象的初始化函数，但我们还没有实现对象的具体操作，所以接下来我们就来实现对象的具体操作。

2.2.1、数据的发送

  在我们使用SPI来实现数据通讯时，免不了要发送数据，所以在我们使用GPIO模拟SPI端口时就需要解决数据发送的问题。这里我们考虑使用模拟SPI发送一个字节的问题，因为发送多个字节无非是多重复几次。根据前面分析的在不同模式下的时序图我们可以编写GPIO模拟SPI发送一个字节的函数如下：

/* 通过模拟SPI发送一个字节 */
static void SendByteBySimuSPI(SimuSPIObjectType *simuSPIInstance,uint8_t byte)
{
//    uint8_t length[2]={8,16};
    
    if(simuSPIInstance->CPOL==SimuSPI_POLARITY_LOW)
    {
        /*拉低SCL引脚准备数据传输*/
        simuSPIInstance->SetSCKPin(SimuSPI_Reset);
        
        if(simuSPIInstance->CPHA==SimuSPI_PHASE_1EDGE)  //模式0
        {
            for(uint8_t count = 0; count < 8; count++)
            {
                if(byte & 0x80)     //每次发送最高位
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Set);
                }
                else
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Reset);
                }
                byte <<= 1;         //发送一位后，左移一位
                
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
            }
        }
        else    //模式1
        {
            for(uint8_t count = 0; count < 8; count++)
            {
                if(byte & 0x80)     //每次发送最高位
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Set);
                }
                else
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Reset);
                }
                byte <<= 1;         //发送一位后，左移一位
                
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
            }
        }
    }
    else
    {
        /*拉低SCL引脚准备数据传输*/
        simuSPIInstance->SetSCKPin(SimuSPI_Set);
        
        if(simuSPIInstance->CPHA==SimuSPI_PHASE_1EDGE)  //模式2
        {
            for(uint8_t count = 0; count < 8; count++)
            {
                if(byte & 0x80)     //每次发送最高位
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Set);
                }
                else
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Reset);
                }
                byte <<= 1;         //发送一位后，左移一位
                
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
            }
        }
        else    //模式3
        {
            for(uint8_t count = 0; count < 8; count++)
            {
                if(byte & 0x80)     //每次发送最高位
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Set);
                }
                else
                {
                    simuSPIInstance->SetMOSIPin(SimuSPI_Reset);
                }
                byte <<= 1;         //发送一位后，左移一位
                
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
            }
        }
    }
}

2.2.2、数据的接收

  对于SPI端口来说不光需要发送数据，也需要从对方接收数据，同样的我们再次考虑接收一个字节的情况。同样我们根据前面对不同模式下，接收数据的时序要求可以编写接收一个字节的函数如下：

/* 通过模拟SPI接收一个字节 */
static uint8_t RecieveByteBySimuSPI(SimuSPIObjectType *simuSPIInstance)
{
    uint8_t receive = 0;
    
    if(simuSPIInstance->CPOL==SimuSPI_POLARITY_LOW)
    {
        /*拉低SCL引脚准备数据传输*/
        simuSPIInstance->SetSCKPin(SimuSPI_Reset);
        
        if(simuSPIInstance->CPHA==SimuSPI_PHASE_1EDGE)  //模式0
        {
            for(uint8_t count = 0; count < 8; count++ )
            {
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                
                receive <<= 1;
                
                if(simuSPIInstance->ReadMISOPin())
                {
                    receive++;
                }
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
            }
        }
        else    //模式1
        {
            simuSPIInstance->SetSCKPin(SimuSPI_Set);
            simuSPIInstance->Delayus(simuSPIInstance->period);
            for(uint8_t count = 0; count < 8; count++ )
            {
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                
                receive <<= 1;
                
                if(simuSPIInstance->ReadMISOPin())
                {
                    receive++;
                }
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
            }
            simuSPIInstance->SetSCKPin(SimuSPI_Reset);
        }
    }
    else
    {
        /*拉低SCL引脚准备数据传输*/
        simuSPIInstance->SetSCKPin(SimuSPI_Set);
        
        if(simuSPIInstance->CPHA==SimuSPI_PHASE_1EDGE)  //模式2
        {
            for(uint8_t count = 0; count < 8; count++ )
            {
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                
                receive <<= 1;
                
                if(simuSPIInstance->ReadMISOPin())
                {
                    receive++;
                }
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
            }
        }
        else    //模式3
        {
            simuSPIInstance->SetSCKPin(SimuSPI_Reset);
            simuSPIInstance->Delayus(simuSPIInstance->period);
            for(uint8_t count = 0; count < 8; count++ )
            {
                simuSPIInstance->SetSCKPin(SimuSPI_Set);
                simuSPIInstance->Delayus(simuSPIInstance->period);
                
                receive <<= 1;
                
                if(simuSPIInstance->ReadMISOPin())
                {
                    receive++;
                }
                simuSPIInstance->SetSCKPin(SimuSPI_Reset);
                simuSPIInstance->Delayus(simuSPIInstance->period);
            }
            simuSPIInstance->SetSCKPin(SimuSPI_Set);
        }
    }
    
    return receive;
}

3、驱动的使用

  我们已经设计并实现了GPIO模拟SPI总线的驱动程序，接下来我们将基于这一驱动设计一个简单的用例，以验证驱动程序的正确性。

3.1、声明并初始化对象

  我们是基于对象来实现GPIO模拟SPI驱动的，所以在开始之前我们需要声明一个模拟SPI对象如下：

SimuSPIObjectType simuSPI;

  声明了这一对象之后，我们还需要对这一变量进行初始化才能使用。前面我们已经实现了对象变量的初始化函数，使用这一函数就可方便的初始化对象变量，该函数有多个输入数：

SimuSPIObjectType *simuSPIInstance,//初始化的模拟SPI对象
uint32_t speed,              //时钟频率
SimuSPICPOLType CPOL,        //时钟极性
SimuSPICPHAType CPHA,        //时钟相位
SimuSPIDataSizeType dataSize,//数据长度
SimuSPISetSCKPin setSCK,     //SCK时钟操作函数指针
SimuSPISetMOSIPin setMOSI,   //MOSI操作函数指针
SimuSPIReadMISOPin getMISO,  //MISO操作函数指针
SimuSPIDelayus delayus       //微秒延时操作函数指针

  在这些参数中simuSPIInstance为我们想要初始化的对象变量的指针。时钟极性、时钟相位以及数据长度都是枚举量，我们根据实际的使用要求选择输入即可。时钟频率为我们希望的时钟速度，最大500K。而余下的几个参数则都是回调函数的指针。而这几个函数则是我们在应用程序中需要实现的，它们的原型如下：

//设置SCL引脚
typedef void (*SimuSPISetSCKPin)(SimuSPIPinValueType op);
//设置SDA引脚
typedef void (*SimuSPISetMOSIPin)(SimuSPIPinValueType op);
//读取SDA引脚位
typedef uint8_t (*SimuSPIReadMISOPin)(void);
//速度延时函数
typedef void (*SimuSPIDelayus)(volatile uint32_t period);

  这些函数的实现与具体的应用平台有关，我们在STM32F407上基于HAL库实现的这些函数如下：

//设置SCL引脚
void SPISCKOperation(SimuSPIPinValueType op)
{
    GPIO_PinState PinState=(GPIO_PinState)op;
    
    HAL_GPIO_WritePin(GPIOSPI, SPISCK, PinState);
}

//设置SDA引脚
void SPIMOSIOperation(SimuSPIPinValueType op)
{
    GPIO_PinState PinState=(GPIO_PinState)op;
    
    HAL_GPIO_WritePin(GPIOSPI, SPIMOSI, PinState);
}

//读取SDA引脚位
uint8_t SPIMISORead(void)
{
    if(HAL_GPIO_ReadPin(GPIOSPI, SPIMISO))
    {
        return 1;
    }
    
    return 0;
}

  而延时操作函数则采用我们系统中通用的Delayus。有了这些参数后我们合一调用初始化函数对对象变量进行初始化如下：

/* GPIO模拟SPI通讯初始化 */
    SimuSPIInitialization(&simuSPI,//初始化的模拟SPI对象
                          500,              //时钟频率
                          SimuSPI_POLARITY_LOW,        //时钟极性
                          SimuSPI_PHASE_1EDGE,        //时钟频率
                          SimuSPI_DataSize_8Bit,//数据长度
                          SPISCKOperation,     //SCK时钟操作函数指针
                          SPIMOSIOperation,   //MOSI操作函数指针
                          SPIMISORead,  //MISO操作函数指针
                          Delayus       //微秒延时操作函数指针
                              );

3.2、基于对象进行操作

  初始化这个对象变量后，我们就可以基于它操作这一对象了。我们基于驱动实现一个简单的读写数据的操作如下：

/* 使用模拟SPI读写数据*/
void SimuSPIDataExchange(void)
{
    uint8_t wDatas[3];
    uint8_t rDatas[3];
    
    /* 通过模拟SPI向从站写数据 */
    WriteDataBySimuSPI(&simuSPI,wDatas,3,1000);

    HAL_Delay(10);
    
    /* 通过模拟SPI自从站读数据 */
    ReadDataBySimuSPI(&simuSPI,rDatas, 3,1000);

    HAL_Delay(10);
    
    /* 通过模拟SPI实现对从站先写数据紧接读数据组合操作 */
    WriteReadDataBySimuSPI(&simuSPI, wDatas,3,rDatas, 3,1000);

    HAL_Delay(10);
    
    /* 通过模拟SPI实现对从站同时写和读数据组合操作*/
    WriteWhileReadDataBySimuSPI(&simuSPI, wDatas,rDatas,3,1000);

}

  我们分别测试了读取数据、下发数据、同时写和读数据以及写完后再读等几种情况的测试，效果还是比较理想的。

4、应用总结

  在这一篇中，我们设计并实现了基于GPIO模拟的SPI接口驱动程序。并在此基础上设计了一个简单的测试应用。我们通过GPIO模拟的SPI接口向SPI接口的Flash中写数据、读数据、同时读写和先写后读试验都没有问题。
  在使用驱动程序时需要注意，由于是使用GPIO模拟的SPI端口，其速度是受到限制的，目前最快能够支持到500K，再快就不能支持了。所以这个驱动程序只能应用于通讯速度小于500K的设备。

欢迎关注：

GPIO引脚模拟SPI总线
MyLovelyJay的博客
04-18 692
GPIO引脚模拟SPI总线
GPIO上模拟SPI通信
MyLovelyJay的博客
04-19 968
GPIO上模拟SPI通信
SPI协议与GPIO模拟SPI的实现
两条眉毛
01-14 4119
SPI（Serial Peripheral Interface, 串口外设接口），它用于MCU与各种外围设备以串行方式进行通信，速度最高可达25MHz以上。SPI接口主要应用在EEPROM、 FLASH、实时时钟、网络控制器、 OLED显示驱动器、 AD转换器，数字信号处理器、数字信号解码器等设备之间。
用GPIO模拟SPI协议的实现
热门推荐
aaronychen的专栏
06-20 1万+
用GPIO模拟SPI协议的实现一 SPI协议概括SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的
GPIO、I2C、SPI、UART
最新发布
xie__jin__cheng的博客
10-07 487
GPIO、I2C、SPI、UART
GPIO模拟SPI
yove_12的专栏
05-27 2185
一 SPI协议概括 SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，
GPIO模拟SPI通信从机代码
03-25
GPIO模拟SPI通信从机代码 主函数为： #include "sys.h" #include "delay.h" #include "usart.h" #include "led.h" #include "key.h" #include "spi.h" #include "lcd.h" #include "sdram.h" unsigned char data[9]="B15020106"; int main(void) { u8 receivr_Data=0,i=0; HAL_Init(); Stm32_Clock_Init(360,25,2,8); delay_init(180); uart_init(115200); LED_Init(); LCD_Init(); SDRAM_Init(); POINT_COLOR=BLUE; LCD_Clear(WHITE); SPI_Init(); LCD_ShowString(10,40, 96,24,24,"Rx data:"); LCD_ShowString(10,80,216,24,24,"Tx data:B15020106"); while(i<9) { receivr_Data=SlaveSPI_read(); if(receivr_Data!=0) { i++; LCD_ShowChar(106+12*(i-1),40,receivr_Data,24,0); } receivr_Data=0; } LED0=0; SPI_MISO_H; delay_ms(500); i=0; for(i=0;i<9;i++) { SPI_MISO_H; while(SPI_MOSI==0) SlaveSPI_write(data[i]); SlaveSPI_write(data[i]); SlaveSPI_write(data[i]); } while(1) { }
用GPIO模拟SPI接口读取传感器数据
sqhone的博客
02-19 1万+
本文基于平头哥开发板RVB2601，简要介绍了用GPIO模拟SPI时序逻辑，实现SPI协议，按照特定温度传感器的时序，读取其数据，及示例程序
STM32CubeF3_V1.11.2 STM32F3xx系列官方固件库驱动库板级支持包源代码，直接加入开发环境调用链接编译
08-21
在STM32CubeF3的板级支持包中，包含了各种外设驱动，如ADC（模拟数字转换器）、DAC（数字模拟转换器）、Timers（定时器）、GPIO（通用输入/输出）、UART（通用异步收发传输器）、SPI（串行外围接口）、I2C（集成电路...
AD9850文件.zip_AD9850基于STM32_STM32模拟 SPI_ad9850_ad9850 STM32_stm32
07-15
描述中提到“AD9850基于STM32的驱动程序，使用I/O口模拟SPI,实测可用”，表明这是一个已经经过验证的解决方案，能够有效地在实际应用中工作。 **AD9850** 是一款高精度、低成本的直接数字频率合成器（DDS），它能...
linux下oled驱动gpio模拟spi
01-23
包含了oled驱动源码以及makefile，下载可直接编译，挂载使用。
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++
09-10
基于STM32等ARM芯片，使用通用GPIO模拟SPI通讯，SPI通讯协议详解
模拟SPI 驱动 AT45DB161-SU
08-24
STC15F2K60S2 模拟SPI驱动AT45DB161-SU，暂时只支持页的擦除，写入和读取，其他还没完善。模拟 SPI，是模拟SPI窝
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++源码.zip
10-15
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++源码
GPIO模拟SPI_stm32模拟_STM32模拟SPI_stm32用GPIO模拟SPI通讯_STM32SPI模拟_stm32g
09-10
基于STM32等ARM芯片，使用通用GPIO模拟SPI通讯，SPI通讯协议详解
lpc43xx系列 sgpio模拟spi例程
10-07
在本例程中，我们将聚焦于如何利用LPC43xx的Special GPIO (SGPIO) 模块来模拟SPI（Serial Peripheral Interface）通信。SPI是一种同步串行接口，广泛用于设备间的通信，如传感器、存储器等。通过SGPIO模拟SPI，可以...
AD9959的stm32驱动
02-19
总的来说，AD9959的STM32驱动开发是一项涉及硬件接口、通信协议、信号处理等多个方面的综合任务，需要扎实的嵌入式系统知识和实践经验。通过深入理解这些知识点，开发者可以构建高效、可靠的驱动程序，充分发挥AD...
STM32：GPIO模拟SPI驱动ADS8361
xikangsoon的博客
10-11 1438
ADS8361是TI公司开发的一款模拟量输入芯片。ADS8361有四种工作模式，本文主要针对模式三进行通信驱动。官方方案使用两路SPI来通信，一路SPI Master，一路SPI Slave。我在使用STM32主控芯片的两路SPI进行通信的时候，发现只有SPI Master这路可以正常工作。Slave一直无法接收到数据。估计是两路SPI同时通信会有问题。所以使用了GPIO模拟SPI来驱动ADS8361。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值