搜索
bottom↓
回复: 8

FPGA作为从机给STM32发送数据,仿真可以通过,实际却不行。

[复制链接]

出0入0汤圆

发表于 2017-11-20 16:50:22 | 显示全部楼层 |阅读模式
本帖最后由 thy110 于 2017-11-20 17:18 编辑

我以114个数据为一组,给stm32发送数据,仿真可以看出数据都发送出去的了,但是接受的数据却不正确,接收的都是114个相同的数据,求助啊
  1. module SPI_Test(
  2.                                                 input clk,
  3.                                                 input rst_n,
  4.                                                 input SCK,
  5.                                                 input CS,
  6.                                                 input MOSI,
  7.                                                 output MISO,                                       
  8.                                                 input        rx,
  9.                                                 output       tx);


  10. reg [7:0] spi_ad [113:0];                        //存储发送的ASIC字符
  11. reg [7:0] txd_data;
  12. reg [15:0] spi_cnt;
  13. reg  spi_stat;
  14. always@(CS)
  15. begin     //定义发送的字符
  16. if(spi_stat == 0) begin
  17.                  spi_ad[0]<=65;                           //存储字符 A
  18.                  spi_ad[1]<=68;                           //存储字符 D
  19.                  spi_ad[2]<=49;                           //存储字符 1
  20.                  spi_ad[3]<=58;                           //存储字符 :
  21.                  spi_ad[4]<=0;                      //存储字符 正负            
  22.                  spi_ad[5]<=48;          //存储字符 个位                          
  23.                  spi_ad[6]<=46;                           //存储字符 .
  24.                  spi_ad[7]<=48;          //存储字符 小数点后一位
  25.                  spi_ad[8]<=48;           //存储字符 小数点后二位
  26.                  spi_ad[9]<=48;            //存储字符 小数点后三位
  27.                  spi_ad[10]<=48;            //存储字符 小数点后四位
  28.                  spi_ad[11]<=86;                          //存储字符 V
  29.                  spi_ad[12]<=32;                          //存储字符 空格
  30.                  spi_ad[13]<=32;                          //存储字符 空格
  31.                  
  32.                  spi_ad[14]<=65;                           //存储字符 A
  33.                  spi_ad[15]<=68;                           //存储字符 D
  34.                  spi_ad[16]<=50;                           //存储字符 2
  35.                  spi_ad[17]<=58;                           //存储字符 :
  36.                  spi_ad[18]<=0;                      //存储字符 正负            
  37.                  spi_ad[19]<= 48;          //存储字符 个位                          
  38.                  spi_ad[20]<=46;                           //存储字符 .
  39.                  spi_ad[21]<=48;          //存储字符 小数点后一位
  40.                  spi_ad[22]<=48;           //存储字符 小数点后二位
  41.                  spi_ad[23]<=48;            //存储字符 小数点后三位
  42.                  spi_ad[24]<=48;            //存储字符 小数点后四位
  43.                  spi_ad[25]<=86;                           //存储字符 V
  44.                  spi_ad[26]<=32;                           //存储字符 空格
  45.                  spi_ad[27]<=32;                           //存储字符 空格
  46.                  
  47.                  spi_ad[28]<=65;                           //存储字符 A
  48.                  spi_ad[29]<=68;                           //存储字符 D
  49.                  spi_ad[30]<=51;                           //存储字符 3
  50.                  spi_ad[31]<=58;                           //存储字符 :
  51.                  spi_ad[32]<=0;                      //存储字符 正负            
  52.                  spi_ad[33]<=48;          //存储字符 个位                          
  53.                  spi_ad[34]<=46;                           //存储字符 .
  54.                  spi_ad[35]<=48;          //存储字符 小数点后一位
  55.                  spi_ad[36]<=48;           //存储字符 小数点后二位
  56.                  spi_ad[37]<=48;            //存储字符 小数点后三位
  57.                  spi_ad[38]<=48;            //存储字符 小数点后四位
  58.                  spi_ad[39]<=86;                           //存储字符 V
  59.                  spi_ad[40]<=32;                           //存储字符 空格
  60.                  spi_ad[41]<=32;                           //存储字符 空格         
  61.                  
  62.                  spi_ad[42]<=65;                           //存储字符 A
  63.                  spi_ad[43]<=68;                           //存储字符 D
  64.                  spi_ad[44]<=52;                           //存储字符 4
  65.                  spi_ad[45]<=58;                           //存储字符 :
  66.                  spi_ad[46]<=0;                      //存储字符 正负            
  67.                  spi_ad[47]<=48;          //存储字符 个位                          
  68.                  spi_ad[48]<=46;                           //存储字符 .
  69.                  spi_ad[49]<=48;          //存储字符 小数点后一位
  70.                  spi_ad[50]<=48;           //存储字符 小数点后二位
  71.                  spi_ad[51]<=48;            //存储字符 小数点后三位
  72.                  spi_ad[52]<=48;            //存储字符 小数点后四位
  73.                  spi_ad[53]<=86;                           //存储字符 V
  74.                  spi_ad[54]<=32;                           //存储字符 空格
  75.                  spi_ad[55]<=32;                           //存储字符 空格
  76.                  
  77.                  spi_ad[56]<=65;                           //存储字符 A
  78.                  spi_ad[57]<=68;                           //存储字符 D
  79.                  spi_ad[58]<=53;                           //存储字符 5
  80.                  spi_ad[59]<=58;                           //存储字符 :
  81.                  spi_ad[60]<=0;                      //存储字符 正负            
  82.                  spi_ad[61]<=48;          //存储字符 个位                          
  83.                  spi_ad[62]<=46;                           //存储字符 .
  84.                  spi_ad[63]<=48;          //存储字符 小数点后一位
  85.                  spi_ad[64]<=48;           //存储字符 小数点后二位
  86.                  spi_ad[65]<=48;            //存储字符 小数点后三位
  87.                  spi_ad[66]<=48;            //存储字符 小数点后四位
  88.                  spi_ad[67]<=86;                           //存储字符 V
  89.                  spi_ad[68]<=32;                           //存储字符 空格
  90.                  spi_ad[69]<=32;                           //存储字符 空格
  91.                  
  92.                  spi_ad[70]<=65;                           //存储字符 A
  93.                  spi_ad[71]<=68;                           //存储字符 D
  94.                  spi_ad[72]<=54;                           //存储字符 6
  95.                  spi_ad[73]<=58;                           //存储字符 :
  96.                  spi_ad[74]<=0;                      //存储字符 正负            
  97.                  spi_ad[75]<=48;          //存储字符 个位                          
  98.                  spi_ad[76]<=46;                           //存储字符 .
  99.                  spi_ad[77]<=48;          //存储字符 小数点后一位
  100.                  spi_ad[78]<=48;           //存储字符 小数点后二位
  101.                  spi_ad[79]<=48;            //存储字符 小数点后三位
  102.                  spi_ad[80]<=48;            //存储字符 小数点后四位
  103.                  spi_ad[81]<=86;                           //存储字符 V
  104.                  spi_ad[82]<=32;                           //存储字符 空格
  105.                  spi_ad[83]<=32;                           //存储字符 空格

  106.                  spi_ad[84]<=65;                           //存储字符 A
  107.                  spi_ad[85]<=68;                           //存储字符 D
  108.                  spi_ad[86]<=55;                           //存储字符 7
  109.                  spi_ad[87]<=58;                           //存储字符 :
  110.                  spi_ad[88]<=0;                      //存储字符 正负            
  111.                  spi_ad[89]<=48;          //存储字符 个位                          
  112.                  spi_ad[90]<=46;                           //存储字符 .
  113.                  spi_ad[91]<=48;          //存储字符 小数点后一位
  114.                  spi_ad[92]<=48;           //存储字符 小数点后二位
  115.                  spi_ad[93]<=48;            //存储字符 小数点后三位
  116.                  spi_ad[94]<=48;            //存储字符 小数点后四位
  117.                  spi_ad[95]<=86;                           //存储字符 V
  118.                  spi_ad[96]<=32;                           //存储字符 空格
  119.                  spi_ad[97]<=32;                           //存储字符 空格       

  120.                  spi_ad[98]<=65;                           //存储字符 A
  121.                  spi_ad[99]<=68;                           //存储字符 D
  122.                  spi_ad[100]<=56;                          //存储字符 8
  123.                  spi_ad[101]<=58;                          //存储字符 :
  124.                  spi_ad[102]<=0;                     //存储字符 正负            
  125.                  spi_ad[103]<=48;         //存储字符 个位                          
  126.                  spi_ad[104]<=46;                          //存储字符 .
  127.                  spi_ad[105]<=48;         //存储字符 小数点后一位
  128.                  spi_ad[106]<=48;          //存储字符 小数点后二位
  129.                  spi_ad[107]<=48;           //存储字符 小数点后三位
  130.                  spi_ad[108]<=48;           //存储字符 小数点后四位
  131.                  spi_ad[109]<=86;                          //存储字符 V
  132.                  spi_ad[110]<=32;                          //存储字符 空格
  133.                  spi_ad[111]<=32;                          //存储字符 空格               

  134.                  spi_ad[112]<=10;                          //换行符
  135.                  spi_ad[113]<=13;                          //回车符  

  136.                  end                
  137. end
  138. wire  CS_n;              
  139. reg CS_r0,CS_r1;                                       
  140. always@(posedge clk or negedge rst_n)
  141. begin
  142.         if(!rst_n)
  143.                 begin
  144.                         CS_r0 <= 1'b0;
  145.                         CS_r1 <= 1'b0;
  146.                 end
  147.         else
  148.                 begin
  149.                         CS_r0 <= CS;
  150.                         CS_r1 <= CS_r0;               
  151.                 end
  152. end
  153. assign CS_n = (~CS_r0 & CS_r1)? 1'b1:1'b0;

  154. always@( CS_n )//CS边缘检测下降沿
  155. begin
  156.         if(!rst_n) begin   
  157.         spi_cnt<=0;
  158.         spi_stat <= 0;
  159.         end
  160.         else if(spi_cnt == 114) begin
  161.         spi_cnt <= 0;
  162.         spi_stat <= 0;
  163.         end
  164.         else if(CS_n & !CS )begin                      
  165.                 txd_data <= spi_ad[spi_cnt];
  166.                 spi_cnt <= spi_cnt + 1'b1;
  167.                 spi_stat <= 1;
  168.         end
  169. end
  170.                                                
  171. wire SCK_n,SCK_p;
  172. SPI_SCK u1(
  173.                                 .clk(clk),
  174.                                 .rst_n(rst_n),
  175.                                 .SCK(SCK),
  176.                                 .SCK_n(SCK_n),
  177.                                 .SCK_p(SCK_p));

  178. SPI_TX u4(
  179.                                 .clk(clk),
  180.                                 .rst_n(rst_n),
  181.                                 .SCK_n(SCK_n),
  182.                                 .CS(CS),
  183.                                 .txd_data(txd_data),
  184.                                 .MISO(MISO));                               
  185. endmodule


复制代码

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有帐号?注册

x

阿莫论坛20周年了!感谢大家的支持与爱护!!

一只鸟敢站在脆弱的枝条上歇脚,它依仗的不是枝条不会断,而是自己有翅膀,会飞。

出0入0汤圆

发表于 2017-11-20 19:11:55 | 显示全部楼层
感脚软件仿真是功能验证,实际不行是硬件不通猜的

出0入0汤圆

发表于 2017-11-20 20:10:05 | 显示全部楼层
用真实的示波器,测量你可以测到的波形来比对看看

出0入0汤圆

发表于 2017-11-20 20:35:48 | 显示全部楼层
本帖最后由 ArthurBruin 于 2017-11-20 20:46 编辑

楼主的Verilog水平还有待加强,以下几点问题:
1. 即便是testbench测试程序也不能出现语法问题:前面是组合逻辑always@(CS),而中间spi_ad 用"<="如何同步?肯定会出现时序问题的;
2. 原则上Verilog代码不管是可综合的还是testbench都应该同步至clk上,这里面你又是组合逻辑又是时序逻辑,又没状态机同步,如何控制时序?

出0入0汤圆

发表于 2017-11-20 20:45:49 | 显示全部楼层
你可以把你要发的数据放在mif文件里作为ROM的初始值,然后从ROM里往出读试试。

出0入22汤圆

发表于 2017-11-20 22:22:45 来自手机 | 显示全部楼层
spi从机没那么复杂把?

出0入0汤圆

发表于 2017-11-21 08:38:09 | 显示全部楼层
拿逻辑分析仪抓一下波形看看。

出0入0汤圆

 楼主| 发表于 2017-11-21 09:06:54 | 显示全部楼层
解决了,我理解错了,spi主机直接连续发过来114*8个时钟,而我写成了不连续的114*8时钟,对spi理解不透测啊

出0入0汤圆

 楼主| 发表于 2017-11-21 09:10:37 | 显示全部楼层
ArthurBruin 发表于 2017-11-20 20:35
楼主的Verilog水平还有待加强,以下几点问题:
1. 即便是testbench测试程序也不能出现语法问题:前面是组合 ...

好的,O(∩_∩)O谢谢,Verilog还不是很熟,还要多练啊
回帖提示: 反政府言论将被立即封锁ID 在按“提交”前,请自问一下:我这样表达会给举报吗,会给自己惹麻烦吗? 另外:尽量不要使用Mark、顶等没有意义的回复。不得大量使用大字体和彩色字。【本论坛不允许直接上传手机拍摄图片,浪费大家下载带宽和论坛服务器空间,请压缩后(图片小于1兆)才上传。压缩方法可以在微信里面发给自己(不要勾选“原图),然后下载,就能得到压缩后的图片】。另外,手机版只能上传图片,要上传附件需要切换到电脑版(不需要使用电脑,手机上切换到电脑版就行,页面底部)。
您需要登录后才可以回帖 登录 | 注册

本版积分规则

手机版|Archiver|amobbs.com 阿莫电子技术论坛 ( 粤ICP备2022115958号, 版权所有:东莞阿莫电子贸易商行 创办于2004年 (公安交互式论坛备案:44190002001997 ) )

GMT+8, 2024-3-29 22:11

© Since 2004 www.amobbs.com, 原www.ourdev.cn, 原www.ouravr.com

快速回复 返回顶部 返回列表