weixin_53090316
weixin_53090316
2020-12-18 22:33
采纳率: 0%
浏览 199

如何用C ++设计卷积码编码器?

使用C ++设计卷积码编码器。 下面是bit generator的初步程序。 它需要生成1004个随机数,最后4个数字为0000。生成的数字应保存在文件中,然后将1004个数字将该数字添加到卷积码编码器的向量中。 需要具有1/2 rate和4个寄存器的卷积码编码器,并且编码器输出的编码器位还需要能够生成文档。

#include<iostream>
#include<cstdlib>
#include<ctime>
using namespace std;

const unsigned N=1000;
int data[N];

int main()
{
    srand((unsigned int)time(NULL));
    
    for(int i=0; i<N; i++)
    {
        data[i]=rand()%2;
        cout<<data[i]<<endl;
    }
    return 0;
}
  • 点赞
  • 收藏

7条回答 默认 最新

  • bosaidongmomo
    bosaidongmomo 2020-12-19 08:37
    点赞 1 评论
  • bill20100829
    歇歇 2020-12-19 14:36

    /***这是一个简单的卷积编码器示例程序。
       *信息序列、寄存器初始状态和生成序列可以在主功能中全部修改。
       */
    #include<stdio.h>

     

    #define LEN(array, len){len=sizeof(array)/sizeof(array[0]);}//Size of array

    int encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
    /*encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
            *这个函数是一个卷积编码器。
            *gen    是生成序列,它是一个二维数组,它是一个二维指针
            *n      是每个时钟周期编码器输出的位数
            *L       为长度
            *reg     用于移位寄存器
            *m      代表寄存器的数量
            *inf    信息序列
            *inf_len 表示inf长度
            *output  用于输出
    */
    {
     int inf_ex[inf_len + m];

     int i,j;//Index

     for (i=0;i < inf_len + m;i++)//m位扩展
     {
      if(i < inf_len)
       inf_ex[i] = inf[i];
      else
       inf_ex[i] = 0;
     }
     for (i=0;i < inf_len + m;i++)//扩展信息
     {
      for (j=0;j < n;j++)//每个时钟周期输出n位
      {
          int out_tem=0;//临时变量
       if (*(gen + L*j) == 1)//在Mod op中判断下一个信息位是否应该参与
                    out_tem += inf_ex[i];

       int k;
       for (k=0;k < m;k++)//循环寄存器
       {
        if (*(gen + L*j + k + 1) == 1)
         out_tem += reg[k];//根据生成顺序修改操作
       }
       out_tem %= 2;//模2
       output[i*n + j] = out_tem;
      }

      for (j=m - 1;j > 0;j--)//位移
      {
       reg[j] = reg[j - 1];
      }
      reg[0] = inf_ex[i];//将信息位输入寄存器

     }

     return 1;
    }

    main()
    {
     int inf[]={1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0};//数组
     int inf_len;//长度
     LEN(inf, inf_len);

     int gen[2][7]={{1, 0, 1, 1, 0, 1, 1}, {1, 1, 1, 1, 0, 0, 1}};//生成顺序

     int n;//每个时钟周期编码器输出的位数
     int L;//长度
     LEN(gen, n);
     LEN(gen[0], L);
     int m=L - 1;//位移长度

     int init_s[]={0, 0, 0, 0, 0, 0}; //初始化

     int reg[m];//注册数组

     int i;//索引

     for (i=0;i < m;i++)
        {
            reg[i] = init_s[i];
        }

     int output_len=(inf_len + m)*n;//输出长度,每一位输入可以产生n位输出序列
     int output[(inf_len + m)*n];//输出序列
     encoder(gen, n, L, reg, m, inf, inf_len, output);//编码

     for (i=0;i < output_len;i++)
     {
      printf("%d", output[i]);
     }
     system("pause");
    }

    点赞 评论
  • SoftwareTeacher
    SoftwareTeacher 2020-12-21 15:27
    点赞 评论
  • weixin_41102528
    Technology——Liu 2021-01-12 20:17
    /***This is an simple example program of convolutional encoder.
       *The information sequence, the register initial states and the generation sequence
       *    can all be modified in the main function.
       */
    #include<stdio.h>
    #define LEN(array, len){len=sizeof(array)/sizeof(array[0]);}//Size of array
    
    int encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
    /*encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
            *This function is a convolutional encoder.
            *gen     is the generation sequence, which is a two-dimension array,
             and it is a two-dimension pointer,
            *n       is the number of bits out the encoder at each clock cycle,
            *L       is for the constraight length,
            *reg     is for the shift registers,
            *m       is for the number of registers,
            *inf     is for the information sequence,
            *inf_len is for the inf length,
            *output  is for the output code.
    */
    {
     int inf_ex[inf_len + m];
    
     int i,j;//Index
    
     for (i=0;i < inf_len + m;i++)//Extend the information sequence to include the last m bits
     {
      if(i < inf_len)
       inf_ex[i] = inf[i];
      else
       inf_ex[i] = 0;
     }
     for (i=0;i < inf_len + m;i++)//Foreach bit in extend information
     {
      for (j=0;j < n;j++)//Output n bits at each clock cycle
      {
          int out_tem=0;//Temp number
       if (*(gen + L*j) == 1)//Judge whether the next information bit should paticipate in the Mod op
                    out_tem += inf_ex[i];
    
       int k;
       for (k=0;k < m;k++)//Foreach registers
       {
        if (*(gen + L*j + k + 1) == 1)
         out_tem += reg[k];//Mod op according to the generation sequence
       }
       out_tem %= 2;//Mod 2
       output[i*n + j] = out_tem;
      }
    
      for (j=m - 1;j > 0;j--)//Register shift
      {
       reg[j] = reg[j - 1];
      }
      reg[0] = inf_ex[i];//Input information bits into register
     }
    
     return 1;
    }
    
    main()
    {
     int inf[]={1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0};//Information sequence
     int inf_len;//Information length
     LEN(inf, inf_len);
    
     int gen[2][7]={{1, 0, 1, 1, 0, 1, 1}, {1, 1, 1, 1, 0, 0, 1}};//Generation sequence
     int n;//The number of bits out the encoder at each clock cycle
     int L;//Constraight length
     LEN(gen, n);
     LEN(gen[0], L);
     int m=L - 1;//The number of shift registers
    
     int init_s[]={0, 0, 0, 0, 0, 0}; //Initial states are all zero
    
     int reg[m];//Register
    
     int i;//Index
    
     for (i=0;i < m;i++)
        {
            reg[i] = init_s[i];
        }
    
     int output_len=(inf_len + m)*n;//Output length, every bit of input can generate n bits of output sequence
     int output[(inf_len + m)*n];//Output sequence
     encoder(gen, n, L, reg, m, inf, inf_len, output);//Encoder
    
     for (i=0;i < output_len;i++)
     {
      printf("%d", output[i]);
     }
     system("pause");
    }
    点赞 评论
  • wlwdecs_dn
    逆向通信猿 2021-01-15 20:58

    你好,可以看我的博客,卷积码Viterbi译码算法基本原理及C语言实现(基于MFC),从编码到译码,从比特存储到0、1字符存储都有,https://blog.csdn.net/wlwdecs_dn/article/details/106741660,博客目前收费,整个专栏都是关于信道编码的,你可以看看对你有没有帮助

    如果有用,配套程序为:https://download.csdn.net/download/wlwdecs_dn/14463620

    该代码是基于(3,1,3)卷积码的硬判决Viterbi译码算法的C语言实现,算法的详细基本原理和实现步骤可参考本人对应的博客,有问题可以直接留言哦! 可更改参数,变为(2,1,m)系列的卷积码,只需更改一下参数即可实现,原理都相同

    如有问题,要是能采纳我的回答,我可以全程解答

    点赞 评论
  • m0_50414588
    淋风沐雨 2021-02-04 13:08

    实现(2, 1, 7)卷积码编码
    信息序列1001 1010 1111 1100
    生成序列g1 = 1011011;g2 = 1111001
    初始状态全0.
    以上参数可自行在main中修改。

     

    代码如下:


    /***This is an simple example program of convolutional encoder.
       *The information sequence, the register initial states and the generation sequence
       *    can all be modified in the main function.
       */
    #include<stdio.h>

     

    #define LEN(array, len){len=sizeof(array)/sizeof(array[0]);}//Size of array

    int encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
    /*encoder(int **gen, int n, int L, int reg[], int m, int inf[], int inf_len, int output[])
            *This function is a convolutional encoder.
            *gen     is the generation sequence, which is a two-dimension array,
             and it is a two-dimension pointer,
            *n       is the number of bits out the encoder at each clock cycle,
            *L       is for the constraight length,
            *reg     is for the shift registers,
            *m       is for the number of registers,
            *inf     is for the information sequence,
            *inf_len is for the inf length,
            *output  is for the output code.
    */
    {
     int inf_ex[inf_len + m];

     int i,j;//Index

     for (i=0;i < inf_len + m;i++)//Extend the information sequence to include the last m bits
     {
      if(i < inf_len)
       inf_ex[i] = inf[i];
      else
       inf_ex[i] = 0;
     }
     for (i=0;i < inf_len + m;i++)//Foreach bit in extend information
     {
      for (j=0;j < n;j++)//Output n bits at each clock cycle
      {
          int out_tem=0;//Temp number
       if (*(gen + L*j) == 1)//Judge whether the next information bit should paticipate in the Mod op
                    out_tem += inf_ex[i];

       int k;
       for (k=0;k < m;k++)//Foreach registers
       {
        if (*(gen + L*j + k + 1) == 1)
         out_tem += reg[k];//Mod op according to the generation sequence
       }
       out_tem %= 2;//Mod 2
       output[i*n + j] = out_tem;
      }

      for (j=m - 1;j > 0;j--)//Register shift
      {
       reg[j] = reg[j - 1];
      }
      reg[0] = inf_ex[i];//Input information bits into register
     }

     return 1;
    }

    main()
    {
     int inf[]={1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 0, 0};//Information sequence
     int inf_len;//Information length
     LEN(inf, inf_len);

     int gen[2][7]={{1, 0, 1, 1, 0, 1, 1}, {1, 1, 1, 1, 0, 0, 1}};//Generation sequence
     int n;//The number of bits out the encoder at each clock cycle
     int L;//Constraight length
     LEN(gen, n);
     LEN(gen[0], L);
     int m=L - 1;//The number of shift registers

     int init_s[]={0, 0, 0, 0, 0, 0}; //Initial states are all zero

     int reg[m];//Register

     int i;//Index

     for (i=0;i < m;i++)
        {
            reg[i] = init_s[i];
        }

     int output_len=(inf_len + m)*n;//Output length, every bit of input can generate n bits of output sequence
     int output[(inf_len + m)*n];//Output sequence
     encoder(gen, n, L, reg, m, inf, inf_len, output);//Encoder

     for (i=0;i < output_len;i++)
     {
      printf("%d", output[i]);
     }
     system("pause");
    }

    点赞 评论
  • RngMLXG1
    RngMLXG1 2021-02-08 18:17

    建议试试我的

    不懂得话可以随时发消息给我

    [2, 1, 7)]
    1001 1010 1111 1100
    ° g1 = 1011011; g2 = 111001
    =0。
    [主]


    /***这是一个简单的卷积编码器示例程序。
    *信息序列、寄存器初始状态和生成
    序列 * 都可以在主函数中修改。
    */
    #include<stdio.h>

    #define LEN(数组,len)[len]大小(数组)/大小(数组{0});]数组大小

    int 编码器(int **gen, int n, int L, int reg_, int m, int inf_, int
    inf_len, int 输出\) /* 编码器 (int **gen, int n, int reg_, int m, int
    inf_, int inf_len, int 输出\) *此函数是一个卷积编码器。
    *gen
    是生成序列,这是一个双维数组,它是一个双维指针,*n
    是每个时钟周期中编码器的位数,*L
    表示
    连续长度,*reg 表示
    移位寄存器
    ,*m 表示寄存器数,*inf 表示
    信息序列,*inf_len 表示 inf 长度,*l
    表示输出为输出代码。
    */

    [ int inf_ex [inf_len] m];

    int i,j;//索引

    用于 (i=0;i < inf_len = m;i=) / / 扩展信息序列以包括最后

    m
    位 [如果(i < inf_len) inf_ex [i] inf_i;

    其他 inf_ex [i]= 0;

    用于 (i=0;i < inf_len [m;i])//在扩展信息中输入位

    = 对于 (j=0;j < n;j=)//输出每个时钟
    周期
    的 n 位 = int out_tem=0;//如果
    (*(gen = L*j) = 1)//判断下一个信息位是否应
    在 Mod op out_tem = inf_ex=i=

    int k;
    用于 (k=0;k < m;k=) /
    /foreach
    寄存器 = 如果 (*(gen = L*j
    = k = 1) = 1) out_tem =

    reg=k=///根据生成序列进行模式操作
    = out_tem % = 2;//Mod 2 输出 =i*n = j = out_tem;
      }

    用于 (j= m - 1;j > 0;j

    -) / / 寄存器移位
    [reg_j] [reg] j - 1];
    reg{0} = inf_ex[i];//输入信息位到寄存器中
     }

    返回 1;
    }

    main()

    = int inf=1、 0、 0、1、1、0、1、1、1、1、1、1、1、1、0、0=;//
    信息序列 int inf_len;//信息
    长度 LEN(inf, inf_len);


    int gen=2=7==1、0、1、1、0、1、1、1、1、0、1、1=;/生成序列 int n;//每个
    时钟周期中编码器的位数 int L;//Constraight 长度
    LEN(gen, n);
    LEN(gen{0},L);
    int m=L - 1;//移位寄存器数

    int init_s 0, 0, 0, 0, 0, 0\;初始状态全部为零

    int reg[m];///注册

    int i;//索引

    用于 (i=0;i < m;i=)
    =reg{i}=init_s[i];

        }

    int output_len=(inf_len = m)*n;//输出长度,每个输入位都可以生成 n 位输出序列
    int 输出=(inf_len = m)*n=;//输出
    序列编码器(gen、n、L、reg、m、inf、inf_len、输出);//编码器

    用于 (i=0;i < output_len;i=)
    =printf("%d",
    输出{i});
    |
    系统("暂停");
    }

    点赞 评论

相关推荐