• SPI总线协议

    提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

    目录

    SPI总线的定义

    SPI总线工作方式

    SPI驱动Verilog实现

    总结

    SPI总线的定义

    SPI（Serial Peripheral Interface）是一种同步串行通信协议，用于在微控制器、传感器、存储器等外设之间进行数据交换。SPI总线是一种全双工的通信方式，它由一个主设备（Master）和一个或多个从设备（Slave）组成。

    spi总线的特点：

    1、传输方式：SPI总线使用同步的时钟信号进行通信，主设备控制时钟信号的频率和极性。数据在时钟的边沿上升或下降时转移。SPI总线支持全双工通信，意味着主设备和从设备可以同时发送和接收数据。

    2、线路结构：SPI总线具有四条线路：时钟线（SCLK），主设备输出的数据线（MOSI），主设备接收的数据线（MISO）和片选线（CS）。

            时钟线(SCLK):时钟信号线，由主机发出，不同的主机可能具有不同的时钟速率，也就是通信频率。

            主设备输出的数据线(MOSI):主机输出数据，从机接收数据。（M代表Master，S代表Slave）

            主设备接收的数据线(MISO):主机接收数据，从机输出数据。

            片选线(CS):由主机选择与某一从机进行通讯。常为低电平有效

    一主一从模式：

    一主多从模式：

    (PS:借用一下大佬孤独的单刀的图，侵权请联系我，会立刻删除，原文章链接：FPGA实现的SPI协议（一）----SPI驱动_fpga spi_孤独的单刀的博客-CSDN博客)

    SPI总线工作方式

    SPI的工作模式通常由两个因素决定：一是时钟极性(CPOL,Clock Polarity)，二是时钟相位(Clock Phase)。其中时钟极性决定了SCLK在空闲时是低电平还是高电平，时钟相位决定了在什么沿采集数据。

    (PS:借用一下大佬孤独的单刀的图，侵权请联系我，会立刻删除，原文章链接：：)

            

    • 模式0：CPOL=0,CPHA=0。SCK串行时钟线空闲是为低电平，数据在SCK时钟的上升沿被采样，数据在SCK时钟的下降沿切换
    • 模式1：CPOL=0,CPHA=1。SCK串行时钟线空闲是为低电平，数据在SCK时钟的下降沿被采样，数据在SCK时钟的上升沿切换
    • 模式2：CPOL=1,CPHA=O。SCK串行时钟线空闲是为高电平，数据在SCK时钟的下降沿被采样，数据在SCK时钟的上升沿切换
    • 模式3：CPOL=1,CPHA=1。SCK串行时钟线空闲是为高电平，数据在SCK时钟的上升沿被采样，数据在SCK时钟的下降沿切换

    通过象限可以将这四种模式进行简要概括：

    SPI总线的优缺点：

    优点：

            1、灵活：SPI可以使用不同的工作模式，以满足不同场景的需要。SPI主设备可以配置不同的时钟频率，灵活可变。

            2、高速：相比与串口(UART)、IIC接口，SPI具有很高的通信频率

            3、简单的线路结构，只有SCLK、MOSI、MISO、CS 4条线路

            4、不限于8位，一次可以传输任意大小的字

    缺点：

            1、仅支持一个主设备，从设备被动响应，不支持从设备主动传输数据。

            2、虽然SPI总线线路相对简单，但每个外设都需要至少四条线路，因此在连接多个外设时，线路数量会增加。(每增加一个从机都会增加一个片选信号)

            3、主/从机没有应答信号

    --------------------------------------------------------------------------------------

    SPI驱动Verilog实现

    说明：模式0，一主一从模式，使用一段式状态机实现。

    (PS:不使用状态机的SPI驱动程序请阅读大佬孤独的单刀的文章：

    FPGA实现的SPI协议（一）----SPI驱动_fpga spi_孤独的单刀的博客-CSDN博客)

    主机代码：

    1. `timescale 1ns / 1ps
    2. //
    3. // Company: 
    4. // Engineer: 
    5. // 
    6. // Create Date: 2023/09/01 17:04:04
    7. // Design Name: 
    8. // Module Name: SPI_derive
    9. // Project Name: 
    10. // Target Devices: 
    11. // Tool Versions: 
    12. // Description: 
    13. // 
    14. // Dependencies: 
    15. // 
    16. // Revision:
    17. // Revision 0.01 - File Created
    18. // Additional Comments:
    19. // SPI总线主机驱动程序
    20. //
    21.  
    22.  
    23. module SPI_derive #(
    24.     parameter   integer DW = 8
    25. )
    26. (
    27.    input                    sys_clk     ,           //系统时钟50M
    28.    input                    sys_rst     ,           //复位信号低电平有效
    29.    
    30.    input[DW-1:0]            din         ,           //要发送的数据
    31.    input                    spi_start   ,           //SPI驱动程序启动信号，一个高电平
    32.    input                    spi_end     ,           //SPI驱动程序结束信号
    33.    output reg [DW-1:0]      dout        ,           //接收的数据
    34.    output reg               rec_over    ,           //单个字节接收完毕信号
    35.    output reg               send_over   ,           //单个字节发送结束信号
    36.    
    37.    output reg               sclk        ,           //SPI程序的SCLK 本程序是对系统时钟的2分频
    38.    output reg               cs_n        ,           //SPI片选信号
    39.    output reg               mosi        ,           //SPI输出，给从机发送数据
    40.    input                    miso                    //SPI输入，从机发送过来的数据
    41.           
    42.     );
    43.     
    44.     localparam          idle        = 3'b001  ;
    45.     localparam          send_recv   = 3'b010  ;
    46.     localparam          over        = 3'b100  ;
    47.     reg[2:0]            state                 ;
    48.      
    49.     reg[DW-1:0]         recv_data   = 'd0     ;
    50.     reg                 clk_2d      = 'd0     ;
    51.     reg[2:0]            send_cnt    = 'd0     ;
    52.     reg[2:0]            recv_cnt    = 'd0     ;
    53.     reg[1:0]            cs_n_cnt    = 'd0     ;
    54.     
    55.     
    56.     
    57.     always@(posedge sys_clk,negedge sys_rst)begin
    58.         if(!sys_rst == 1)begin
    59.             state <= idle;
    60.             cs_n  <= 1'b1;
    61.             sclk  <= 1'b0;
    62.             mosi  <= 1'b1;
    63.             send_cnt<= 'd0 ;
    64.             recv_cnt<= 'd0 ;
    65.             dout    <= 'd0 ;
    66.             send_over <= 1'b0;
    67.             rec_over <= 1'b0;
    68.             cs_n_cnt <= 2'b0;
    69.         end
    70.         else begin
    71.             case(state)
    72.                 idle:
    73.                     begin
    74.                         if(spi_start == 1)begin
    75.                             state <= send_recv;
    76.                         end
    77.                         else begin
    78.                             state <= state;
    79.                         end
    80.                     end
    81.            send_recv:                                           //send and receive
    82.                     begin
    83.                           if(spi_end == 1)begin 
    84.                             state <= over;  
    85.                           end                
    86.                           else begin         
    87.                             state  <= state; 
    88.                           end  
    89.                           
    90.                          if(cs_n_cnt == 2 || sclk == 1)begin                    //发送 相对于CS的下降沿，发送延迟1个SCLK周期
    91.                              mosi <= din[DW-1-send_cnt];
    92.                              if(send_cnt < 3'b111)begin
    93.                                 send_cnt  <= send_cnt + 1 ;
    94.                              end
    95.                              else begin 
    96.                                 send_cnt  <= 3'b0;
    97.                              end
    98.                          end
    99.                          else begin
    100.                              mosi <= mosi;                   
    101.                              send_cnt <= send_cnt;
    102.                          end
    103.                          
    104.                          if(send_cnt == 3'b111 && sclk == 1)begin
    105.                             send_over <= 1'b1;
    106.                          end
    107.                          else begin
    108.                             send_over <= 1'b0; 
    109.                          end
    110. ///                         
    111.                         if(cs_n_cnt > 2 && sclk == 0)begin                    //接收
    112.                              recv_data[DW-1-recv_cnt] <= miso;
    113.                              if(recv_cnt < 3'b111)begin
    114.                                 recv_cnt <= recv_cnt + 1;
    115.                                 rec_over <= 1'b0;
    116.                              end
    117.                              else begin
    118.                                 rec_over <= 1'b1;
    119.                                 recv_cnt <= 3'b0;
    120.                              end   
    121.                          end
    122.                          else begin
    123.                              recv_data<= recv_data;
    124.                              recv_cnt <= recv_cnt;
    125.                              rec_over <= rec_over;
    126.                          end
    127.                          
    128.                          if(recv_cnt == 3'b000 && sclk == 1)begin
    129.                             rec_over <= 1'b1;
    130.                             dout     <= recv_data;
    131.                          end
    132.                          else begin
    133.                             rec_over <= 1'b0;
    134.                             dout     <= 'd0; 
    135.                          end
    136.                          
    137.                          
    138.                          
    139.                          cs_n  <= 1'b0;
    140.                          if(cs_n_cnt < 3)begin
    141.                             cs_n_cnt <= cs_n_cnt + 1;
    142.                          end
    143.                          else begin
    144.                             cs_n_cnt <= cs_n_cnt;
    145.                          end
    146.                             
    147.                             
    148.                          if(cs_n_cnt < 3)begin          //空余出1个的SCLK周期,使得主从机收发的数据对其
    149.                             sclk  <= sclk;
    150.                          end
    151.                          else begin
    152.                             sclk  <= !sclk;
    153.                          end              
    154.                     end
    155.                 over:
    156.                     begin
    157.                         state <= idle;
    158.                         cs_n  <= 1'b1;   
    159.                         sclk  <= 1'b0;   
    160.                         mosi  <= 1'b1;   
    161.                         send_cnt <= 'd0 ; 
    162.                         recv_cnt<= 'd0 ;
    163.                         dout  <= 'd0 ; 
    164.                         send_over <= 1'b0;
    165.                         rec_over <= 1'b0;
    166.                         cs_n_cnt <= 2'b0;    
    167.                     end
    168.             endcase
    169.         end
    170.     end
    171.     
    172.     
    173.     
    174.     
    175. endmodule

    从机代码：

    1. `timescale 1ns / 1ps
    2. //
    3. // Company: 
    4. // Engineer: 
    5. // 
    6. // Create Date: 2023/09/01 17:04:04
    7. // Design Name: 
    8. // Module Name: SPI_derive
    9. // Project Name: 
    10. // Target Devices: 
    11. // Tool Versions: 
    12. // Description: 
    13. // 
    14. // Dependencies: 
    15. // 
    16. // Revision:
    17. // Revision 0.01 - File Created
    18. // Additional Comments:
    19. // SPI总线从机驱动程序
    20. //
    21.  
    22.  
    23. module spi_slave #(
    24.     parameter   integer DW = 8
    25. )
    26. (
    27.    input                    sys_clk     ,       //系统时钟50M  
    28.    input                    sys_rst     ,       //复位信号低电平有效
    29.    
    30.    input[DW-1:0]            din         ,       //要发送的数据               
    31.    output reg               spi_start   ,       //SPI驱动程序启动信号，通知后级SPI程序已经启动  
    32.    output reg               spi_end     ,       //SPI驱动程序结束信号，通知后级SPI程序已经结束          
    33.    output reg [DW-1:0]      dout        ,       //接收的数据                
    34.    output reg               rec_over    ,       //单个字节接收完毕信号           
    35.    output reg               send_over   ,       //单个字节发送结束信号           
    36.    
    37.    input                    sclk        ,       //SPI程序的SCLK 本程序是对系统时钟的2分频    
    38.    input                    cs_n        ,       //SPI片选信号                     
    39.    input                    mosi        ,       //SPI输入，主机发送过来的数据               
    40.    output reg               miso                //SPI输出，从机发送的数据             
    41.           
    42.     );
    43.     
    44.     localparam          idle        = 3'b001  ;
    45.     localparam          send_recv   = 3'b010  ;
    46.     localparam          over        = 3'b100  ;
    47.     reg[2:0]            state                 ;
    48.        
    49.     reg[DW-1:0]         recv_data   = 'd0     ;
    50.     reg                 clk_2d      = 'd0     ;
    51.     reg[2:0]            send_cnt    = 'd0     ;
    52.     reg[2:0]            recv_cnt    = 'd0     ;
    53.     reg                 sd_rc_flag  = 'd0     ;
    54.     
    55.     
    56.     
    57.  
    58.     
    59.     always@(posedge sys_clk,negedge sys_rst)begin
    60.         if(!sys_rst == 1)begin
    61.             state <= idle;
    62.             send_cnt<= 'd0 ;
    63.             recv_cnt<= 'd0 ;
    64.             dout    <= 'd0 ;
    65.             send_over <= 1'b0;
    66.             rec_over <= 1'b0;
    67.             sd_rc_flag <= 1'b0;
    68.             spi_start<= 1'b0;
    69.             spi_end  <= 1'b0;
    70.         end
    71.         else begin
    72.             case(state)
    73.                 idle:
    74.                     begin
    75.                         send_cnt<= 'd0 ; 
    76.                         recv_cnt<= 'd0 ; 
    77.                         dout    <= 'd0 ; 
    78.                         send_over <= 1'b0;
    79.                         rec_over <= 1'b0;
    80.                         sd_rc_flag <= 1'b0;
    81.                         spi_end  <= 1'b0;       
    82.                         if(cs_n == 0)begin
    83.                             state <= send_recv;
    84.                             spi_start<= 1'b1;
    85.                         end
    86.                         else begin
    87.                             state <= state;
    88.                             spi_start<= spi_start;
    89.                         end
    90.                     end
    91.            send_recv:                                           //send and receive
    92.                     begin
    93.                           if(cs_n  == 1)begin 
    94.                             state <= over;  
    95.                           end                
    96.                           else begin         
    97.                             state  <= state; 
    98.                           end  
    99.                           
    100.  
    101.                          if(sd_rc_flag == 0 || sclk == 1)begin                    //发送
    102.                              miso <= din[DW-1-send_cnt];
    103.                              if(send_cnt < 3'b111)begin
    104.                                 send_cnt  <= send_cnt + 1 ;
    105.                              end
    106.                              else begin 
    107.                                 send_cnt  <= 3'b000;
    108.                              end
    109.                          end
    110.                          else begin         
    111.                              send_cnt <= send_cnt;
    112.                          end
    113.                          
    114.                          if(send_cnt == 3'b111 && sclk == 1)begin
    115.                             send_over <= 1'b1;
    116.                          end
    117.                          else begin
    118.                             send_over <= 1'b0; 
    119.                          end
    120. ///                         
    121.                         if(sd_rc_flag == 1 && sclk == 0)begin                    //接收
    122.                              recv_data[DW-1-recv_cnt] <= mosi;
    123.                              if(recv_cnt < 3'b111)begin
    124.                                 recv_cnt <= recv_cnt + 1;
    125.                                 rec_over <= 1'b0;
    126.                              end
    127.                              else begin
    128.                                 rec_over <= 1'b1;
    129.                                 recv_cnt <= 3'b000;
    130.                              end   
    131.                          end
    132.                          else begin
    133.                              recv_data<= recv_data;
    134.                              recv_cnt <= recv_cnt;
    135.                              rec_over <= rec_over;
    136.                          end
    137.                          
    138.                          if(recv_cnt == 3'b000 && sclk == 1)begin
    139.                             rec_over <= 1'b1;
    140.                             dout <= recv_data;
    141.                          end
    142.                          else begin
    143.                             rec_over <= 1'b0;
    144.                             dout <= 'd0; 
    145.                          end
    146.                          
    147.                       spi_start<= 1'b0;
    148.                       spi_end  <= 1'b0;
    149.                       sd_rc_flag <= 1'b1;
    150.                   end       
    151.                 over:
    152.                     begin
    153.                         state <= idle;  
    154.                         send_cnt <= 'd0 ; 
    155.                         recv_cnt<= 'd0 ;
    156.                         dout  <= 'd0 ; 
    157.                         send_over <= 1'b0;
    158.                         rec_over <= 1'b0;
    159.                         sd_rc_flag <= 1'b0;
    160.                         spi_start<= 1'b0;
    161.                         spi_end  <= 1'b1;
    162.                             
    163.                     end
    164.             endcase
    165.         end
    166.     end
    167.     
    168.     
    169.     
    170.     
    171. endmodule

     主机仿真波形

    从机仿真波形

    Testbench源代码：

    1. `timescale 1ns / 1ps
    2. //
    3. // Company: 
    4. // Engineer: 
    5. // 
    6. // Create Date: 2023/09/02 10:38:32
    7. // Design Name: 
    8. // Module Name: tb_spi_derive
    9. // Project Name: 
    10. // Target Devices: 
    11. // Tool Versions: 
    12. // Description: 
    13. // 
    14. // Dependencies: 
    15. // 
    16. // Revision:
    17. // Revision 0.01 - File Created
    18. // Additional Comments:
    19. // 
    20. //
    21.  
    22.  
    23. module tb_spi_derive();
    24.  
    25. reg          sys_clk    ;
    26. reg          sys_rst    ;
    27. reg[7:0]     din        ;
    28. reg          dval_i     ;
    29. reg          spi_start  ;
    30. reg          spi_end    ;
    31.  
    32. wire[7:0]    dout       ;
    33. wire         dval_o     ;
    34. wire         rec_over   ;
    35. wire         send_over  ;
    36.  
    37. wire         sclk       ;
    38. wire         cs_n       ;
    39. wire         mosi       ;
    40. wire         miso       ;
    41.  
    42.  
    43. reg[7:0]     din_s      ;
    44. wire         spi_start_s  ;
    45. wire         spi_end_s    ;
    46.  
    47. wire[7:0]    dout_s       ;
    48. wire         rec_over_s   ;
    49. wire         send_over_s  ;
    50.  
    51.  
    52.  
    53.  
    54.  
    55.  
    56. reg[3:0]     send_cnt     ;
    57. reg[3:0]     send_cnt_s   ;
    58.  
    59.  
    60.  
    61.  
    62.  
    63. SPI_derive #(
    64.     .DW     (8  )
    65. )
    66. u_SPI_derive(
    67.     .sys_clk            (sys_clk ) ,  
    68.     .sys_rst            (sys_rst ) ,
    69.     .din                (din      ),
    70.     .spi_start          (spi_start),
    71.     .spi_end            (spi_end  ),
    72.     .dout               (dout     ),
    73.     .rec_over           (rec_over ),
    74.     .send_over          (send_over),
    75.     .sclk               (sclk     ),
    76.     .cs_n               (cs_n     ),
    77.     .mosi               (mosi     ),
    78.     .miso               (miso     )  
    79. );
    80.  
    81.  
    82. spi_slave #(
    83.     .DW     (8  )
    84. )
    85. u_spi_slave(
    86.     .sys_clk            (sys_clk    ) ,  
    87.     .sys_rst            (sys_rst    ) ,
    88.     .din                (din_s      ),
    89.     .spi_start          (spi_start_s),
    90.     .spi_end            (spi_end_s  ),
    91.     .dout               (dout_s     ),
    92.     .rec_over           (rec_over_s ),
    93.     .send_over          (send_over_s),
    94.     .sclk               (sclk       ),
    95.     .cs_n               (cs_n       ),
    96.     .mosi               (mosi       ),
    97.     .miso               (miso       )  
    98. );
    99.  
    100.  
    101.  
    102. initial begin
    103.     sys_clk     = 1;
    104.     sys_rst     = 0;
    105.     spi_start   = 1'b0;
    106.     din         = 8'd0;
    107.     dval_i      = 1'b0;
    108.     spi_end     = 1'b0;
    109.     
    110.     
    111.     #80
    112.     sys_rst     = 1;
    113.     din_s       = 8'h51;
    114.     #30
    115.     spi_start = 1'b1; din = 8'b00110011;
    116.     #20
    117.     spi_start = 1'b0;
    118.     
    119. end
    120.  
    121. always@(posedge sys_clk,negedge sys_rst)
    122. begin
    123.     if(!sys_rst)begin
    124.         din  <= 8'd0;
    125.         spi_end <= 1'b0;
    126.         send_cnt <= 4'b0;
    127.     end
    128.     else if(send_over == 1) begin
    129.         din <= din + 8'b01;
    130.         if(send_cnt < 10)begin
    131.             send_cnt <= send_cnt + 1;
    132.             spi_end <= 1'b0;
    133.         end
    134.         else begin
    135.             send_cnt <= 4'b0;
    136.             spi_end <= 1'b1;         
    137.         end
    138.     end
    139.     else begin
    140.        spi_end <= 1'b0; 
    141.        send_cnt <= send_cnt;
    142.        din <= din; 
    143.     end
    144. end
    145.  
    146. always@(posedge sys_clk,negedge sys_rst)
    147. begin
    148.     if(!sys_rst)begin
    149.         din_s  <= 8'b0;
    150.         send_cnt_s<= 4'b0;
    151.     end
    152.     else if(spi_start_s == 1|| send_over_s ==1) begin
    153.         din_s <= din_s + 8'b01;
    154.         if(send_cnt_s < 10)begin
    155.             send_cnt_s <= send_cnt_s + 1;
    156.         end
    157.         else begin
    158.             send_cnt_s <= 4'b0;       
    159.         end
    160.     end
    161.     else begin
    162.        send_cnt_s <= send_cnt_s;
    163.        din_s <= din_s; 
    164.     end
    165. end
    166.  
    167.  
    168.  
    169.  
    170. initial begin
    171.     forever #10 sys_clk = !sys_clk;
    172. end
    173.  
    174.  
    175.  
    176.  
    177. endmodule


    总结

    本文只是对SPI总线的模式0做初步实现，如有错误欢迎指正。

  • 相关阅读:
    redis 启动，关闭，查看状态
    Ubuntu安装freeSwitch
    如何通过API调用EasyPlayer.js播放器的视频实时录像功能？
    面试题-5
    数据结构笔记——树与二叉树
    飞利浦zigbee智能灯泡的软硬件设计
    鸿蒙HarmonyOS实战-ArkUI事件（键鼠事件）
    【JavaSE】继承和多态
    kafka安装与相关配置详解
    RD算法（一）—— 算法原理
  • 原文地址：https://blog.csdn.net/sqzjiayou/article/details/126686930