卷积码编码和BCJR译码

实现卷积码编码和BCJR译码。

以下是实现该算法的代码：

convolution.h

#define EDGE_NUM 8
#define INF 0x3fffff
#define CONV_CODE_RATE 0.5
#define LL 1000
#include <iostream>
struct edge {int left;int right;int input;int output;
};
static int next_state[8][2] = { { 0, 2 },
{ 2, 0 },
{ 4, 6 },
{ 6, 4 },
{ 5, 7 },
{ 7, 5 },
{ 1, 3 },
{ 3, 1 } };
static int output[8][2] = { { 0, 11 },
{ 0, 11 },
{ 0, 11 },
{ 0, 11 },
{ 1, 10 },
{ 1, 10 },
{ 1, 10 },
{ 1, 10 } };
static edge trans_M[16];
static int cost_matrix[LL + 2][EDGE_NUM];
static int prestate[LL + 2][EDGE_NUM];
static int decoding_seq[LL + 2];
static int encode_con[2 * LL + 2];
void ini_edge();
int* encode_convolution(int* source, int len);
int *convolution_decoing(int* received_seq, int seq_length);

convolution.cpp

#include"convolution.h"
#include<iostream>
using namespace std;
void ini_edge() {for (int i = 0; i < 16; i++) {trans_M[i].left = i / 2;trans_M[i].right = next_state[trans_M[i].left][i % 2];trans_M[i].input = i % 2;trans_M[i].output = output[trans_M[i].left][i % 2];}
}
int* encode_convolution(int* source, int len) {int cur_state = 0;int i = 0;int j = 0;while (len--) {encode_con[i] = ((output[cur_state][source[j]] + 100) / 10) % 10;encode_con[i + 1] = (output[cur_state][source[j]] + 100) % 10;cur_state = next_state[cur_state][source[j]];j++;i = i + 2;}return encode_con;
}
int *convolution_decoing(int* received_seq, int seq_length) {ini_edge();int length = seq_length / 2;memset(cost_matrix, -1, EDGE_NUM*(length + 2)*sizeof(int));cost_matrix[0][0] = 0;int active_node[EDGE_NUM];int temp_node[EDGE_NUM];memset(active_node, 0, EDGE_NUM*sizeof(int));memset(temp_node, 0, EDGE_NUM*sizeof(int));active_node[0] = 1;for (int i = 1; i <= length; i++) {for (int j = 0; j < EDGE_NUM; j++) {if (i > 8 || active_node[j] > 0) {for (int k = 0; k < 2; k++) {int distance = abs(received_seq[2 * i - 2] - trans_M[2 * j + k].output / 10) + abs(received_seq[2 * i - 1] - trans_M[2 * j + k].output % 10);int cur_cost = cost_matrix[i - 1][j] + distance;temp_node[trans_M[2 * j + k].right] = 1;if (cur_cost < cost_matrix[i][trans_M[2 * j + k].right] || cost_matrix[i][trans_M[2 * j + k].right] == -1) {cost_matrix[i][trans_M[2 * j + k].right] = cur_cost;prestate[i][trans_M[2 * j + k].right] = j;}}}}if (i <= 10) {for (int k = 0; k < EDGE_NUM; k++) {active_node[k] = temp_node[k];temp_node[k] = 0;}}}int traceback_index = 0;int min_cost = cost_matrix[length][0];for (int i = 1; i < EDGE_NUM; i++) {if (cost_matrix[length][i] < min_cost) {traceback_index = i;min_cost = cost_matrix[length][i];}}int next_index;for (int i = length; i > 0; i--) {next_index = traceback_index;traceback_index = prestate[i][traceback_index];if (trans_M[2 * traceback_index].right == next_index) {decoding_seq[i - 1] = 0;}else if (trans_M[2 * traceback_index + 1].right == next_index) {decoding_seq[i - 1] = 1;}else {decoding_seq[i - 1] = -1;}}return decoding_seq;
}

main.cpp

#include"RandNum.h"
#include<iostream>
#include<stdlib.h>
#include<time.h>
#include<math.h>
#include<stdlib.h>
#include<fstream>
#include<cstdlib>
#include"convolution.h"
using namespace std;
#define L 1000
int source_arr[L];
int encode_arr[L * 3];
double total_arr[L * 3];
int decode_arr[L * 3];
int* generator(int length) {double token;CLCRandNum temp = CLCRandNum();temp.SetSeed(0);for (int i = 0; i < length; i++) {token = temp.Uniform();source_arr[i] = token > 0.5 ? 1 : 0;}return source_arr;
}
int *encode(int *src_arr, int length) {for (int i = 0; i < length; i++) {encode_arr[i] = (src_arr[i] > 0.5) ? 1 : -1;}return encode_arr;
}
double *add_noise(int *encode_arr, int length, double delta) {CLCRandNum temp = CLCRandNum();temp.SetSeed(0);temp.Normal(total_arr, length);for (int i = 0; i < length; i++) {total_arr[i] = delta*total_arr[i] + encode_arr[i];}return total_arr;
}
int *decode(double *total_arr, int length) {for (int i = 0; i < length; i++) {decode_arr[i] = total_arr[i] > 0 ? 1 : 0;}return decode_arr;
}
int error_num(int *source_arr, int *decode_arr, int length) {int error_num = 0;for (int i = 0; i < length; i++) {if (source_arr[i] != decode_arr[i]) {error_num++;}}return error_num;
}
double calculate_delta(double E_No, double code_rate) {double temp = E_No;temp = pow(10, temp / 10);temp = sqrt(0.5 / (temp*code_rate));return temp;
}
int main() {double *E_No = new double[100];double *delta = new double[100];double conv_delta[100];for (int i = 2; i < 100; i++) {double temp_int = i;E_No[i] = double(temp_int / 10);delta[i] = calculate_delta(E_No[i], 1);conv_delta[i] = calculate_delta(E_No[i], CONV_CODE_RATE);}fstream DataWriter;DataWriter.open("data.txt", ios::out);if (!DataWriter) {cout << "Create File Error" << endl;exit(0);}DataWriter << "   Es/No         BPSK-Bit-Error Rate                  Conv-Bit-Error Rate" << endl;cout << "   Es/No" << "         BPSK-Bit-Error Rate                  Conv-Bit-Error Rate" << endl;for (int i = 2; i < 100; i++) {int times = 0;int CONV_ERROR_NUM = 0;while (CONV_ERROR_NUM < 1000 && times < 10000000) {int *source_arr = generator(L);times++;int codeword_length = int(L / CONV_CODE_RATE);int *CONV_CODE_Arr = encode_convolution(source_arr, L);int *encode_arr = encode(CONV_CODE_Arr, codeword_length);double *total_arr = add_noise(encode_arr, codeword_length, conv_delta[i]);int *decode_arr = decode(total_arr, codeword_length);int *received_arr = convolution_decoing(decode_arr, codeword_length);CONV_ERROR_NUM += error_num(source_arr, received_arr, L - 100);}double CONV_ERROR_RATE = double(CONV_ERROR_NUM) / double(times * 900);int BPSK_ERROR_NUM = 0;times = 0;while (BPSK_ERROR_NUM < 1000 && times < 10000000) {times++;int *source_arr = generator(L);int *encode_arr = encode(source_arr, L);double *total_arr = add_noise(encode_arr, L, delta[i]);int *decode_arr = decode(total_arr, L);BPSK_ERROR_NUM += error_num(source_arr, decode_arr, L);}double BPSK_ERROR_RATE = double(BPSK_ERROR_NUM) / double(times * 1000);cout.precision(2);cout << "ES/N0: " << fixed << E_No[i];cout.precision(12);cout << ",         " << "Y1:  " << BPSK_ERROR_RATE << "            Y2:  " << CONV_ERROR_RATE << endl;DataWriter << E_No[i] << "       " << BPSK_ERROR_RATE << "            " << CONV_ERROR_RATE << "\n";}DataWriter.close();system("pause");
}

实验结果：
BCJR算法和BPSK算法比较：

卷积码编码和BCJR译码相关推荐

(2,1,2)卷积码BCJR译码matlab仿真
文章目录前言一.卷积码 1.1 卷积码状态转移图 1.2 分支度量 1.3 前向状态度量 1.4 后向状态度量 1.5 比特似然计算二.仿真代码 1.设置仿真参数 2.仿真所需系统对象 3.定义 ...
卷积码matlab仿真程序,卷积码编码译码程序仿真程序卷积码应用详解
(2) 通常称K为约束长度(一般来说,约束长度越大,则码字纠错性能越好). (3) 码的效率:k/n (4) 编码前,k(K-1)个寄存器单元全部复位清零. (5) 由于一段消息不仅影响当前段的编码 ...
fano译码 matlab,卷积码编码和维特比译码的原理、性能与仿真分析
1.引言卷积码的编码器是由一个有k位输入.n位输出,且具有m位移位寄存器构成的有限状态的有记忆系统,通常称它为时序网络.编码器的整体约束长度为v,是所有k个移位寄存器的长度之和.具有这样的编码器的卷 ...
卷积码编码及维特比译码（Viterbi）算法的原理及其FPGA实现
引言卷积码是一种信道纠错编码,在通信中具有广泛的应用.在发送端根据生成多项式进行卷积码编码,在接收端根据维特比(Viterbi)译码算法进行译码,能够有效抵抗信道噪声的影响,在误码率门限 ...
AWGN信道下卷积编码、viterbe译码、分别采用软硬判决，进行误码率分析
一.卷积编码仿真 (硬判决译码误码率和理论值比较) 已知卷积码生成函数: 可知码率为1/3,相应的抽头系数为(557 663 711)的卷积码.编写程序,采用卷积编码.维特比译码(硬判决),BPS ...
卷积码树状图怎么画_卷积码是什么卷积码编码原理介绍【图文】
卷积码,卷积码是什么意思卷积码在一个二进制分组码(n,k)当中,包含k个信息位,码组长度为n,每个码组的(n-k)个校验位仅与本码组的k个信息位有关,而与其它码组无关.为了达到一定的纠错能力和编码效 ...
对文件进行哈夫曼编码压缩与译码的C++实现以及压缩率计算 ——HIT杨朔
哈夫曼编码压缩原理:由于每个字符在内存中都是以ASCII码进行存储,所以每个字符都占用了八个01位,利用哈夫曼树对每个字符进行01编码,根据字符在文章中出现的频率调整01串长度,出现频率高的字符在哈夫 ...
基于FPGA的DVB-S2、DVB-S2X标准的 LDPC 编码IP、译码 IP core
IP Core特点: 1.全部代码由FPGA代码实现: 2.支持DVB-S2.DVB-S2X全部格式: 3.支持编码.译码: 4.支持标标准中16200.32400.64800三种帧长: 5.支持AC ...
卷积码编码c语言实现,卷积码编码程序的c语言实现.docx
卷积码编码程序的c 语言实现 #include using namespace std; int table1[8]={1,2,4,8,16,32,64,128}; int myn=0; int st ...

卷积码编码和BCJR译码

卷积码编码和BCJR译码相关推荐

最新文章

热门文章