基于FPGA查找表的8b10b编码

已于 2023-10-06 23:56:45 修改
阅读量763 收藏 17
点赞数 2
分类专栏： # FPGA设计 文章标签： fpga开发
于 2023-10-06 23:52:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51116586/article/details/133625323
版权

文章目录

参考文献

[1] https://blog.csdn.net/qq_37654178/article/details/112391245

[2] https://ieeexplore.ieee.org/document/5390392
//8b10b编码原论文

前言

  在高速串行通信中，信号可能会受到噪声、衰减和干扰等影响，在实际应用中可以使用8b10b等编码技术增加信号的抗干扰能力，提高了数据传输的可靠性，使得高速串行通信更加稳定和可靠。8b/10b方式最初由IBM公司于1983年发明并应用于ESCON (200M互连系统），由Al Widmer和Peter Franaszek在IBM的刊物“研究与开发”上描述。本文基于查找表实现8b10b编码。

一、8b10b编码

  顾名思义，8b10b编码是在高速串行通信中将8bit的数据映射成10bit的码字进行传输。直观看来，8b10b编码带来了20%的数据冗余，那舍弃效率带来的好处是什么呢？

  8b10b编码最直接的好处是实现了直流均衡。在高速串行传输中，通常采用交流耦合方式，发送和接收端之间串联电容，利用电容“通交隔直”的特性去除信号的直流偏置，使得接收和发送端处于同一电平标准。但万物有利弊，当串行数据流出现多个连续的0或1时，可以认为该时间段信号是直流的，直流信号被滤除，幅度降低，导致接收端无法正确识别0和1，使得解码失败。

  这里回顾下电容“通交隔直”的原理。根据理想电容阻抗公式
Z c = 1 2 π f c Z_c = \frac{1}{2{\pi}fc} Zc​=2πfc1​
  信号频率越高，电容阻抗越低，当信号为直流时，f=0，此时电容阻抗趋近于无穷，信号无法通过。

  那8b10b编码又是如何实现这个直流均衡的呢？核心思路便是不让串行数据出现连续的5个0或1。首先我们先了解下8b10b编码的组成，8b10b编码包含256数据码和12控制码，8bit原始数据对应256个数据码加上12个控制码，而编码后的10bit数据有1024个码，因此8b10b实际上就是从1024个码中挑选合适的码来表示数据码和控制码，使得编码后的码字0和1的数量尽可能相等且不出现过长的0或1。

二、基本原理

  假设原始8bit数据由高到低用HGFEDCBA表示，8b10b编码先将8bit数据分成高3位HGF和低5位EDCBA两部分，然后经过3b4b编码将高3位映射到fghj；同时低5位映射成abcdei。最后合并成abcdeifghj发送，发送为小端发送，低位a先发送。
请添加图片描述

  由上文可知，8b10b编码可以分成控制码D.x.y和数据码K.x.y，其中x表示为低五位的十进制数值，y表示为高三位的十进制数值，例如D.1.0表示的时8bit数000_00001代表的原始数据码。顾名思义，数据码是对数据进行编码，而控制码是用来标识传输的开始、结束等状态，控制码也称为K码或者是Comma码，用于高速传输接收端的数据对齐和恢复。比如8b10b编码的协议通常使用K28.5（正码10’b1110000011，负码10’b0001111100）来作为对齐码。

以下表1是对低5位进行数据编码
请添加图片描述

以下表2是对高3位进行数据编码
请添加图片描述

以下表3是8b10b的部分编码
请添加图片描述

以下表4是12种控制码的编码
请添加图片描述

  由上面三个编码表，我们可以发现同个8位的数据有可能会有两种不同的编码方式，下面将介绍如何判断应该选择哪种编码。首先啊我们先了解“disparity”和“running disparity（RD）”的概念。

  disparity为不一致性或者极性，表示编码后的数据中“0”和“1”的个数差值。由上表可以的得到编码后的数据极性只存在三种情况，分别为“+2”（1比0多两个），“0”（0和1一样多），“-2”（1比0少两个）。我们称极性为0的编码称为平衡码。

  RD为运行不一致性或者极性偏差，RD是数据流的极性特性，是当前时刻之前所有数据极性的统计，如果之前数据流中1比0多，则RD为正，否则为负。8b10b编码便是根据串行数据流的RD特性进行控制编码，改善编码的直流特性。举例说明，见表1，比如说当前时刻要传输数据的低5位为D.00，如果之前数据流1比0多RD为正时，此时编码应该增加0的个数，D.00应该编码为6’b011000，反之编码为6’b100111。下图为RD状态转移图。
请添加图片描述

  如下表Rules for running disparity，也就是RD的选择原则。由该表格可以得到三种规律。一是当编码的极性Disparity为0时，previous RD和next RD保持不变。二是当编码的极性Disparity可为 ± 2 \pm2 ±2且previous RD为-1时，编码极性选择+2，next RD与previous RD取反。三是当编码的极性Disparity可为 ± 2 \pm2 ±2且previous RD为+1时，编码极性选择-2，next RD与previous RD取反。

请添加图片描述

  对8b10b编码举例说明，当当前数据为D.0.00，先发送低5位，再发送高3位。初始化RD为负，对于低5位来说，previous RD = -1(0多)，则低5位5’b00000编码6’b100111（disparity = +2，1多），此时next RD = +1(1多)。后续发送高3位，对于高3位来说，previous RD = +1，则高3位3’b000编码为4’b0100(disparity = -2，0多)，此时next RD = -1(0多)。对比表3可以知道，此处推导D.0.00（RD-）的编码为10’b100111_0100，推导成功。

三、实现

8b10b编码

module encode_8bto10b(
    input clk,
    input rst_n,
    input din_en,            //输入使能
    input is_k,              //是否为k码
    input [7:0] din_8b,      //输入的8bit数据
    output reg [9:0] dout_10b    //输出的10bit数据
);
reg RD_pre,RD_next;


always @(posedge clk or negedge rst_n)begin
    if(!rst_n)  {RD_next,dout_10b} <= 'd0;
    else if(din_en)        {RD_next,dout_10b} <= code_10b(is_k,RD_pre,din_8b);
    else {RD_next,dout_10b} <= {RD_next,dout_10b};
end
    
always @(posedge clk) RD_pre <= RD_next;

function [10:0] code_10b;
    input is_k;
    input RD_pre;       //上一次的RD
    input [7:0] din_8b;
    //中间寄存器
    reg RD_mid;     //经过6b编码后的RD
    reg is_k28;
    reg [5:0] b6;
    reg [3:0] b4;
    reg is_P7,A7_cnd1,A7_cnd2;
    integer i;      //循环变量
    
    //输出
    reg [9:0] dout_10b;
    reg RD_next;     //经过4b编码后的RD
    
    begin
    
    //判断是否为控制码
    is_k28 = is_k && (din_8b[4:0] == 5'd28);
    //判断是用P7编码还是A7编码，数据码一般使用P7编码，只有在下列情况才用A7编码，目的是防止出现5个连0或者连1
    //if RD=-1, 5b = 17,18,20
    //if RD=+1, 5b = 11,13,14
    A7_cnd1 = (!RD_pre) & (din_8b[7:3] == 5'b11110 & (din_8b[2:0] == 3'b001 | din_8b[2:0] == 3'b010 | din_8b[2:0] == 3'b100));
    A7_cnd2 = (RD_pre) & (din_8b[7:3] == 5'b11101 & (din_8b[2:0] == 3'b011 | din_8b[2:0] == 3'b101 | din_8b[2:0] == 3'b110));
    
    is_P7 = !(is_k | A7_cnd1 | A7_cnd2);
    
    //5b to 6b code
    if(is_k28) begin
            b6 = (RD_pre)?6'b110000:6'b001111;  //abcdei
            RD_mid = ~RD_pre;
        end
    else 
        case(din_8b[4:0])       //input EDCBA  output abcdei
            5'd0 :begin b6 = (RD_pre)? 6'b011000:6'b100111; RD_mid = ~RD_pre;  end      //RD_mid是否反向的判断依据是，编码后有是否为完美编码（01平衡）
            5'd1 :begin b6 = (RD_pre)? 6'b100010:6'b011101; RD_mid = ~RD_pre;  end
            5'd2 :begin b6 = (RD_pre)? 6'b010010:6'b101101; RD_mid = ~RD_pre;  end
            5'd3 :begin b6 = 6'b110001; RD_mid = RD_pre;  end
            5'd4 :begin b6 = (RD_pre)? 6'b001010:6'b110101; RD_mid = ~RD_pre;  end
            5'd5 :begin b6 = 6'b101001; RD_mid = RD_pre;  end
            5'd6 :begin b6 = 6'b011001; RD_mid = RD_pre;  end
            5'd7 :begin b6 = (RD_pre)? 6'b000111:6'b111000; RD_mid = RD_pre;  end
            5'd8 :begin b6 = (RD_pre)? 6'b000110:6'b111001; RD_mid = ~RD_pre;  end
            5'd9 :begin b6 = 6'b100101; RD_mid = RD_pre;  end
            5'd10:begin b6 = 6'b010101; RD_mid = RD_pre;  end
            5'd11:begin b6 = 6'b110100; RD_mid = RD_pre;  end
            5'd12:begin b6 = 6'b001101; RD_mid = RD_pre;  end
            5'd13:begin b6 = 6'b101100; RD_mid = RD_pre;  end
            5'd14:begin b6 = 6'b011100; RD_mid = RD_pre;  end
            5'd15:begin b6 = (RD_pre)? 6'b101000:6'b010111; RD_mid = ~RD_pre;  end
            5'd16:begin b6 = (RD_pre)? 6'b100100:6'b011011; RD_mid = ~RD_pre;  end
            5'd17:begin b6 = 6'b100011; RD_mid = RD_pre;  end
            5'd18:begin b6 = 6'b010011; RD_mid = RD_pre;  end
            5'd19:begin b6 = 6'b110010; RD_mid = RD_pre;  end
            5'd20:begin b6 = 6'b001011; RD_mid = RD_pre;  end
            5'd21:begin b6 = 6'b101010; RD_mid = RD_pre;  end
            5'd22:begin b6 = 6'b011010; RD_mid = RD_pre;  end
            5'd23:begin b6 = (RD_pre)? 6'b000101:6'b111010; RD_mid = ~RD_pre;  end
            5'd24:begin b6 = (RD_pre)? 6'b001100:6'b110011; RD_mid = ~RD_pre;  end
            5'd25:begin b6 = 6'b100110; RD_mid = RD_pre;  end
            5'd26:begin b6 = 6'b010110; RD_mid = RD_pre;  end
            5'd27:begin b6 = (RD_pre)? 6'b001001:6'b110110; RD_mid =~RD_pre;  end
            5'd28:begin b6 = 6'b001110; RD_mid = RD_pre; end
            5'd29:begin b6 = (RD_pre)? 6'b010001:6'b101110; RD_mid = ~RD_pre;  end
            5'd30:begin b6 = (RD_pre)? 6'b100001:6'b011110; RD_mid = ~RD_pre;  end
            5'd31:begin b6 = (RD_pre)? 6'b010100:6'b101011; RD_mid = ~RD_pre;  end
            default:begin b6 = 6'bXXXXXX;RD_mid = RD_pre;  end
        endcase
    //3b to 4b code
    case(din_8b[7:5])       //input HGF  output fghj
        3'd0:begin b4 = (RD_mid)?           4'b0100:4'b1011; RD_next = ~RD_mid; end
        3'd1:begin b4 = (!RD_mid & is_k28)? 4'b0110:4'b1001; RD_next = RD_mid; end
        3'd2:begin b4 = (!RD_mid & is_k28)? 4'b1010:4'b0101; RD_next = RD_mid; end
        3'd3:begin b4 = (RD_mid)?           4'b0011:4'b1100; RD_next = RD_mid; end
        3'd4:begin b4 = (RD_mid)?           4'b0010:4'b1101; RD_next = ~RD_mid; end
        3'd5:begin b4 = (!RD_mid & is_k28)? 4'b0101:4'b1010; RD_next = RD_mid; end
        3'd6:begin b4 = (!RD_mid & is_k28)? 4'b1001:4'b0110; RD_next = RD_mid; end
        3'd7:begin 
                RD_next = ~RD_mid;
                if(is_P7)  b4 = (RD_mid)?4'b0001:4'b1110;
                else       b4 = (RD_mid)?4'b0111:4'b1000;
             end
        default:begin b4 = 4'bXXXX;  RD_next = RD_mid; end
    
    endcase
    
    code_10b = {RD_next,{b6,b4}};
    end
    
endfunction
endmodule

8b10b解码


module decode_10bto8b(
    input clk,
    input rst_n,
    input [9:0] din_10b,
    output [7:0] dout_8b
    );
reg [2:0] dout_3b_r;
reg [4:0] dout_5b_r;
reg is_k28 ;
wire [3:0] din_4b;
wire [5:0] din_6b;
assign din_4b = din_10b[3:0];
assign din_6b = din_10b[9:4];

initial is_k28 = 0;
//4b to 3b
//always @(posedge clk or negedge rst_n)begin
//        if(!rst_n)
//            dout_3b_r <= 'd0;
//        else 
always @(*)begin    //6和1 2和5是编码重复但反向的
            case(din_4b)
            4'b1011:dout_3b_r =  3'd0;
            4'b0100:dout_3b_r =  3'd0;
            4'b1001:dout_3b_r = (is_k28)? 3'd6: 3'd1;       //(D28)？
            4'b0110:dout_3b_r = (is_k28)? 3'd1: 3'd6;      //K码的编码,RD=-1
//            4'b0110:dout_3b_r =  3'd6;
//            4'b1001:dout_3b_r =  3'd6;      //K码的编码，RD=-1
            
            4'b0101:dout_3b_r = (is_k28)? 3'd5: 3'd2;      //(D28)？
            4'b1010:dout_3b_r = (is_k28)? 3'd2: 3'd5;      //K码的编码,RD=-1
//            4'b1010:dout_3b_r =  3'd5;
//            4'b0101:dout_3b_r =  3'd5;      //K码的编码，RD=-1
            4'b1100:dout_3b_r =  3'd3;
            4'b0011:dout_3b_r =  3'd3;
            4'b1101:dout_3b_r =  3'd4;
            4'b0010:dout_3b_r =  3'd4;


            4'b1110:dout_3b_r =  3'd7;//P7
            4'b0001:dout_3b_r =  3'd7;//P7
            4'b0111:dout_3b_r =  3'd7;//A7,K
            4'b1000:dout_3b_r =  3'd7;//A7,K
            default: dout_3b_r = 3'bXXX; 
            endcase
    end
    
//6b to 5b
//    always @(posedge clk or negedge rst_n)begin
//        if(!rst_n)
//            dout_5b_r <= 'd0;
//        else 
always @(*)begin
            case(din_6b)
               6'b100111 : dout_5b_r = 5'd0 ;
               6'b011101 : dout_5b_r = 5'd1 ;
               6'b101101 : dout_5b_r = 5'd2 ;
               6'b110001 : dout_5b_r = 5'd3 ;
               6'b110101 : dout_5b_r = 5'd4 ;
               6'b101001 : dout_5b_r = 5'd5 ;
               6'b011001 : dout_5b_r = 5'd6 ;
               6'b111000 : dout_5b_r = 5'd7 ;
               6'b111001 : dout_5b_r = 5'd8 ;
               6'b100101 : dout_5b_r = 5'd9 ;
               6'b010101 : dout_5b_r = 5'd10;
               6'b110100 : dout_5b_r = 5'd11;
               6'b001101 : dout_5b_r = 5'd12;
               6'b101100 : dout_5b_r = 5'd13;
               6'b011100 : dout_5b_r = 5'd14;
               6'b010111 : dout_5b_r = 5'd15;
               6'b011011 : dout_5b_r = 5'd16;
               6'b100011 : dout_5b_r = 5'd17;
               6'b010011 : dout_5b_r = 5'd18;
               6'b110010 : dout_5b_r = 5'd19;
               6'b001011 : dout_5b_r = 5'd20;
               6'b101010 : dout_5b_r = 5'd21;
               6'b011010 : dout_5b_r = 5'd22;
               6'b111010 : dout_5b_r = 5'd23;
               6'b110011 : dout_5b_r = 5'd24;
               6'b100110 : dout_5b_r = 5'd25;
               6'b010110 : dout_5b_r = 5'd26;
               6'b110110 : dout_5b_r = 5'd27;
               6'b001110 : dout_5b_r = 5'd28;
               6'b101110 : dout_5b_r = 5'd29;
               6'b011110 : dout_5b_r = 5'd30;
               6'b101011 : dout_5b_r = 5'd31;
               6'b011000 : dout_5b_r = 5'd0 ;
               6'b100010 : dout_5b_r = 5'd1 ;
               6'b010010 : dout_5b_r = 5'd2 ; 
               6'b001010 : dout_5b_r = 5'd4 ;
               6'b000111 : dout_5b_r = 5'd7 ; 
               6'b000110 : dout_5b_r = 5'd8 ; 
               6'b101000 : dout_5b_r = 5'd15;
               6'b100100 : dout_5b_r = 5'd16;
               6'b000101 : dout_5b_r = 5'd23;
               6'b001100 : dout_5b_r = 5'd24;
               6'b001001 : dout_5b_r = 5'd27;
               6'b010001 : dout_5b_r = 5'd29;
               6'b100001 : dout_5b_r = 5'd30;
               6'b010100 : dout_5b_r = 5'd31;
               6'b001111 : begin dout_5b_r = 5'd28; is_k28 = 1;end
               6'b110000 : begin dout_5b_r = 5'd28; is_k28 = 1;end
               default : begin dout_5b_r = 5'bXXXXX; is_k28 = 0;end
            endcase
    end

assign dout_8b = {dout_3b_r,dout_5b_r};
endmodule

四、仿真

testbench如下：

module tb_8bto10b(    );
    reg clk;
    reg rst_n;
    reg  [7:0] din_8b,din_8b_d0;
    reg is_k;
    wire error;
    wire [7:0] dout_8b;
    wire [9:0] dout_10b;
    
    integer i;
    
    initial begin
    clk = 0;rst_n = 1;din_8b='d0;is_k=1'b0;
    #100 rst_n=0;
    #100 rst_n=1;
    for(i=0;i<255;i=i+1)begin
        #10 din_8b = din_8b + 8'd1;
    end
    end
    always #5 clk = ~clk;
    always @(posedge clk) din_8b_d0 <= din_8b;
    assign error = (din_8b_d0 != dout_8b);
    encode_8bto10b encode_8bto10b(
    .clk        (clk     ),
    .rst_n      (rst_n   ),
    .din_en     (1'b1    ),
    .is_k       (is_k    ),     //是否为k码
    .din_8b     (din_8b  ),     //输入的8bit数据
    .dout_10b   (dout_10b)      //输出的10bit数据
    );
    
    decode_10bto8b decode_10bto8b(
        .clk            (clk     ),
        .rst_n          (rst_n   ),
        .din_10b        (dout_10b),
        .dout_8b        (dout_8b )
     );
endmodule

下图是数据编码
请添加图片描述

总结

  本文基于查找表实现了8b10b编码，资源不是最优，可以使用门电路来实现达到资源最优，还是那句话实现逻辑为主，该模块也为后面serdes的基础。

AIBCI_05
关注
  • 2
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
verilog设计实现8b-10b编码器包括3b4b,5b6b 及modelsim仿真
QQ_778132974的博客
04-22 814
根据应用选择最佳编码表，8b10b编码器至少应使用一张编码表。详细了解和选择编码表有利于改善编码器的性能。编写编码器的状态机。编码器的状态应针对输入数据，在状态转移前确定符号的输出。在每个状态中，都必须关联与该状态相关联的输出符号。用Verilog将设计转换为FPGA或ASIC的物理实现，并通过测试验证设计性能。设计电路包括选择元件，例如寄存器、计数器、直接构成，以及各种传输门、存储器等。例如，您需要确定8位并行数据输入和10位串行数据输出。使用Verilog开发环境进行仿真测试，并通过仿真验证电路功能。
Xilinx FPGA 7系列 GTX/GTH Transceivers (5）-- Aurora 8b10b 信号传输实战--小试牛刀
baidu_34971492的博客
09-26 755
使用GTX传输高速ADC或者FPGA内部数字信号处理产生的高速信号（一般10G左右），采用GTX在芯片之间或者板级光纤连接等，快捷方便高效。1，data_gen类似高速adc ,产生5M采样率 32bit位宽的sine波，这个实际0.16G,远低于GTX的传输能力。2，data_gen 产生的数据首先写入异步fifo里，等待GTX时钟端的frame_gen读取。3，frame_gen 读取异步fifo的数据后进行组包后发送数据。
基于FPGA的8b10b编解码verilog实现
07-12
本设计是采用EDA技术设计的一种8B /10B 编解码电路,实现了在高速的串行数据传输中的直流平衡。利用verilog HDL 逻辑设计语言，经过modelsim、quartus II的仿真和下载验证，实现其编码和解码的功能。 该编解码电路设计大体上可以由五个模块构成，分别是默认编码模块、差异度计算模块、编码校正模块、并串转换模块、显示模块。 采用Verilog HDL 描述、modelsim 10.2a 进行功能仿真、Quartus II 13.1 进行FPGA逻辑综合和适配下载，最后在Alter 公司的Cyclone IV E 的芯片EP4CE6F17C8 上实现并完成测试。 资源包中附有quartusII 的项目文件和代码,直接打开即可使用。
8B10B编码（高速收发器五）
最新发布
weixin_50810761的博客
05-16 1037
8B10B编码是IBM在1983年提出的高速传输编码标准，用于解决时钟恢复和直流偏移问题。它将8位数据编码为10位，通过3B4B和5B6B编码规则实现，保证数据变化，利于时钟恢复。编码包括12个控制字符K码，用于同步和控制。编码过程简单，通过查表法实现，但存在数据损耗问题。
让我们来搞清楚8b/10b编码到底是怎么回事吧
笨蛋大乌龟的博客
03-26 1万+
前言：很多知识我们往往只是了解了皮毛，不知道它为什么产生，更不清楚它深层的应用，很多人半瓶水晃荡，而这正是我最厌恶的，对于8B/10B编码这个知识点我就来扯开它的神秘面纱。 8b/10b的由来： 8B/10b编码也叫做8字节/10字节，是目前高速串行通信中经常用到的一种编码方式，该编码方式最初是由IBM公司在1983年发明并应用于ESCON[200M互联系统]，由AI widmer和Peter Franaszek在IBM的刊物“研究与开发”上提出。 8b/10b提出原因： 高速穿行信号为啥要编码？它
详解FPGA实现8b10b编码原理（含VHDL及verilog源码）
neufeifatonju的博客
09-29 2048
高速串行总线通常会使用AC耦合电容，而通过编码技术使得DC平衡的原理可以从电容“隔直流、通交流”的角度理解。 如下图所示，DC平衡时，位流中的1和0交替出现，可认为是交流信号，可以顺利的通过电容；DC不平衡时，位流中出现多个连续的1或者0，可认为该时间段内的信号是直流，通过电容时会因为电压位阶的关系导致传输后的编码错误。高速串行总线采用编码技术的目的是平衡位流中的1和0，从而达到DC平衡。大多数串行电路都是ac coupling，就是会在tx端有串电容。电容是隔直通交的，如果不做dc balance，会把直
8B/10B编码解析或者说是理解
HHH的博客
11-05 8888
本文就说下我自己对8B/10B的理解； 8b/10b最常见的是应用于光纤通讯和LVDS信号的。由于光模块光模块只能发送亮或者不亮，也就是0或者1这两种状态这种单极性码，那么这会存在一个问题，如果传输中出现较长的连0或者连1（例如111111100000000），那么接收端将没有办法正确的采样识别信号，另外还会由于单极性码含有直流分量，这种直流成分会随数据中1和0的随机变化也呈现随机性，这会引起接收端的基线漂移导致接收端误判。LVDS信号一样会存在这个问题，随着线路上的信号频率越来越高，如果线路上的0.
基于FPGA的8B/10B编解码设计
04-18
为提高8B/10B编解码的工作速度和简化逻辑方法，提出一种基于FPGA的8B/10B编解码系统设计方案。与现有的8B/10B编解码方案相比，该方案是一种利用FPGA实现8B/10B编解码的模块方法，接收模块在收到外部发送的并行数据时...
8B10B编解码FPGA程序
03-17
该文件包含了实现8B10B编码和解码功能的逻辑门级描述，开发者可以通过阅读和理解这个代码来学习如何在FPGA上实现这一重要的通信协议。不过，由于我们无法直接查看文件内容，具体的实现细节和设计特点就无从得知了。...
8b10b.rar_8B10B fpga_8b_8b/10b_fpga 8b10b_stayz7z
07-15
"8b10b.rar_8B10B fpga_8b_8b/10b_fpga 8b10b_stayz7z"这个标题表明，这是一个与FPGA（Field-Programmable Gate Array）相关的项目，涉及到8B/10B编码的实现。 FPGA是一种可编程逻辑器件，能够根据设计者的需要进行...
Enc8b10b.rar
12-13
综上所述，这个8B/10B编码器设计关注的是高速、低延迟和高效的数据编码，其基于LUT的实现可以优化FPGA资源利用，并通过分步编码策略简化设计流程。提供的测试平台将帮助开发者验证编码器的功能和性能，确保在实际...
8b10b_encdec_latest.tar.gz_8b10b_8b10b encoder
09-23
2. **数据编码**：对于有效数据代码，通过查找预定义的8B10B编码表，将8位数据转换为10位代码。这个转换过程中，会确保新生成的10位序列中没有连续的5个“1”或5个“0”，以防止直流偏移。 3. **控制编码**：如果...
线路/信道编码技术(1)——8B/10B编码
热门推荐
hit_wzj的博客
12-25 3万+
1. 线路编码技术 线路编码机制将输入原始数据转变为接收器可接收的数据格式，同时保证数据流中有足够的时钟信息提供给接收端的时钟恢复电路。线路编码技术提供了一种将数据对齐到字节/字的方法，可以保持良好的直流平衡，增加了数据的传输距离，提供了更为有效的错误检测机制。除此之外，线路编码技术也可以用来实现时钟修正、块同步、通道绑定和将带宽划分到子信道等。 线路编码技术主要有两种：数值查找表机制和自修改
8B10B编解码的Verilog实现
独木舟216的博客
07-04 6603
0. 8B/10B编码原理 8B/10B编码是由IBM公司在1983年所提出的一种编码方式。该编码根据对应的映射码表和极性取值规则把8bit码字编码成10bit来传输。使编码后的二进制序列中，0、1的个数基本均衡。创造这种编码的目的在于解决在高速串行数据传输时，若出现有多个连0或连1，接收端就会出现时钟漂移或同步丢失的问题。而且8B/10B编码可以根据其特定的编码规则，在接收端检测出传输过程中出错的信息。 图1 编码规则 在编码过程中，8bit原始码字被分成两部分：低位5bit记为EDCBA（..
8B10B verilog 实现
qq_31221529的博客
11-30 825
首发自https://hifpga.com/%E9%97%AE%E9%A2%98/37599 8b10_encoder.v module encode (datain, dispin, dataout, dispout) ; input [8:0] datain ; input dispin ; // 0 = neg disp; 1 = pos disp output [9:0] dataout ; output dispout ; wire ai =
【8B10B编解码及verilog（xilinx example）解析】
weixin_43189165的博客
09-21 653
简单介绍8b10b编解码方法
基于FPGA的8B10B编解码程序设计Verilog 开发
weixin_46018688的博客
06-01 1159
部分参考代码 (末尾附文件) module code8_10( input clk, input rst_n, input [7:0] i_data, input i_is_k, output reg [9:0] o_data ); reg dp_out; always@(posedge clk,negedge rst_n) begin if(~rst_n) {dp_out, o_data} <= 0; else {dp_out, o_data} <= dp_data_10
8B10B编解码原理与FPGA代码
qq_53281270的博客
11-09 3272
8B/10B编码将待发送的8位数据转换成10位代码组，其目的是保证直流平衡，以及足够密集的电平转换。
FPGA 8b10b编码。
baidu_34971492的博客
03-25 178
在8b/10b编码中，8位数据被映射成10位代码，其中每个8位的数据块都映射到一个10位的代码中，以便进行传输。数据和控制字符分离： 在8b/10b编码中，从要传输的数据中选取8位，这8位数据通常被称为“数据字符”。总之，8b/10b编码的原理在于通过数据字符到码字的映射，实现了直流平衡、支持控制字符以及一定程度的错误检测与纠正，从而在高速串行通信中发挥重要作用。综上所述，8b/10b编码器的Verilog实现需要遵循8b/10b编码规范，同时考虑到时序逻辑和控制逻辑，以实现数据字符到码字的映射。
fpga的8b10b编码解码器
05-27
FPGA的8b10b编码解码器是一种将8位数据编码成10位数据的技术，它可以用于串行通信中的数据传输。在8b10b编码中，每8位数据会被编码成10位数据，这样可以提高数据传输的可靠性和速率。解码器则是将编码后的10位数据还原成原始的8位数据。FPGA的8b10b编码解码器通常使用Verilog或VHDL进行实现，可以通过FPGA开发板进行验证和测试。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值