由于 LED 矩阵的 PWM，我正在尝试对 Arduino 进行编程。我需要在绘制每条线之前准备好数据，但是过程中最内层的循环太慢了。当前屏幕闪烁。循环应该在 500us 以下完成。 Arduino 有一个 84MHz Cortex-M3 ARM 处理器。

这是我需要如何重新组装输出位的概念:

5 位颜色数据:

R1=12, G1=4, B1=7, R2=0, G2=2, B2=27

下一步是创建连续 1 的 32 位流。 1s的个数由颜色值给出:

r1 = 0b00000000000000000000111111111111
g1 = 0b00000000000000000000000000001111
b1 = 0b00000000000000000000000001111111
r2 = 0b00000000000000000000000000000000
g2 = 0b00000000000000000000000000000011
b2 = 0b00000111111111111111111111111111

最后一步是将 10 个像素(总共 30 个颜色值)的每个第 n 位重新组合成一个 32 位整数:

pack1 = 0b00 ... 111011
pack2 = 0b00 ... 111011
pack3 = 0b00 ... 111001
pack4 = 0b00 ... 111001
pack5 = 0b00 ... 101001
...

这是代码:

  // In my case scanwidth is 64*2 (64 is the width of the LED matrix and two lines are scanned at once)
  for ( i=0; i<scanwidth/5; i++) { // each run uses 5 upper and 5 lower pixels
      data = *lineptr++; // each int in the line buffer contains 2*15-bit inverted color data (red = 31-red etc.)
      p1uR = 0x7FFFFFFF >> (data >> 26); // pixel 1 of upper line red channel
      p1uG = 0x7FFFFFFF >> (data >> 21 & 0b11111);
      p1uB = 0x7FFFFFFF >> (data >> 16 & 0b11111);
      p1lR = 0x7FFFFFFF >> (data >> 10 & 0b11111);
      p1lG = 0x7FFFFFFF >> (data >> 5  & 0b11111);
      p1lB = 0x7FFFFFFF >> (data  & 0b11111);
      data = *lineptr++;
      p2uR = 0x7FFFFFFF >> (data >> 26);
      p2uG = 0x7FFFFFFF >> (data >> 21 & 0b11111);
      p2uB = 0x7FFFFFFF >> (data >> 16 & 0b11111);
      p2lR = 0x7FFFFFFF >> (data >> 10 & 0b11111);
      p2lG = 0x7FFFFFFF >> (data >> 5  & 0b11111);
      p2lB = 0x7FFFFFFF >> (data  & 0b11111);
      data = *lineptr++;
      p3uR = 0x7FFFFFFF >> (data >> 26);
      p3uG = 0x7FFFFFFF >> (data >> 21 & 0b11111);
      p3uB = 0x7FFFFFFF >> (data >> 16 & 0b11111);
      p3lR = 0x7FFFFFFF >> (data >> 10 & 0b11111);
      p3lG = 0x7FFFFFFF >> (data >> 5  & 0b11111);
      p3lB = 0x7FFFFFFF >> (data  & 0b11111);
      data = *lineptr++;
      p4uR = 0x7FFFFFFF >> (data >> 26);
      p4uG = 0x7FFFFFFF >> (data >> 21 & 0b11111);
      p4uB = 0x7FFFFFFF >> (data >> 16 & 0b11111);
      p4lR = 0x7FFFFFFF >> (data >> 10 & 0b11111);
      p4lG = 0x7FFFFFFF >> (data >> 5  & 0b11111);
      p4lB = 0x7FFFFFFF >> (data  & 0b11111);
      data = *lineptr++;
      p5uR = 0x7FFFFFFF >> (data >> 26);
      p5uG = 0x7FFFFFFF >> (data >> 21 & 0b11111);
      p5uB = 0x7FFFFFFF >> (data >> 16 & 0b11111);
      p5lR = 0x7FFFFFFF >> (data >> 10 & 0b11111);
      p5lG = 0x7FFFFFFF >> (data >> 5  & 0b11111);
      p5lB = 0x7FFFFFFF >> (data  & 0b11111);

      index = i;
      for (j=0; j<31; j++){ // loop over all 30 bits
          index += (scanwidth/5+1);
          scanbuff[index] = (p5uR>>j&1)<<29 | (p5uG>>j&1)<<28 | (p5uB>>j&1)<<27 | (p5lR>>j&1)<<26 | (p5lG>>j&1)<<25 | (p5lB>>j&1)<<24 
                          | (p4uR>>j&1)<<23 | (p4uG>>j&1)<<22 | (p4uB>>j&1)<<21 | (p4lR>>j&1)<<20 | (p4lG>>j&1)<<19 | (p4lB>>j&1)<<18 
                          | (p3uR>>j&1)<<17 | (p3uG>>j&1)<<16 | (p3uB>>j&1)<<15 | (p3lR>>j&1)<<14 | (p3lG>>j&1)<<13 | (p3lB>>j&1)<<12 
                          | (p2uR>>j&1)<<11 | (p2uG>>j&1)<<10 | (p2uB>>j&1)<<9  | (p2lR>>j&1)<<8  | (p2lG>>j&1)<<7  | (p2lB>>j&1)<<6 
                          | (p1uR>>j&1)<<5  | (p1uG>>j&1)<<4  | (p1uB>>j&1)<<3  | (p1lR>>j&1)<<2  | (p1lG>>j&1)<<1  | (p1lB>>j&1);
         }
     }

我认为没有必要改进外层循环。我确实尝试展开内部循环，但没有明显改善。

Cortex-M3 可以在一个时钟周期内完成移位和逻辑运算。我估计外循环和内循环大约需要 51000 个时钟周期 (600us)。

我可以使用标准 C++ 代码改进什么吗？内联汇编有什么可以改进的地方吗？

最佳答案

是时候使用一些 Cortex-M 3 黑魔法了。

#include <cstdint>
#include <memory>
#include <cstring>

volatile char *const bitband_packed = (volatile char*)0x20000000;
volatile uint32_t *const bitband_exploded = (volatile uint32_t*)0x22000000;

static inline void transform_32_32(uint32_t buff[32]) {
    const std::size_t size = sizeof(buff[0])*32;
    volatile char *const tmp = bitband_packed;
    std::memcpy(const_cast<char*>(tmp), buff, size);
    for(std::size_t i = 0; i < 32; i++) {
        for(std::size_t j = i + 1; j < 32; j++) {
            std::swap(bitband_exploded[(32 * i + j)], bitband_exploded[(32 * j + i)]);
        }
    }
    std::memcpy(buff, const_cast<char*>(tmp), size);
}

void transform_pwm_32channel_5bit(const uint8_t input[32], uint32_t output[32]) {
    for(std::size_t i = 0; i < 32; i++) {
        output[i] = 0xffffffff >> input[i];
    }
    transform_32_32(output);
}

Cortex-M 系列有一个很好的特性叫做 Bit-Banding .这允许非常有效的按位矩阵变换，这恰好正是您有效地进行 bitbang 所需要的。

转换应该在每个位大约 3 个周期内执行 (compiled on GCC 6.3 with -funroll-loops)，所以这应该总共只有大约 12k 个周期，或者大约 150us。

唯一的收获？这假定您的特定 Cortex-M 3 实际上支持 Bit-Band 功能。我没有机会在 Arduino 上测试这个。

关于c++ - 如何在 C++ 中加速平面到打包/交错图形？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/45311439/