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

原创 2016年12月29日 09:46:02

在工作中偶尔会遇到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

单片机软件模拟SPI接口—加深理解SPI总线协议

单片机软件模拟SPI接口—加深理解SPI总线协议           SPI(Serial Peripheral Interfacer 串行外设接口)是摩托罗拉公司推出的一种同步串行通讯接口,用于微...
  • ce123
  • ce123
  • 2011年11月01日 00:01
  • 44490

模拟SPI实现和调试流程

一般来说,所有的spi通信设备都可以使用模拟spi来实现,而且模拟spi的好处就是不需要针对每一款mcu去重新熟悉其spi控制器的配置,只要简单配置一下spi_clk、spi_cs、spi_mosi、...
  • GCE7212201
  • GCE7212201
  • 2016年11月22日 20:27
  • 4480

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

在工作中偶尔会遇到SPI不够用的情况,而我们又要去使用SPI通信协议,此时就需要我们自己去模拟SPI通信协议。我们知道SPI通信协议有四种模式,它们分别如下所示: 下面是我基于ATSAM4SD1...
  • Andy001847
  • Andy001847
  • 2016年12月29日 09:46
  • 4073

嵌入式学习--work11 关于SPI的深入学习及软件模拟SPI(LCD调试所遇)

在调试液晶LCD时,LCD是某清洋实业公司生产,在其液晶显示模块规格书里,描述了尺寸为 1.22 inch,接口类型为 SPI 3Line2Lane Interface,SPI为三线两通道的SPI,液...
  • wangwangmoon_light
  • wangwangmoon_light
  • 2016年11月12日 22:00
  • 1504

单片机IO口模拟SPI四种模式的程序

http://www.rationmcu.com/clang/495.htmlhttp://blog.csdn.net/zyboy2000/article/details/11861329
  • fly__chen
  • fly__chen
  • 2016年12月23日 14:22
  • 1106

嵌入式项目1--修改LCD为使用硬件SPI(之前为软件模拟SPI协议)

前提: 三线SPI的,没有控制位不能使用硬件SPI的,不能够区分写命令还是数据,除非你看一下,你自己把LCD屏打开,把里面的控制位自己飞出来,(前提是人家裸屏把控制位引出来,没有的话,就...
  • wangwangmoon_light
  • wangwangmoon_light
  • 2017年02月13日 21:31
  • 795

普通IO口模拟实现SPI通信及应用解析

根据SPI通信规范(具体可以参考“浅谈I2C总线”),通过普通IO端口模拟可以实现单片机(主设备)与从设备的SPI通信,其中SCL通过IO口延时高低电平变化实现,SDA根据SCL状态变化产生开始信号,...
  • bluewhaletech
  • bluewhaletech
  • 2014年08月21日 12:14
  • 3583

软件模拟SPI程序(测试过的)

  • 2010年03月12日 17:44
  • 6KB
  • 下载

单片机IO口模拟SPI四种模式的程序

/IO端口定义 #define SPI_SCK  PC0 #define SPI_MOSI PC1 #define SPI_MISO PC2 #define SPI_DDR  DDRC #define...
  • zyboy2000
  • zyboy2000
  • 2013年09月21日 10:00
  • 18191

GPIO口模拟SPI - 驱动W25Qxx

废话少说,直接上代码: DataFlash_reg.h:/* Using SPIO simulator PB8 -- spi cs PA9 -- spi clock PA10 -- spi MO...
  • EFM32
  • EFM32
  • 2016年01月11日 22:26
  • 4052
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:普通GPIO模拟SPI通信协议(软件SPI)
举报原因:
原因补充:

(最多只允许输入30个字)