我需要从硬件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的其余八位所有三位的codeIndex = 1，然后是最高有效的五位codeIndex = 2，发送到SPI接口(interface)的下一个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)
}
}
我希望不要太凌乱。
好像这种问题在我解决之前就已经出现了。有没有更快的方法来执行此计算？
最佳答案
您正在询问运行时速度(而不是编程速度)。我假设这是一个16位 Controller /处理器？
存储器中有4 * 68个代码字，我们必须将其转换为147个SPI的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调用可以由小型计算机例程生成。
或者，您可以使用boost header 库(仅提供 header ，而仅使用boost的一小部分)。它在预处理器内提供循环和算术运算(通过使用现有的预处理器和非常巧妙的符号操作)。