精华内容
下载资源
问答
  • 编码原理相关个人自学笔记,参考中国地质大学在中国大学慕课上的《信息论与编码》网课
  • (7,4)(63,45)纠错码的生成矩阵和校验矩阵的C++实现
  • 校验矩阵和低密度奇偶校验码的构造方法 摘要 - 低密度奇偶校验(LDPC)码是具有稀疏奇偶校验矩阵的线性分组码。 在本文中,给出了用于生成LDPC码的一些构造方法的简要描述。 这些方法通常分为两类:随机和分析。 ...

    偶校验矩阵和低密度奇偶校验码的构造方法

    摘要 - 低密度奇偶校验(LDPC)码是具有稀疏奇偶校验矩阵的线性分组码。 在本文中,给出了用于生成LDPC码的一些构造方法的简要描述。 这些方法通常分为两类:随机和分析。 随机构造的代码包括来自Gallager和Mackay的代码。 所描述的分析构造方法是来自有限几何形状的代码。 一种类型是根据Gallager的原始处方随机构建的。 另一个是从欧几里德和投影几何分析建立的。 可以使用基于似然差的解码算法来检查它们的性能。

    1.引言

    LDPC码概述

    在信息论中,Shannon的信道编码定理被认为是刺激了错误控制码的发展。 它表明,所有数据速率rb小于信道容量C的,都可以实现任意小的误差概率Pe,其中C由Shannon-Hartley公式[1]给出:
    ܥ(1.1)C=Blog2[S/N](Bitspersecond)C = B log_2 [S/N] \quad (Bits per second) \tag{1.1}
    这里,B是以Hz为单位的信道带宽,S / N是信噪比(SNR)。 SNR与“比特能量与单侧噪声功率谱密度比”有关
    (1.2)SN=rbEbBN0=rbB×EbN0\frac{S}{N}= {r_bE_b\over BN_0}= {r_b\over B}×{E_b\over N_0}\tag{1.2}
    使用公式(1.2),公式(1.1)可以写成:
    (1.3)CB=log2(1+(ηmaxEbN0))\frac{C}{B}= log_2(1+(η_{max}{E_b\over N_0}))\tag{1.3}
    或者
    (1.4)EbN0=2ηmax1ηmax\frac{E_b}{N_0}= \frac{2^{η_{max}}-1}{η_{max}}\tag{1.4}
    等式(1.4)被称为香农极限。 它提供所需的Eb / N0,以接近信道容量的速率传输数据。 该限制始终用作评估编码调制方案的基准。 据报道,Turbo码和LDPC码的性能非常接近香农极限[2]
    LDPC码,也称为Gallager码,是由Gallager在60年代早期设计的[3]。 作为一类线性分组码,它们通过稀疏二进制奇偶校验矩阵来区分。在每个矩阵中,每一行有固定的(j)个1,每列也有固定(k)个1。 然而,当时,计算能力还不足以显示它们的有效性,因此LDPC代码直到最近才被遗忘[2]。Mackay和Neal被称为“重新发现”Gallager代码,他们指出了使用基于和积算法的解码算法的代码的出色功能[4]
    从Gallager的原始处方中,Luby等人通过引入不规则代码标志了LDPC码的重要进展[5]。 LDPC码的另一个进步是由Davey和Mackay在GF(q)(q> 2)上引入不规则码。 在[6]中,这类LDPC码显示出比GF(2)中的代码具有显着改进的性能。

    2. LDPC代码的构建

    在这一部分中,我们描述了一些常规和不规则LDPC码的结构。 用于构造LDPC码的奇偶校验矩阵的方法分为两大类:随机和分析方法。但是,根据Johnson和Weller [10],随机构造方法仍然占主导地位,因为分析创建的LDPC代码只占很小的一部分。 已经表明,如果Tanner图没有周期,迭代和积解码算法可以收敛于最优解[8]。 较短的周期将使算法恶化。
    下面介绍了处理LDPC码构造的一些有用概念
    Tanner图:Tanner图用于表示线性分组码的码字比特和奇偶校验比特之间的关系。 Tanner图已被推广成因子图[7]。
    循环:Tanner图中的循环是一系列连接的码字节点和奇偶校验节点,它们在同一节点处开始和结束,并且序列中不会出现多次其他节点。
    长度:循环的长度是循环中的边数。
    周长:Tanner图的周长是其最短周期的长度。
    度:Tanner图中节点的度数是连接到它的边数。
    图1和2分别示出了长度为4和长度为6的两个周期,以及它们对应的奇偶校验矩阵
    在这里插入图片描述
    码字顶点和奇偶校验顶点的作用在形成周期中是相等的。 因此,使用I或其转置,IT作为奇偶校验矩阵将创建相同的循环集。
    特别是,对于长度为4的周期情况,下面的三个语句对于LDPC代码是等效的:
    Tanner图中没有长度为4的循环。
    任意两行之间的重叠1的数量小于2.
    任意两列之间的重叠1的数量小于2.
    这些备注将用于简化与LDPC码的周期长度和周长相关的证明,以及 在检查模拟程序中的重叠时也是如此。

    3.随机构造的代码

    A. Gallager的处方

    在Gallager [3]的原始论文中,LDPC码被定义为一种线性块码,其奇偶校验矩阵H是稀疏矩阵,即主要包含0,只有少量1的矩阵。 此外,在此矩阵中,每行具有相同数量的1,并且每列具有相同数量的1。 特别地,Gallager将(n,j,i)LDPC码定义为具有块长度n,奇偶校验矩阵中每列1的数量为j,每行1的数量为i的代码。 这种类型的奇偶校验矩阵如图3所示
    在这里插入图片描述
    该矩阵可以分成三个相等的子矩阵,例如:每列的权重为1,如图3所示。第一个子矩阵是一个特殊的矩阵:1以向下的方式放置,整个子矩阵看起来像一个单位矩阵,每列重复四次。事实上,子矩阵只需要是这种特殊结构的随机列排列。还可以容易地看出,第一子矩阵(或任何后续子矩阵)的随机列置换将在每行中恰好具有四个1并且在每列中具有单个1。反之亦然,每行中具有四个1并且每列中具有单个1的任何(5×20)子矩阵仅是第一子矩阵的列置换。 图4给出了这种奇偶校验矩阵的表示[2]。
     。
    图4具有行权重4和列权重3的Gallager结构的表示。具有对角线的正方形表示单位矩阵。 带箭头的椭圆表示随机列排列。
    通常,(n,j,i)矩阵可以被划分为列权重为1的j个子矩阵。(n,j,i)矩阵的行数由nj / i给出(j是 每列中的1的数量,因此1的总数是nj,并且i是每行中1的数量)。 因此,每个子矩阵将具有n / i行。
    考虑到LDPC码作为一种线性块码,我们可以如下计算(n,j,i)LDPC码的码率R:首先,假设H的所有行是线性独立的(或者H是满秩) ),H的等级(以模2算术计算)将与行数J相同,其为nj / i(J <n,即J = nk)。 然后,生成矩阵G的维数为(n-nj / i)×n(j <i为J <n),码率R为
    R=(nnj/i)/n=1j/i.R = (n-nj/i)/n = 1 – j/i.
    当H的行不是线性独立的时,H的秩将小于nj / i,并且G的行数将大于n-nj / i,这导致R> 1-j / i。 所以,一般来说,我们有:
    (1.5)Rnnjin=1jiR≥ \frac{n-n{j\over i}}{n}= 1-\frac{j}{i}\tag{1.5}

    B. Mackay’s构建

    LDPC码的Tanner图中存在短周期将降低迭代解码算法。 考虑图5中给出的Tanner图的部分。
    在这里插入图片描述
    图5长度为4的周期及其对迭代解码算法的影响
    三个噪声符号连接到五个校验符号,如图5所示。长度为4的循环由粗线绘制。 如果所有这三个噪声符号都是错误的(从1变为0或反之亦然),则只能警告最右边的检查(s5)。根据Davey的说法,这种情况会降低解码过程的性能[2]。

    展开全文
  • 使用矩阵进行编码解码 学科:编码理论 一种使用用户提供的生成器或奇偶校验矩阵对数据进行编码解码的程序。
  • 该文件可用于描述如何在没有手动生成矩阵的情况下对消息进行编码。 提供了一个取自 IEEE 802.11n 标准的示例矩阵。 如果你想使用不同的,它必须是下三角形式。 该算法取自论文:T. Richardson R. Urbanke。 ...
  • 线性分组码: 一个线性分组码的生成矩阵G,相应的系统生成矩阵Gs,一致校验矩阵为Hs。求其线性分组码.
  • 本文介绍了格码低密度格码的基本理论,提出了一种新的构造八环拉丁方LDLC奇偶校验矩阵的算法。在八环构造算法中,首先利用排列矩阵生成一个六环的矩阵;然后通过邻接矩阵的相关理论来检测消除该矩阵中所有的六环,...
  • 生成 LDPC 矩阵而编写的程序,如研究论文“具有低密度奇偶校验的时变周期卷积码”中所讨论的那样。 矩阵”,作者 Alberto jiménez Felström Kamil Sh. zigangirov IEEE 信息论汇刊,第 45 卷,1999 年 9 月 6...
  • LDPC仿真程序

    2016-12-09 18:36:59
    包含802.11n标准和CCSDS标准中的LDPC码校验矩阵和生成矩阵的生成和仿真
  • 对于正整数n,[p,s] = permn(n)以矩阵[size- [factorial(n),n]的形式返回1:n的所有排列,还返回排列奇偶数size- [factorial( n),1]。 s(j)对于偶数排列p(j,:)为+1,对于奇数排列为-1。
  • MATLAB的M函数,利用高斯消去法编码,输出校验矩阵和生成矩阵
  • 使用两个12×24原型矩阵生成第一级代码C 0的奇偶校验矩阵H 0 。通过使用Z = n / 24的Z-by-Z矩阵替换条目,将每个原型矩阵转换为二进制矩阵。操作如下。元素-1代表零矩阵。元素0表示一个单位矩阵I。并且正元素指示...
  • 使用方法:设置相应参数,运行LDPC_Simulation,可自动生成并绘制校验矩阵生成矩阵。同时Monte Carlo仿真将运行,并将结果保存在文本文档内。Monte Carlo 仿真会消耗大量时间。(效率较低不建议用做误码率仿真) 2...
  • 该程序可以模拟具有准圆形生成器矩阵和1/2码率的快速Tanner LDPC编解码器。... 当前版本发布时间:2010-11-5 在我接下来的书中,我... 现有的 Tanner 码无法导出准圆形生成矩阵,我们修改了 Tanner 码的奇偶校验矩阵 [1,2]
  • 有任何疑问问题欢迎大家提出来,一起学习,相互监督,共同进步! 需求:题型包含:单选题、多选题、文本框、矩阵题型 实现功能的相关技术:vue(router,axios,element-ui) 实现结果大致如下:几种常见的题型,表单...

    有任何疑问和问题欢迎大家提出来,一起学习,相互监督,共同进步!

    需求:题型包含:单选题、多选题、文本框、矩阵题型

    实现功能的相关技术:vue(router,axios,element-ui)

    实现结果大致如下:几种常见的题型,表单校验,以及提交给后端的表单数据
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述

    具体实现方案

    1、利用mock出来的json数据,进行问卷调查表单的渲染。一个问卷表单包含多个不同类型的问题。大体的json格式如下,包含问卷的一些的信息questionNaire,以及最重要的是,渲染问卷的题目(formList数组):

    在这里插入图片描述

    由于整个json比较长的原因,下面我们依次详细看下常用题型的json格式:

    单选题
    在这里插入图片描述
    post:用于后面进行表单提交的字段名,
    type:题目的类型,
    label:题目的标题,
    option:题目的选项,label用于页面渲染,value用于表单提交

    多选题

    在这里插入图片描述

    多行文本框:

    在这里插入图片描述
    矩阵题型:
    在这里插入图片描述
    2、代码目录结构如下:
    在这里插父图片描述
    3、父子关系如下:
    在这里插入图片描述
    QuestionForm.vue是QuestionContent.vue的父组件,QuestionContent.vue是FormItem.vue的父组件,FormItem.vue是el-input、el-radio、el-date…的父组件。

    4、下面依次看下各个vue设计的思路以及具体的代码

    a、首先是QuestionForm.vue,代码如下:
    在这里插入图片描述
    这个vue主要是用来获取json数据(_getForm方法),然后把数据传给子组件。
    data用于表单提交

    _getForm代码如下:
    在这里插入图片描述

    如果类型是checkbox或者table,把data里面对应的postName值设置为[],提交给后端的是一个数组类型

    b、其次是QuestionForm.vue,代码如下:
    在这里插入图片描述
    props:用来接收父组件(QuestionContent.vue)传给子组件的数据;
    $emit:自动触发父组件中的自定义事件’on-submit’
    el-form:ref属性用于表单提交。element-ui自带一个validate方法,如果验证成功,则提交表单数据

    c、其次是FormItem.vue,代码如下
    在这里插入图片描述
    prop:用于表单提交给后端的字段名
    rules:字段验证
    component:根据题目类型判断,展示对应的组件。里面包含传给子组件的数据post,options,label,ruleForm,tableData

    d、最后是el-radio.vue等组件

    在这里插入图片描述
    i.考虑了单选项值为图片的场景。这边功能可以实现,但感觉后期还需要优化
    ii.v-model:填写的值与ruleForm[post]相互绑定。这里的ruleForm[post]追踪到最开始父组件QuestionForm.vue。最终提交给后端的data类似于{“sex”:2}

    在这里插入图片描述
    i.考虑选项有其他文本框。
    ii.v-model:填写的值与ruleForm[post]相互绑定。这里的ruleForm[post]追踪到最开始父组件QuestionForm.vue。最终提交给后端的data类似于{“productFunction”:[1,2,3]}

    在这里插入图片描述
    v-model:填写的值与ruleForm[post]相互绑定。这里的ruleForm[post]追踪到最开始父组件QuestionForm.vue。最终提交给后端的data类似于{“advice”:“ssee”}

    在这里插入图片描述
    i.考虑到矩阵类型由单选和多选两种情况。
    ii.v-model:填写的值与ruleForm[post]相互绑定。这里的ruleForm[post]追踪到最开始父组件QuestionForm.vue。最终提交给后端的data类似于{“tableRadio”:
    [{
    {“apperance”:“baidu”},{“checked”:[true,false,false]},{“chooseType”:“radio”},{“label”:“one”}
    },{
    {“apperance”:“sogou”},{“checked”:[false,tue,false]},{“chooseType”:“radio”},{“label”:“three”}
    },{
    {“apperance”:“google”},{“checked”:[false,tue,false]},{“chooseType”:“radio”},{“label”:“two”}
    }
    ]}

    getCurrentColumn代码如下:
    在这里插入图片描述
    改方法主要用与:修改数据绑定的值ruleForm[post]

    大概的设计思路如上,其实在做的过程中,遇到很多很细的问题,如有疑问,欢迎大家提出!同样,有不合理或者可以优化的地方,也欢迎大家指正!

    展开全文
  • 从编码的数学原理出发,分析CRC的编码本质、生成校验矩阵、最小码重等参推导了编码应用中的检错概率、漏检错误概率结论给出了利用CRC纠正单比特错误的实现算法仿真性能.
  • 仿真(7,4)Hamming码的编码及硬判决译码过程。 %仿真(7,4)Hamming码的编码及硬判决译码过程 clear all ... %产生一个(n,n-m)Hamming码的校验矩阵和生成矩阵 x = randi([0,1],N,n-m); %产生比特数据 y =

    仿真(7,4)Hamming码的编码及硬判决译码过程。

    %仿真(7,4)Hamming码的编码及硬判决译码过程
    clear all
    N = 10;          %信息比特行数
    n = 7;           %Hamming码组长度n=2^m-1
    m = 3;           %监督位长度
    [H,G] = hammgen(m);            %产生一个(n,n-m)Hamming码的校验矩阵和生成矩阵
    x = randi([0,1],N,n-m);        %产生比特数据
    y = mod(x*G,2);                %Hamming编码
    y1 = mod(y+randerr(N,n),2);    %在每一个编码码组中引入一个随机比特错误
    mat1 = eye(n);                 %生成n*n的单位矩阵,其中每一行的1代表错误比特位置
    errvec = mat1*H';              %校验结果对应的所有错误矢量
    y2 = mod(y1*H',2);             %译码
    %根据译码结果对应的错误矢量找出错误比特位置,并纠错
    for index = 1:N
        for index1 = 1:n
            if(y2(index,:) == errvec(index1,:))
                y1(index,:) = mod(y1(index,:)+mat1(index1,:),2);
            end
        end
    end
    x_dec = y1(:,m+1:end);         %恢复原始信息比特
    s = find(x ~= x_dec)           %纠错后的信息比特与原始信息比特对比
    

    具体理论与分析:
    https://blog.csdn.net/qq_43520653/article/details/111407766
    案例2:仿真未编码和进行(7,4)Hamming码的编码的QPSK调制通过AWGN信道后的误比特性能比较
    https://editor.csdn.net/md/?articleId=111461238

    展开全文
  •  2.1 校验矩阵和生成矩阵   2.1.1 校验矩阵   2.1.2 生成矩阵   2.1.3 系统编码   2.2 重量和距离   2.3 线性分组码的译码   2.4 分组码的最小距离界   2.4.1 Hamming(汉明)球包...
  • 计算编码电路中使用的数据矩阵和crc矩阵。 需要生成多项式(以十六进制形式),数据宽度和crc宽度作为输入。 计算在解码器-校正器电路中使用的错误位置图。 输入要求是相同的。 自动生成用于编码器和解码器功能模块...
  • 提出了基于GF(q)上缩短RS...该方法能够从结构上避免校验矩阵中环4结构的出现,并且提出了码字矩阵、码字候选矩阵和码元候选矩阵的构造方法;给出了码字矩阵一些性质的构造性证明,这些性质对于消除环4结构至关重要。
  • 主要改进是将QC-LDPC码QC-MDPC码的奇偶校验矩阵结合作为私钥,生成两者的级联码字应用于McEliece变型方案,并且给出了改进的译码算法。分析表明在80 bit安全参数下该体制密钥量小且实现的复杂度低,能抵抗最近提出...
  • 在进行数据校验时我们会使用到crc(循环冗余校验校验的方式,例如在以太网通信网络中会对信息进行编码和校验生成码采用的就是33位的 crc-32:x32+x26+x23+...+x2+x+1; (104c11db7)。循环冗余校验码的计算是模2...

    在进行数据校验时我们会使用到crc(循环冗余校验)校验的方式,例如在以太网通信网络中会对信息进行编码和校验,生成码采用的就是33位的

    crc-32:x32+x26+x23+...+x2+x+1; (104c11db7)。循环冗余校验码的计算是模2的除法运算。模2指的是运算的时候不进行借位和进位的操作。可以用下面的例子来说明。假如信息码为11011,生成码为101(2+1)则校验码的计算过程是

    先把信息码左移两位(二进制),得1101100。

    然后通过异或操作

    1101100

    101

    ---------

     111100

     101

    ---------

     010100

      101

    --------

      00000

    这个计算结果为00

    假如信信息码为1100时,余码就是01

    110000

    101

    ----

    010000

     101

    --------

     00100

       101

    ------

       001

    所以根据上面的运算可以得出任何信息码的余码。

    一般使用线性反馈移位寄存器LFSR或(LFSR2)来进行物理实现。这两种方式结构如下:

    本篇文章我使用的是LFSR2结构,假如使用LFSR结构需要在先输入n位的0(n是冗余码的位数)。为简单起见推导过程使用的4位信息码,8位的冗余码,生成式为P={p7,p6,p5,p4,p3,p2,p1,p0},初始余码为X0={x0(7),x0(6),x0(5),x0(4),x0(3),x0(2),x0(1),x0(0)}。输入数据D={d3,d2,d1,d0};

    则当输入一位d3时表达式;+表示异或

    x1(7)=x0(6)+p7(x0(7)+d3)=p7x0(7)+x0(6)+p7d3;

    x1(6)=x0(5)+p6(x0(7)+d3)=p6x0(7)+x0(5)+p6d3;

    x1(5)=x0(4)+p5(x0(7)+d3)=p5x0(7)+x0(4)+p5d3;

    x1(4)=x0(3)+p4(x0(7)+d3)=p4x0(7)+x0(3)+p4d3;

    x1(3)=x0(2)+p3(x0(7)+d3)=p3x0(7)+x0(2)+p3d3;

    x1(2)=x0(1)+p2(x0(7)+d3)=p2x0(7)+x0(1)+p2d3;

    x1(1)=x0(0)+p1(x0(7)+d3)=p1x0(7)+x0(0)+p1d3;

    x1(0)=p0(x0(7)+d3)=p0x0(7)+p0d3;

    X1'=FX0'+P'd3;其中

    F={ p7,1,0,0,0,0,0,0

         p6,0,1,0,0,0,0,0

       p5,0,0,1,0,0,0,0

       p4,0,0,0,1,0,0,0    

       p3,0,0,0,0,1,0,0

       p2,0,0,0,0,0,1,0

       p1,0,0,0,0,0,0,1

       p0,0,0,0,0,0,0,0}

    同样可以得X2'=FX1'+P'd2;

              X3'=FX2'+P'd1;

         X4'=FX3'+P'd0;

    进而得X4'=F*F*F*F*X0+{F*F*F*P',F*F*P',F*P',P'}*D';

    所以输入四位数据时最后余码的状态与初始的状态有关。

    对于任意的n位并行信息码Xn=Fn*X0+{F(n-1)p'.....p'}D'。

    下面是用表格对8位信息码,32位余码,生成码为0x04c11db7;

    参考Excel表格。最后的结果为(左边为低位x0~x31)

    以下为在verilog中的验证代码:

      1 module arc_8(input clk,output reg [31:0] crc);
      2 reg [4:0]count=0;
      3 reg [31:0] fcs_temp,datatemp2;
      4 reg [31:0] R ;
      5 reg[2:0] step=0;
      6 reg [7:0]data_count=0;
      7 reg [2:0] num=0;
      8 reg on=1;
      9 reg [7:0] datatemp;
     10 always@(posedge clk)
     11 begin 
     12         case(step)
     13             0:begin if(on) step<=1;else step<=0;R<=0;end 
     14             1:begin         
     15                                             if(data_count<126)begin // 主要是第一个循环0x60e84e34,验证的结果应该为0x7db9cbc8
     16                                             case(num)
     17                                                 0:begin datatemp<=8'h60;num<=1;on<=1;end
     18                                                 1:begin datatemp <=8'he8;num<=2;end
     19                                                 2:begin datatemp<=8'h4e;num<=3;end 
     20                                                 3:begin datatemp<=8'h34;num<=0;data_count<=data_count+1;end 
     21                                         endcase 
     22                                         step<=3;end
     23                                     else begin on<=0; step<=6;end end
     24             3:begin     step<=4;
     25                             //00100000100000000000000000000000
     26                             fcs_temp[31]<=R[23]^R[29];
     27                             //10010000010000000000000000000000
     28                             fcs_temp[30]<=R[22]^ R[28]^R[31];
     29                             //11001000001000000000000000000000
     30                             fcs_temp[29]<=R[21]^ R[27]^R[30]^R[31];
     31                             //01100100000100000000000000000000
     32                             fcs_temp[28]<=R[20]^R[26]^R[29]^R[30];
     33                             //10110010000010000000000000000000
     34                             fcs_temp[27]<=R[19]^R[25]^R[28]^R[29]^R[31];
     35                           //01011001000001000000000000000000
     36                           fcs_temp[26]<= R[18]^R[24]^R[27]^ R[28]^ R[30];
     37                             //00001100000000100000000000000000
     38                             fcs_temp[25]<=R[17]^R[26]^R[27];
     39                             //10000110000000010000000000000000
     40                             fcs_temp[24]<=R[16]^R[25]^R[26]^R[31];
     41                             //01000011000000001000000000000000
     42                             fcs_temp[23]<=R[15]^R[24]^R[25]^R[30];
     43                             //00000001000000000100000000000000
     44                             fcs_temp[22]<=R[14]^R[24];
     45                             //00100000000000000010000000000000
     46                             fcs_temp[21]<=R[13]^R[29];
     47                             //00010000000000000001000000000000
     48                             fcs_temp[20]<=R[12]^ R[28];
     49                             //10001000000000000000100000000000
     50                             fcs_temp[19]<=R[11]^R[27]^ R[31];
     51                             //11000100000000000000010000000000
     52                             fcs_temp[18]<=R[10]^ R[26]^R[30]^R[31];
     53                             //01100010000000000000001000000000
     54                             fcs_temp[17]<=R[ 9]^R[25]^R[29]^R[30];
     55                             //00110001000000000000000100000000
     56                             fcs_temp[16]<=R[ 8]^R[24]^R[28]^R[29];
     57                             //10111000000000000000000010000000
     58                             fcs_temp[15]<=R[ 7]^R[27]^R[28]^R[29]^R[31];
     59                             //11011100000000000000000001000000
     60                             fcs_temp[14]<=R[ 6]^R[26]^R[27]^R[28]^R[30]^R[31];
     61                             //11101110000000000000000000100000
     62                             fcs_temp[13]<=R[ 5]^R[25]^R[26]^R[27]^ R[29]^ R[30]^ R[31];
     63                             //01110111000000000000000000010000
     64                             fcs_temp[12]<=R[ 4]^R[24]^R[25]^R[26]^R[28]^R[29]^R[30];
     65                             //00011011000000000000000000001000
     66                             fcs_temp[11]<=R[ 3]^R[24]^R[25]^R[27]^R[28];
     67                             //00101101000000000000000000000100
     68                             fcs_temp[10]<=R[ 2]^R[24]^R[26]^R[27]^R[29];
     69                             //00110110000000000000000000000010
     70                             fcs_temp[9]<=R[ 1]^R[25]^R[26]^R[28]^R[29];
     71                             //00011011000000000000000000000001
     72                             fcs_temp[8]<=R[ 0]^R[24]^R[25]^R[27]^R[28];
     73                             //10101101000000000000000000000000
     74                             fcs_temp[7]<=R[24]^R[26]^R[27]^R[29]^R[31];
     75                             //11110110000000000000000000000000
     76                             fcs_temp[6]<=R[25]^R[26]^R[28]^R[29]^R[30]^R[31];
     77                             //11111011000000000000000000000000
     78                             fcs_temp[5]<=R[24]^R[25]^R[27]^R[28]^R[29]^R[30]^R[31];
     79                             //01011101000000000000000000000000
     80                             fcs_temp[4]<=R[24]^R[26]^R[27]^R[28]^R[30];
     81                             //10001110000000000000000000000000
     82                             fcs_temp[3]<=R[25]^R[26]^R[27]^R[31];
     83                             //11000111000000000000000000000000
     84                             fcs_temp[2]<=R[24]^R[25]^R[26]^R[30]^R[31];
     85                             //11000011000000000000000000000000
     86                             fcs_temp[1]<=R[24]^R[25]^R[30]^R[31];
     87                             //01000001000000000000000000000000
     88                             fcs_temp[0]<=R[24]^R[30];end
     89     
     90             4:begin     step<=5;
     91                                 datatemp2[31]<=datatemp[ 5];
     92                                 datatemp2[30]<=datatemp[ 4]^datatemp[ 7];
     93                                 datatemp2[29]<=datatemp[ 3]^datatemp[ 6]^datatemp[ 7];
     94                                 datatemp2[28]<=datatemp[ 2]^datatemp[ 5]^datatemp[ 6];
     95                                 datatemp2[27]<=datatemp[ 1]^datatemp[ 4]^datatemp[ 5]^datatemp[ 7];
     96                                 datatemp2[26]<=datatemp[ 0]^datatemp[ 3]^datatemp[ 4]^datatemp[ 6];
     97                                 datatemp2[25]<=datatemp[ 2]^datatemp[ 3];
     98                                 datatemp2[24]<=datatemp[ 1]^datatemp[ 2]^datatemp[ 7];
     99                                 datatemp2[23]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 6];
    100                                 datatemp2[22]<=datatemp[ 0];
    101                                 datatemp2[21]<=datatemp[ 5];
    102                                 datatemp2[20]<=datatemp[ 4];
    103                                 datatemp2[19]<=datatemp[ 3]^datatemp[ 7];
    104                                 datatemp2[18]<=datatemp[ 2]^datatemp[ 6]^datatemp[ 7];
    105                                 datatemp2[17]<=datatemp[ 1]^datatemp[ 5]^datatemp[ 6];
    106                                 datatemp2[16]<=datatemp[ 0]^datatemp[ 4]^datatemp[ 5];
    107                                 datatemp2[15]<=datatemp[ 3]^datatemp[ 4]^datatemp[ 5]^datatemp[ 7];
    108                                 datatemp2[14]<=datatemp[ 2]^datatemp[ 3]^datatemp[ 4]^datatemp[ 6]^datatemp[ 7];
    109                                 datatemp2[13]<=datatemp[ 1]^datatemp[ 2]^datatemp[ 3]^datatemp[ 5]^datatemp[ 6]^datatemp[ 7];
    110                                 datatemp2[12]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 2]^datatemp[ 4]^datatemp[ 5]^datatemp[ 6];
    111                                 datatemp2[11]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 3]^datatemp[ 4];
    112                                 datatemp2[10]<=datatemp[ 0]^datatemp[ 2]^datatemp[ 3]^datatemp[ 5];
    113                                 datatemp2[9]<=datatemp[ 1]^datatemp[ 2]^datatemp[ 4]^datatemp[ 5];
    114                                 datatemp2[8]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 3]^datatemp[ 4];
    115                                 datatemp2[7]<=datatemp[ 0]^datatemp[ 2]^datatemp[ 3]^datatemp[ 5]^datatemp[ 7];
    116                                 datatemp2[6]<=datatemp[ 1]^datatemp[ 2]^datatemp[ 4]^datatemp[ 5]^datatemp[ 6]^datatemp[ 7];
    117                                 datatemp2[5]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 3]^datatemp[ 4]^datatemp[ 5]^datatemp[ 6]^datatemp[ 7];
    118                                 datatemp2[4]<=datatemp[ 0]^datatemp[ 2]^datatemp[ 3]^datatemp[ 4]^datatemp[ 6];
    119                                 datatemp2[3]<=datatemp[ 1]^datatemp[ 2]^datatemp[ 3]^datatemp[ 7];
    120                                 datatemp2[2]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 2]^datatemp[ 6]^datatemp[ 7];
    121                                 datatemp2[1]<=datatemp[ 0]^datatemp[ 1]^datatemp[ 6]^datatemp[ 7];
    122                                 datatemp2[0]<=datatemp[ 0]^datatemp[ 6];end 
    123     
    124              5:begin R<=fcs_temp^datatemp2; step<=1;end             
    125             6:begin step<=0;crc<=~R;end 
    126             endcase
    127 end
    128 endmodule

    modelsim 中显示结果

     

    转载于:https://www.cnblogs.com/kabe/p/4119729.html

    展开全文
  • 我们利用LDPC奇偶校验矩阵的speci_c结构来并行化行行。列编码操作。 还提出了一种优化的方法来控制存储器,该存储器可以以不同的码率重用于LDPC码,以提高硬件资源的利用率。 所提出的LDPC编码器解码器在Xilinx ...
  • 当CP对称性强加于该模型时,SO(10)的离散量规C子类C与之组合以生成有效的奇偶对称性,从而导致埃尔米特夸克质量矩阵。 施加一个额外的离散对称性G,我们表明模型中没有其他θ的树级别源; G还保证了对θ的一环...
  • BCH纠错码 matlab

    2020-02-03 23:40:42
    基于matlab的纠错码源码实现。在编码端,根据BCH码的(n,k)产生生成矩阵G和校验矩阵H 基于matlab的纠错码源码实现。在编码端,根据BCH码的(n,k)产生生成矩阵G和校验矩阵H
  • 两个指定基本矩阵的加性矩阵分散,其中 是基于乘法的 循环基团。 另外,代码构造中的制作技术可以 也适用于两种构造。 仿真结果表明 本文生成的代码在迭代中表现良好 在AWGN频道上解码。 该代码具有优于 Maykay...
  • LDPC project.rar

    2019-06-13 14:47:41
    码长 列重 编码 误码性能 LDPC码的编码方法及其实现本文首先回顾了数字通信系统信道编码的内容,简单了解了LDPC编码的研究现状发展前景之后,从第二章开始从校验矩阵构造方法、LDPC编码方法、LDPC译码方法这三个...
  • 介绍了删除卷积码的定义,根据删除卷积码与源...Hadamard变换(PWHT),有效地识别出校验矩阵,并在此基础上识别源码的生成矩阵和删除模式,进行仿真实验。结果表明在误码率为0.03的情况下,识别概率达到99.8%以上。
  • 本程序是以渐进的方法生成衰落信道下的ldpc码率数据,多普勒频移信噪比大小可调,码字长度传输包的数量可调,但是首先要在genhh中生成对应的校验矩阵 myH_1500首先生成了10个变量节点1500,校验节点由75开始,...
  • 最后采用改进后具有下三角结构的QC-LDPC算法生成循环移位矩阵和有限域系数矩阵,同时消除短环影响,从中选取最优的校验矩阵。仿真结果表明,混合构造算法所构造的多元LDPC码不仅具有线性的编码和存储复杂度,且有较...

空空如也

空空如也

1 2 3 4 5
收藏数 89
精华内容 35
关键字:

校验矩阵和生成矩阵