devbox
人工智能uu
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SPI总线协议

作者：人工智能uu | 2024-06-22 10:30:44

赞

踩

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做初步实现，如有错误欢迎指正。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/人工智能uu/article/detail/746246
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号