【Verilog】汉明码

已于 2023-06-08 14:19:02 修改
阅读量2.3k 收藏 22
点赞数 3
分类专栏： 数字芯片研发 # Verilog 文章标签： c++ Verilog 汉明码 编码与解码
于 2023-06-08 14:15:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44321600/article/details/131106612
版权

文章目录

汉明码

定义
  • 在传输的信息流中插入验证码，侦测单一比特错误
  • 只能发现和修正一位错误，对于两位或两位以上的错误无法发现与修正
校验位个数
  • 2r ≥ k + r + 1
  • 其中：
    • k为数据位
    • r为校验位
编码规则
  • 在新的编码的2(k - 1)( k >= 0)位上填入0（即校验位），把新的编码的其余位把源码按原顺序填入
  • 校验位的编码方式为：
    • 第k位校验码从则从新的编码的第2(k - 1)位开始，每计算2(k - 1)位的异或，跳2(k - 1)位，再计算下一组2(k - 1)位的异或，填入2(k - 1)位
    • 比如：
      • 第1位校验码位于新的编码的第1位(2 (1-1) == 1)（汉明码从1位开始），计算1,3,5,7,9,11,13,15,…位的异或，填入新的编码的第1位
      • 第2位校验码位于新的编码的第2位(2 (2-1) == 2)，计算2,3,6,7,10,11,14,15,…位的异或，填入新的编码的第2位
      • 第3位校验码位于新的编码的第4位(2 (3-1) == 4)，计算4,5,6,7,12,13,14,15,20,21,22,23,…位的异或，填入新的编码的第4位
      • 第4位校验码位于新的编码的第8位(2 (4-1) == 8)，计算8-15,24-31,40-47,…位的异或，填入新的编码的第8位
      • 第5位校验码位于新的编码的第16位(2 (5-1) == 16)，计算16-31,48-63,80-95,…位的异或，填入新的编码的第16位
一个例子
  • 以10101编码为例，创建一个汉明码编码的空间，并且需要将原本数据位的校验位放置于对应位置中
  • 计算校验位数
    • 23 < 5 + 3 + 1
    • 24 ≥ 5 + 4 + 1
    • r = 4
  • 数据位记为P1~P5 = 10101
  • 校验位记为C1~C4
  • 数据输出为：C1C2P1C3P2P3P4C4P5
编码
  • 计算校验位
    • C1 = P1 ^ P2 ^ P4 ^ P5 = 1 ^ 0 ^ 0 ^ 1 = 0
    • C2 = P1 ^ P3 ^ P4 = 1 ^ 1 ^ 0 = 0
    • C3 = P2 ^ P3 ^ P4 = 0 ^ 1 ^ 0 = 1
    • C4 = P5 = 1
  • 插入校验位
    • C1C2P1C3P2P3P4C4P5 = 001101011
解码
  • 假设收到的编码数据为：001101001
  • 计算校验位数
    • 23 < 5 + 3 + 1
    • 24 ≥ 5 + 4 + 1
    • r = 4
  • 2(k - 1)（k = 1, 2, 3, 4）为校验位位置
  • 校验
    • C1 ^ P1 ^ P2 ^ P4 ^ P5 = 0 ^ 1 ^ 0 ^ 0 ^ 1 = 0
    • C2 ^ P1 ^ P3 ^ P4 = 0 ^ 1 ^ 1 ^ 0 = 0
    • C3 ^ P2 ^ P3 ^ P4 = 1 ^ 0 ^ 1 ^ 0 = 0
    • C4 ^ P5 = 0 ^ 1 = 1
  • 将各校验结果逆序排列 = 2’b1000 = 1’d8
  • 则第8位出错，纠正后 = 001101001 -> 001101011
C++实现
功能编写
  • 计算编码校验位
// calculate the number of check digits for encode
auto cal(size_t sz) -> decltype(auto)
{
  decltype(sz) k = 0;
  decltype(sz) cur = 1;
  while (cur - 1 < sz + k)
  {
    cur <<= 1;
    k++;
  }
  return k;
}
  • 编码
// encode
bool encode(const string &data, string &str)
{

  str.clear();
  auto check = cal(data.size());
  str.resize(data.size() + check);

  for (decltype(str.size()) i = 0, j = 0, p = 0; i != str.size(); i++)
  {
    if ((i + 1) == pow(2, p) && p < check)
    {
      str[i] = '0';
      p++;
    }
    else if (data[j] == '0' || data[j] == '1')
    {
      str[i] = data[j++];
    }
    else
    {
      return false;
    }
  }

  for (auto i = 0; i != check; i++)
  {
    int count = 0, index = 1 << i;
    for (auto j = index - 1; j < str.size(); j += index)
    {
      for (auto k = 0; k != index && j < str.size(); k++, j++)
      {
        count ^= str[j] - '0';
      }
      str[index - 1] = '0' + count;
    }
  }

  return true;
}
  • 计算解码校验位
// calculate the number of check digits for decode
auto antical(size_t sz) -> decltype(auto)
{
  decltype(sz) k = 0;
  decltype(sz) cur = 1;
  while (cur < sz)
  {
    cur <<= 1;
    k++;
  }
  return k;
}
  • 解码
// decode
auto decode(string &data, string &str) -> decltype(auto)
{

  data.clear();
  auto check = antical(str.size());
  data.resize(str.size() - check);
  decltype(data.size()) sum = 0;

  for (decltype(check) i = 0; i != check; i++)
  {
    int pAnti = 0;
    decltype(check) index = 1 << i;
    for (decltype(str.size()) j = index - 1; j < str.size(); j += index)
    {
      for (auto k = 0; k < index && j < str.size(); j++, k++)
      {
        pAnti ^= str[j] - '0';
      }
    }
    sum += pAnti << i;
  }

  if (sum != 0)
  {
    str[sum - 1] = (1 - (int)(str[sum - 1] - '0')) + '0';
  }

  for (decltype(str.size()) i = 0, j = 0, k = 0; i != str.size(); i++)
  {
    if ((i + 1) == (1 << j) && j < check)
    {
      j++;
    }
    else
    {
      data[k++] = str[i];
    }
  }

  return sum;
}
测试结果
int main()
{
  string source, dest;
  while (cin >> source)
  {
    if (encode(source, dest))
    {
      cout << "source            : " << source << endl;
      cout << "dest              : " << dest << endl;
    }
    size_t index;
    cout << "input error index : ";
    cin >> index;
    auto check = dest.size();
    if (index != 0 && index <= dest.size())
    {
      dest[index - 1] = (1 - (int)(dest[index - 1] - '0')) + '0';
    }
    cout << "code              : " << dest << endl;
    auto ret = decode(source, dest);
    if (ret == 0)
    {
      cout << "source            : " << source << endl;
      cout << "dest              : " << dest << endl;
    }
    else
    {
      cout << "error index       : " << ret << endl;
      cout << "corret source     : " << source << endl;
      cout << "corret dest       : " << dest << endl;
    }
    cout << endl;
  }
  return 0;
}
  • 结果
    在这里插入图片描述
Verilog实现
.v功能代码
  • 编码
module ham_encoder(
  input  wire        clk,
  input  wire        rst_n,
  input  wire        data_v,
  input  wire [ 7:0] data_in,
  output reg         encode,
  output reg  [11:0] data_out
);

always @ (posedge clk or negedge rst_n) begin
  if (!rst_n) begin
    encode <= 1'b0;
  end else begin
    encode <= 1'b1;
  end
end

always @ (posedge clk or negedge rst_n) begin
  if (!rst_n) begin
    data_out <= 12'b0;
  end else if (data_v) begin
    data_out[11:4] <= data_in[7:0];
    data_out[3]    <= data_in[7]^data_in[5]^data_in[3]^data_in[2];
    data_out[2]    <= data_in[7]^data_in[6]^data_in[4]^data_in[2]^data_in[1];
    data_out[1]    <= data_in[7]^data_in[6]^data_in[5]^data_in[3]^data_in[1]^data_in[0];
    data_out[0]    <= data_in[6]^data_in[4]^data_in[3]^data_in[0];
  end else begin
    data_out <= 12'b0;
  end
end

endmodule
  • 解码
module	ham_decoder(
	input	 wire			   clk,
	input	 wire			   rst_n,
	input	 wire		     data_v,
	input	 wire	[11:0] data_in,
	output reg	[ 7:0] data_out,
	output reg				 decode
);

wire [ 3:0] checkout;
wire [11:0]	data;

always @ (posedge clk or negedge rst_n) begin
  if(!rst_n) begin 
    decode <= 1'd0;
  end else begin
    decode <= 1'b1;
  end
end

assign checkout[3] = data_in[11]^data_in[ 9]^data_in[7]^data_in[6]^data_in[3];
assign checkout[2] = data_in[11]^data_in[10]^data_in[8]^data_in[6]^data_in[5]^data_in[2];
assign checkout[1] = data_in[11]^data_in[10]^data_in[9]^data_in[7]^data_in[5]^data_in[4]^data_in[1];
assign checkout[0] = data_in[10]^data_in[ 8]^data_in[7]^data_in[4]^data_in[0];

assign	data[11] = data_in[11]^( checkout[3]& checkout[2]& checkout[1]&~checkout[0]); 
assign	data[10] = data_in[10]^(~checkout[3]& checkout[2]& checkout[1]& checkout[0]);
assign	data[ 9] = data_in[ 9]^( checkout[3]&~checkout[2]& checkout[1]&~checkout[0]);  
assign	data[ 8] = data_in[ 8]^(~checkout[3]& checkout[2]&~checkout[1]& checkout[0]);   
assign	data[ 7] = data_in[ 7]^( checkout[3]&~checkout[2]& checkout[1]& checkout[0]);   
assign	data[ 6] = data_in[ 6]^( checkout[3]& checkout[2]&~checkout[1]&~checkout[0]);  
assign	data[ 5] = data_in[ 5]^(~checkout[3]& checkout[2]& checkout[1]&~checkout[0]); 
assign	data[ 4] = data_in[ 4]^(~checkout[3]&~checkout[2]& checkout[1]& checkout[0]);  
assign	data[ 3] = data_in[ 3]^( checkout[3]&~checkout[2]&~checkout[1]&~checkout[0]); 
assign	data[ 2] = data_in[ 2]^(~checkout[3]& checkout[2]&~checkout[1]&~checkout[0]); 
assign	data[ 1] = data_in[ 1]^(~checkout[3]&~checkout[2]& checkout[1]&~checkout[0]);
assign	data[ 0] = data_in[ 0]^(~checkout[3]&~checkout[2]&~checkout[1]& checkout[0]);

always @(posedge clk or negedge rst_n) begin
	if (!rst_n) begin
		data_out<= 12'b0;
  end else if(decode) begin
		data_out <= data[11:4];
  end else begin
		data_out <= 12'b0;
  end
end

endmodule
testbench
`timescale  1ns / 1ps
`include "ham_encoder.v"
`include "ham_decoder.v"

module tb_ham;

// edge_detect Parameters
parameter PERIOD  = 10;


// Inputs
reg         clk                                  = 0 ;
reg         rst_n                                = 0 ;
reg         data_v                               = 0 ;
reg  [ 7:0] data_in                                  ;

// Output
wire [11:0] encoder                                  ;
wire        encode                                   ;
wire [ 7:0] decoder                                  ;
wire        decode                                   ;

initial begin
  forever begin
    #(PERIOD) clk = ~clk;
  end
end

initial begin
  #(PERIOD*2) rst_n = ~rst_n;
end

initial begin
  #(PERIOD*2)
  @ (posedge clk)
  data_in = 8'h35;
  data_v  = 1'b1;

  #(PERIOD*2)
  data_in = 8'h0;
  data_v  = 1'b0;
 
end


initial
begin
    $dumpfile("./build/ham.vcd");
    $dumpvars;

    #1000
    $finish;
end

ham_encoder  u_ham_encoder (
    .clk                     ( clk                         ),
    .rst_n                   ( rst_n                       ),
    .data_v                  ( data_v                      ),
    .data_in                 ( data_in   [ 7:0]            ),

    .encode                  ( encode                      ),
    .data_out                ( encoder                     )
);

wire [11:0] err_encoder;
assign err_encoder = {encoder[11:1], ~encoder[0]};

ham_decoder  u_ham_decoder (
    .clk                     ( clk                         ),
    .rst_n                   ( rst_n                       ),
    .data_v                  ( encode                      ),
    .data_in                 ( err_encoder                 ),

    .data_out                ( decoder[ 7:0]               ),
    .decode                  ( decode                      )
);


endmodule
波形

在这里插入图片描述

秃头仔仔
关注
  • 3
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
verilog语言实现汉明、卷积编解码与2FSK调制解调
12-11
利用verilog语言编写的卷积编解码、汉明编解码和2FSK调制解调模块。使用的是（7,4）汉明码以及（2,1,3）卷积码，解码是viterbi译码。
Verilog数字系统基础设计-检错与纠错（汉明码、BCH编码等）
OpenFPGA的博客
08-25 6164
Verilog数字系统基础设计-检错与纠错（汉明码、BCH编码等）在过去的50到60年中，检错与纠错技术有了长足的发展。现今我们对检错和纠错理论有了更好的理解，并且该理论还在不断的发展。编...
汉明码(海明码)的计算的规则
最新发布
m0_74459049的博客
05-24 983
汉明码(海明码)的计算的规则
汉明码(海明码)解析
m0_51723227的博客
12-08 1万+
相信使用过光盘的读者都会有这样一种经历,如果不小心刮花了盘面,大部分情况下,把它放进DVD机器却仍然可以播放视频,这是为什么呢?什么意思呢?假设光盘存储的内容为:,那么实际光盘会有三份这样的内容,假设我们在光盘某个位置刮花了,即二进制数据可能被修改了,那么当进行播放前,会将三份内容按照下面规则进行排列检验: 但是这样就会比较浪费存储空间,因为要存储一份内容,却要多花两倍空间,那怎么解决呢?这就是本文将要引入的汉明码问题解析;它所需要的检验错误的空间,只占整个内容的非常小一部分,它怎么实现的呢?我们慢慢道来在
【通俗易懂的通信】信道编码之——汉明码
热门推荐
Norstc的博客
10-28 3万+
一、什么是汉明码（hamming code） “汉明码”，也称作“海明码”，英文名为“hanming code”，在通信领域中，“汉明码”有广泛的应用，由理查德·卫斯里·汉明于1950年发明。“汉明码”是一种“错误纠正码”，可以用来检测并且纠正数据从发送端发往接收端中发生的错误。 汉明码的发明者理查德汉明在1940年代晚期，运用贝尔模型V（Bell Model V）电脑于贝尔实验室（Bell Labs）工作。输入端是依靠打孔卡（Punched Card），这不免会造成些读取错误。在工作日，当机器检测到错
汉明码---存储器校验（简单易懂详解）
gl620321的博客
05-10 9579
存储器校验 1.对存储器校验的原因： 以内存为例，内存是电子设备，信息保存在电容当中，若采用静态RAM，则是保存在四管的触发器当中，若内存所处的电磁环境比较复杂，或在空间环境下受到带电粒子的打击，可能造成电容的充放电或触发器的翻转，存在在存储器的信息可能会出错 2.编码的检测能力和纠错能力与任意两组合法代码之间二进制的最少差异数有关 差异的位数越多，检错能力和纠错能力就越强 若只差一位，既不能检错，也不能纠错 若相差两位，可以检1位错，纠0位错 若相差三位，可以检1位错，纠1位错 3.编码的最小距
FPGA实现汉明码的编解码
weixin_44422853的博客
07-13 651
FPGA的汉明码
海明码（汉明码）详解
InterestAndFun的博客
04-11 2万+
海明码简介 海明码是由Richard Hanming于1950年提出的，它具有一位纠错能力。 海明码的计算 设欲检测的二进制代码为n位，为使其具有纠错能力，需要添加k位检测位，组成n+k位的代码。为了能准确对错误定位以及指出代码没错，新添加的检测位数k应满足：2k ≥ n+k+1 由此关系可求得不同代码长度n所需要检测位的位数k。 海明码的编码规则如下： 设k个校验位为Pk,Pk-1,·····,P1， n个数据位为 Dn-1,Dn-2,·····,D1,D0，对应的海明码为Hn+k,Hn+k-1,····
Verilog汉明码编解码客.mhtml
08-23
Verilog汉明码编解码客.mhtml
Verilog汉明码
09-13
计算机结构与逻辑设计课程 ，基于Verilog的汉明码设计。
Verilog汉明码的编译设计
04-13
使用m序列发生器，产生输入信号，经过串并转换为汉明码编码器的输入，得到汉明码编码。再随机产生错误，输入到汉明码译码器中，得到正确输出。经过并串转换，得到输出信号。
基于FPGA的verilog实现8位到16位汉明码编码
07-12
基于Cyclone,通过verilog语言实现8位数据转16位的汉明码。
基于Cyclon的verilog实现汉明码解码
07-12
通过verilog语言实现汉明码的解码，并已经通过调试，在Cyclon的实验板上调试成功~~希望能对大家有所帮助
基于Verilog对m序列进行汉明码编译码(附仿真)
04-22
用Verilog语言编写的对m序列进行汉明码编译码的程序。具体实现为产生m序列后对其进行(7,4)汉明码编码并加错，然后将其纠错译码并输出，详细过程见仿真。
自动生成汉明码
12-28
输入原码，将会自动生成加入了汉明码的已经加密的密码
用Verilog HDL编写的汉明码校验
04-21
用Verilog HDL编写的汉明码校验、 此只是一个试验
汉明码编码
asscwf的博客
04-20 3384
汉明码是用来校验存储器传输数据是否正确的一种编码方式。 汉明码具有一位纠错能力。 汉明码需要在原有数据位上增加一定数据位进行校验。 设数据为 n 位，则需要增加 k 位校验位。公式：2^k>=n+k+1 数据在计算机中用二进制表示，故将汉明码增加在2^k位置上使得每组测试数据中该位置一样。 故得测试小组： C1: 1，3，5，7，9，11……位 （符合XXXX1) C2：2，3，6，7，10，11……位（符合XXX1X) C3：4，5，6，7，12，13……位（符合XX1XX) ..
汉明编码及其应用——你看这一篇就够了！！！！
weixin_44750790的博客
06-10 1万+
学习了汉明码后一点总结，真的是汉明这个人，太强了。看完就一个感觉，真是妙蛙种子吃着妙脆角妙进妙妙屋妙到家了
【FPGA Verilog】扩展汉明码(16,11) BCH(16,11) eHamming_n16_k11
凡森
04-29 868
标题MATLAB仿真编码代码版本一解码 MATLAB仿真 编码 代码版本一 eHamming_n16_k11_encoder `timescale 1ns / 1ps ////////////////////////////////////////////////////////////////////////////////// // Company: // Engineer: // // Create Date: 2022/04/29 09:49:51 // Design Name: // Mo

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值