C++:不规则大小二进制码字的快速连接

Question

我需要从硬件 SPI 模块中流出串行数据。该 SPI 模块接受 16 位字并先发送 MSB。

为了给 SPI 模块提供数据，我准备了一个 16 位整数数组。

这是棘手的部分:我将从 SPI 模块流出的数据不是由 16 位宽的字构成的。相反，需要输出 68 个码字中的 588 位，如下所示:

第一个字，codeIndex=0，是 24 位宽
每隔一个字(对于所有奇数 x，codeIndex=x)都是 3 位宽
所有剩余的代码字(对于所有非零偶数，codeIndex=x)都是 14 位宽

SPI 接口(interface)必须按顺序输出所有这些代码字，不得添加或丢失位。这意味着我发送到 SPI 接口(interface)的第一个 16 位字需要是 24 位 codeIndex=0 的最高有效 16 位，下一个 16 位字将是 codeIndex=0 的剩余 8 位由 codeIndex=1 的所有三位后跟 codeIndex=2 的最高有效 5 位，发送到 SPI 接口(interface)的下一个 16 位字将结束 codeIndex=2，依此类推。

我为此提出了一种方法，该方法大量使用二进制 OR 运算符和按位移位，但似乎应该有一种更快的方法来通过操作指针或其他方式来做到这一点。

我的方法使用查找表。查找表的每一行定义了一个 16 位字，根据其中出现了多少不规则码字，其中出现了哪些码字，以及在这些码字被 OR'd 到 16位字。因为 588 位恰好填充了 36.75 个 16 位字，所以我将这张表制作了四次迭代，以完美填充 147 个 16 位字。您可以在下面的代码中看到，我在程序中展开了一些循环，以尝试进一步加快它的速度。

void fillBuffer(volatile uint16_t *buf) {
  #define THIS_CODE_INDEX *codeIndex
  #define THIS_CODE_OFFSET *codeOffset

  //is the codeword merging bits? 
  #define CODE_SELECT_ITERATION \
  if ( (THIS_CODE_INDEX & 1) == 1) { \
    codeWord = mBitPattern[frame.mBits[(THIS_CODE_INDEX-1)>>1]];\
  }\
  /*is it a normal data word?*/\
  else if (THIS_CODE_INDEX > 2) {\
    codeWord = efmCode[frame.data[(THIS_CODE_INDEX>>1)-1]];\
  }\
  /*is it the sync word?*/\
  else if (THIS_CODE_INDEX == 0) {\
    codeWord = 0b100000000001000000000010;\
  }\
  /*it must be the control bits*/\
  else {\
    if (frameIndex >= 2) { /*if this is the third frame or beyond,*/\
      codeWord = efmCode[frame.data[(THIS_CODE_INDEX>>1)-1]];\
    }\
    else if (frameIndex==0) {  /*if it's the first frame,*/\
      codeWord = 0b00100000000001; /*use s1*/\
    }\
    else {  /*if it's the second frame,*/\
      codeWord = 0b00000000010010; /*use s2*/\
    }\
  }\

  #define CODE_OUTPUT_ITERATION(n) \
  if (THIS_CODE_OFFSET < 0) buf[n] |= ((uint16_t) (codeWord >> (THIS_CODE_OFFSET*-1)));\
  buf[n] |= ((uint16_t) (codeWord << THIS_CODE_OFFSET));

  #define THIS_CODE_COUNT wordCount

  #define FRAME_ITERATION(n) \
    int8_t wordCount = decompTable[n][0];\
    buf[n]=0;\
    \
    /*for each codeword that makes up this 16 bit frame:*/\
    codeIndex = &decompTable[n][1];\
    codeOffset = &decompTable[n][2];\
    \
    {\
      CODE_SELECT_ITERATION\
      CODE_OUTPUT_ITERATION(n)\
      \
      if (THIS_CODE_COUNT > 1){\
        codeIndex+=2;\
        codeOffset+=2;\
        \
        CODE_SELECT_ITERATION\
        CODE_OUTPUT_ITERATION(n)\
        \
        if (THIS_CODE_COUNT > 2) {\
          codeIndex+=2;\
          codeOffset+=2;\
          \
          CODE_SELECT_ITERATION\
          CODE_OUTPUT_ITERATION(n)\
        }\
      }\
    }\



  uint32_t codeWord;

  const int8_t *codeIndex = &decompTable[0][1];
  const int8_t *codeOffset = &decompTable[0][2];


  for (uint8_t i =  0; i <  37; i++) {
    FRAME_ITERATION(i)
  }

  frameIndex++;

  for (uint8_t i = 37; i <  74; i++) {
    FRAME_ITERATION(i)
  }

  frameIndex++;

  for (uint8_t i = 74; i < 111; i++) {
    FRAME_ITERATION(i)
  }

  frameIndex++;

  for (uint8_t i =111; i < 147; i++) {
    FRAME_ITERATION(i)
  }
}

我希望这不会太困惑。

不过，这种类型的问题似乎在我解决之前就已经出现在某个地方了。有没有更快的方法来执行这个计算？

Answer 1

您在询问运行时速度(而不是编程速度)。我假设这是一个 16 位 Controller /处理器？

我们有来自内存的 4*68 个代码字，我们必须将其转换为 147 个 16 位字用于 SPI。

最快的方法似乎是

读取码字

选择:左移码字，或

opt.:写入结果，增加指针，SET 0

opt.:码字右移，SET

与您当前的解决方案相比，由于您已经展开循环，因此我不会从内存中读取 decompTables，而是将它们硬编码到程序中。您可以创建一个添加一个代码字的宏，并将所有相关的值和操作作为宏名称和参数提供。然后调用这个宏 272 次。例如。:

#define ADDCW16_SHL(shl) \
   cw = *ptr_cw; \
   ptr_cw++; \
   temp |= cw << shl;

#define ADDCW16_WRITE() \
   cw = *ptr_cw; \
   ptr_cw++; \
   temp |= cw;
   *ptr_spi = temp; \
   ptr_spi++; \
   temp = 0;

#define ADDCW16_SHR_WRITE_SHL(shr, shl) \
   cw = *ptr_cw; \
   ptr_cw++; \
   temp |= cw >> shr;
   *ptr_spi = temp; \
   ptr_spi++; \
   temp = cw << shl;

uint16_t cw;
uint16_t temp;
ptr_cw = &codewords[0];
ptr_spi = &spibuf[0];

ADDCW16_WRITE() // first 16 bits of 24 bit codeword 1
ADDCW16_SHL(8) // second 8 bits of 24 bit codeword 1
ADDCW16_SHL(5) // 3 bit codeword 2
ADDCW16_SHR_WRITE_SHL(9, 7) // 14 bit codeword 3 (split 5 bit / 9 bit)
ADDCW16_SHL(4) // 3 bit codeword 4
ADDCW16_SHR_WRITE_SHL(10, 6) // 14 bit codeword 5 (split 4 bit / 10 bit)
// ...

您可以将第一个 24 位代码字拆分为两个代码字(两次调用 ADDCW16)。其他码字每个码字只有一个宏调用。 ADDCW16 调用可以由一个小型计算机程序生成。

或者，您可以使用 boost header 库(它仅是 header ，您只需使用 boost 的一小部分)。它在预处理器中提供循环和算术运算(通过使用现有的预处理器和非常聪明的符号操作)。