C ++：不规则大小的二进制码字的快速串联

Question

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

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

这是棘手的部分：我要从SPI模块流式传输的数据不是由16位宽的字构成的。相反，需要按以下方式输出68个码字中的588位：

第一个单词，codeIndex = 0，是24位宽每隔一个字（对于所有奇数x，codeIndex = x）为3位宽所有其余的码字（对于所有非零偶数，codeIndex = x）为14位宽

SPI接口必须按顺序流出所有这些代码字，且没有添加或丢失的位。这意味着我发送到SPI接口的第一个16位字必须是24位codeIndex = 0的最高16位，而下一个16位字就是codeIndex = 0的其余8位紧接codeIndex = 1的所有三位，然后是codeIndex = 2的最高有效五位，发送到SPI接口的下一个16位字将以codeIndex = 2结束，依此类推。

为此，我想出了一种方法，该方法大量使用了二进制OR运算符和按位移位，但是似乎应该有一种通过操纵指针或其他方法来实现此目的的更快方法。

我的方法使用查找表。查找表的每一行根据出现在其中的不规则码字的数量，在其中出现的码字以及在将这些码字的或进行16位或运算之前必须应用于这些码字的按位偏移量定义一个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位控制器/处理器？

我们从存储器中获得了4 * 68个代码字，必须将其转换为147个SPI的147个16位字。

最快的方法似乎是

• 读取代码字
• 选择：左移代码字，或
• 选择：写入结果，增加指针
• 选择：右移代码字，或
• 选择：写入结果，增加指针

与您当前的解决方案相比，因为您已经展开了循环，所以我不会从内存中读取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调用可以由小型计算机例程生成。