将嵌入在 8 位数组中的数据提取到不同大小的数组中

发布于 2025-01-17 06:40:15 字数 511 浏览 4 评论 0原文

我正在开发一个项目，该项目接收一系列压缩为 8 位数组的参数。这些参数的大小可以不同，但始终以 8 位数组形式发送。目标是将这些参数提取到一个数组中，该数组的大小为最大参数的大小（事先已经知道）。

例如，参数数组的第一个索引中可能存储有两个 4 位参数，然后是一个 8 位参数，然后是一个 16 位参数。目标是将每个参数单独放置在长度为 4 的 16 位数组中，其中额外的空间只是 0。我正在努力寻找一种有效地执行此操作的方法，特别是因为 i2c 数组可能在数组的一个字节中嵌入多个参数。任何建议将不胜感激！

为了更好地说明这一点，我们的 8 位数据数组 = [0011 1011, 0110 1111]，参数长度 = [2, 2, 4, 8]。然后，我希望结果数组显示为 [0000 0000, 0000 0011, 0000 1011, 0110 1111< /强>]。粗体数字表示从数据数组中获取的位。

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

口干舌燥 2025-01-24 06:40:15

我之前通过简单地将接收到的字节数组视为位流来解决此类问题。

因此，很容易读取 3 位，然后是 7 位，然后是 10 位，然后是 2 位，等等，直到缓冲区末尾。

您只需保留当前位的索引：

struct bitflow {
  unsigned char* data ; // Received data
  size_t datasize ; // Data size, in bytes.
  size_t pc ;  // Current bit pointer, initialize it to zero.
}

获取下一位（0/1=位，-1=错误）：

int getnextbit (struct bitflow* b) {
  // Check if we didn't already reached the end of buffer.
  // "pc" must be stricly below (classic C indexes) than the number of bytes (datasize) multiplied by 8 (number of bits per byte).
  // A shift of 3 ranks to the left is the same as multiplying by 8, but is faster and will be faster even without any enabled optimization from compiler.
  if (pc>=(datasize<<3))
    return -1 ;
  // Where is the bit:
  // - Targeted byte is the integer part of "pc/8". Again, a shift to accelerate that.
  // - Targeted bit is the remainder of "pc/8". A binary mask with 7 do the same, again faster than a modulo even without optimizations.
  // We then shift a bit (1) to the position of the remainder, and with a bitwise "AND", we extract the bit.
  // If the result is zero, the bit wasn't set, we return zero.
  // If non-zero (equal to (1<<((b->pc) & 7)), in fact), we return "1".
  int result = (((b->data[(b->pc)>>3]) & (1<<((b->pc) & 7))) ? 1 : 0) ;
  // We extracted a bit, so we increment the pointer to next bit.
  b->pc++ ;
  return result ;
}

获取接下来的 N 位（最多 31 位，>=0 = OK，< ;0=错误）：

// l2m==0: read from LSB to MSB, otherwise, read from MSB to LSB.
int getnextbits (struct bitflow* b, int nbbits, int l2m) {
  if ((nbbits<0) || (nbbits>31))
    return -2 ;
  if ((pc+nbbits)>=(datasize<<3))
    return -1 ;
  int result = 0 ;
  size_t j=b->pc ;
// Alternatives for endianness (depends on both CPU used and I2C data format, read both datasheets and/or simply test):
  if (l2m) {
    // 1st read bit is LSB (least significant bit), last read bit is MSB (most significant bit).
    for (int i=0 ; i<nbbits ; i++, j++)
      result |= (((b->data[j>>3]) & (1<<(j & 7))) ? (1<<i) : 0) ;
  } else {
    // 1st read bit is MSB, last read bit is LSB.
    for (int i=(nbbits-1) ; i>=0 ; i--, j++)
      result |= (((b->data[j>>3]) & (1<<(j & 7))) ? (1<<i) : 0) ;
  }
  b->pc += nbbits ;
  return result ;
}

如果nbbits（或仍要提取的位数) 大于或等于剩余位数在当前字节中。但如果您没有大量数据，则不需要它，如果您从 I²C 获取这些数据，则不太可能出现这种情况。

字节序可能会使事情变得有点复杂，但这并非不可能解决 - 我通常在需要时直接在接待处进行字节序交换。

最后，你可以这样读取数据：

// Considering structure is filled by reception routine.
struct bitflow b = getdatafromi2c() ;
// Number of bits for each consecutive element.
int format[10] = { 4, 4, 2, 2, 4, 16, 10, 2, 1, 1 } ;
unsigned short int result[10] ;
for (int i=0 ; i<10 ; i++ ) {
  int v = getnextbits(&b, format[i]) ;
  if (v<0) {
    // Error handling
    ....
  }
  result[i] = (unsigned short int)v ;
}
// Use result array normally from now.

I solved this kind of problem before by simply considering the received array of bytes as a bit flow.

So it's quite easy to read 3 bits, then 7 bits, then 10 bits, then 2 bits, etc. until the end of the buffer.

You simply need to keep an index to the current bit:

struct bitflow {
  unsigned char* data ; // Received data
  size_t datasize ; // Data size, in bytes.
  size_t pc ;  // Current bit pointer, initialize it to zero.
}

To get the next bit (0/1=bit, -1=error):

int getnextbit (struct bitflow* b) {
  // Check if we didn't already reached the end of buffer.
  // "pc" must be stricly below (classic C indexes) than the number of bytes (datasize) multiplied by 8 (number of bits per byte).
  // A shift of 3 ranks to the left is the same as multiplying by 8, but is faster and will be faster even without any enabled optimization from compiler.
  if (pc>=(datasize<<3))
    return -1 ;
  // Where is the bit:
  // - Targeted byte is the integer part of "pc/8". Again, a shift to accelerate that.
  // - Targeted bit is the remainder of "pc/8". A binary mask with 7 do the same, again faster than a modulo even without optimizations.
  // We then shift a bit (1) to the position of the remainder, and with a bitwise "AND", we extract the bit.
  // If the result is zero, the bit wasn't set, we return zero.
  // If non-zero (equal to (1<<((b->pc) & 7)), in fact), we return "1".
  int result = (((b->data[(b->pc)>>3]) & (1<<((b->pc) & 7))) ? 1 : 0) ;
  // We extracted a bit, so we increment the pointer to next bit.
  b->pc++ ;
  return result ;
}

To get the next N bits (max. 31 bits, >=0 = OK, <0=error):

// l2m==0: read from LSB to MSB, otherwise, read from MSB to LSB.
int getnextbits (struct bitflow* b, int nbbits, int l2m) {
  if ((nbbits<0) || (nbbits>31))
    return -2 ;
  if ((pc+nbbits)>=(datasize<<3))
    return -1 ;
  int result = 0 ;
  size_t j=b->pc ;
// Alternatives for endianness (depends on both CPU used and I2C data format, read both datasheets and/or simply test):
  if (l2m) {
    // 1st read bit is LSB (least significant bit), last read bit is MSB (most significant bit).
    for (int i=0 ; i<nbbits ; i++, j++)
      result |= (((b->data[j>>3]) & (1<<(j & 7))) ? (1<<i) : 0) ;
  } else {
    // 1st read bit is MSB, last read bit is LSB.
    for (int i=(nbbits-1) ; i>=0 ; i--, j++)
      result |= (((b->data[j>>3]) & (1<<(j & 7))) ? (1<<i) : 0) ;
  }
  b->pc += nbbits ;
  return result ;
}

This last function can be heavily optimized by getting directly all possible remaining bits of the current byte, if nbbits (or the number of bits still to extract) is greater or equal to the number of bits left in the current byte. But it shouldn't be needed if you don't have a huge load of data, which is quite unlikely if you get these data from I²C.

Endianness can complexify things a bit, but it's not impossible to solve - I usually do the endianness swap directly at reception when needed.

Finally, you can read data this way:

// Considering structure is filled by reception routine.
struct bitflow b = getdatafromi2c() ;
// Number of bits for each consecutive element.
int format[10] = { 4, 4, 2, 2, 4, 16, 10, 2, 1, 1 } ;
unsigned short int result[10] ;
for (int i=0 ; i<10 ; i++ ) {
  int v = getnextbits(&b, format[i]) ;
  if (v<0) {
    // Error handling
    ....
  }
  result[i] = (unsigned short int)v ;
}
// Use result array normally from now.

回复收藏 0 原文

云朵有点甜 2025-01-24 06:40:15

    uint8_t input_array[4];
    uint16_t output_array[4];

    // I have to make an assumption that the two fours are filled little-endian. If it's wrong, it's wrong.
    // You will generally have this problem whenever parameters span bytes. You have to know.
    output_array[0] = input_array[0] & 0xF;
    output_array[1] = input_array[0] >> 4;
    output_array[2] = input_array[1];
    // Similar story here. I assume that input_array's bytes are little endian.
    // You normally find bit-endian and byte-endian are the same but a contrary system could exist.
    output_array[3] = input_array[2] | (input_array[3] << 8);

在过去，人们常常使用结构来做到这一点。有人会过来告诉我这是未定义的，等等；这并不重要。为上面的代码生成糟糕的代码的编译器会为下面的代码生成良好的代码。现代优化编译器为上述问题找到了最有效的方法，但却会搞乱下面的事情。它内置了各种对齐方式和字节序假设；然而，在它起作用的地方，它运作良好。它不起作用的地方是未定义的。

     union u {
         uint8_t input_array[4];
         struct input {
             unsigned char param0 : 4;
             unsigned char param1 : 4;
             unsigned char param2 : 8;
             unsigned char param3 : 6;
         }
     } input_form;

    union input_form input;
    uint16_t output_array[4];
    output_array[0] = input.input.param0;
    output_array[1] = input.input.param1;
    output_array[2] = input.input.param2;
    output_array[3] = input.input.param3;

    uint8_t input_array[4];
    uint16_t output_array[4];

    // I have to make an assumption that the two fours are filled little-endian. If it's wrong, it's wrong.
    // You will generally have this problem whenever parameters span bytes. You have to know.
    output_array[0] = input_array[0] & 0xF;
    output_array[1] = input_array[0] >> 4;
    output_array[2] = input_array[1];
    // Similar story here. I assume that input_array's bytes are little endian.
    // You normally find bit-endian and byte-endian are the same but a contrary system could exist.
    output_array[3] = input_array[2] | (input_array[3] << 8);

In the old days people used to do this with structs. Somebody's going to come by and tell me this is undefined, etc; it doesn't really matter. A compiler that emits terrible code for the above emits good code for the below. It's the modern optimizing compilers that an figure the most efficient way for the above that will mess up the below. This has all kinds of alignment and endian assumptions built into it; however where it works, it works well. Where it doesn't work it's undefined.

     union u {
         uint8_t input_array[4];
         struct input {
             unsigned char param0 : 4;
             unsigned char param1 : 4;
             unsigned char param2 : 8;
             unsigned char param3 : 6;
         }
     } input_form;

    union input_form input;
    uint16_t output_array[4];
    output_array[0] = input.input.param0;
    output_array[1] = input.input.param1;
    output_array[2] = input.input.param2;
    output_array[3] = input.input.param3;

回复收藏 0 原文

~没有更多了~