【GAOPS051】(xilinx First-Word Fall-Through模式)预读FIFO

这篇具有很好参考价值的文章主要介绍了【GAOPS051】(xilinx First-Word Fall-Through模式)预读FIFO。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

FIFO对比

预读FIFO:rdata在ren当拍有效。(xilinx First-Word Fall-Through模式)
普通FIFO:rdata在ren下拍有效。(xilinx Standard模式)

实现思路

注:实现的思路各有千秋,下面是我的实现思路。
首先用简单双口RAM包装出一个Lfifo,这个Lfifo有以下关键特征:
raddr可以由外部输入的switch_addr信号来切换

Lfifo_raddr_ori_puls=Lfifo_raddr_ori+1
Lfifo_raddr = switch_addr ? Lfifo_raddr_ori_puls : Lfifo_raddr_ori;//二选一,

正是由于raddr地址的提前导致的rdata的提前出来。
其次,在Lfifo外面包一层逻辑,这层逻辑的原理:控制Lfifo_ren、switch_addr等,也产生一些状态信号。
注:下文的buf等价于图中的fifo_rdata寄存器

整个模块的输入信号是:fifo_ren
在产生读Lfifo_ren控制逻辑的角度来看:有每一拍4种可能状态
case1.Lfifo空1    &  buf空1  ----此时输入fifo_ren不会生效(后级保证不会空读) 忽略此状态
case2.Lfifo空1    &  buf满0  ----if(fifo_ren==1)将buf读空,buf变成空,不读Lfifo,else 保持
case3.Lfifo有数0  &  buf空1  ----fifo_ren不会生效(后级保证不会空读) ,本拍内部产生预读读Lfifo,
                                 准备取1个数放buf,数据下一拍有效,下一拍产生load。01状态会持续2拍,只有第1拍需要读。
case4.Lfifo有数0  &  buf满0  ----if(fifo_ren==1) ram_raddr切换为+1(本拍就切换地址,那么Lfifo_rdata数据下拍就预取出来了)。

补充:FIFO的状态变化是有顺序的,不可能直接从case1跳变为case4,其中必然要经过case2 | case3中间状态。


xilinx fifo时序 first-word-fall-through,fpga开发

仿真效果

写完后连续读

xilinx fifo时序 first-word-fall-through,fpga开发

写完后间隔读

xilinx fifo时序 first-word-fall-through,fpga开发

非空就读(边写边读)

xilinx fifo时序 first-word-fall-through,fpga开发

只写1个数据,非空读

xilinx fifo时序 first-word-fall-through,fpga开发文章来源地址https://www.toymoban.com/news/detail-700005.html

代码和tb

Lfifo

//-------------------------------------------------------
//------------------little_fifo--------------------------------
//-------------------------------------------------------
module   Lfifo #(//L:Little  小FIFO
    parameter      RAM_TYPE =  "block_ram"  ,
    parameter      WIDTH    =  9            ,
    parameter      DEPTH    =  10           
)(
    input                            clk                     ,
    input                            rst                     ,
    input                            Lfifo_wr                ,
    input           [WIDTH-1:0]      Lfifo_wdata             ,
    input                            Lfifo_ren               ,
    input                            switch_addr             ,//1:地址+1,相当于预取
    input           [WIDTH-1:0]      Lfifo_rdata             ,
    output                           Lfifo_empty             ,
    output                           Lfifo_aempty             //FIFO只剩最后1个,用于预取情况,来判断rdata是否有效
);
reg      [DEPTH-1:0]      Lfifo_waddr ={DEPTH{1'b0}}            ;//RAM待写入的地址
wire     [DEPTH-1:0]      Lfifo_raddr             ;//RAM待读出的地址
reg      [DEPTH-1:0]      Lfifo_raddr_ori={DEPTH{1'b0}}         ;//RAM待读出的地址
reg      [DEPTH-1:0]      Lfifo_raddr_ori_puls={DEPTH{1'b0}}    ;// Lfifo_raddr_ori + 1 
assign    Lfifo_empty    =     (Lfifo_raddr_ori==Lfifo_waddr)  ;
assign    Lfifo_aempty   =     (Lfifo_raddr_ori_puls==Lfifo_waddr)  ;
always @(posedge clk or posedge rst) 
begin
    if(rst)   
        Lfifo_raddr_ori_puls  <=#1  {{(DEPTH-1){1'b0}},1'b1}; 
    else  if (Lfifo_ren) 
        Lfifo_raddr_ori_puls <=#1   Lfifo_raddr_ori_puls + 1'b1;
end
always @(posedge clk or posedge rst) 
begin
    if(rst)   
        Lfifo_raddr_ori  <=#1  {DEPTH{1'b0}}; 
    else if (Lfifo_ren) 
        Lfifo_raddr_ori <=#1  Lfifo_raddr_ori_puls;
end
assign   Lfifo_raddr  =  switch_addr ?   Lfifo_raddr_ori_puls : Lfifo_raddr_ori;
always @(posedge clk) if(rst)   Lfifo_waddr <=#1 {(2**DEPTH){1'b0}};  else if(Lfifo_wr)    Lfifo_waddr <=#1  Lfifo_waddr +1'b1 ;
SPRAM #(RAM_TYPE,WIDTH,DEPTH) u_RAM (
    .clk  (clk                           ),//input                            clk                      ,
    .wen  (Lfifo_wr                      ),//input                            wen                      ,
    .waddr(Lfifo_waddr                   ),//input           [DEPTH-1:0]      waddr                    ,
    .wdata(Lfifo_wdata                   ),//input           [WIDTH-1:0]      wdata                    ,
    .raddr(Lfifo_raddr                   ),//input           [DEPTH-1:0]      raddr                    ,
    .rdata(Lfifo_rdata                   ) //output    reg   [WIDTH-1:0]      rdata                     
);
endmodule
//-------------------------------------------------------
//------------------SPRAM--------------------------------
//-------------------------------------------------------
module   SPRAM #(//sample    double    port   RAM 
    parameter      RAM_TYPE =  "block_ram"  ,
    parameter      WIDTH    =  9            ,
    parameter      DEPTH    =  10           
)(
    input                            clk                      ,
    input                            wen                      ,
    input           [DEPTH-1:0]      waddr                    ,
    input           [WIDTH-1:0]      wdata                    ,
    input           [DEPTH-1:0]      raddr                    ,
    output    reg   [WIDTH-1:0]      rdata                     
);
(* syn_ramstyle = RAM_TYPE , cascade_height=1 *) reg   [WIDTH-1:0]    RAM   [(2**DEPTH)-1:0]   ;
always @(posedge clk) if(wen)   RAM[waddr] <=#1 wdata;
always @(posedge clk)           rdata      <=#1 RAM[raddr];
endmodule


SYNC_FIFO


//-------------------------------------------------------
//------------------SYNC_FIFO----------------------------
//-------------------------------------------------------
module   SYNC_FIFO #(//show_ahead
    parameter      RAM_TYPE =  "block_ram"  ,
    parameter      WIDTH    =  9            ,
    parameter      DEPTH    =  10           
)(
    input                            clk                      ,
    input                            rst                      ,
    input                            fifo_wr                  ,
    input           [WIDTH-1:0]      fifo_wdata               ,
    output                           fifo_full                ,    
    input                            fifo_ren                 ,
    output   reg    [WIDTH-1:0]      fifo_rdata               ,
    output   reg                     fifo_empty=1             //标志fifo_rdata寄存器内的数据是否为有效
);
//数据只能存储2个位置:1.在LFIFO内   2.fifo_rdata寄存器内
reg                       Lfifo_ren               ;
wire     [WIDTH-1:0]      Lfifo_rdata             ;
reg                       Lfifo_rdata_vld         ;//fifo_rdata是有效的数据,有可能是延后一拍数据,有可能是预取数据
wire                      Lfifo_empty             ;
wire                      Lfifo_aempty            ;
wire                      load_en                 ;
reg                       switch_addr             ;
reg      [DEPTH  :0]      cnt                     ;

always @(posedge clk or posedge rst) begin if(rst) Lfifo_rdata_vld     <=#1  1'b0; else if(switch_addr&Lfifo_aempty)Lfifo_rdata_vld     <=#1 1'b0 ; else  Lfifo_rdata_vld     <=#1  ~Lfifo_empty  ;end//只剩最后1个,还预读,那就是读出无效
always @(posedge clk or posedge rst) //空  读有关
begin
    if(rst)   
        fifo_empty <=#1  'b1 ; 
    else if(Lfifo_rdata_vld==0 && fifo_ren==1'b1 )
        fifo_empty <=#1  1'b1  ; 
    else if(Lfifo_rdata_vld==1 && load_en==1'b1 )
        fifo_empty <=#1  1'b0  ; 
    else if(Lfifo_rdata_vld==0 && load_en==1'b1 )
        fifo_empty <=#1  1'b1  ; 
end
assign  load_en =  fifo_empty | fifo_ren;//拿走1个数据,就load一次
always @(*) 
begin
    case({Lfifo_empty,fifo_empty})//此处是关键  
        2'b00    :if(fifo_ren){switch_addr,Lfifo_ren} =  2'b11;else {switch_addr,Lfifo_ren} =  2'b00;  
        2'b01    :if(Lfifo_rdata_vld==0){switch_addr,Lfifo_ren} =  2'b01;else {switch_addr,Lfifo_ren} =  2'b00;
        2'b10    :{switch_addr,Lfifo_ren} =  2'b00;
        2'b11    :{switch_addr,Lfifo_ren} =  2'b00;
        default  :{switch_addr,Lfifo_ren} =  2'b00;
    endcase
end
always @(posedge clk )  if(load_en) fifo_rdata   <=#1   Lfifo_rdata ;
always @(posedge clk or posedge rst) 
begin
    if(rst)   
        cnt  <=#1 'b0; 
    else if((~fifo_wr) & fifo_ren) 
        cnt <=#1  cnt -'b1 ;
    else if(fifo_wr & (~fifo_ren)) 
        cnt <=#1  cnt + 'b1 ;
end
assign  fifo_full  = cnt [DEPTH] ;
Lfifo #(RAM_TYPE,WIDTH,DEPTH) u_Lfifo(//地址控制只依赖于ren
    .clk        (clk                           ),//input                            clk                     ,
    .rst        (rst                           ),//input                            rst                     ,
    .Lfifo_wr   (fifo_wr                       ),//input                            Lfifo_wr                ,
    .Lfifo_wdata(fifo_wdata                    ),//input           [WIDTH-1:0]      Lfifo_wdata             ,
    .Lfifo_ren  (Lfifo_ren                     ),//input                            Lfifo_ren               ,
    .switch_addr(switch_addr                   ),//input                            switch_addr               ,
    .Lfifo_rdata(Lfifo_rdata                   ),//input           [WIDTH-1:0]      Lfifo_rdata             ,
    .Lfifo_empty(Lfifo_empty                   ), //output                           Lfifo_empty              
    .Lfifo_aempty(Lfifo_aempty                 ) //output                           Lfifo_empty              
);
endmodule


tb


`timescale 1ns/100ps//正确
module tb (  );
    parameter      RAM_TYPE =  "block_ram"  ;
    parameter      WIDTH    =  9            ;
    parameter      DEPTH    =  9           ;
    reg                 rst=1                 ;
    reg                 clk=0                 ;
    always clk   =#10  ~clk;    
    reg                   fifo_wr =  0             ;
    reg  [WIDTH-1:0]      fifo_wdata               ;
    wire                  fifo_full                ; 
    reg                   fifo_ren  =0             ;
    reg  [WIDTH-1:0]      fifo_rdata               ;
    wire                  fifo_empty               ;
    initial //产生时钟
    begin
        rst=1                 ;
        #100;@(posedge clk);#1;
        rst=0                 ;
        
        #100;@(posedge clk);#1;       
        // fifo_wr_task(en,wdata);
        // fifo_rd_task(en);
//case 1 ://写连续入1个数据,非空就立马读
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);        
//case 2 ://写连续入1个数据,延时几拍后再读
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #1000;@(posedge clk);                
//case 3 ://写连续入2个数据,第1拍非空就立马读,第二拍延时一定时间读
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 4 ://写连续入2个数据,第1拍非空就立马读,第二拍非空就立马读
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        fifo_rd_task(1);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 5 ://写连续入2个数据,第1拍延时一定时间,再连续读2次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 6 ://写连续入2个数据,第1拍延时一定时间,再连延时一定时间读第二拍
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #1000;@(posedge clk);
//case 7 ://写连续入3个数据,非空立马读3次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);        
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 8 ://写连续入3个数据,非空读1次,延时,连续读2次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);        
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 9://写连续入3个数据,非空读2次,延时,读1次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        fifo_rd_task(1);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
//case 10://写连续入3个数据,延时 ,连续读3次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);        
        fifo_rd_task(1);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);

//case 11://写连续入3个数据,延时 ,读1次,延时,读1次,延时,读1次
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);        
        fifo_rd_task(1);
        fifo_rd_task(0);
        #50;@(posedge clk);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #1000;@(posedge clk);
//case 11://写连续入8个数据,看full信号是否正确
        fifo_wr_task(1,32'h1111);
        fifo_wr_task(1,32'h2222);
        fifo_wr_task(1,32'h3333);
        fifo_wr_task(1,32'h4444);
        fifo_wr_task(1,32'h5555);
        fifo_wr_task(1,32'h6666);
        fifo_wr_task(1,32'h7777);
        fifo_wr_task(1,32'h8888);
        fifo_wr_task(0,32'hxxxx);
        wait(fifo_empty==0);
        #50;@(posedge clk);         
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #1000;@(posedge clk);
//case 12://边写边读
        fifo_wr_task(1,32'h0001);
        fifo_wr_task(1,32'h0002);
        fifo_wr_task(1,32'h0003);
        fifo_wr<=1;fifo_wdata<=32'h0004;fifo_ren<=1;@(posedge clk); #1;
        fifo_wr<=1;fifo_wdata<=32'h0005;fifo_ren<=1;@(posedge clk); #1;
        fifo_wr<=1;fifo_wdata<=32'h0006;fifo_ren<=1;@(posedge clk); #1;
        fifo_wr<=1;fifo_wdata<=32'h0007;fifo_ren<=1;@(posedge clk); #1;
        fifo_wr<=0;fifo_wdata<=32'hxxxx;fifo_ren<=1;@(posedge clk); #1;
        fifo_rd_task(1);
        fifo_rd_task(1);
        fifo_rd_task(0);
        #100;@(posedge clk);
    end
SYNC_FIFO #(RAM_TYPE,WIDTH,DEPTH)  u_SYNC_FIFO (
    .clk       (clk                       ),//input                            clk                      ,
    .rst       (rst                       ),//input                            rst                      ,
    .fifo_wr   (fifo_wr                   ),//input                            fifo_wr                  ,
    .fifo_wdata(fifo_wdata                ),//input           [WIDTH-1:0]      fifo_wdata               ,
    .fifo_full (fifo_full                 ),//output                           fifo_full                ,    
    .fifo_ren  (fifo_ren                  ),//input                            fifo_ren                 ,
    .fifo_rdata(fifo_rdata                ),//output          [WIDTH-1:0]      fifo_rdata               ,
    .fifo_empty(fifo_empty                ) //output                           fifo_empty              
);
task  fifo_wr_task   ;
input                 en ;
input   [WIDTH-1:0]   wdata ;
begin 
    fifo_wr<=en;fifo_wdata<=wdata;@(posedge clk);#1; 
end endtask
task  fifo_rd_task   ;
input                 en ;
begin 
     fifo_ren<= en;@(posedge clk); #1;
end endtask
endmodule

到了这里,关于【GAOPS051】(xilinx First-Word Fall-Through模式)预读FIFO的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 基于目标检测、跟踪 的人体姿态估计 算法进行跌倒检测 ---- fall detection

    前序文章: 深度学习与视频分析简介 视频分析:基于目标检测(YOLO)实现走路看手机检测、玩手机检测、跌倒检测等 基于深度学习算法的行为识别解决方案:打电话、玩手机、摔倒等行为动作的识别,跟踪

    2024年02月09日
    浏览(57)
  • 【leetcode100-051到054】【图论】四题合集

    【岛屿数量】 给你一个由  \\\'1\\\' (陆地)和  \\\'0\\\' (水)组成的的二维网格,请你计算网格中岛屿的数量。 岛屿总是被水包围,并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。 此外,你可以假设该网格的四条边均被水包围。 思路: 很经典也很基础的图搜

    2024年01月23日
    浏览(43)
  • 6.s081/6.1810(Fall 2022)Lab2: System calls

    这个lab主要介绍了用户态到内核态的系统调用做了什么,并让我们照猫画虎完成了两个系统调用的实现。 环境搭建 Lab1: Utilities Lab2: System calls Lab3: Page tables Lab4: Traps Lab5: Copy-on-Write Fork for xv6 官网链接 xv6手册链接,这个挺重要的,建议做lab之前最好读一读。 xv6手册中文版,这

    2024年02月13日
    浏览(56)
  • c语言200例 051 使用指针实现逆序存放数组元素

    关键技术: 1.自定义创建了个函数 inverte()用来实现对数组元素的逆序存放 2.自定义函数的形参为个指向数组的指针变量x,初始值指向数组 a 的首元素的地址,x+n是 a[n]元素的地址 3.声明指针变量i、j和 p,i初始值为x,即指向数组首元素地址,j的初始值为 x+n-1,即指向数组最

    2024年02月03日
    浏览(49)
  • CMU15445 (Fall 2020) 数据库系统 Project#2 - B+ Tree 详解(上篇)

    考虑到 B+ 树较为复杂,CMU15-445 将 B+ 树实验拆成了两部分,这篇博客将介绍 Checkpoint#1、Checkpoint#2 删除操作和迭代器的实现过程,搭配教材 《DataBase System Concepts》食用更佳。 许多查询只涉及文件中的少量记录,例如“找出物理系所有教师”的查询就只涉及教师记录中的一小部

    2024年02月08日
    浏览(44)
  • 九齐NY8A051F单片机呼吸灯

    一、呼吸灯简介 呼吸灯是指LED灯通过单片机控制实现由亮到暗的逐渐变化,就和人体呼吸一样。这里我们单片机要用到定时器和PWM占位来实现这项功能。 二、NY81051F定时器的定义 三、PWM(脉冲宽度调制) 通过改变脉冲宽度来改变电压的输出,T=1/f,T是周期,f是频率。如果频

    2024年03月23日
    浏览(38)
  • B051-cms06-退出 回车登录 登录拦截 记住我 SVN

    注销功能实现 1.找到退出按钮修改请求路径 header.jsp 2.后端删除Session并跳转到登录页面 UserController 回车登录功能 1.整个登录页面绑定键盘按压回车键事件 2.发送抽取之后的登陆请求 login.jsp 登陆拦截 防止直接跳过登录页面直接访问后台页面 1.编写登录拦截器 LoginInterceptor 2.配

    2024年02月11日
    浏览(45)
  • 编程笔记 html5&css&js 051 CSS表格2-2

    多数时候是按列设计表格样式的。 在HTML表格中,可以通过CSS来按列设置样式。以下是一个简单的例子: 在这个例子中,我们使用了CSS伪类选择器first-child和nth-child(n)来分别选择表格的每一列,并分别为它们设置了不同的样式。 按列设置样式列具实用性。

    2024年01月22日
    浏览(50)
  • 【051】基于Vue、Springboot电商管理系统(含源码、详细论文、数据库)

    基于Vue、Springboot、Mysql的前后端分离的电商管理系统,不仅功能完善,还有详细课设报告供查看,这不收藏起来, 源码和论文 获取见 文末结尾 部分报告内容如下(省略图片)

    2024年02月10日
    浏览(47)
  • STM32L051使用HAL库操作实例(14)- ADC采集电压

    目录 一、前言 二、ADC外设简要说明 三、STM32CubeMX配置(本文使用的STM32CubeMX版本为6.1.2) 1.MCU选型 2.时钟使能 3.外部时钟配置 4.串口配置 5.ADC引脚配置 6.配置STM32CubeMX生成工程文件 7.点击GENERATE CODE生成工程文件 四、工程源码 五、运行状态 一、前言 本文主要介绍通过HAL库搭建

    2024年01月16日
    浏览(59)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包