3

我正在编写一个OFDM系统，包括发送端和接收端。位去的第一个函数是加扰器，它基本上是一个 LFSR，我的多项式是x^7 + x^4 + 1，简单地说，我对寄存器中的第 7 位和第 4 位进行异或，并使其成为移位寄存器的新第一位，以及异或该值与输入值，得到输出值。从图片上看，它可以在下面看到。

在此处输入图像描述

我正在使用一个类型的数组short来保存这些位。由于程序中的一些后续功能，我需要这种数组类型。对我来说更方便。我创建了一个函数来右移寄存器，以及扰频器的另一个函数。代码如下：

void leftshift(short *in, short *out, unsigned long len, unsigned short shift) {

    unsigned long i;

    for (i = 0; i < len - shift; i++) {
        out[i] = in[i + shift];
    }

    for (i = len - shift; i < len; i++) {
        out[i] = 0;
    }
}

void rightshift(short *in, short *out, unsigned long len, unsigned short shift) {

    unsigned long i;

    for (i = len - 1; i >= shift; i--) {
        out[i] = in[i - 1];
    }

    for (i = 0; i < shift; i++) {
        out[i] = 0;
    }
}

void scrambler(short *in, short *out, unsigned long len, short *initial_state) {

    unsigned long i;
    short carry;
    short *shift_register = initial_state;

    for (i = 0; i < len; i++) {
        carry = (shift_register[3] + shift_register[6]) % 2;
        rightshift(shift_register, shift_register, 7, 1);
        shift_register[0] = carry;
        out[i] = (in[i] + carry) % 2;
    }
}

现在，关键是作为解扰器过程的一部分，我需要对扰频器的逆进行编码。在我的扰频器中，我正在右移。它的反面是否只涉及左移，并使抽头序列和寄存器的初始配置保持不变？同时，如果我进行左移并检查结果，它与初始输入的结果不同。有任何想法吗？

编辑：

int main(void) {

    const unsigned SIZE = 24;

    short in[SIZE] = { 0, 0, 0, 0, 1, 0, 0, 0, 
                       0, 1, 1, 1, 0, 0, 1, 0,
                       1, 0, 0, 1, 1, 1, 0, 0 };
    short init[7] = { 1, 1, 1, 1, 1, 1, 1 };

    short *out_scrambler = (short *)malloc(sizeof(short)*SIZE);
    short *out_descrambler = (short *)malloc(sizeof(short)*SIZE);

    scrambler(in, out_scrambler, SIZE, init);
    scrambler(out_scrambler, out_descrambler, SIZE, init);

    return 0;
}
4

2 回答 2

1

加扰过程是它自己的逆过程。您只需要再次对相同的序列进行异或。

(a ^ b) ^ b == a
于 2016-08-26T10:47:10.393 回答
0

你有A xor X = B，你的问题是如何A从B，对吧？或者我在这里错过了什么？

A xor X = B=>B xor X = A

此外，您的整个 lfsr 可以简化为：

uint8_t state;
outbit = ((state >> 7) ^ (state >> 4)) & 1;
state = (state >> 1) | outbit;

lfsrs 的全部意义在于它们非常便宜。使用多出 128 倍的内存和比必要的多出一到三个数量级的指令来实现它们会适得其反。

于 2016-08-26T10:47:20.253 回答