[转]普通GPIO口模拟SPI通信协议

最新推荐文章于 2022-10-21 17:09:43 发布
最新推荐文章于 2022-10-21 17:09:43 发布
阅读量8.6k 收藏 14
点赞数 1
分类专栏： spi协议 文章标签： 通信 spi协议


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


<span class="hljs-keyword">if</span>(p_Spi-&gt;spiMode == SPIMaster)
{
    ioport_set_pin_dir(p_Spi-&gt;ui_CS, IOPORT_DIR_OUTPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_SCLK, IOPORT_DIR_OUTPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_MOSI, IOPORT_DIR_OUTPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_MISO, IOPORT_DIR_INPUT);
}
<span class="hljs-keyword">else</span>
{
    ioport_set_pin_dir(p_Spi-&gt;ui_CS, IOPORT_DIR_INPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_SCLK, IOPORT_DIR_INPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_MOSI, IOPORT_DIR_INPUT);
    ioport_set_pin_dir(p_Spi-&gt;ui_MISO, IOPORT_DIR_OUTPUT);
}

pio_set_pin_high(p_Spi-&gt;ui_CS);
<span class="hljs-keyword">switch</span>(p_Spi-&gt;spiMode)
{
<span class="hljs-keyword">case</span> Mode_1:
<span class="hljs-keyword">case</span> Mode_2:
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;
<span class="hljs-keyword">case</span> Mode_3:
<span class="hljs-keyword">case</span> Mode_4:
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;
}




}



/* 

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);



<span class="hljs-keyword">if</span>(i_IsEnable)
{
    pio_set_pin_low(p_Spi-&gt;ui_CS);
}
<span class="hljs-keyword">else</span>
{
    pio_set_pin_high(p_Spi-&gt;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 != <span class="hljs-literal">NULL</span>);

<span class="hljs-keyword">switch</span>(p_Spi-&gt;spiMode)
{
<span class="hljs-keyword">case</span> Mode_1: <span class="hljs-comment">/* Clock Polarity is 0 and Clock Phase is 0 */</span>
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">7</span>; i &gt;= <span class="hljs-number">0</span>; i--)
    {
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        SPIDelay;
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        <span class="hljs-keyword">if</span>(uc_Bt &amp; (<span class="hljs-number">1</span> &lt;&lt; i))
        {
            pio_set_pin_high(p_Spi-&gt;ui_MOSI);
        }
        <span class="hljs-keyword">else</span>
        {
            pio_set_pin_low(p_Spi-&gt;ui_MOSI);
        }
        SPIDelay;
    }
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_2: <span class="hljs-comment">/* Clock Polarity is 0 and Clock Phase is 1 */</span>
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">7</span>; i &gt;= <span class="hljs-number">0</span>; i--)
    {
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        <span class="hljs-keyword">if</span>(uc_Bt &amp; (<span class="hljs-number">1</span> &lt;&lt; i))
        {
            pio_set_pin_high(p_Spi-&gt;ui_MOSI);
        }
        <span class="hljs-keyword">else</span>
        {
            pio_set_pin_low(p_Spi-&gt;ui_MOSI);
        }
        SPIDelay;
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        SPIDelay;
    }
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_3: <span class="hljs-comment">/* Clock Polarity is 1 and Clock Phase is 0 */</span>
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">7</span>; i &gt;= <span class="hljs-number">0</span>; i--)
    {
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        <span class="hljs-keyword">if</span>(uc_Bt &amp; (<span class="hljs-number">1</span> &lt;&lt; i))
        {
            pio_set_pin_high(p_Spi-&gt;ui_MOSI);
        }
        <span class="hljs-keyword">else</span>
        {
            pio_set_pin_low(p_Spi-&gt;ui_MOSI);
        }
        SPIDelay;
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        SPIDelay;
    }
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_4: <span class="hljs-comment">/* Clock Polarity is 1 and Clock Phase is 1 */</span>
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">7</span>; i &gt;= <span class="hljs-number">0</span>; i--)
    {
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        <span class="hljs-keyword">if</span>(uc_Bt &amp; (<span class="hljs-number">1</span> &lt;&lt; i))
        {
            pio_set_pin_high(p_Spi-&gt;ui_MOSI);
        }
        <span class="hljs-keyword">else</span>
        {
            pio_set_pin_low(p_Spi-&gt;ui_MOSI);
        }
        SPIDelay;
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        SPIDelay;
    }
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">default</span>:
    <span class="hljs-keyword">break</span>;
}




}



/* 

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 != <span class="hljs-literal">NULL</span>);
assert(puc_Data != <span class="hljs-literal">NULL</span>);
assert(i_DataLength &gt; <span class="hljs-number">0</span>);

v_CSIsEnableSimulate(p_Spi, <span class="hljs-number">1</span>);
delay_us(<span class="hljs-number">8</span>);

<span class="hljs-comment">// Write data</span>
<span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; i_DataLength; i++)
{
    v_SPIWriteByte(p_Spi, puc_Data[i]);
}

delay_us(<span class="hljs-number">8</span>);
v_CSIsEnableSimulate(p_Spi, <span class="hljs-number">0</span>);




}



/* 

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 != <span class="hljs-literal">NULL</span>);

<span class="hljs-keyword">switch</span>(p_Spi-&gt;spiMode)
{
<span class="hljs-keyword">case</span> Mode_1: <span class="hljs-comment">/* Clock Polarity is 0 and Clock Phase is 0 */</span>
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-number">8</span>; i++)
    {
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        SPIDelay;
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        uc_ReadData = uc_ReadData &lt;&lt; <span class="hljs-number">1</span>;
        uc_ReadData |= pio_get_pin_value(p_Spi-&gt;ui_MISO);
        SPIDelay;
    }
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_2: <span class="hljs-comment">/* Clock Polarity is 0 and Clock Phase is 1 */</span>
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-number">8</span>; i++)
    {
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        SPIDelay;
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        uc_ReadData = uc_ReadData &lt;&lt; <span class="hljs-number">1</span>;
        uc_ReadData |= pio_get_pin_value(p_Spi-&gt;ui_MISO);
        SPIDelay;
    }
    pio_set_pin_low(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_3: <span class="hljs-comment">/* Clock Polarity is 1 and Clock Phase is 0 */</span>
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-number">8</span>; i++)
    {
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        SPIDelay;
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        uc_ReadData = uc_ReadData &lt;&lt; <span class="hljs-number">1</span>;
        uc_ReadData |= pio_get_pin_value(p_Spi-&gt;ui_MISO);
        SPIDelay;
    }
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">case</span> Mode_4:  <span class="hljs-comment">/* Clock Polarity is 1 and Clock Phase is 1 */</span>
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; <span class="hljs-number">8</span>; i++)
    {
        pio_set_pin_low(p_Spi-&gt;ui_SCLK);
        SPIDelay;
        pio_set_pin_high(p_Spi-&gt;ui_SCLK);
        uc_ReadData = uc_ReadData &lt;&lt; <span class="hljs-number">1</span>;
        uc_ReadData |= pio_get_pin_value(p_Spi-&gt;ui_MISO);
        SPIDelay;
    }
    pio_set_pin_high(p_Spi-&gt;ui_SCLK);
    <span class="hljs-keyword">break</span>;

<span class="hljs-keyword">default</span>:
    <span class="hljs-keyword">break</span>;
}

<span class="hljs-keyword">return</span> 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 != <span class="hljs-literal">NULL</span>);
assert(i_DataLength &gt; <span class="hljs-number">0</span>);

v_CSIsEnableSimulate(p_Spi, <span class="hljs-number">1</span>);
delay_us(<span class="hljs-number">8</span>);

<span class="hljs-comment">// Read data</span>
<span class="hljs-keyword">for</span>(i = <span class="hljs-number">0</span>; i &lt; i_DataLength; i++)
{
    puc_Data[i] = uc_SPIReadByte(p_Spi);
}

delay_us(<span class="hljs-number">8</span>);
v_CSIsEnableSimulate(p_Spi, <span class="hljs-number">0</span>);




}
    醒着的树懒
    关注
    专栏目录
    SPI通信协议
    YuLong5530330的博客
    10-15 1613
    学习资料：正点原子STM32 SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线。两根是双工 通信线，一根时钟线（同步），一根外设片选线。开发板有三个SPI接口。 要发送的数据写到发送数据缓存区，缓存区经过移位寄存器，一位一位的通过MOSI接口移出去， 同时MISO接口接收到的数据经过移位寄存器一位一位的移到接收缓存区。 SPI接口一般使用4条线通信： M...
    SPI 通信协议详解
    最新发布
    Teminator_的博客
    08-17 3万+
    SPI（串行外围设备接口） 通信协议是 Motorola 公司首先在其MC68HCXX 系列处理器上定义的。SPI 接口是一种高速的全双工同步的通信总线，已经广泛应用在众多 MCU、存储芯片、AD 转换器和 LCD 之间。由SPI连成的串行总线是一种三线同步总线，总线上可以连接多个可作为主机的 MCU，装有SPI接口的输出设备，输入设备如液晶驱动、A/D 转换等外设，也可以简单连接到单个 TTL 移位寄存器的芯片。总线上允许连接多个能作主机的设备，但在任一瞬间只允许有一个设备作为主机。
    SPI协议模拟
    qq_36613247的博客
    04-11 134
    上升沿写，下降沿读 SPI写时序 void SPI_write(unsigned char dat) { unsigned char temp; for(temp=0x80;temp!=0;temp>>=1) { SCK=0; if(temp&dat==0) ...
    模拟SPI传输协议
    Poseidon's Maserati
    10-18 259
    SPI传输协议最重要的是相位和极性，通俗讲是SPI时钟空闲时是高电平或低，采样模式是上升沿或下降沿。            硬件SPI一般厂家给予库函数使用，只需要根据DEMO稍做修改即可，但是需要对主控芯片有个大体了解，移植起来不方便。            软件SPI是通过I/O口模拟SPI通信的协议，简单快速，移植性好，但是要根据时序图配置号相应的延时时间，才能达到理想效果。平常使用软件SP...
    spi通信协议
    suji404的博客
    07-19 346
    SPI总线协议介绍 一、技术性能         SPI接口是Motorola 首先提出的全双工三线同步串行外围接口，采用主从模式（Master Slave）架构；支持多slave模式应用，一般仅支持单Master。时钟由Master控制，在时钟移位脉冲下，数据按位传输，高位在前，低位在后（MSB first）；SPI接口有2根单向数据线，为全双工通信，目前应用中的数据速率可达几Mbps的水平。...
    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是一种同步串行通信协议，广泛应用于微控制器与各种外设之间，如传感器、显示模块、存储器...
    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_stm32模拟_STM32模拟SPI_stm32用GPIO模拟SPI通讯_STM32SPI模拟_stm32g
    09-10
    以下是对STM32使用GPIO模拟SPI通信的详细讲解。 1. SPI协议基础 SPI是一种同步串行通信协议，通常由主机（Master）驱动，与一个或多个从机（Slave）进行全双工数据传输。SPI有四种传输模式（CPOL和CPHA的组合），...
    GPIO 模拟SPI
    qq_29890089的博客
    10-21 3336
    GPIO 模拟SPI总线
    SPI通信接口
    kyokusanagl的专栏
    03-09 840
    UART、I2C和 SPI 是单片机系统中最常用的三种通信协议。前边我们已经学了 UART 和I2C通信协议，这节课我们来学习剩下的 SPI 通信协议。 SPI 是英语 Serial Peripheral Interface 的缩写，顾名思义就是串行外围设备接口。SPI 是一种高速的、全双工、同步通信总线，标准的 SPI 也仅仅使用 4 个引脚，常用于单片机和 EEPROM、FL
    SPI协议简介(转)
    asdfasdfhhh的专栏
    02-03 1099
           SPI，是英语Serial Peripheral interface的缩写，顾名思义就是串行外围设备接口。SPI，是一种高速的，全双工，同步的通信总线，并且在芯片的管脚上只占用四根线，节约了芯片的管脚，同时为PCB的布局上节省空间，提供方便，正是出于这种简单易用的特性，现在越来越多的芯片集成了这种通信协议，比如P89LPC900.        SPI，是一种高速的，全双工，同步的通
    评论
    添加红包

    请填写红包祝福语或标题

    个

    红包个数最小为10个

    元

    红包金额最低5元

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

    抵扣说明：

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

    余额充值