RS纠错编码和解码

最新推荐文章于 2024-03-02 11:18:27 发布
最新推荐文章于 2024-03-02 11:18:27 发布
阅读量1.4w 收藏 62
点赞数 14
分类专栏： C/C++ 文章标签： primitive output algorithm numbers encoding search
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hustspy1990/article/details/6632855
版权 
只需要改变mm的值以及对应nn、kk、tt，就可以适应其他GF(2^m)空间的编码了。
//rs code
//m=8

#include <math.h>
#include <stdio.h>
#include <string.h>

#define mm  8          /* RS code over GF(2**4) - change to suit */
#define nn  255          /* nn=2**mm -1   length of codeword */
#define tt  10           /* number of errors that can be corrected */
#define kk  235           /* kk = nn-2*tt  */

int pp[mm+1] = {1, 0, 1, 1, 1, 0, 0, 0, 1};
int alpha_to [nn+1], index_of [nn+1], gg [nn-kk+1] ;
int recd [nn], data [kk], bb [nn-kk] ;

void generate_gf()
/* 生成GF(2^m)空间 */
{
	register int i, mask ;
	mask = 1 ;
	alpha_to[mm] = 0 ;
	for (i=0; i<mm; i++)
	{	
		alpha_to[i] = mask ;
		index_of[alpha_to[i]] = i ;
		if (pp[i]!=0)
			alpha_to[mm] ^= mask ;
		mask <<= 1 ;
	}
	index_of[alpha_to[mm]] = mm ;
	mask >>= 1 ;
	for (i=mm+1; i<nn; i++)
	{	
		if (alpha_to[i-1] >= mask)
			alpha_to[i] = alpha_to[mm] ^ ((alpha_to[i-1]^mask)<<1) ;
		else 
			alpha_to[i] = alpha_to[i-1]<<1 ;
		index_of[alpha_to[i]] = i ;
	}
	index_of[0] = -1 ;
	//alpha_to[nn] = 1;
	for(i=0;i<mm;i++)
		printf("gf%d is%d\n",i,alpha_to[i]);
}

void gen_poly()
/* 生成---生成多项式*/
{
	register int i,j ;
	gg[0] = 2 ;    /* primitive element alpha = 2  for GF(2**mm)  */
	gg[1] = 1 ;    /* g(x) = (X+alpha) initially */
	for (i=2; i<=nn-kk; i++)
    {
		gg[i] = 1 ;
		for (j=i-1; j>0; j--)
			if (gg[j] != 0)  
				gg[j] = gg[j-1]^ alpha_to[(index_of[gg[j]]+i)%nn];
			else 
				gg[j] = gg[j-1] ;
		gg[0] = alpha_to[(index_of[gg[0]]+i)%nn] ;     /* gg[0] can never be zero */
   }
   //printf("polynomial:\n");
   //for(i=0; i<=nn-kk; i++)
	//   printf("%d      ", gg[i]);
   //printf("\n");
   /* convert gg[] to index form for quicker encoding */
   for (i=0; i<=nn-kk; i++)  
	   gg[i] = index_of[gg[i]];

   //printf("polynomial:\n");
   //for(i=0; i<=nn-kk; i++)
	//   printf("%d      ", gg[i]);
   //printf("\n");
}

void encode_rs()
/* 编码*/
{
	register int i,j ;
	int feedback ;
	for (i=0; i<nn-kk; i++)   bb[i] = 0 ;
	for (i=kk-1; i>=0; i--)
    {
		//逐步的将下一步要减的，存入bb(i)
		feedback = index_of[data[i]^bb[nn-kk-1]] ;
		if(feedback != -1)
        {
			for (j=nn-kk-1; j>0; j--)
            if (gg[j] != -1)
				bb[j] = bb[j-1]^alpha_to[(gg[j]+feedback)%nn] ;		//plus = ^
            else
				bb[j] = bb[j-1] ;
			bb[0] = alpha_to[(gg[0]+feedback)%nn] ;
        }
		else
        {
			for (j=nn-kk-1; j>0; j--)
				bb[j] = bb[j-1] ;
			bb[0] = 0 ;
        };
    };
}

void decode_rs()
 {/*解码*/
	register int i,j,u,q ;
	int elp[nn-kk+2][nn-kk], d[nn-kk+2], l[nn-kk+2], u_lu[nn-kk+2], s[nn-kk+1] ;
	int count=0, syn_error=0, root[tt], loc[tt], z[tt+1], err[nn], reg[tt+1] ;
/* first form the syndromes */
	for(i=0; i<nn; i++) //转换成GF空间的alpha幂次
		if(recd[i] == -1)
			recd[i] = 0;
		else
			recd[i] = index_of[recd[i]];

	for (i=1; i<=nn-kk; i++)
	{
		s[i] = 0 ;
		for (j=0; j<nn; j++)
        if (recd[j]!=-1)
			s[i] ^= alpha_to[(recd[j]+i*j)%nn] ;      /* recd[j] in index form */
								/* convert syndrome from polynomial form to index form  */
		if (s[i]!=0)  
			syn_error=1 ;        /* set flag if non-zero syndrome => error */
		printf("%3d", s[i]);
		s[i] = index_of[s[i]] ;
		printf("%3d", s[i]);
    } ;
	if (syn_error)       /* if errors, try and correct */
    {printf("*\n");
/* compute the error location polynomial via the Berlekamp iterative algorithm,
   following the terminology of Lin and Costello :   d[u] is the 'mu'th
   discrepancy, where u='mu'+1 and 'mu' (the Greek letter!) is the step number
   ranging from -1 to 2*tt (see L&C),  l[u] is the
   degree of the elp at that step, and u_l[u] is the difference between the
   step number and the degree of the elp.*/
/* initialise table entries */
		d[0] = 0 ;           /* index form */
		d[1] = s[1] ;        /* index form */
		elp[0][0] = 0 ;      /* index form */
		elp[1][0] = 1 ;      /* polynomial form */
		for (i=1; i<nn-kk; i++)
        {	
			elp[0][i] = -1 ;   /* index form */
			elp[1][i] = 0 ;   /* polynomial form */
        }
		l[0] = 0 ;
		l[1] = 0 ;
		u_lu[0] = -1 ;
		u_lu[1] = 0 ;
		u = 0 ;
		do
		{
			u++ ;
			if (d[u]==-1)
			{ 
				l[u+1] = l[u] ;
				for (i=0; i<=l[u]; i++)
				{  
					elp[u+1][i] = elp[u][i] ;
					elp[u][i] = index_of[elp[u][i]] ;
				}
			}
			else
/* search for words with greatest u_lu[q] for which d[q]!=0 */
			{ 
				q = u-1 ;
				while ((d[q]==-1) && (q>0)) 
					q-- ;
/* have found first non-zero d[q]  */
				if (q>0)
				{ 
					j=q ;
				do
				{ 
					j-- ;
					if ((d[j]!=-1) && (u_lu[q]<u_lu[j]))
					q = j ;
				}while (j>0) ;
             } ;
/* have now found q such that d[u]!=0 and u_lu[q] is maximum */
/* store degree of new elp polynomial */
            if (l[u]>l[q]+u-q)  
				l[u+1] = l[u] ;
            else  
				l[u+1] = l[q]+u-q ;
/* form new elp(x) */
            for (i=0; i<nn-kk; i++)    
				elp[u+1][i] = 0 ;
            for (i=0; i<=l[q]; i++)
				if (elp[q][i]!=-1)
					elp[u+1][i+u-q] = alpha_to[(d[u]+nn-d[q]+elp[q][i])%nn] ;
            for (i=0; i<=l[u]; i++)
              { 
				  elp[u+1][i] ^= elp[u][i] ;
                elp[u][i] = index_of[elp[u][i]] ;  /*convert old elp value to index*/
              }
		}
		u_lu[u+1] = u-l[u+1] ;
/* form (u+1)th discrepancy */
        if (u<nn-kk)    /* no discrepancy computed on last iteration */
		{
			if (s[u+1]!=-1)
				d[u+1] = alpha_to[s[u+1]] ;
            else
				d[u+1] = 0 ;
            for (i=1; i<=l[u+1]; i++)
				if ((s[u+1-i]!=-1) && (elp[u+1][i]!=0))
					d[u+1] ^= alpha_to[(s[u+1-i]+index_of[elp[u+1][i]])%nn] ;
            d[u+1] = index_of[d[u+1]] ;    /* put d[u+1] into index form */
		}
	} while ((u<nn-kk) && (l[u+1]<=tt)) ;
	u++ ;
	if (l[u]<=tt)         /* can correct error */
	{
/* put elp into index form */
		for (i=0; i<=l[u]; i++)   
			elp[u][i] = index_of[elp[u][i]] ;
/* find roots of the error location polynomial */
		/*求错误位置多项式的根*/
		for (i=1; i<=l[u]; i++)
			reg[i] = elp[u][i] ;
		count = 0 ;
		for (i=1; i<=nn; i++)
		{  
			q = 1 ;
			for (j=1; j<=l[u]; j++)
			if (reg[j]!=-1)
			{ 
				reg[j] = (reg[j]+j)%nn ;
				q ^= alpha_to[reg[j]] ;
			} ;
			if (!q)        /* store root and error location number indices */
			{ 
				root[count] = i;
				loc[count] = nn-i ;
				count++ ;
				printf("根%d=%d\n", q, nn-i);
			};
		} ;
		if (count==l[u])    /* no. roots = degree of elp hence <= tt errors */
		{/* form polynomial z(x) */
			for (i=1; i<=l[u]; i++)        /* Z[0] = 1 always - do not need */
            { 
				if ((s[i]!=-1) && (elp[u][i]!=-1))
					z[i] = alpha_to[s[i]] ^ alpha_to[elp[u][i]] ;
				else if ((s[i]!=-1) && (elp[u][i]==-1))
					z[i] = alpha_to[s[i]] ;
				else if ((s[i]==-1) && (elp[u][i]!=-1))
					z[i] = alpha_to[elp[u][i]] ;
				else
					z[i] = 0 ;
				for (j=1; j<i; j++)
					if ((s[j]!=-1) && (elp[u][i-j]!=-1))
						z[i] ^= alpha_to[(elp[u][i-j] + s[j])%nn] ;
				z[i] = index_of[z[i]] ;         /* put into index form */
            } ;
  /* evaluate errors at locations given by error location numbers loc[i] */
			/*计算错误图样*/
			for (i=0; i<nn; i++)
			{ 
				err[i] = 0 ;
				if (recd[i]!=-1)        /* convert recd[] to polynomial form */
					recd[i] = alpha_to[recd[i]] ;
				else  
					recd[i] = 0 ;
             }
			for (i=0; i<l[u]; i++)    /* compute numerator of error term first */
            { 
				err[loc[i]] = 1;       /* accounts for z[0] */
				for (j=1; j<=l[u]; j++)
					if (z[j]!=-1)
						err[loc[i]] ^= alpha_to[(z[j]+j*root[i])%nn] ;
				if (err[loc[i]]!=0)
				{ 
					err[loc[i]] = index_of[err[loc[i]]] ;
					q = 0 ;     /* form denominator of error term */
					for (j=0; j<l[u]; j++)
					if (j!=i)
						q += index_of[1^alpha_to[(loc[j]+root[i])%nn]] ;
					q = q % nn ;
					err[loc[i]] = alpha_to[(err[loc[i]]-q+nn)%nn] ;
					recd[loc[i]] ^= err[loc[i]] ;  /*recd[i] must be in polynomial form */
				}
			}
		}
		else    /* no. roots != degree of elp => >tt errors and cannot solve */
		{	/*错误太多，无法更正*/
			for (i=0; i<nn; i++)        /* could return error flag if desired */
				if (recd[i]!=-1)        /* convert recd[] to polynomial form*/
					recd[i] = alpha_to[recd[i]] ;
				else  
					recd[i] = 0 ;     /* just output received codeword as is */
		}
		}
		else         /* elp has degree has degree >tt hence cannot solve */
		{	/*错误太多，无法更正*/
			for (i=0; i<nn; i++)       /* could return error flag if desired */
				if (recd[i]!=-1)        /* convert recd[] to polynomial form */
					recd[i] = alpha_to[recd[i]] ;
				else  
					recd[i] = 0 ;     /* just output received codeword as is */
		}
	}
	else       /* no non-zero syndromes => no errors: output received codeword */
		for (i=0; i<nn; i++)
		{
			if (recd[i]!=-1)        /* convert recd[] to polynomial form */
				recd[i] = alpha_to[recd[i]] ;
			else  
				recd[i] = 0 ;
			//printf("*");
		}

 }

int main()
{
	int i, length;
	char strSrc[255], strDst[255];
	printf("请输入要编码的字符串：\n");
	scanf("%s", strSrc);
	length = strlen(strSrc);
	if(length <= 0)
		return 0;

	generate_gf();
	printf("Look-up tables for GF(2**%2d)\n",mm) ;
	printf("  i   alpha_to[i]  index_of[i]\n") ;
	for (i=0; i<=nn; i++)
		printf("%3d      %3d          %3d\n",i,alpha_to[i],index_of[i]);
	printf("\n\n");

	gen_poly();

	for(i=0; i<kk; i++)
		data[i] = 0;

	/* for example, say we transmit the following message (nothing special!) */
	for(i=0; i<length; i++)
		data[i] = strSrc[i];
/*	data[0] = 8 ;
	data[1] = 6 ;
	data[2] = 8 ;
	data[3] = 1 ;
	data[4] = 2 ;
	data[5] = 4 ;
	data[6] = 15 ;
	data[7] = 9 ;
	data[8] = 55 ;*/

	encode_rs();

	data[0] = 19 ;
	for (i=0; i<nn-kk; i++)  
		recd[i] = bb[i] ;
	for (i=0; i<kk; i++) 
		recd[i+nn-kk] = data[i] ;


/*	printf("Results for Reed-Solomon code (n=%3d, k=%3d, t= %3d)\n\n",nn,kk,tt) ;
	printf("  i  data[i]   recd[i](decoded)   (data, recd in polynomial form)\n");
	for (i=0; i<nn-kk; i++)
		printf("%3d    %3d      %3d\n",i, bb[i], recd[i]) ;
	for (i=nn-kk; i<=nn; i++)
		printf("%3d    %3d      %3d\n",i, data[i-nn+kk], recd[i]) ;*/

	decode_rs() ; 

	printf("Results for Reed-Solomon code (n=%3d, k=%3d, t= %3d)\n\n",nn,kk,tt) ;
	printf("  i  data[i]   recd[i](decoded)   (data, recd in polynomial form)\n");
	for (i=0; i<nn-kk; i++)
		printf("%3d    %3d      %3d\n",i, bb[i], recd[i]) ;
	for (i=nn-kk; i<=nn; i++)
	{
		printf("%3d    %3d      %3d\n",i, data[i-nn+kk], recd[i]) ;
	}
	for(i=0; i<length; i++)
		strDst[i] = recd[i+nn-kk];
	strDst[length] = '\0';
	printf("%s\n", strDst);
}

albon_arith
关注
  • 14
    点赞
  • 踩
  • 62
    收藏
    觉得还不错? 一键收藏
  • 13
    评论
专栏目录
RS纠错编码算法C++实现
03-23
RS纠错与编码的源代码实现，程序采用c++，在VC6.0环境下用对话框形式实现，完好直接的显示了RS算法。程序可直接运行。
RS纠错编码原理及其实现方法.rar_RS信道编码_RS编码_rs解码原理_信道编码RS_纠错
09-23
RS纠错编码原理及其实现方法 matlab信道编码
RS编码的FPGA实现
最新发布
cckkppll的博客
03-02 816
RS编码的FPGA实现
C语言按两个字节读写二进制文件,C语言 读写二进制文件(示例代码)
weixin_39742568的博客
05-18 515
查找了比较多的资源， 发现没有办法把text 文件转成binary文件仅作为记录，不过这个例子可以去除换行符。#include#include#defineN255intmain(){chara[N];FILE*fp1,*fp2;fp1=fopen("test_seq.fa","r");fp2=fopen("testSeq.dat","wb");/*inputtextfile...
RS编码和纠错算法
FPGA/MATLAB学习教程/源码/项目合作开发
12-02 8347
一个n次不可约多项式，如果只能整除1＋Z^2^n-1而不能整除其它1＋Z^L(L<2^n-1)，则这种不可约多项式就称为本原多项式。 对于一个n次多项式，其本原多项式一般有若干个。下面将给出的一个算法，是求解在给定任意n值及一个本原多项式的情况下，其余本原多项式的求解方法。该算法的意义在于提供了同一n值情况下若干个可选的本原多项式，这样就允许在构造应用系统时有不同的选择方案。 已知一个n级本原多项式，求解其余的本原多项式按以下步骤进行。 (1) 首先确定n级本原多项式的个数λ(n),λ(n)即是n级本
Reed-Solomon Codes——RS纠错码
mutourend的博客
08-01 6249
Reed-Solomon Codes为基于block的纠错码，在数字通信和存储中有大量应用，在如下系统中用于纠错： * 存储设备（包括磁带、光盘、DVD、条形码等） * 无线或移动通信（包括手机、微波连接等） * 卫星通信 * 数字电视/DVB * 高速调制解调器，如ADSL、xDSL等 .................................
13.2 RS编码和纠错算法
OpenHero 开勇
08-17 1万+
13.2 RS编码和纠错算法13.2.1. GF(2m)域RS(Reed-Solomon)码在伽罗华域(Galois Field，GF)中运算的，因此在介绍RS码之前先简要介绍一下伽罗华域。CD-ROM中的数据、地址、校验码等都可以看成是属于GF(2m) = GF(28)中的元素或称符号。GF(28)表示域中有256个元素，除0，1之外的254个元素由本原多项式P(x)生成。本原多项式
Reed-Solomon纠错码(RS码)（里德-所罗门码）
热门推荐
weixin_42388255的博客
06-03 1万+
Reed-Solomon纠错码(RS码) Reed-Solomon利用范特蒙矩阵或者柯西矩阵的特性来实现纠错码的功能。 Reed-Solomon编码： 把输入数据视为向量D=（D1,D2,…,Dn），编码后数据视为向量（D1,D2,…Dn,C1,C2,…,Cm），RS编码可以看做为如下图的矩阵运算。编码矩阵B必须具有任意子矩阵可逆的特性。 Reed-Solomon解码： RS最多能容忍m个数据块被删除，m包括实际数据和冗余数据。数据恢复的过程如下： (1)假设D1,D4,C2丢失，从编码矩阵中删掉丢失的数
2020-09-17
qq_41687938的博客
09-17 317
（多核DSP快速入门）4.编译测试多核DSP实例Vlfft 转载请注册来源http://blog.csdn.net/tostq 系列教程目录：http://blog.csdn.net/tostq/article/details/51245979 点击更多：https://www.zhihu.com/people/san-hao-bai-du-ren-79       Vlfft是由TI官网...
IIC、UART
qq_41687938的博客
06-30 941
一、IIC: 1.1 IIC总线简介 串行、半双工、一条时钟线一条数据线。 1.2 IIC总线通信过程 1.3 IIC寻址方式 1.4 起始信号和停止信号 1.5 字节传送与应答 IIC是串行，一个字节8位，先高位再低位。 1.6 同步信号 传输之前需要让双方互相知道。 IIC上升沿接收数据，下降沿发送数据，解决如何认出发送00时，接收端判断接收了多少个0. 1.7 典型IIC时序 三种： 二、UART 2.1 UART简介： 串行、异步、全双工
RS编解码，用vc++实现
12-25
采用c++语言，对信号进行加密算法。采用RS编解码算法实现，本算法可以对系统码（255，247）进行截短码（18，10）进行RS信道编解码，纠错4位
C++RS编码解码.cpp C++RS编码解码.cpp
05-04
C++RS编码解码.cppC++RS编码解码.cppC++RS编码解码.cppC++RS编码解码.cpp
RS纠错编码原理及其实现方法_matlab_rs_
09-29
介绍了RS编码和解码的原理，给出了MATLAB仿真程序
rs编解码.c （rs纠错码）
12-16
利用c语言编写的rs编解码程序，里边有大概的注释。方便学习和研究，有一定的参考价值。里边包含编码和解码，有需要可以自取。
RS纠错编码算法C++.zip
11-19
解码处理，VC++环境，包含有完整的工程；使用QR等解码场景，配合开源解码库使用，安利CSDN技术网友。。。
RS纠错编码原理及其实现方法
10-14
RS编码是信道编码中常见的前向纠错码 RS实现原理，GF域表示方式，RS生成多项式及校验多项式的生成 MATLAB实现代码
Linux C连接Mysql数据库
albon arith
03-31 1万+
1. 连接数据库 /*练习mysql数据库的连接*/ #include #include int main() { MYSQL mysql; int t, r; /*连接之前，先用mysql_init初始化MYSQL连接句柄*/ mysql_init(&mysql); /*使用mysql_real_connect连接服务器,其参数依次为MYSQL句柄，服务器IP地址， 登录my
Linux exec函数的使用
albon arith
04-11 8330
1. 示例 /*exec函数示例*/ #include #include int main(void) { int flag; pid_t pid; char *const argv[] = {"%U", "--user-data-dir=/home/Administrator/.chromiun", NULL}; //exec把当前进程印象替换成新的程序文件，故调用进程被覆盖
rs纠错编码原理及其实现方法 陈文礼
01-16
RS纠错编码的实现方法包括编码和解码两部分。编码过程是将原始数据转换为多项式形式，并根据纠错码的参数进行计算，生成一定数量的冗余码。解码过程是根据接收到的数据，进行定位和纠错操作，以恢复原始数据。 在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值