用C语言编写的10个通用RGB灯效算法

ID:46750 · 发表于 2025-2-16 10:51

以下是用C语言编写的10个通用RGB灯效算法，适用于大多数RGB LED控制场景（非硬件特定版本）。每个算法都包含可调节参数，代码设计为独立函数形式，便于集成到不同项目中：

```c
#include <stdint.h>
#include <math.h>

// 颜色结构体（通用RGB格式）
typedef struct {
uint8_t r;
uint8_t g;
uint8_t b;
} RGBColor;

// 1. 呼吸灯效果（单色）
void breathEffect(RGBColor* leds, int numLeds, uint8_t* phase, uint8_t speed, RGBColor color) {
static uint8_t brightness = 0;
static int8_t direction = 1;

brightness += direction * speed;
if(brightness >= 255 - speed) direction = -1;
if(brightness <= speed) direction = 1;

for(int i=0; i<numLeds; i++) {
      leds[i].r = (color.r * brightness) >> 8;
      leds[i].g = (color.g * brightness) >> 8;
      leds[i].b = (color.b * brightness) >> 8;
}
}

// 2. 彩虹波浪效果
void rainbowWave(RGBColor* leds, int numLeds, uint8_t* phase, uint8_t speed) {
*phase += speed;
for(int i=0; i<numLeds; i++) {
      uint8_t hue = *phase + (i * 255 / numLeds);
      hsv2rgb(hue, 255, 255, &leds[i].r, &leds[i].g, &leds[i].b);
}
}

// 3. 跑马灯效果（可调宽度）
void runningDot(RGBColor* leds, int numLeds, uint8_t* position, uint8_t speed, uint8_t width, RGBColor color) {
*position = (*position + speed) % numLeds;

for(int i=0; i<numLeds; i++) {
      uint8_t distance = abs((int)(*position) - i);
      if(distance > width) {
         leds[i] = (RGBColor){0,0,0};
      } else {
         uint8_t intensity = 255 - (distance * 255 / width);
         leds[i].r = (color.r * intensity) >> 8;
         leds[i].g = (color.g * intensity) >> 8;
         leds[i].b = (color.b * intensity) >> 8;
      }
}
}

// 4. 颜色渐变过渡
void colorTransition(RGBColor* leds, int numLeds, uint8_t* phase,
                  RGBColor start, RGBColor end, uint8_t step) {
*phase = (*phase + step) % 255;

for(int i=0; i<numLeds; i++) {
      leds[i].r = start.r + ((end.r - start.r) * *phase) / 255;
      leds[i].g = start.g + ((end.g - start.g) * *phase) / 255;
      leds[i].b = start.b + ((end.b - start.b) * *phase) / 255;
}
}

// 5. 随机流星效果
void meteorShower(RGBColor* leds, int numLeds, uint8_t* pos, uint8_t speed,
               uint8_t tailLength, RGBColor color) {
static uint8_t trail[64] = {0}; // 最大支持64长度拖尾

// 移动流星位置
*pos = (*pos + speed) % (numLeds + tailLength);

// 生成拖尾数据
for(int i=0; i<tailLength; i++) {
      trail[i] = (255 * (tailLength - i)) / tailLength;
}

// 应用效果
for(int i=0; i<numLeds; i++) {
      int trailIndex = i - (*pos - tailLength);
      if(trailIndex >=0 && trailIndex < tailLength) {
         uint8_t intensity = trail[trailIndex];
         leds[i].r = (color.r * intensity) >> 8;
         leds[i].g = (color.g * intensity) >> 8;
         leds[i].b = (color.b * intensity) >> 8;
      } else {
         leds[i] = (RGBColor){0,0,0};
      }
}
}

// 6. 音频频谱风格效果
void spectrumAnalyzer(RGBColor* leds, int numLeds, uint8_t* heights,
                  uint8_t decay, RGBColor color) {
for(int i=0; i<numLeds; i++) {
      // 模拟随机输入数据（实际使用时替换为真实音频数据）
      if(rand()%20 == 0 && heights[i] < 240) heights[i] += 15;

      // 高度衰减
      if(heights[i] > decay) heights[i] -= decay;
      else heights[i] = 0;

      // 绘制柱状图
      leds[i].r = (i < heights[i]/10) ? color.r : 0;
      leds[i].g = (i < heights[i]/10) ? color.g : 0;
      leds[i].b = (i < heights[i]/10) ? color.b : 0;
}
}

// 7. 火焰模拟效果
void fireEffect(RGBColor* leds, int numLeds, uint8_t* heat, uint8_t cooling, uint8_t sparking) {
// 生成随机火花
for(int i=0; i<numLeds; i++) {
      if(rand()%255 < sparking) {
         heat[i] = 255;
      }
}

// 热量扩散
for(int i=numLeds-1; i>=2; i--) {
      heat[i] = (heat[i-1] + heat[i-2] + heat[i-2])/3;
}

// 应用颜色映射
for(int i=0; i<numLeds; i++) {
      uint8_t temp = heat[i];
      leds[i].r = temp;
      leds[i].g = temp/3;
      leds[i].b = temp/10;

      // 冷却
      if(heat[i] >= cooling) heat[i] -= cooling;
      else heat[i] = 0;
}
}

// 8. 双色交替扫描
void dualScan(RGBColor* leds, int numLeds, uint8_t* phase, uint8_t speed,
         RGBColor color1, RGBColor color2) {
static uint8_t direction = 0;
*phase += speed;

if(*phase >= numLeds) {
      *phase = 0;
      direction = !direction;
}

for(int i=0; i<numLeds; i++) {
      if((direction && (i < *phase)) || (!direction && (i >= numLeds - *phase))) {
         leds[i] = color1;
      } else {
         leds[i] = color2;
      }
}
}

// 9. 星光闪烁效果
void starTwinkle(RGBColor* leds, int numLeds, uint8_t* states, uint8_t fadeSpeed) {
for(int i=0; i<numLeds; i++) {
      if(states[i] == 0 && rand()%1000 == 0) {
         states[i] = 255; // 随机点亮
      }

      if(states[i] > 0) {
         leds[i].r = states[i];
         leds[i].g = states[i];
         leds[i].b = states[i];

         if(states[i] > fadeSpeed) states[i] -= fadeSpeed;
         else states[i] = 0;
      } else {
         leds[i] = (RGBColor){0,0,0};
      }
}
}

// 10. 三维立方体效果
void cubeEffect(RGBColor* leds, int numLeds, uint8_t* angle, uint8_t speed,
            RGBColor color) {
// 假设LED排列为8x8x8立方体（需要根据实际布局修改坐标计算）
static const uint8_t cubeSize = 8;
*angle += speed;

for(int x=0; x<cubeSize; x++) {
      for(int y=0; y<cubeSize; y++) {
         for(int z=0; z<cubeSize; z++) {
            int index = x + y*cubeSize + z*cubeSize*cubeSize;
            uint8_t intensity =
                  (sin8(x*32 + *angle) +
                  sin8(y*32 + *angle/2) +
                  sin8(z*32 + *angle/3)) / 3;

            leds[index].r = (color.r * intensity) >> 8;
            leds[index].g = (color.g * intensity) >> 8;
            leds[index].b = (color.b * intensity) >> 8;
         }
      }
}
}

// HSV转RGB辅助函数（优化整数版本）
void hsv2rgb(uint8_t hue, uint8_t sat, uint8_t val,
         uint8_t* r, uint8_t* g, uint8_t* b) {
uint8_t region, remainder;
uint8_t p, q, t;

if(sat == 0) {
      *r = *g = *b = val;
      return;
}

region = hue / 43;
remainder = (hue - (region * 43)) * 6;

p = (val * (255 - sat)) >> 8;
q = (val * (255 - ((sat * remainder) >> 8))) >> 8;
t = (val * (255 - ((sat * (255 - remainder)) >> 8))) >> 8;

switch(region) {
      case 0:  *r = val; *g = t; *b = p; break;
      case 1:  *r = q; *g = val;  *b = p; break;
      case 2:  *r = p; *g = val;  *b = t; break;
      case 3:  *r = p; *g = q; *b = val;  break;
      case 4:  *r = t; *g = p; *b = val;  break;
      default: *r = val; *g = p; *b = q; break;
}
}

// 正弦查表函数（0-255输入，0-255输出）
uint8_t sin8(uint8_t theta) {
static const uint8_t sineTable[] = {
      128, 140, 152, 165, 176, 188, 199, 209, 219, 228, 236, 243, 249, 254,
      255, 254, 249, 243, 236, 228, 219, 209, 199, 188, 176, 165, 152, 140,
      128, 115, 103, 90, 79, 67, 56, 46, 36, 27, 19, 12, 6, 1, 0, 1, 6, 12,
      19, 27, 36, 46, 56, 67, 79, 90, 103, 115
};
return sineTable[theta % 64];
}
```

### 使用说明：
1. **数据结构**：
- 使用`RGBColor`结构体存储颜色值
- LED数组按顺序排列，长度由`numLeds`参数指定

2. **状态管理**：
- 带`*phase`参数的效果需要调用者维护状态变量
- 多LED效果（如流星、火焰）需要预先分配状态数组

3. **性能优化**：
- 使用查表法实现三角函数（`sin8`）
- 全部使用整数运算，避免浮点计算
- 可调节的speed参数控制动画速度

4. **典型调用方式**：
```c
int main() {
const int NUM_LEDS = 64;
RGBColor leds[NUM_LEDS];

// 状态变量
uint8_t phase = 0;
uint8_t meteorPos = 0;
uint8_t fireHeat[NUM_LEDS] = {0};
uint8_t starStates[NUM_LEDS] = {0};

while(1) {
      // 选择要运行的效果（示例）
      fireEffect(leds, NUM_LEDS, fireHeat, 30, 100);
      // rainbowWave(leds, NUM_LEDS, &phase, 3);
      // meteorShower(leds, NUM_LEDS, &meteorPos, 2, 10, (RGBColor){255,0,0});

      // 此处插入实际硬件更新代码
      // ws2812_update(leds, NUM_LEDS);

      delay_ms(30);
}
}
```

### 扩展建议：
1. **颜色混合**：添加颜色混合函数实现更复杂效果
2. **参数动态调整**：通过外部输入（旋钮、传感器等）实时控制参数
3. **效果组合**：使用多层混合实现组合效果
4. **内存优化**：对于资源受限系统，可减少状态变量数量
5. **时间同步**：使用定时器中断确保稳定的刷新率

这些算法经过模块化设计，可根据具体硬件平台轻松适配，适合从Arduino到嵌入式Linux系统的各种应用场景。