普通GPIO模拟SPI通信协议(软件SPI)

最新推荐文章于 2024-08-29 12:33:43 发布
最新推荐文章于 2024-08-29 12:33:43 发布
阅读量2.6w 收藏 137
点赞数 24
分类专栏： 算法 C语言 数据编码 嵌入式 单片机 文章标签： 芯片 GPIO SPI 通信 嵌入式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Andy001847/article/details/53924349
版权
C语言 同时被 3 个专栏收录
26 篇文章 0 订阅
订阅专栏
嵌入式
16 篇文章 4 订阅
订阅专栏
算法
5 篇文章 2 订阅
订阅专栏

在工作中偶尔会遇到SPI不够用的情况，而我们又要去使用SPI通信协议，此时就需要我们自己去模拟SPI通信协议。我们知道SPI通信协议有四种模式，它们分别如下所示：
这里写图片描述
下面是我基于ATSAM4SD16B芯片在Atmel Studio上用普通GPIO模拟的SPI通信协议的代码：

#include "ioport.h"
#include "pio.h"
#include "delay.h"
#include "SAM4S_FSA.h"
#include <assert.h>

// Define 4 SPI pins
#define CS       IOPORT_CREATE_PIN(PIOA, 8)
#define SCLK     IOPORT_CREATE_PIN(PIOA, 7)
#define MOSI     IOPORT_CREATE_PIN(PIOA, 23)
#define MISO     IOPORT_CREATE_PIN(PIOA, 20)

#define SPIDelay  delay_us(1)

// Define SPI communication mode
typedef enum SPIMode
{
    Mode_1,   /* Clock Polarity is 0 and Clock Phase is 0 */
    Mode_2,   /* Clock Polarity is 0 and Clock Phase is 1 */
    Mode_3,   /* Clock Polarity is 1 and Clock Phase is 0 */
    Mode_4,   /* Clock Polarity is 1 and Clock Phase is 1 */
}SPIMode;

// Define SPI type
typedef enum SPIType
{
    SPIMaster,
    SPISlave,
}SPIType;

// Define SPI attribute
typedef struct SpiStruct
{
    unsigned int ui_CS;
    unsigned int ui_SCLK;
    unsigned int ui_MOSI;
    unsigned int ui_MISO;
    SPIMode spiMode;
    SPIType spiType;
}Spi_t;

// Function prototypes
void v_SPIInitSimulate(Spi_t* p_Spi);
void v_CSIsEnableSimulate(Spi_t* p_Spi, int i_IsEnable);
void v_SPIWriteSimulate(Spi_t* p_Spi, unsigned char* puc_Data, int i_DataLength);
void v_SPIReadSimulate(Spi_t* p_Spi, unsigned char* puc_Data, int i_DataLength);

// Define SPI pins
Spi_t Spi_0 = 
{
    .ui_CS = CS,
    .ui_SCLK = SCLK,
    .ui_MOSI = MOSI,
    .ui_MISO = MISO,
    .spiMode = Mode_1,
    .spiType = SPIMaster,
};

/*
Brief: SPI protocol initiate
Input: p_Spi, which spi use
Output: None
Return: None
Author: Andy Lai
*/
void v_SPIInitSimulate(Spi_t* p_Spi)
{
    assert(p_Spi != NULL);

    if(p_Spi->spiMode == SPIMaster)
    {
        ioport_set_pin_dir(p_Spi->ui_CS, IOPORT_DIR_OUTPUT);
        ioport_set_pin_dir(p_Spi->ui_SCLK, IOPORT_DIR_OUTPUT);
        ioport_set_pin_dir(p_Spi->ui_MOSI, IOPORT_DIR_OUTPUT);
        ioport_set_pin_dir(p_Spi->ui_MISO, IOPORT_DIR_INPUT);
    }
    else
    {
        ioport_set_pin_dir(p_Spi->ui_CS, IOPORT_DIR_INPUT);
        ioport_set_pin_dir(p_Spi->ui_SCLK, IOPORT_DIR_INPUT);
        ioport_set_pin_dir(p_Spi->ui_MOSI, IOPORT_DIR_INPUT);
        ioport_set_pin_dir(p_Spi->ui_MISO, IOPORT_DIR_OUTPUT);
    }

    pio_set_pin_high(p_Spi->ui_CS);
    switch(p_Spi->spiMode)
    {
    case Mode_1:
    case Mode_2:
        pio_set_pin_low(p_Spi->ui_SCLK);
        break;
    case Mode_3:
    case Mode_4:
        pio_set_pin_high(p_Spi->ui_SCLK);
        break;
    }
}

/*
Brief: CS low level signal enable and high level signal disable
Input: (1)p_Spi, which spi use
       (2)i_IsEnable, Chip select(Slave select) enable flag
Output: None
Return: None
Author: Andy Lai
*/
void v_CSIsEnableSimulate(Spi_t* p_Spi, int i_IsEnable)
{
    assert(p_Spi != NULL);

    if(i_IsEnable)
    {
        pio_set_pin_low(p_Spi->ui_CS);
    }
    else
    {
        pio_set_pin_high(p_Spi->ui_CS);
    }
}

/*
Brief: Use SPI to write a byte data
Input: (1)p_Spi, which spi use
       (2)uc_Bt, write byte data
Output: None
Return: None
Author: Andy Lai
*/
static void v_SPIWriteByte(Spi_t* p_Spi, unsigned char uc_Bt)
{
    int i = 0;

    assert(p_Spi != NULL);

    switch(p_Spi->spiMode)
    {
    case Mode_1: /* Clock Polarity is 0 and Clock Phase is 0 */
        pio_set_pin_low(p_Spi->ui_SCLK);
        for(i = 7; i >= 0; i--)
        {
            pio_set_pin_low(p_Spi->ui_SCLK);
            SPIDelay;
            pio_set_pin_high(p_Spi->ui_SCLK);
            if(uc_Bt & (1 << i))
            {
                pio_set_pin_high(p_Spi->ui_MOSI);
            }
            else
            {
                pio_set_pin_low(p_Spi->ui_MOSI);
            }
            SPIDelay;
        }
        pio_set_pin_low(p_Spi->ui_SCLK);
        break;

    case Mode_2: /* Clock Polarity is 0 and Clock Phase is 1 */
        pio_set_pin_low(p_Spi->ui_SCLK);
        for(i = 7; i >= 0; i--)
        {
            pio_set_pin_high(p_Spi->ui_SCLK);
            if(uc_Bt & (1 << i))
            {
                pio_set_pin_high(p_Spi->ui_MOSI);
            }
            else
            {
                pio_set_pin_low(p_Spi->ui_MOSI);
            }
            SPIDelay;
            pio_set_pin_low(p_Spi->ui_SCLK);
            SPIDelay;
        }
        pio_set_pin_low(p_Spi->ui_SCLK);
        break;

    case Mode_3: /* Clock Polarity is 1 and Clock Phase is 0 */
        pio_set_pin_high(p_Spi->ui_SCLK);
        for(i = 7; i >= 0; i--)
        {
            pio_set_pin_high(p_Spi->ui_SCLK);
            if(uc_Bt & (1 << i))
            {
                pio_set_pin_high(p_Spi->ui_MOSI);
            }
            else
            {
                pio_set_pin_low(p_Spi->ui_MOSI);
            }
            SPIDelay;
            pio_set_pin_low(p_Spi->ui_SCLK);
            SPIDelay;
        }
        pio_set_pin_high(p_Spi->ui_SCLK);
        break;

    case Mode_4: /* Clock Polarity is 1 and Clock Phase is 1 */
        pio_set_pin_high(p_Spi->ui_SCLK);
        for(i = 7; i >= 0; i--)
        {
            pio_set_pin_low(p_Spi->ui_SCLK);
            if(uc_Bt & (1 << i))
            {
                pio_set_pin_high(p_Spi->ui_MOSI);
            }
            else
            {
                pio_set_pin_low(p_Spi->ui_MOSI);
            }
            SPIDelay;
            pio_set_pin_high(p_Spi->ui_SCLK);
            SPIDelay;
        }
        pio_set_pin_high(p_Spi->ui_SCLK);
        break;

    default:
        break;
    }
}

/*
Brief: Use SPI protocol to write data
Input: (1)p_Spi, which spi use
       (2)puc_Data, write data string
       (3)i_DataLength, write data length
Output: None
Return: None
Author: Andy Lai
*/
void v_SPIWriteSimulate(Spi_t* p_Spi, unsigned char* puc_Data, int i_DataLength)
{
    int i = 0;

    assert(p_Spi != NULL);
    assert(puc_Data != NULL);
    assert(i_DataLength > 0);

    v_CSIsEnableSimulate(p_Spi, 1);
    delay_us(8);

    // Write data
    for(i = 0; i < i_DataLength; i++)
    {
        v_SPIWriteByte(p_Spi, puc_Data[i]);
    }

    delay_us(8);
    v_CSIsEnableSimulate(p_Spi, 0);
}

/*
Brief: Read a byte data from SPI
Input: p_Spi, which spi use
Output: None
Return: Read data
Author: Andy Lai
*/
static unsigned char uc_SPIReadByte(Spi_t* p_Spi)
{
    int i = 0;
    unsigned char uc_ReadData = 0;

    assert(p_Spi != NULL);

    switch(p_Spi->spiMode)
    {
    case Mode_1: /* Clock Polarity is 0 and Clock Phase is 0 */
        pio_set_pin_low(p_Spi->ui_SCLK);
        for(i = 0; i < 8; i++)
        {
            pio_set_pin_low(p_Spi->ui_SCLK);
            SPIDelay;
            pio_set_pin_high(p_Spi->ui_SCLK);
            uc_ReadData = uc_ReadData << 1;
            uc_ReadData |= pio_get_pin_value(p_Spi->ui_MISO);
            SPIDelay;
        }
        pio_set_pin_low(p_Spi->ui_SCLK);
        break;

    case Mode_2: /* Clock Polarity is 0 and Clock Phase is 1 */
        pio_set_pin_low(p_Spi->ui_SCLK);
        for(i = 0; i < 8; i++)
        {
            pio_set_pin_high(p_Spi->ui_SCLK);
            SPIDelay;
            pio_set_pin_low(p_Spi->ui_SCLK);
            uc_ReadData = uc_ReadData << 1;
            uc_ReadData |= pio_get_pin_value(p_Spi->ui_MISO);
            SPIDelay;
        }
        pio_set_pin_low(p_Spi->ui_SCLK);
        break;

    case Mode_3: /* Clock Polarity is 1 and Clock Phase is 0 */
        pio_set_pin_high(p_Spi->ui_SCLK);
        for(i = 0; i < 8; i++)
        {
            pio_set_pin_high(p_Spi->ui_SCLK);
            SPIDelay;
            pio_set_pin_low(p_Spi->ui_SCLK);
            uc_ReadData = uc_ReadData << 1;
            uc_ReadData |= pio_get_pin_value(p_Spi->ui_MISO);
            SPIDelay;
        }
        pio_set_pin_high(p_Spi->ui_SCLK);
        break;

    case Mode_4:  /* Clock Polarity is 1 and Clock Phase is 1 */
        pio_set_pin_high(p_Spi->ui_SCLK);
        for(i = 0; i < 8; i++)
        {
            pio_set_pin_low(p_Spi->ui_SCLK);
            SPIDelay;
            pio_set_pin_high(p_Spi->ui_SCLK);
            uc_ReadData = uc_ReadData << 1;
            uc_ReadData |= pio_get_pin_value(p_Spi->ui_MISO);
            SPIDelay;
        }
        pio_set_pin_high(p_Spi->ui_SCLK);
        break;

    default:
        break;
    }

    return uc_ReadData;
}

/*
Brief: Use SPI to read data
Input: (1)p_Spi, which SPI use;    
       (2)i_DataLength, the length of data that need to read
Output: puc_Data, need to get data
Return: None
Author: Andy Lai
*/
void v_SPIReadSimulate(Spi_t* p_Spi, unsigned char* puc_Data, int i_DataLength)
{
    int i = 0;

    assert(p_Spi != NULL);
    assert(i_DataLength > 0);

    v_CSIsEnableSimulate(p_Spi, 1);
    delay_us(8);

    // Read data
    for(i = 0; i < i_DataLength; i++)
    {
        puc_Data[i] = uc_SPIReadByte(p_Spi);
    }

    delay_us(8);
    v_CSIsEnableSimulate(p_Spi, 0);
}

参考博客：http://blog.csdn.net/yangzheng_yz/article/details/50470577

Andy001847
关注
专栏目录
GPIO上模拟SPI通信
MyLovelyJay的博客
04-19 968
GPIO上模拟SPI通信
dac80501_DAC_DAC80501_
10-01
这是一款DAC的数据手册，DAC80501，有多种封装可选择，为16bitDAC，分装体积很小
IO模拟SPI通信协议实现与应用
最新发布
weixin_28713083的博客
08-29 1129
本文还有配套的精品资源，点击获取 简介：SPI（Serial Peripheral Interface）是一种用于微控制器之间串行通信的接口，具有高速和低引脚数的特点。本压缩包包含使用IO端口模拟SPI协议的资料，适合没有内置SPI硬件模块或需要额外SPI接口的场合。通过软件编程控制GPIO引脚，可以模拟SPI通信协议的时序，实现数据在主机（Master）和从机（Slave...
GPIO模拟SPI
yove_12的专栏
05-27 2185
一 SPI协议概括 SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。是Motorola首先在其MC68HCXX系列处理器上定义的。SPI接口主要应用在 EEPROM，FLASH，实时时钟，AD转换器，还有数字信号处理器和数字信号解码器之间。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，
GPIO模拟SPI通讯接口
热门推荐
学习笔记
10-17 1万+
一、什么是SPI     SPI 是一种允许一个主设备启动一个与从设备的同步通讯的协议，从而完成数据的交换。也就是说，SPI是一种规定好的通讯方式。这种通信方式的优点是占用端口较少，一般4根就够基本通讯了。同时传输速度也很高。一般来说要求主设备要有SPI控制器（但可用模拟方式），就可以与基于SPI的芯片通讯了。     常见的SPI外围设备包括FLASHRAM、网络控制器、LCD显示驱
用GPIO模拟SPI协议的实现
aaronychen的专栏
06-20 1万+
用GPIO模拟SPI协议的实现一 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]=...
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++
09-10
标题中的“GPIO模拟SPI”指的是使用微控制器（如STM32）上的通用输入/输出（GPIO）引脚来模拟SPI（串行外围接口）通信。SPI是一种同步串行通信协议，广泛应用于微控制器与各种外设之间，如传感器、显示模块、存储器...
GPIO模拟SPI_stm32模拟_STM32模拟SPI_stm32用GPIO模拟SPI通讯_STM32SPI模拟_stm32g
09-10
以下是对STM32使用GPIO模拟SPI通信的详细讲解。 1. SPI协议基础 SPI是一种同步串行通信协议，通常由主机（Master）驱动，与一个或多个从机（Slave）进行全双工数据传输。SPI有四种传输模式（CPOL和CPHA的组合），...
linux下oled驱动gpio模拟spi
01-23
总之，"linux下oled驱动gpio模拟spi"涉及了Linux驱动开发、SPI通信、GPIO编程等多个方面，是嵌入式系统和物联网领域常见的技术组合。通过理解这些概念并实践代码，开发者可以更好地控制和利用硬件资源，实现定制化的...
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++源码.zip
10-15
GPIO模拟SPI,gpio模拟spi 四种模式,C,C++源码
软件模拟SPI程序（测试过的）
03-12
软模拟SPI程序软模拟SPI程序软模拟SPI程序
SPI模拟GPIO.rar_SPI模拟GPIO_gpio spi_sof_stm32 模拟 spi_tm1629a spi
07-14
标题中的“SPI模拟GPIO.rar”指的是使用SPI（Serial Peripheral Interface）总线协议来模拟GPIO...开发者可以参考这个项目，学习如何在自己的应用中使用SPI模拟GPIO来控制其他外设，或者理解SPI通信与GPIO模拟的原理。
[转]普通GPIO口模拟SPI通信协议
静溪小筑
08-30 8698
在工作中偶尔会遇到SPI不够用的情况，而我们又要去使用SPI通信协议，此时就需要我们自己去模拟SPI通信协议。我们知道SPI通信协议有四种模式，它们分别如下所示： 下面是我基于ATSAM4SD16B芯片在Atmel Studio上用普通GPIO模拟的SPI通信协议的代码：#include "ioport.h" #include "pio.h" #include "delay.h" #inclu
GPIO 模拟SPI
qq_29890089的博客
10-21 3428
GPIO 模拟SPI总线
SPI协议模拟
qq_36613247的博客
04-11 145
上升沿写，下降沿读 SPI写时序 void SPI_write(unsigned char dat) { unsigned char temp; for(temp=0x80;temp!=0;temp>>=1) { SCK=0; if(temp&dat==0) ...
GPIO口模拟SPI
weixin_41320142的博客
01-03 1401
SPI是一种高速、全双工、同步通信总线，标准的SPI有4个引脚，常用于单片机和EEPROM、FLASH、实时时钟、数字信号处理等器件的通信。 SCK : Serial Clock 串行时钟 SS/CS : Slave Select 片选信号 低电平使能 MOSI : Master Output, Slave Input 主发从收信号 MISO : Master Input, Slave Output 主收从发信号 以下使用一款集成芯片举例 GPIO 口模拟SPI 16.1 SPI Block Descri
28335 gpio模拟spi
08-05
GPIO模拟SPI是一种在树莓派或其他单片机中使用通用输入输出引脚来模拟SPI（串行外围设备接口）通信协议的方法。SPI是一种常用的串行通信协议，可以用于与各种外围设备（如传感器、显示屏、存储器等）进行数据交互。 要在树莓派中实现GPIO模拟SPI通信，首先需要通过软件创建SPI协议所需的时序。树莓派的GPIO引脚可以通过编程来实现读写操作，因此可以利用这些引脚来模拟SPI的时序。 具体实现步骤如下： 1. 首先，需要设置SPI引脚的模式，并确定引脚的输入输出方向。 2. 然后，可以通过编程实现SPI通信的时序，包括将数据发送给目标设备、接收目标设备返回的数据等。 3. 当需要发送数据时，可以将数据分别写入每个GPIO引脚，根据SPI协议，一般包括时钟线、数据线（MOSI）、数据输出线（MISO）和片选线（CS）。 4. 同样地，当需要接收数据时，可以通过读取GPIO引脚上的电平来获取目标设备返回的数据。 5. 在整个通信过程中，需要根据SPI协议规定的时序进行数据的发送和接收，以确保数据的正确传输。 需要注意的是，使用GPIO模拟SPI通信可能会面临一些性能上的限制，因为GPIO引脚的速度相对较慢。同时，在实际应用中，也要考虑到引脚的数目、通信距离等因素，以确保通信的可靠性和稳定性。 总的来说，通过GPIO模拟SPI通信可以在硬件资源有限的情况下实现与外围设备的串行数据交互，为嵌入式系统的开发提供了一种简单而经济的选择。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值