21ic电子技术开发论坛 › 个人版区 › 贝贝的实验室 › FastLED可以实现二维点阵LED的显示效果
返回列表 发新帖我要提问

FastLED可以实现二维点阵LED的显示效果

[复制链接]
 楼主| keer_zu 发表于 2025-5-13 22:31 | 显示全部楼层 |阅读模式
FAST, 点阵LED, matrix, ma, ID, IDT

FastLED 完全可以实现二维点阵（矩阵）LED的显示效果！虽然 FastLED 原生设计主要用于一维 LED 灯带控制，但通过合理的 坐标映射 和 逻辑处理，可以轻松将一维灯带数据转换为二维矩阵的显示效果。以下是具体实现方法和示例：

1. 硬件连接与布局

二维点阵的 LED 通常以网格形式排列（如 8x8、16x16 等），常见连接方式有两种：

  • 蛇形排列（Snake Layout）： LED 灯带在行间交替方向（例如，第一行从左到右，第二行从右到左），以缩短走线。
  • 逐行排列（Row-by-Row）： 每行 LED 独立连接，方向一致。

需要根据实际硬件布局编写 坐标映射函数。

2. 核心步骤

(1) 定义二维矩阵参数

#define MATRIX_WIDTH  16  // 矩阵宽度（列数）
#define MATRIX_HEIGHT 8   // 矩阵高度（行数）
#define NUM_LEDS (MATRIX_WIDTH * MATRIX_HEIGHT) // LED总数
CRGB leds[NUM_LEDS];

(2) 坐标映射函数

将二维坐标 (x, y) 转换为一维 LED 索引。 示例代码（蛇形排列）：

cpp

复制

下载

uint16_t XY(uint8_t x, uint8_t y) {
  if (y % 2 == 0) {
    // 偶数行：从左到右
    return y * MATRIX_WIDTH + x;
  } else {
    // 奇数行：从右到左
    return y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x);
  }
}

(3) 控制二维点阵

通过 XY(x, y) 函数直接操作指定坐标的 LED：

// 在坐标 (3, 5) 显示红色
leds[XY(3, 5)] = CRGB::Red;

// 在坐标 (0, 0) 到 (4, 4) 绘制绿色方块
for (int x = 0; x < 5; x++) {
  for (int y = 0; y < 5; y++) {
    leds[XY(x, y)] = CRGB::Green;
  }
}

3. 示例效果实现

(1) 滚动文字/图案

通过偏移坐标实现水平或垂直滚动：

void loop() {
  static int offset = 0;
  for (int x = 0; x < MATRIX_WIDTH; x++) {
    for (int y = 0; y < MATRIX_HEIGHT; y++) {
      // 计算滚动后的坐标（水平滚动）
      int shiftedX = (x + offset) % MATRIX_WIDTH;
      // 根据图案显示颜色（示例：间隔点亮）
      leds[XY(shiftedX, y)] = (x % 2 == 0) ? CRGB::Blue : CRGB::Black;
    }
  }
  FastLED.show();
  offset++;
  delay(100);
}

(2) 动态波纹效果

结合二维坐标计算动态亮度：

void loop() {
  static uint8_t wave = 0;
  for (int x = 0; x < MATRIX_WIDTH; x++) {
    for (int y = 0; y < MATRIX_HEIGHT; y++) {
      // 计算距离中心的波纹强度
      float dx = x - MATRIX_WIDTH/2;
      float dy = y - MATRIX_HEIGHT/2;
      uint8_t brightness = 255 * (sin8(sqrt(dx*dx + dy*dy) + wave) / 255;
      leds[XY(x, y)] = CHSV(128, 255, brightness);
    }
  }
  FastLED.show();
  wave += 5;
  delay(30);
}

4. 高级技巧

(1) 使用二维数组缓存

为简化逻辑，可先将颜色数据存储在二维数组，再批量写入 LED：

CRGB buffer[MATRIX_WIDTH][MATRIX_HEIGHT];

// 更新缓冲区
buffer[3][2] = CRGB::Purple;

// 将缓冲区写入实际 LED
for (int x = 0; x < MATRIX_WIDTH; x++) {
  for (int y = 0; y < MATRIX_HEIGHT; y++) {
    leds[XY(x, y)] = buffer[x][y];
  }
}
FastLED.show();

(2) 优化性能

  • 并行刷新：如果使用多个 LED 控制器（如多个 WS2812B 灯带），可分割矩阵并并行驱动。
  • 颜色预计算：对动态效果预先计算颜色值，减少实时计算量。

5. 完整示例：8x8 矩阵显示彩虹波浪

#include <FastLED.h>
#define MATRIX_WIDTH  8
#define MATRIX_HEIGHT 8
#define NUM_LEDS (MATRIX_WIDTH * MATRIX_HEIGHT)
CRGB leds[NUM_LEDS];

// 坐标映射（蛇形排列）
uint16_t XY(uint8_t x, uint8_t y) {
  return (y % 2 == 0) ? (y * MATRIX_WIDTH + x) : (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x));
}

void setup() {
  FastLED.addLeds<WS2812B, 6>(leds, NUM_LEDS);
}

void loop() {
  static uint8_t hue = 0;
  for (int x = 0; x < MATRIX_WIDTH; x++) {
    for (int y = 0; y < MATRIX_HEIGHT; y++) {
      // 根据坐标生成色相和明度波浪
      uint8_t ledHue = hue + x * 10 + y * 5;
      uint8_t brightness = sin8(x * 20 + y * 20 + hue);
      leds[XY(x, y)] = CHSV(ledHue, 255, brightness);
    }
  }
  FastLED.show();
  hue += 2;
  delay(20);
}

注意事项

  • 硬件布局：务必确认 LED 的物理排列方式（蛇形/逐行），否则坐标会错乱。
  • 性能限制：大型矩阵（如 32x32）可能因刷新率不足导致卡顿，需优化代码或使用更高性能控制器（如 ESP32）。

通过 FastLED 的灵活性和二维坐标映射，你可以轻松实现复杂的动态图案、游戏甚至低分辨率动画！

回复 赏

举报

相关帖子
 楼主| keer_zu 发表于 2025-5-19 21:56 | 显示全部楼层
复制
  1. static uint8_t wave = 0;
    

  2.   for (int x = 0; x < MATRIX_WIDTH; x++) {
    

  3.     for (int y = 0; y < MATRIX_HEIGHT; y++) {
    

  4.       // 计算距离中心的波纹强度
    

  5.       float dx = x - MATRIX_WIDTH/2;
    

  6.       float dy = y - MATRIX_HEIGHT/2;
    

  7.       uint8_t brightness = 255 * (sin8(sqrt(dx*dx + dy*dy) + wave) / 255);
    

  8.       leds[XY(x, y)] = CHSV(128, 255, brightness);
    

  9.     }
    

  10.   }
    

  11.   FastLED.show();
    

  12.   wave += 5;
    

  13.   delay(300);


回复 赏

举报

 楼主| keer_zu 发表于 2025-5-20 11:07 | 显示全部楼层
彩红效果：

复制
  1. static uint8_t hue = 0;
    

  2.   for (int x = 0; x < MATRIX_WIDTH; x++) {
    

  3.     for (int y = 0; y < MATRIX_HEIGHT; y++) {
    

  4.       // 根据坐标生成色相和明度波浪
    

  5.       uint8_t ledHue = hue + x * 10 + y * 5;
    

  6.       uint8_t brightness = sin8(x * 20 + y * 20 + hue);
    

  7.       leds[XY(x, y)] = CHSV(ledHue, 255, brightness);
    

  8.     }
    

  9.   }
    

  10.   FastLED.show();
    

  11.   hue += 2;
    

  12.   delay(20);


回复 赏

举报

 楼主| keer_zu 发表于 2025-5-20 14:41 | 显示全部楼层
复制
  1. #include <BluetoothSerial.h>
    

  2. #include <FastLED.h>
    

  3. #include <math.h>
    

  4. struct Polar { float radius; float angle_radians; };
    


  5. 

  6. Polar cartesianToPolar(float x, float y) {
    

  7.     return {
    

  8.         sqrt(x*x + y*y),
    

  9.         atan2(y, x)
    

  10.     };
    

  11. }
    


  12. 

  13. #define MATRIX_WIDTH  30  // 矩阵宽度（列数）
    

  14. #define MATRIX_HEIGHT 15   // 矩阵高度（行数）
    

  15. #define NUM_LEDS (MATRIX_WIDTH * MATRIX_HEIGHT) // LED总数
    


  16. 

  17. #define LED_PIN     15   // 数据线连接的GPIO引脚
    

  18. //#define NUM_LEDS    450  // LED数量
    

  19. #define BRIGHTNESS 100  // 亮度（0-255）
    

  20. CRGB leds[NUM_LEDS];
    

  21. CRGB red_c   = CRGB(255, 0, 0);    // 红色
    

  22. CRGB green_c   = CRGB(0, 255, 0);    // 绿色
    

  23. CRGB blue_c   = CRGB(0, 0, 255);    // 蓝色
    

  24. CRGB black_c   = CRGB(0, 0, 0);      // 黑色（关闭LED）
    

  25. CRGB white_c   = CRGB(255, 255, 255);// 白色（全亮度）
    


  26. 

  27. CRGB yellow_c   = CRGB(255, 255, 0);  // 黄色
    

  28. CRGB qing_c   = CRGB(0, 255, 255);  // 青色
    

  29. CRGB pin_c   = CRGB(255, 0, 255);  // 品红
    

  30. CRGB cheng_c   = CRGB(255, 165, 0);  // 橙色
    

  31. CRGB zi_c   = CRGB(128, 0, 128);  // 紫色
    

  32. CRGB fen_c   = CRGB(255, 192, 203);// 粉色
    

  33. int flag=0;
    


  34. 

  35. //===================================================
    

  36. // 定义主色和辅助色的HSV范围（H:0-255对应0-360度）
    

  37. const uint8_t MAIN_HUE = 0;     // 主色Hue（例如红色）
    

  38. const uint8_t ACCENT_HUE = 32;  // 辅助色Hue（例如橙色）
    

  39. const uint8_t HUE_RANGE = 16;   // 主辅色之间的过渡范围
    


  40. 

  41. // 动态参数
    

  42. uint8_t baseBrightness = 128;   // 基础亮度
    

  43. uint8_t brightnessJitter = 50;  // 亮度波动范围
    

  44. uint8_t saturation = 200;       // 饱和度（0-255）
    

  45. uint8_t spreadRatio = 50;       // 主色占比（%）
    


  46. 

  47. //===================================================
    


  48. 

  49. #define FILL_LEDS(value) do { \
    

  50.     for (size_t i = 0; i < NUM_LEDS; ++i) { \
    

  51.         (leds)[i] = (value); \
    

  52.     } \
    

  53. } while(0)
    


  54. 

  55. #if !defined(CONFIG_BT_ENABLED) || !defined(CONFIG_BLUEDROID_ENABLED)
    

  56. #error Bluetooth is not enabled! Please run `make menuconfig` to and enable it
    

  57. #endif
    


  58. 

  59. #if !defined(CONFIG_BT_SPP_ENABLED)
    

  60. #error Serial Bluetooth not available or not enabled. It is only available for the ESP32 chip.
    

  61. #endif
    


  62. 

  63. uint16_t XY(uint8_t x, uint8_t y) {
    

  64.   return (y % 2 == 0) ? (y * MATRIX_WIDTH + x) : (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x));
    

  65. }
    


  66. 

  67. BluetoothSerial SerialBT;
    

  68. #define BUFFER_SIZE 1024
    

  69. uint8_t buffer[BUFFER_SIZE];
    

  70. int write_idx = 0;
    

  71. int read_idx = 0;
    

  72. unsigned long total_bytes = 0;
    

  73. unsigned long last_time = 0;
    


  74. 

  75. #define BT_DISCOVER_TIME 10000
    


  76. 

  77. static bool btScanAsync = true;
    

  78. static bool btScanSync = true;
    


  79. 

  80. void btAdvertisedDeviceFound(BTAdvertisedDevice *pDevice) {
    

  81.   Serial.printf("Found a device asynchronously: %s\n", pDevice->toString().c_str());
    

  82. }
    


  83. 

  84. void setup() {
    

  85.   FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
    

  86.   FastLED.setBrightness(BRIGHTNESS);
    

  87.   randomSeed(analogRead(0));    // 初始化随机种子
    

  88.   
    

  89.   Serial.begin(115200);
    

  90.   SerialBT.begin("ESP32-liuyan");  //Bluetooth device name
    

  91.   Serial.println("The device started, now you can pair it with bluetooth!");
    

  92.   // SerialBT.setMTU(1024);
    


  93. 

  94.   if (btScanAsync) {
    

  95.     Serial.print("Starting asynchronous discovery... ");
    

  96.     if (SerialBT.discoverAsync(btAdvertisedDeviceFound)) {
    

  97.       Serial.println("Findings will be reported in "btAdvertisedDeviceFound"");
    

  98.       delay(10000);
    

  99.       Serial.print("Stopping discoverAsync... ");
    

  100.       SerialBT.discoverAsyncStop();
    

  101.       Serial.println("stopped");
    

  102.     } else {
    

  103.       Serial.println("Error on discoverAsync f.e. not working after a "connect"");
    

  104.     }
    

  105.   }
    


  106. 

  107.   if (btScanSync) {
    

  108.     Serial.println("Starting synchronous discovery... ");
    

  109.     BTScanResults *pResults = SerialBT.discover(BT_DISCOVER_TIME);
    

  110.     if (pResults) {
    

  111.       pResults->dump(&Serial);
    

  112.     } else {
    

  113.       Serial.println("Error on BT Scan, no result!");
    

  114.     }
    

  115.   }
    

  116. }
    


  117. 

  118. void fill_shape( struct CRGB * targetArray, int numToFill,
    

  119.                   uint8_t initialhue,
    

  120.                   uint8_t deltahue )
    

  121. {
    

  122.     CHSV hsv;
    

  123.     hsv.hue = initialhue;
    

  124.     hsv.val = 255;
    

  125.     hsv.sat = 240;
    

  126.     for( int i = 0; i < numToFill; ++i) {
    

  127.         targetArray[i] = hsv;
    

  128.         hsv.hue += deltahue;
    

  129.     }
    

  130. }
    


  131. 

  132. void breath_light()
    

  133. {
    

  134.  static uint8_t brightness = 0;
    

  135.   // 使用正弦波生成明度值（0-255）
    

  136.   brightness = beatsin8(10, 50, 255); // 参数：频率（Hz）, 最小值, 最大值
    

  137.   fill_solid(leds, NUM_LEDS, CHSV(96, 255, brightness)); // 固定色相（如绿色）
    

  138.   FastLED.show();
    

  139. }
    


  140. 

  141. void loop() {
    

  142. #if 0
    

  143.   int index;
    

  144.   static uint8_t hue = 0;
    

  145.     // 非阻塞读取蓝牙数据
    

  146.   while (SerialBT.available()) {
    

  147.     int bytes_to_read = SerialBT.available();
    

  148.     bytes_to_read = min(bytes_to_read, BUFFER_SIZE - write_idx);
    


  149. 

  150.     // 写入缓冲区
    

  151.     if (bytes_to_read > 0) {
    

  152.       flag = 1;
    

  153.       SerialBT.readBytes(&buffer[write_idx], bytes_to_read);
    

  154.       if(buffer[write_idx] == 'r' || buffer[write_idx] == 'R'){
    

  155.         FILL_LEDS(red_c);
    

  156.       } else if(buffer[write_idx] == 'g' || buffer[write_idx] == 'G'){
    

  157.         FILL_LEDS(green_c);
    

  158.       } else if(buffer[write_idx] == 'b' || buffer[write_idx] == 'B'){
    

  159.         FILL_LEDS(blue_c);
    

  160.       } else if(buffer[write_idx] == 'w' || buffer[write_idx] == 'W'){
    

  161.         FILL_LEDS(white_c);
    

  162.       } else if(buffer[write_idx] == 'y' || buffer[write_idx] == 'Y'){
    

  163.         FILL_LEDS(yellow_c);
    

  164.       } else if(buffer[write_idx] == 's' || buffer[write_idx] == 'S'){
    

  165.         FILL_LEDS(black_c);
    

  166.         flag = 0;
    

  167.       } else if(buffer[write_idx] == 'q' || buffer[write_idx] == 'Q'){
    

  168.         FILL_LEDS(qing_c);
    

  169.       } else if(buffer[write_idx] == 'p' || buffer[write_idx] == 'P'){
    

  170.         FILL_LEDS(pin_c);
    

  171.       } else if(buffer[write_idx] == 'c' || buffer[write_idx] == 'C'){
    

  172.         FILL_LEDS(cheng_c);
    

  173.       } else if(buffer[write_idx] == 'z' || buffer[write_idx] == 'Z'){
    

  174.         FILL_LEDS(zi_c);
    

  175.       } else if(buffer[write_idx] == 'f' || buffer[write_idx] == 'F'){
    

  176.         FILL_LEDS(fen_c);
    

  177.       } else if(buffer[write_idx] == 'v' || buffer[write_idx] == 'V'){
    

  178.         FILL_LEDS(fen_c);
    

  179.       }
    

  180.       
    

  181.       FastLED.show();
    

  182.         
    

  183.       for(index = 0;index < bytes_to_read;index ++)
    

  184.       Serial.printf("%c",buffer[write_idx + index]);
    

  185.       write_idx = (write_idx + bytes_to_read) % BUFFER_SIZE;
    

  186.       total_bytes += bytes_to_read;
    

  187.     } else {
    

  188.       
    

  189.     }
    


  190. 

  191.     // 缓冲区切换检查（防止覆盖未读数据）
    

  192.     if (write_idx >= BUFFER_SIZE / 2 && read_idx < BUFFER_SIZE / 2) {
    

  193.       read_idx = BUFFER_SIZE / 2;  // 切换到后半缓冲区
    

  194.     }
    

  195.   }
    


  196. 

  197.   // 计算实时带宽
    

  198.   unsigned long current_time = millis();
    

  199.   if (current_time - last_time >= 1000) {
    

  200.     float rate = (total_bytes * 8) / 1000.0;  // 转换为Kbps
    

  201.     //Serial.printf("当前接收速率: %.2f Kbps\n", rate);
    

  202.     total_bytes = 0;
    

  203.     last_time = current_time;
    

  204.   }
    

  205.   
    

  206.   //if(!flag) {
    

  207.     fill_shape(leds, NUM_LEDS, hue++, 10);
    

  208.     FastLED.show();
    

  209.     //Serial.printf("%d\n",hue);
    

  210.     //delay(1000);
    

  211.     //FILL_LEDS(black_c);
    

  212.     //FastLED.show();
    

  213.     //delay(1000);
    

  214.     //delay(10);
    

  215.     //flag = !flag;
    

  216.   //}
    

  217. #else
    

  218. static uint8_t hue = 0;
    

  219.   for (int x = 0; x < MATRIX_WIDTH; x++) {
    

  220.     for (int y = 0; y < MATRIX_HEIGHT; y++) {
    

  221.       // 根据坐标生成色相和明度波浪
    

  222.       uint8_t ledHue = hue + x * 10 + y * 5;
    

  223.       uint8_t brightness = sin8(x * 20 + y * 20 + hue);
    

  224.       leds[XY(x, y)] = CHSV(ledHue, 255, brightness);
    

  225.     }
    

  226.   }
    

  227.   FastLED.show();
    

  228.   hue += 2;
    

  229.   delay(20);
    

  230. //breath_light();
    

  231. #endif
    

  232. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-20 19:12 | 显示全部楼层
复制
  1. #if 1
    

  2. void optim_vision()
    

  3. {
    

  4. float global_brightness = breathe(20.0);  // 20秒呼吸周期
    

  5.   rotation_angle += ROTATION_SPEED * (millis() % 20) / 1000.0;
    

  6.   
    

  7.   for(int i=0; i<NUM_LEDS; i++) {
    

  8.     float r = led_r[i];
    

  9.     float theta = led_theta[i] + rotation_angle;
    

  10.     
    

  11.     // 添加角度扰动
    

  12.     theta += randomGaussian();
    

  13.     
    

  14.     CRGB color;
    

  15.     if(r < 0.15) {  // 核心层
    

  16.       float layerBrightness = 0.8 + 0.2 * sin(millis()/500.0);  // 动态亮度
    

  17.       color = colorBlend(coreColor1, coreColor2, layerBrightness);
    

  18.     } 
    

  19.     else if(r < 0.4) {  // 过渡层
    

  20.       color = colorBlend(mainColor, coreColor2, 0.3);
    

  21.     } 
    

  22.     else {  // 背景层
    

  23.       color = bgColor;
    

  24.     }
    

  25.     
    

  26.     // 应用全局亮度
    

  27.     color.fadeToBlackBy(255 * (1 - global_brightness));
    

  28.     leds[i] = color;
    

  29.   }
    

  30.   
    

  31.   FastLED.show();
    

  32.   FastLED.delay(20);  // 控制刷新率
    

  33. }
    

  34. #endif
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-20 19:14 | 显示全部楼层
复制
  1. #include "led_functions.h"
    


  2. 

  3. #define NOISE_STRENGTH 0.3   // 扰动强度
    


  4. 

  5. CRGB leds[NUM_LEDS]; // 实际定义LED数组
    


  6. 

  7. // 极坐标系统
    

  8. float led_r[NUM_LEDS];      // 半径（归一化 0-1）
    

  9. float led_theta[NUM_LEDS];  // 初始角度（弧度）
    

  10. float rotation_angle = 0;   // 当前旋转角度
    


  11. 


  12. 

  13. // 高斯噪声生成
    

  14. float randomGaussian() {
    

  15.   // 使用Box-Muller转换生成高斯分布
    

  16.   static float z0, z1;
    

  17.   static bool generate = false;
    

  18.   generate = !generate;
    

  19.   
    

  20.   if (!generate) return z1 * NOISE_STRENGTH;
    

  21.   
    

  22.   float u1, u2;
    

  23.   do {
    

  24.     u1 = random(1, 1000) / 1000.0;
    

  25.     u2 = random(1, 1000) / 1000.0;
    

  26.   } while (u1 <= 0.0001);
    

  27.   
    

  28.   z0 = sqrt(-2.0 * log(u1)) * cos(TWO_PI * u2);
    

  29.   z1 = sqrt(-2.0 * log(u1)) * sin(TWO_PI * u2);
    

  30.   return z0 * NOISE_STRENGTH;
    

  31. }
    


  32. 

  33. // 呼吸效果生成器
    

  34. float breathe(float periodSeconds) {
    

  35.   static unsigned long lastUpdate;
    

  36.   float cycle = (millis() - lastUpdate) / (periodSeconds * 1000);
    

  37.   return (sin(cycle * TWO_PI) * 0.5 + 0.5);  // 输出0-1
    

  38. }
    


  39. 

  40. // 极坐标初始化
    

  41. void initPolarCoords() {
    

  42.   // 假设LED排列在圆形区域（需要根据实际布局调整）
    

  43.   for(int i=0; i<NUM_LEDS; i++) {
    

  44.     // 转换为虚拟坐标（示例用圆形布局）
    

  45.     float x = (i % MATRIX_WIDTH) / MATRIX_WIDTH - 0.5;  // 假设50x10的布局
    

  46.     float y = (i / MATRIX_WIDTH) / MATRIX_HEIGHT - 0.5;
    

  47.     
    

  48.     led_r[i] = sqrt(x*x + y*y) * 2;    // 归一化半径
    

  49.     led_theta[i] = atan2(y, x);        // 初始角度
    

  50.   }
    

  51. }
    


  52. 

  53. // 颜色混合函数
    

  54. CRGB colorBlend(CRGB color1, CRGB color2, float weight) {
    

  55.   return CRGB(
    

  56.     color1.r * (1-weight) + color2.r * weight,
    

  57.     color1.g * (1-weight) + color2.g * weight,
    

  58.     color1.b * (1-weight) + color2.b * weight
    

  59.   );
    

  60. }
    


  61. 

  62. uint16_t XY(uint8_t x, uint8_t y) 
    

  63. {
    

  64.   return (y % 2 == 0) ? (y * MATRIX_WIDTH + x) : (y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x));
    

  65. }
    


  66. 


  67. 

  68. void leds_setup()
    

  69. {
    

  70.   FastLED.addLeds<WS2812B, LED_PIN, GRB>(leds, NUM_LEDS);
    

  71.   FastLED.setBrightness(BRIGHTNESS);
    

  72.   initPolarCoords();
    

  73. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-24 00:48 | 显示全部楼层
显示“祝你生日快乐”

复制
  1. #include <FastLED.h>
    


  2. 

  3. #define LED_PIN     15
    

  4. #define COLOR_ORDER GRB
    

  5. #define CHIPSET     WS2815
    

  6. #define NUM_LEDS    450
    

  7. CRGB leds[NUM_LEDS];
    


  8. 

  9. #define MATRIX_WIDTH  30
    

  10. #define MATRIX_HEIGHT 15
    


  11. 

  12. #define BITMAP_WIDTH 96
    


  13. 

  14. #define BITMAP_INDEX(x,y) ((14-y)*12 + (x/8) - 1)
    

  15. #define BITMMAP_POSITION(x) (x%8)
    


  16. 


  17. 

  18. // 颜色定义
    

  19. const CRGB BACKGROUND_COLOR = CRGB(0x0, 0x0, 0x100); // 
    

  20. const CRGB TEXT_COLOR = CRGB(0xFF, 0x0, 0x00);       // 
    


  21. 

  22. // 点阵数据（已转换格式）
    

  23.  /*96 x 15*/
    

  24. static const unsigned char textBitmap[] = {
    

  25.     0x33, 0xfc, 0x08, 0x80, 0x11, 0x00, 0x1f, 0xf0, 0x10, 0x40, 0x00, 0xf0, 
    

  26.     0x13, 0xfc, 0x08, 0x80, 0x11, 0x00, 0x1f, 0xf0, 0x10, 0x40, 0x1f, 0xf0, 
    

  27.     0xfa, 0x04, 0x19, 0xfe, 0x11, 0x00, 0x10, 0x10, 0x13, 0xf8, 0x1f, 0x00, 
    

  28.     0xfa, 0x04, 0x11, 0xfe, 0x3f, 0xfc, 0x10, 0x10, 0x1b, 0xf8, 0x11, 0x00, 
    

  29.     0x1a, 0x04, 0x33, 0x06, 0x3f, 0xfc, 0x10, 0x10, 0x5c, 0x48, 0x31, 0x00, 
    

  30.     0x13, 0xfc, 0x36, 0x24, 0x61, 0x00, 0x10, 0x10, 0x54, 0x48, 0x21, 0x00, 
    

  31.     0x3b, 0xfc, 0x74, 0x20, 0xc1, 0x00, 0x1f, 0xf0, 0x50, 0x48, 0x3f, 0xfc, 
    

  32.     0x7c, 0x90, 0xd1, 0x28, 0x81, 0x00, 0x1f, 0xf0, 0xd7, 0xfe, 0x3f, 0xfc, 
    

  33.     0xd4, 0x90, 0x91, 0x2c, 0x3f, 0xf8, 0x10, 0x10, 0x97, 0xfe, 0x09, 0x20, 
    

  34.     0x94, 0x90, 0x13, 0x24, 0x3f, 0xf8, 0x10, 0x10, 0x10, 0xe0, 0x09, 0x30, 
    

  35.     0x11, 0x92, 0x12, 0x26, 0x01, 0x00, 0x10, 0x10, 0x10, 0xa0, 0x19, 0x18, 
    

  36.     0x11, 0x12, 0x16, 0x22, 0x01, 0x00, 0x10, 0x10, 0x11, 0xb0, 0x31, 0x0c, 
    

  37.     0x13, 0x12, 0x14, 0x22, 0x01, 0x00, 0x10, 0x10, 0x11, 0x10, 0x61, 0x04, 
    

  38.     0x16, 0x1e, 0x10, 0xa0, 0xff, 0xfe, 0x1f, 0xf0, 0x13, 0x18, 0x45, 0x04, 
    

  39.     0x1c, 0x0e, 0x10, 0xe0, 0xff, 0xfe, 0x1f, 0xf0, 0x16, 0x0e, 0x07, 0x00
    

  40. };
    


  41. 

  42. int scrollOffset = 0;
    


  43. 

  44. // 蛇形布局坐标转换
    

  45. int getLedIndex(int x, int y) {
    

  46.   if (x < 0 || x >= MATRIX_WIDTH || y < 0 || y >= MATRIX_HEIGHT) return -1;
    

  47.   if (y % 2 == 0) return y * MATRIX_WIDTH + x;
    

  48.   else return y * MATRIX_WIDTH + (MATRIX_WIDTH - 1 - x);
    

  49. }
    


  50. 

  51. void setup() {
    

  52.   FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
    

  53.   FastLED.setBrightness(50);
    

  54. }
    


  55. 

  56. void loop() {
    

  57.   static unsigned long lastUpdate = 0;
    

  58.   if (millis() - lastUpdate > 100) {
    

  59.     lastUpdate = millis();
    

  60.     
    

  61.     fill_solid(leds, NUM_LEDS, BACKGROUND_COLOR);
    


  62. 

  63.     for (int x = 0; x < MATRIX_WIDTH; x++) {
    

  64.       int bitmapX = (scrollOffset + x) % BITMAP_WIDTH;
    

  65.       for (int y = 0; y < MATRIX_HEIGHT; y++) {
    

  66.         if ((textBitmap[BITMAP_INDEX(bitmapX,y)] << BITMMAP_POSITION(bitmapX)) &0x80) {
    

  67.           int ledIndex = getLedIndex(x, y);
    

  68.           if (ledIndex != -1) leds[ledIndex] = TEXT_COLOR;
    

  69.         }
    

  70.       }
    

  71.     }
    


  72. 

  73.     FastLED.show();
    

  74.     scrollOffset = (scrollOffset + 1) % BITMAP_WIDTH;
    

  75.   }
    

  76. }
回复 赏

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 注册

本版积分规则

keer_zu
个人签名：qq群：49734243 Email:zukeqiang@gmail.com

1477

主题

12909

帖子

55

粉丝
快速回复 在线客服 返回列表 返回顶部