精华内容
下载资源
问答
  • 本文章是关于FPGA串并转换
  • FPGA串并转换代码 (verilog) 可用.
  • 本文章是关于串并转换的相关程序。
  • FPGA重要的设计思想——串并转换

    千次阅读 2018-05-06 22:18:57
     串并转换是高速流水处理重要的设计技巧之一,串并转换的方法也多种多样,根据数据的顺序和数量要求,可以选择寄存器,双口RAM,(Dual RAM),SRAM , SDRAM,FIFO等实现,对于数量比较少的设计,可以采用移位...

     

      串并转换是高速流水处理重要的设计技巧之一,串并转换的方法也多种多样,根据数据的顺序和数量要求,可以选择寄存器,双口RAM,(Dual RAM),SRAM , SDRAM,FIFO等实现,对于数量比较少的设计,可以采用移位寄存器设计。

         在工程应用中,如何体现串并转换设计思想呢?怎样才能提高系统的设计速度呢?我们可以先来做一个串并转换的设计框图,   如图所示,串行输入的数据通过FPGA内部的n个寄存器后,最后并行输出的是一个n位宽的并行总线数据。

        

    移位一般是要有时钟做同步的,也就是说,n个时钟采样到的串行数据需要在n个时钟周期后以并行方式输出,这是最基本的传入并出设计思想,对于串行接口大行其道的高速传输领域,这种简单的转换也是接口芯片的重要任务之一,但从FPGA的角度来看,串并转换又有着更深的意义,串并转换正是面积换速度思想的体现。

    展开全文
  • FPGA/CPLD 的设计思想与技巧是一个非常大的话题,由于篇幅所限,本文仅介绍一些常用的设计思想与技巧,包括乒乓球操作、串并转换、流水线操作和数据接口的同步。
  • 串并转换FPGA设计的一个重要技巧,是数据流出来的常用手段,也是面积与速度互换思想的直接体现。串并转换的实现方法多种多样,根据数据的排序和数量的要求,可以选用寄存器、ram等实现。 并行转串行数据输出:采用...

    串并转换是FPGA设计的一个重要技巧,是数据流出来的常用手段,也是面积与速度互换思想的直接体现。串并转换的实现方法多种多样,根据数据的排序和数量的要求,可以选用寄存器、ram等实现。

    并行转串行数据输出:采用计数方法,将并行的数据总数先表示出来,然后发送一位数据减一。

     module p2s(
    	input clk,
    	input rst_n,
    	input load,
    	input [7:0] pdata,
    	output sdata
    );
    reg [2:0]bit_cnt;
    reg [7:0] temp_data;
    reg en;
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		en <= 'b0;
    	end
    	else if(load) begin
    		en <= 1'b1;
    	end
    	else if(bit_cnt==3'd7) begin
    		en <= 1'b0;
    	end
    end
    
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		bit_cnt <= 3'b0;
    	end
    	else if(en) begin
    		bit_cnt <= bit_cnt + 1'b1;
    	end
    	else begin
    		bit_cnt <= 3'b0;
    	end
    end
    
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		temp_data <= 8'b0;
    	end
    	else if(load) begin
    		temp_data <= pdata;
    	end
    	else if(en) begin
    		temp_data <= temp_data << 1;
    	end
    end
    
    assign sdata = temp_data[7];
    endmodule
    	
    	/*  module p2s (
    	input clk,
    	input rst_n,
    	input load,
    	input [7:0] pdata,
    	output sclk,
    	output sdata
    );
    reg [3:0] bit_cnt;
    reg en;
    reg [7:0] shuff;
    
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		en <= 1'b0;
    	end
    	else if(load) begin
    		en <= 1'b1;
    	end
    	else if(bit_cnt==4'hf) begin
    		en <= 1'b0;
    	end
    end
    
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		bit_cnt <= 'b0;
    	end
    	else if(en) begin
    		bit_cnt <= bit_cnt + 1'b1;
    	end
    	else begin
    		bit_cnt <= 'b0;
    	end
    end
    
    
    assign sclk = bit_cnt[0];
    
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		shuff <= 8'b0;
    	end
    	else if(load) begin
    		shuff <= pdata;
    	end
    	else if(sclk) begin
    		shuff <= shuff << 1;
    	end
    end
    
    assign sdata = shuff[7];
    
    
    endmodule */
    

    测试代码:

    `timescale 1ps/1ps
    module p2s_tb();
    reg clk;
    reg rst_n;
    reg load;
    reg [7:0] pdata;
    wire sdata;
    wire sclk;
    initial begin
    	clk = 0;
    	pdata=8'h0;
    	rst_n = 0;
    	load = 0;
    	#14;
    	rst_n = 1;
    	#32;
    	load = 1;
    	pdata = 8'haa;
    	#10;
    	load = 0;
    	pdata = 8'h12;
    	#100;
    	load = 1;
    	pdata=8'h55;
    	#10;
    	load = 0;
    	pdata = 8'h34;
    	
    	#100;
    	load = 1;
    	pdata=8'hff;
    	#10;
    	load = 0;
    	pdata = 8'h34;
    end
    
    always #5 clk = ~clk;
    
    p2s p2s_inst(
    	.clk(clk),
    	.rst_n(rst_n),
    	.load(load),
    	.pdata(pdata),
    	.sdata(sdata)
    	//.sclk(sclk)
    );
    
    
    
    
    endmodule
    
    

    在这个代码中,最后的输出数据就刚好和en使能信号是完全对齐的那8个数据。

    串行转并行数据输出:采用位拼接结束,将串行的数据总数先表示出来,然后发送一位数据加一。

    module p2s(
    	input clk,
    	input datain,
    	input rst_n,
    	input valid,
    	output [7:0] dataout,
    	output reg done
    );
    
    reg [2:0] cnt;
    reg [7:0] tempdata;
    always @ (posedge clk or negedge rst_n) begin
    	if(!rst_n) begin
    		tempdata <= 8'b0;
    		cnt <= 3'b0;
    		done <= 1'b0;
    	end
    	else if(valid) begin
    		case(cnt)
    			3'd0 : begin
    					tempdata[0] <= datain;
    					cnt <= cnt + 1'b1;
    					done <= 1'b0;
    				end
    			3'd1 : begin
    					tempdata[1] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd2 : begin
    					tempdata[2] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd3 : begin
    					tempdata[3] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd4 : begin
    					tempdata[4] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd5 : begin
    					tempdata[5] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd6 : begin
    					tempdata[6] <= datain;
    					cnt <= cnt + 1'b1;
    				end
    			3'd7 : begin
    					tempdata[7] <= datain;
    					cnt <= 3'd0;
    					done <= 1'b1;
    				end
    		endcase
    	end
    	else begin
    		tempdata <= 8'b0;
    		cnt <= 3'b0;
    		done <= 1'b0;
    	end
    end
    
    assign dataout = done ? tempdata : 8'b0;
    
    
    
    
    endmodule
    
    

    测试代码

    `timescale 1ps/1ps
    module p2s_tb();
    reg clk;
    reg datain;
    reg rst_n;
    reg valid;
    wire [7:0] dataout;
    wire done;
    
    p2s p2s_inst(
    	.clk(clk),
    	.datain(datain),
    	.rst_n(rst_n),
    	.valid(valid),
    	.dataout(dataout),
    	.done(done)
    );
    
    initial begin
    	rst_n = 0;
    	clk = 0;
    	#13;
    	rst_n = 1;
    end
    
    always #5 clk = ~clk;
    
    initial begin
    	valid = 0;
    	#30;
    	valid = 1;
    	#170;
    	valid = 0;
    end
    
    initial begin
    	datain = 0;
    	#5;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain= 0;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 0;
    	#10;
    	datain =1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain= 0;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 0;
    	#10;
    	datain =1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 0;
    	#10;
    	datain =1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain= 0;
    	#10;
    	datain = 1;
    	#10;
    	datain = 0;
    	#10;
    	datain =1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain= 0;
    	#10;
    	datain = 1;
    	#10;
    	datain = 0;
    	#10;
    	datain =1;
    	#10;
    	datain = 1;
    	#10;
    	datain = 1;
    	#10;
    	datain= 0;
    	#10;
    end
    
    
    
    endmodule
    
    

    流水线操作设计思想
    流水线处理是高速设计中的一个常用设计手段。如果某个设计的处理流程分为若干步骤,而且整个数据处理是“单流向”的,即没有反馈或者迭代运算,前一个步骤的输出是下一个步骤的输入,就可以考虑流水线设计方法来提高系统的工作频率。在这里插入图片描述
    流水线设计的结构如下图所示,将适当划分的n个操作步骤单流向串联起来。流水线操作的最大特点和要求是,数据流在各个步骤的处理从时间上看是连续的,如果每个操作步骤简化假设为通过一个D触发器(就是用寄存器打一个节拍),那么流水线操作就类似一个移位寄存器组,数据流依次流经D触发器,完成每个步骤的操作。流水线设计时序如下图:
    在这里插入图片描述
    流水线设计的一个关键在于整个设计时序的合理安排,要求每个操作步骤的划分合理。如果前级操作时间恰好等于后级的操作时间,设计最为简单,前级的输出直接汇入后级的输入即可;如果前级的操作时间大于后级的操作时间,则需要对前级的输出数据适当缓存才能汇入到后级输入端;如果前级操作时间恰好小于后级的 操作时间,则必须通过复制逻辑,将数据流分流,或者在前级对数据采用存储、后处理方式,否则会造成后级数据溢出。

    展开全文
  • 本系列讨论的四种常用FPGA/CPLD设计思想与技巧:乒乓操作、串并转换、流水线操作、数据接口同步化,都是FPGA/CPLD逻辑设计的内在规律的体现,合理地采用这些设计思想能在FPGA/CPLD设计工作种取得事半功倍的效果。...

      本系列讨论的四种常用FPGA/CPLD设计思想与技巧:乒乓操作、串并转换、流水线操作、数据接口同步化,都是FPGA/CPLD逻辑设计的内在规律的体现,合理地采用这些设计思想能在FPGA/CPLD设计工作种取得事半功倍的效果。
           串并转换是 FPGA 设计的一个重要技巧,它是数据流处理的常用手段,也是面积与速度互换思想的直接体现。串并转换的实现方法多种多样,根据数据的排序和数量的要求,可以选用 寄存器、 RAM 等实现。前面在乒乓操作的图例中,就是通过 DPRAM 实现了数据流的串并转换,而且由于使用了 DPRAM ,数据的缓冲区可以开得很大,对于数量比较小的设计可以采用寄存器完成串并转换。如无特殊需求,应该用同步时序设计完成串并之间的转换。比如数据从串行到 并行,数据排列顺序是高位在前,可以用下面的编码实现:
    prl_temp<={prl_temp,srl_in};
    其中, prl_temp 是并行输出缓存寄存器, srl_in 是串行数据输入。对于排列顺序有规定的串并转换,可以用 case 语句判断实现。对于复杂的串并转换,还可以用状态机实现。串并转换的方法比较简单,在此不必赘述。
    流水线操作设计思想
    首先需要声明的是,这里所讲述的流水线是指一种处理流程和顺序操作的设计思想,并非 FPGA 、 ASIC 设计中优化时序所用的 “Pipelining” 。
    流水线处理是高速设计中的一个常用设计手段。如果某个设计的处理流程分为若干步骤,而且整个数据处理是 “ 单流向 ” 的,即没有反馈或者迭代运算,前一个步骤的输出是下一个步骤的输入,则可以考虑采用流水线设计方法来提高系统的工作频率。
    <ignore_js_op> 
    流水线设计的结构示意图如图 3 所示。其基本结构为:将适当划分的 n 个操作步骤单流向串联起来。流水线操作的最大特点和要求是,数据流在各个步骤的处理从时间上看是连续的,如果将每个操作步骤简化假设为通过一个 D 触发器 ( 就是用寄存器打一个节拍 ) ,那么流水线操作就类似一个移位寄存器组,数据流依次流经 D 触发器,完成每个步骤的操作。流水线设计时序如图 4 所示。
    <ignore_js_op> 
    流水线设计的一个关键在于整个设计时序的合理安排,要求每个操作步骤的划分合理。如果前级操作时间恰好等于后级的操作时间,设计最为简单,前级的输 出直接汇入后级的输入即可;如果前级操作时间大于后级的操作时间,则需要对前级的输出数据适当缓存才能汇入到后级输入端;如果前级操作时间恰好小于后级的 操作时间,则必须通过复制逻辑,将数据流分流,或者在前级对数据采用存储、后处理方式,否则会造成后级数据溢出。
    在 WCDMA 设计中经常使用到流水线处理的方法,如 RAKE 接收机、搜索器、前导捕获等。流水线处理方式之所以频率较高,是因为复制了处理模块,它是面积换取速度思想的又一种具体体现。

    转载于:https://www.cnblogs.com/lifan3a/articles/4371058.html

    展开全文
  • 数据流中,用面积换速度-串行转并行的操作 并行转串行数据输出:采用计数方法,将并行的数据的总数先表示出来,然后发送一位数据减一,后面的接收的这样表示: data_out <= data[cnt];//cnt表示计数器 ...

    数据流中,用面积换速度-串行转并行的操作

    并行转串行数据输出:采用计数方法,将并行的数据的总数先表示出来,然后发送一位数据减一,后面的接收的这样表示: data_out <= data[cnt];//cnt表示计数器

    `timescale  1ns/1ns
    
    module  p2s
        (
          input         clk,
          input         rst_n,
          input         load,
          input [7:0]   pdata,
          output        sclk,
          output        sdat
        );
    `define FULL  4'hf 
    reg [3:0]   bitcnt;
    reg         en;
    reg [7:0]   sbuff;
    always @(posedge clk or negedge rst_n)
      if(!rst_n)      en  <=  0;
      else if(load) en  <=  1'b1; 
      else if(bitcnt==`FULL)  en  <= 1'b0; 
    always @(posedge clk or negedge rst_n)
     if(!rst_n)  bitcnt  <=  0;
      else if(en) bitcnt  <=  bitcnt + 'b1;
      else  bitcnt  <=  0;
    assign  sclk  = bitcnt[0];
    always @(posedge clk or negedge rst_n)
      if(!rst_n)  sbuff <=  8'b0;
      else if(load) sbuff <=  pdata;
      else if(sclk) sbuff <=  sbuff<<1;
    assign  sdat  = sbuff[7];
    endmodule


    串行转并行数据输出:采用位拼接结束,将串行的数据总数先表示出来,然后发送一位数据加一,后面的接收的这样标志:data <= {data[6:0],data_out };------用过的74HC595

    module SerialToParallel(
        input         CLK,    //时钟
        input         RSTn,    //复位
        input         Enable,    //输入有效
        input         DataIn,    //串行输入
        output reg    Ready,    //输出有效
        output[7:0]    Index,    //并行数据索引
        output[7:0] ParallelData    //并行数据输出
        );
        
        reg[7:0]    Data_Temp;    //数据缓存
        reg[3:0]    counter;    //位数计数器
        reg[3:0]    state;        //状态机
        reg[7:0]    Index_Temp;    //索引缓存
        
        assign    Index=Index_Temp;
        assign    ParallelData=Ready?Data_Temp:8'd0;
        
        ////
        //state:
        //4'd0:复位 
        //
        //4'd1:未复位,未使能
        //
        //4'd2:未复位,输入使能
        //
        
        always@(posedge CLK or negedge RSTn)
        if(!RSTn)
            begin
                state<=4'd0;        //复位
                Ready<=0;
                counter<=4'd0;
                Data_Temp<=8'd0;
                Index_Temp<=8'd0;
            end
        else
            begin
                case(state)
                    4'd0:
                    begin
                        if(!Enable)state<=4'd1;
                        else state<=4'd2;
                        Ready<=0;
                    end
                    4'd1:
                    begin
                        if(!Enable)state<=4'd1;
                        else state<=4'd2;
                        Ready<=0;
                        counter<=4'd0;
                        Data_Temp<=8'd0;
                    end
                    4'd2:
                    begin
                        if(!Enable)state<=4'd1;
                        else state<=4'd2;
                        case(counter)
                        4'd0:begin Data_Temp[0]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd1:begin Data_Temp[1]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd2:begin Data_Temp[2]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd3:begin Data_Temp[3]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd4:begin Data_Temp[4]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd5:begin Data_Temp[5]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd6:begin Data_Temp[6]<=DataIn;counter<=counter + 1'b1;Ready<=0;end
                        4'd7:begin Data_Temp[7]<=DataIn;counter<=4'd0;Index_Temp<=Index_Temp + 1'b1;Ready<=1'b1;end
                        endcase
                    end
                endcase
            end
    
    endmodule

     

    转载于:https://www.cnblogs.com/Dinging006/p/9486530.html

    展开全文
  • FPGA学习-8-串并转换

    2019-06-17 22:37:24
    系统:win10 软件编辑和程序下载平台:...FPGA:EP4CE6 代码,(已经运行成功) `define bit0 8 module serial_to_parallel_8bit( input sys_clk, input sys_rst_n, input en, input in, output reg [`bit0 - 1...
  • 想在FPGA中实现20G的串并转换,但是ISERDES貌似不支持这么高速度,请问还有别的什么方法吗?
  • IP核参数配置总结页:串行输入,8bit并行输出,single-end信号,速率为...FPGA的仿真重要性远大于RTL代码,所以本次从simulation的测试文件开始,即 module selectio_wiz_0_tb (); // From the system into the d...
  • FPGA中的简单并串,串并转换

    千次阅读 2019-01-10 14:32:32
    笔者在做OFDM扰码模块的时候,发现PSDU数据帧输入是并行数据,需要进行并串转换,才能进入扰码器进行扰码 在进行FFT的时候需要串转并,后面添加仿真图; 并——&gt;串 从图中可以看出,并串转换的原理是:...
  • 刚写完2w字报告,写点verilog压压惊。...1.串并转换模块(1 to 8) 1 `timescale 1ns / 1ps 2 ////////////////////////////////////////////////////////////////////////////////// 3 // Company: ...
  • 欢迎FPGA工程师加入官方微信技术群一、FPGA的UART设计前准备1、准备硬件开发板一个,altera芯片就行,成本低;2、熟悉VHDL硬件描述语言编程及其调试方法;3、熟练使用软件开发工具使用,QuartusII9.0,仿真工具...
  • 五、FPGA设计之8比特串并转换设计

    千次阅读 2015-05-17 10:23:18
    module serial_to_parrell(clk,rst_n,din,data);  input clk;  input rst_n;  input din;  output[7:0] data;    reg[7:0]Q;  reg[7
  • FPGA:EP4CE6 实验仿真结果 设计思路: 由于是程序员,所以结构要清晰,操作要骚 首先创建三个个块 块1 serial_in 目的: 实现串口输入.将输入的数据保存到八位寄存器中,每次连续输入8位后, 再一次性将八位分别在并行...
  • 引言:本节我们介绍FPGA收发器RX以下相关内容:RX字节和字对齐RX弹性缓冲器1.RX字节和字对齐1.1功能描述输入到FPGA收发器的串行数据在解串(串并转换)之前必须进行符号边界对齐。为了保证数据对齐,发送器发送一个...
  • Xilinx 7系列FPGA全系所支持的GT(GT,Gigabyte Transceiver,G比特收发器)。通常称呼为Serdes、高速收发器、GT或者具体信号(如GTX)称呼。7系列中,按支持的最高线速排序,GTP<GTX<GTH<GTZ。GTP被用于A7...
  • 数字IC设计-FPGA——用Verilog实现串并转换 一、串转并转换模块 1. 利用移位寄存器 2. 利用计数器 input clk, rst_n, data_i; output [7:0] data_o; module Deserialize( input clk, input rst_n, input data_i, ...
  • 串并转换 1. 复习verilog语法 【选做题】 - 文件操作fopen fdisplay fwrite fclose - 生成随机数 random - 初始化 readmemh readmemb - finish stop 这几个我真没用过,先给一个优秀的链接:FPGA篇(四)...
  • 设计的思想是这样的:有一组数据以 N MHz 的速率从 FPGA 的一个 I/O 口传入,要...下面是串并转换器的 Verilog代码实现: module Serial2Pal( input Clk, input din, input ena, output reg [3:0] dout = 4'b00.
  • FPGA/CPLD重要设计思想及工程应用   概述 “乒乓操作”是一个常常应用于数据流控制的处理技巧,典型的乒乓操作方法如下图所示。   乒乓操作的处理流程 输入数据流通过“输入数据选择单元”将数据...
  • //*****************************************...//根据腾讯课堂至-FPGA从入门到实战-上海V3学院中学习写出,代码来源与此,注释由自己所写 //******************************************************************...

空空如也

空空如也

1 2 3 4 5 ... 8
收藏数 149
精华内容 59
关键字:

串并转换fpga