NodeMCU ESP8266 LED矩阵多脉冲动画叠加方案咨询

• 本人是微控制器及相关编程语言新手，拥有一块11×10的LED矩阵，已编写代码实现从中心向边缘扩散的脉冲动画：采用270度周期实现脉冲从中心启动，达到最大亮度后点亮下一个LED；设置90度偏移，使脉冲到达边缘时中心再次变暗，形成环形扩散效果。
• 希望实现音频输入响应音乐，在随机时间点生成重叠脉冲的效果，现有初步思路：
  • 创建大小为10的数组，存储最多10个脉冲的起始时间
  • 遍历所有脉冲计算每个LED的各脉冲RGB亮度
  • 将LED值设为所有状态的中位数
• 咨询问题：
  1. 是否有更优方案？
  2. 我的思路是否完全错误？
  3. 该控制器是否支持异步代码？
  4. 能否通过计算亮度增量替代中位数，直接累加所有增量？

以下是现有代码：

#include <FastLED.h>
#include <math.h>

#define LED_PIN D4        // Pin connected to the LED
#define LED_COUNT 150     // Total number of LEDs
#define MATRIX_WIDTH 11   // Width of the LED matrix
#define MATRIX_HEIGHT 10  // Height of the LED matrix
#define PULSE_TIME 1500   // Time in milliseconds for the pulse effect

CRGB leds[LED_COUNT];
const int matrixLEDCount = MATRIX_WIDTH * MATRIX_HEIGHT;
float brightnessValues[matrixLEDCount];
int mappedMatrix[matrixLEDCount] = {...}; // custom LED's do not match up with the matrix so it is mapped, irrelevant for funcitonality
int center_x = (MATRIX_WIDTH - 1) / 2;
int center_y = (MATRIX_HEIGHT - 1) / 2;
float maxDistance = sqrt(pow(center_x, 2) + pow(center_y, 2));  // 7-ish

void setup() {
  FastLED.addLeds<WS2812B, LED_PIN>(leds, LED_COUNT);
  FastLED.setBrightness(50);  // Adjust overall brightness if needed
  FastLED.clear(true);
}

unsigned long pulseInterval = millis();
unsigned long pulseStart = millis();
unsigned long pulseRateTime = millis();

void loop() {
  if (millis() - pulseInterval <= PULSE_TIME) {// Ignore this duplicate for now, it is to potentially start the pulse at different rates
    if (millis() - pulseStart <= PULSE_TIME) {
      if (millis() - pulseRateTime >= 30) {
        pulseRateTime = millis();

        float pulseProgress = float(millis() - pulseStart) / PULSE_TIME;  // %

        // Calculate brightness for each LED based on its distance from the center
        for (int i = 0; i < matrixLEDCount; i++) {
          int x = i % MATRIX_WIDTH;
          int y = i / MATRIX_WIDTH;

          float distance = sqrt(pow(x - center_x, 2) + pow(y - center_y, 2));
          float brightnessOffset = (distance / (maxDistance + 1));  // %
          if (brightnessOffset > pulseProgress) {
            leds[mappedMatrix[i]] = CRGB(0, 0, 0);
            continue;
          }

          float fadeDegree = (pulseProgress * 270.0) - (90 * brightnessOffset); // Edge to center should be exact opposites
          int brightness = sin(fadeDegree * (3.14159 / 180.0)) * 255;

          // Preventing the restart so all LED's go off
          if(brightness <0){
            brightnessValues[i]; // In case this becomes relevant in overlapping pulses
            leds[mappedMatrix[i]] = CRGB(0, 0, 0);
            continue;
          }
          brightnessValues[i] = brightness;
          leds[mappedMatrix[i]] = CRGB(0, 0, brightnessValues[i]);
        }
        FastLED.show();
      }
    }
  } else {
    // Resetting
    pulseInterval = millis();
    pulseStart = millis();
  }
}

1. 你的思路并非完全错误，存在可行基础 #

用数组存储脉冲起始时间的逻辑是合理的，但取中位数的处理不是最优选择——中位数会抹平脉冲的叠加亮度，视觉上不如直接叠加自然，且计算成本更高。

2. 更优方案：脉冲对象数组+亮度累加 #

推荐定义一个简单的脉冲结构体，存储每个脉冲的核心参数（如起始时间、可选的颜色/强度），然后在每一帧：

• 先清空所有LED的亮度缓存
• 遍历所有未过期的脉冲（即当前时间 - 起始时间 ≤ PULSE_TIME）
• 对每个LED，计算该脉冲对它的亮度贡献，累加到缓存中
• 最后将缓存值限制在0-255之间，赋值给LED

这种方式视觉效果更自然（重叠区域亮度更高），计算逻辑也更简洁。

3. 关于异步代码的支持 #

普通Arduino类微控制器是单线程架构，没有真正的操作系统级异步，但可以用非阻塞式编程（就像你代码中用millis()替代delay()的方式）来模拟“多任务”：在loop()循环中依次处理脉冲计算、音频检测、LED刷新，只要每个步骤不阻塞太久，就能实现同时响应音乐和更新动画的效果。

4. 亮度累加完全可行，且优于中位数 #

直接累加每个脉冲的亮度增量是更合理的选择：

• 符合人眼对叠加光的感知（多个脉冲重叠处更亮）
• 计算比中位数简单，节省MCU资源
• 只需最后用constrain()函数把亮度值限制在0-255即可，避免LED过亮或数值溢出

代码修改示例 #

以下是基于你的思路优化后的核心代码片段：

// 定义脉冲结构体
struct Pulse {
  unsigned long startTime;
  // 可扩展：添加color、intensity等参数
};

#define MAX_PULSES 10
Pulse pulses[MAX_PULSES];
int pulseCount = 0;

// 添加新脉冲的函数（音乐触发时调用）
void addNewPulse() {
  if (pulseCount < MAX_PULSES) {
    pulses[pulseCount].startTime = millis();
    pulseCount++;
  } else {
    // 队列满时，替换最早的脉冲
    for (int i = 0; i < MAX_PULSES - 1; i++) {
      pulses[i] = pulses[i+1];
    }
    pulses[MAX_PULSES - 1].startTime = millis();
  }
}

void loop() {
  // 模拟音乐触发：这里可以替换为音频检测逻辑（比如检测到音量阈值时调用addNewPulse()）
  if (random(100) < 2) { // 随机触发，仅作示例
    addNewPulse();
  }

  if (millis() - pulseRateTime >= 30) {
    pulseRateTime = millis();

    // 清空亮度缓存
    memset(brightnessValues, 0, sizeof(brightnessValues));

    // 遍历所有脉冲
    for (int p = 0; p < pulseCount; p++) {
      unsigned long elapsed = millis() - pulses[p].startTime;
      if (elapsed > PULSE_TIME) {
        // 移除过期脉冲
        for (int i = p; i < pulseCount - 1; i++) {
          pulses[i] = pulses[i+1];
        }
        pulseCount--;
        p--; // 回退索引，避免跳过下一个脉冲
        continue;
      }

      float pulseProgress = float(elapsed) / PULSE_TIME;

      // 计算该脉冲对每个LED的亮度贡献
      for (int i = 0; i < matrixLEDCount; i++) {
        int x = i % MATRIX_WIDTH;
        int y = i / MATRIX_WIDTH;

        float distance = sqrt(pow(x - center_x, 2) + pow(y - center_y, 2));
        float brightnessOffset = distance / (maxDistance + 1);
        if (brightnessOffset > pulseProgress) {
          continue;
        }

        float fadeDegree = (pulseProgress * 270.0) - (90 * brightnessOffset);
        int brightness = sin(fadeDegree * PI / 180.0) * 255;
        if (brightness > 0) {
          brightnessValues[i] += brightness;
        }
      }
    }

    // 将累加后的亮度赋值给LED，限制在0-255
    for (int i = 0; i < matrixLEDCount; i++) {
      int finalBrightness = constrain(brightnessValues[i], 0, 255);
      leds[mappedMatrix[i]] = CRGB(0, 0, finalBrightness);
    }

    FastLED.show();
  }
}

内容的提问来源于stack exchange，提问作者Branchverse