21ic电子技术开发论坛 › 个人版区 › 贝贝的实验室 › 很好的LED显示例子
返回列表 发新帖我要提问

很好的LED显示例子

[复制链接]
 楼主| keer_zu 发表于 2025-5-21 12:15 | 显示全部楼层 |阅读模式
LED显示, bi, TE, RA, FRAM, RAM
代码：

复制
  1. // TETRIS
    

  2. #include <FastLED.h>
    

  3. #include <LEDMatrix.h>
    

  4. #include <LEDSprites.h>
    

  5. #include <LEDText.h>
    

  6. #include <FontMatrise.h>
    

  7. #include "BluetoothSerial.h"
    


  8. 

  9. #define LED_PIN        15
    

  10. #define COLOR_ORDER    GRB
    

  11. #define CHIPSET        WS2812B
    

  12. #define MATRIX_WIDTH   30
    

  13. #define MATRIX_HEIGHT  15
    

  14. #define MATRIX_TYPE    HORIZONTAL_MATRIX
    


  15. 

  16. // NOTE the '-' sign before the width, this is due to my leds matrix origin being on the right hand side
    

  17. cLEDMatrix<MATRIX_WIDTH, -MATRIX_HEIGHT, MATRIX_TYPE> leds;
    


  18. 

  19. BluetoothSerial SerialBT;
    


  20. 

  21. #define TARGET_FRAME_TIME    15  // Desired update rate, though if too many leds it will just run as fast as it can!
    

  22. #define INITIAL_DROP_FRAMES  20  // Start of game block drop delay in frames
    


  23. 

  24. // Bluetooth input
    

  25. enum btnInput {NONE, ROTATE, DOWN, LEFT, RIGHT};
    

  26. btnInput currentInput = NONE;
    


  27. 

  28. const uint8_t TetrisIData[] = 
    

  29. {
    

  30.   // Frame 1
    

  31.   B8_3BIT(00000000),
    

  32.   B8_3BIT(00000000),
    

  33.   B8_3BIT(00000000),
    

  34.   B8_3BIT(11110000),
    

  35.   // Frame 2
    

  36.   B8_3BIT(10000000),
    

  37.   B8_3BIT(10000000),
    

  38.   B8_3BIT(10000000),
    

  39.   B8_3BIT(10000000),
    

  40.   // Frame 3
    

  41.   B8_3BIT(00000000),
    

  42.   B8_3BIT(00000000),
    

  43.   B8_3BIT(00000000),
    

  44.   B8_3BIT(11110000),
    

  45.   // Frame 4
    

  46.   B8_3BIT(10000000),
    

  47.   B8_3BIT(10000000),
    

  48.   B8_3BIT(10000000),
    

  49.   B8_3BIT(10000000)
    

  50. };
    

  51. const uint8_t TetrisIMask[] = 
    

  52. {
    

  53.   // Frame 1
    

  54.   B8_1BIT(00000000),
    

  55.   B8_1BIT(00000000),
    

  56.   B8_1BIT(00000000),
    

  57.   B8_1BIT(11110000),
    

  58.   // Frame 2
    

  59.   B8_1BIT(10000000),
    

  60.   B8_1BIT(10000000),
    

  61.   B8_1BIT(10000000),
    

  62.   B8_1BIT(10000000),
    

  63.   // Frame 3
    

  64.   B8_1BIT(00000000),
    

  65.   B8_1BIT(00000000),
    

  66.   B8_1BIT(00000000),
    

  67.   B8_1BIT(11110000),
    

  68.   // Frame 4
    

  69.   B8_1BIT(10000000),
    

  70.   B8_1BIT(10000000),
    

  71.   B8_1BIT(10000000),
    

  72.   B8_1BIT(10000000)
    

  73. };
    

  74. const uint8_t TetrisJData[] = 
    

  75. {
    

  76.   // Frame 1
    

  77.   B8_3BIT(00000000),
    

  78.   B8_3BIT(00000000),
    

  79.   B8_3BIT(22200000),
    

  80.   B8_3BIT(00200000),
    

  81.   // Frame 2
    

  82.   B8_3BIT(00000000),
    

  83.   B8_3BIT(02000000),
    

  84.   B8_3BIT(02000000),
    

  85.   B8_3BIT(22000000),
    

  86.   // Frame 3
    

  87.   B8_3BIT(00000000),
    

  88.   B8_3BIT(00000000),
    

  89.   B8_3BIT(20000000),
    

  90.   B8_3BIT(22200000),
    

  91.   // Frame 4
    

  92.   B8_3BIT(00000000),
    

  93.   B8_3BIT(22000000),
    

  94.   B8_3BIT(20000000),
    

  95.   B8_3BIT(20000000)
    

  96. };
    

  97. const uint8_t TetrisJMask[] = 
    

  98. {
    

  99.   // Frame 1
    

  100.   B8_1BIT(00000000),
    

  101.   B8_1BIT(00000000),
    

  102.   B8_1BIT(11100000),
    

  103.   B8_1BIT(00100000),
    

  104.   // Frame 2
    

  105.   B8_1BIT(00000000),
    

  106.   B8_1BIT(01000000),
    

  107.   B8_1BIT(01000000),
    

  108.   B8_1BIT(11000000),
    

  109.   // Frame 3
    

  110.   B8_1BIT(00000000),
    

  111.   B8_1BIT(00000000),
    

  112.   B8_1BIT(10000000),
    

  113.   B8_1BIT(11100000),
    

  114.   // Frame 4
    

  115.   B8_1BIT(00000000),
    

  116.   B8_1BIT(11000000),
    

  117.   B8_1BIT(10000000),
    

  118.   B8_1BIT(10000000)
    

  119. };
    

  120. const uint8_t TetrisLData[] = 
    

  121. {
    

  122.   // Frame 1
    

  123.   B8_3BIT(00000000),
    

  124.   B8_3BIT(00000000),
    

  125.   B8_3BIT(33300000),
    

  126.   B8_3BIT(30000000),
    

  127.   // Frame 2
    

  128.   B8_3BIT(00000000),
    

  129.   B8_3BIT(33000000),
    

  130.   B8_3BIT(03000000),
    

  131.   B8_3BIT(03000000),
    

  132.   // Frame 3
    

  133.   B8_3BIT(00000000),
    

  134.   B8_3BIT(00000000),
    

  135.   B8_3BIT(00300000),
    

  136.   B8_3BIT(33300000),
    

  137.   // Frame 4
    

  138.   B8_3BIT(00000000),
    

  139.   B8_3BIT(30000000),
    

  140.   B8_3BIT(30000000),
    

  141.   B8_3BIT(33000000)
    

  142. };
    

  143. const uint8_t TetrisLMask[] = 
    

  144. {
    

  145.   // Frame 1
    

  146.   B8_1BIT(00000000),
    

  147.   B8_1BIT(00000000),
    

  148.   B8_1BIT(11100000),
    

  149.   B8_1BIT(10000000),
    

  150.   // Frame 2
    

  151.   B8_1BIT(00000000),
    

  152.   B8_1BIT(11000000),
    

  153.   B8_1BIT(01000000),
    

  154.   B8_1BIT(01000000),
    

  155.   // Frame 3
    

  156.   B8_1BIT(00000000),
    

  157.   B8_1BIT(00000000),
    

  158.   B8_1BIT(00100000),
    

  159.   B8_1BIT(11100000),
    

  160.   // Frame 4
    

  161.   B8_1BIT(00000000),
    

  162.   B8_1BIT(10000000),
    

  163.   B8_1BIT(10000000),
    

  164.   B8_1BIT(11000000)
    

  165. };
    

  166. const uint8_t TetrisOData[] = 
    

  167. {
    

  168.   // Frame 1
    

  169.   B8_3BIT(00000000),
    

  170.   B8_3BIT(00000000),
    

  171.   B8_3BIT(44000000),
    

  172.   B8_3BIT(44000000),
    

  173.   // Frame 2
    

  174.   B8_3BIT(00000000),
    

  175.   B8_3BIT(00000000),
    

  176.   B8_3BIT(44000000),
    

  177.   B8_3BIT(44000000),
    

  178.   // Frame 3
    

  179.   B8_3BIT(00000000),
    

  180.   B8_3BIT(00000000),
    

  181.   B8_3BIT(44000000),
    

  182.   B8_3BIT(44000000),
    

  183.   // Frame 4
    

  184.   B8_3BIT(00000000),
    

  185.   B8_3BIT(00000000),
    

  186.   B8_3BIT(44000000),
    

  187.   B8_3BIT(44000000)
    

  188. };
    

  189. const uint8_t TetrisOMask[] = 
    

  190. {
    

  191.   // Frame 1
    

  192.   B8_1BIT(00000000),
    

  193.   B8_1BIT(00000000),
    

  194.   B8_1BIT(11000000),
    

  195.   B8_1BIT(11000000),
    

  196.   // Frame 2
    

  197.   B8_1BIT(00000000),
    

  198.   B8_1BIT(00000000),
    

  199.   B8_1BIT(11000000),
    

  200.   B8_1BIT(11000000),
    

  201.   // Frame 3
    

  202.   B8_1BIT(00000000),
    

  203.   B8_1BIT(00000000),
    

  204.   B8_1BIT(11000000),
    

  205.   B8_1BIT(11000000),
    

  206.   // Frame 4
    

  207.   B8_1BIT(00000000),
    

  208.   B8_1BIT(00000000),
    

  209.   B8_1BIT(11000000),
    

  210.   B8_1BIT(11000000)
    

  211. };
    

  212. const uint8_t TetrisSData[] = 
    

  213. {
    

  214.   // Frame 1
    

  215.   B8_3BIT(00000000),
    

  216.   B8_3BIT(00000000),
    

  217.   B8_3BIT(05500000),
    

  218.   B8_3BIT(55000000),
    

  219.   // Frame 2
    

  220.   B8_3BIT(00000000),
    

  221.   B8_3BIT(50000000),
    

  222.   B8_3BIT(55000000),
    

  223.   B8_3BIT(05000000),
    

  224.   // Frame 3
    

  225.   B8_3BIT(00000000),
    

  226.   B8_3BIT(00000000),
    

  227.   B8_3BIT(05500000),
    

  228.   B8_3BIT(55000000),
    

  229.   // Frame 4
    

  230.   B8_3BIT(00000000),
    

  231.   B8_3BIT(50000000),
    

  232.   B8_3BIT(55000000),
    

  233.   B8_3BIT(05000000)
    

  234. };
    

  235. const uint8_t TetrisSMask[] = 
    

  236. {
    

  237.   // Frame 1
    

  238.   B8_1BIT(00000000),
    

  239.   B8_1BIT(00000000),
    

  240.   B8_1BIT(01100000),
    

  241.   B8_1BIT(11000000),
    

  242.   // Frame 2
    

  243.   B8_1BIT(00000000),
    

  244.   B8_1BIT(10000000),
    

  245.   B8_1BIT(11000000),
    

  246.   B8_1BIT(01000000),
    

  247.   // Frame 3
    

  248.   B8_1BIT(00000000),
    

  249.   B8_1BIT(00000000),
    

  250.   B8_1BIT(01100000),
    

  251.   B8_1BIT(11000000),
    

  252.   // Frame 4
    

  253.   B8_1BIT(00000000),
    

  254.   B8_1BIT(10000000),
    

  255.   B8_1BIT(11000000),
    

  256.   B8_1BIT(01000000)
    

  257. };
    

  258. const uint8_t TetrisTData[] = 
    

  259. {
    

  260.   // Frame 1
    

  261.   B8_3BIT(00000000),
    

  262.   B8_3BIT(00000000),
    

  263.   B8_3BIT(66600000),
    

  264.   B8_3BIT(06000000),
    

  265.   // Frame 2
    

  266.   B8_3BIT(00000000),
    

  267.   B8_3BIT(06000000),
    

  268.   B8_3BIT(66000000),
    

  269.   B8_3BIT(06000000),
    

  270.   // Frame 3
    

  271.   B8_3BIT(00000000),
    

  272.   B8_3BIT(00000000),
    

  273.   B8_3BIT(06000000),
    

  274.   B8_3BIT(66600000),
    

  275.   // Frame 4
    

  276.   B8_3BIT(00000000),
    

  277.   B8_3BIT(60000000),
    

  278.   B8_3BIT(66000000),
    

  279.   B8_3BIT(60000000)
    

  280. };
    

  281. const uint8_t TetrisTMask[] = 
    

  282. {
    

  283.   // Frame 1
    

  284.   B8_1BIT(00000000),
    

  285.   B8_1BIT(00000000),
    

  286.   B8_1BIT(11100000),
    

  287.   B8_1BIT(01000000),
    

  288.   // Frame 2
    

  289.   B8_1BIT(00000000),
    

  290.   B8_1BIT(01000000),
    

  291.   B8_1BIT(11000000),
    

  292.   B8_1BIT(01000000),
    

  293.   // Frame 3
    

  294.   B8_1BIT(00000000),
    

  295.   B8_1BIT(00000000),
    

  296.   B8_1BIT(01000000),
    

  297.   B8_1BIT(11100000),
    

  298.   // Frame 4
    

  299.   B8_1BIT(00000000),
    

  300.   B8_1BIT(10000000),
    

  301.   B8_1BIT(11000000),
    

  302.   B8_1BIT(10000000)
    

  303. };
    

  304. const uint8_t TetrisZData[] = 
    

  305. {
    

  306.   // Frame 1
    

  307.   B8_3BIT(00000000),
    

  308.   B8_3BIT(00000000),
    

  309.   B8_3BIT(77000000),
    

  310.   B8_3BIT(07700000),
    

  311.   // Frame 2
    

  312.   B8_3BIT(00000000),
    

  313.   B8_3BIT(07000000),
    

  314.   B8_3BIT(77000000),
    

  315.   B8_3BIT(70000000),
    

  316.   // Frame 3
    

  317.   B8_3BIT(00000000),
    

  318.   B8_3BIT(00000000),
    

  319.   B8_3BIT(77000000),
    

  320.   B8_3BIT(07700000),
    

  321.   // Frame 4
    

  322.   B8_3BIT(00000000),
    

  323.   B8_3BIT(07000000),
    

  324.   B8_3BIT(77000000),
    

  325.   B8_3BIT(70000000)
    

  326. };
    

  327. const uint8_t TetrisZMask[] = 
    

  328. {
    

  329.   // Frame 1
    

  330.   B8_1BIT(00000000),
    

  331.   B8_1BIT(00000000),
    

  332.   B8_1BIT(11000000),
    

  333.   B8_1BIT(01100000),
    

  334.   // Frame 2
    

  335.   B8_1BIT(00000000),
    

  336.   B8_1BIT(01000000),
    

  337.   B8_1BIT(11000000),
    

  338.   B8_1BIT(10000000),
    

  339.   // Frame 3
    

  340.   B8_1BIT(00000000),
    

  341.   B8_1BIT(00000000),
    

  342.   B8_1BIT(11000000),
    

  343.   B8_1BIT(01100000),
    

  344.   // Frame 4
    

  345.   B8_1BIT(00000000),
    

  346.   B8_1BIT(01000000),
    

  347.   B8_1BIT(11000000),
    

  348.   B8_1BIT(10000000)
    

  349. };
    


  350. 

  351. #define TETRIS_SPR_WIDTH  4
    

  352. #define TETRIS_SPR_HEIGHT 4
    

  353. const uint8_t *TetrisSprData[] = { TetrisIData, TetrisJData, TetrisLData, TetrisOData, TetrisSData, TetrisTData, TetrisZData };
    

  354. const uint8_t *TetrisSprMask[] = { TetrisIMask, TetrisJMask, TetrisLMask, TetrisOMask, TetrisSMask, TetrisTMask, TetrisZMask};
    

  355. const struct CRGB TetrisColours[] = { CRGB(0, 255, 255), CRGB(0, 0, 255), CRGB(255, 165, 0), CRGB(255, 255, 0), CRGB(50, 205, 50), CRGB(255, 0, 255), CRGB(255, 0, 0) };
    


  356. 

  357. uint8_t PlayfieldData[MATRIX_HEIGHT * ((MATRIX_WIDTH + 7) / 8) * _3BIT];
    

  358. uint8_t PlayfieldMask[MATRIX_HEIGHT * ((MATRIX_WIDTH + 7) / 8) * _1BIT];
    

  359. uint8_t CompletedLinesData[TETRIS_SPR_HEIGHT * ((MATRIX_WIDTH + 7) / 8) * _1BIT];
    

  360. const struct CRGB CompletedLinesColour[] = { CRGB(255, 255, 255) };
    

  361. cSprite Playfield, CompletedLines, CurrentBlock;
    

  362. cLEDSprites Sprites(&leds);
    


  363. 

  364. unsigned char AttractMsg[144], GameOverMsg[88];
    

  365. char BlankMsg[32];
    

  366. cLEDText TetrisMsg;
    


  367. 

  368. uint8_t DropDelay;
    

  369. boolean AttractMode, NextBlock;
    

  370. int16_t TotalLines;
    

  371. unsigned int HighScore = 0, LastScore;
    


  372. 

  373. uint16_t PlasmaTime, PlasmaShift;
    

  374. uint32_t LoopDelayMS, LastLoop;
    


  375. 

  376. void setup()
    

  377. {
    

  378.   Serial.begin(115200);
    

  379.   SerialBT.begin("ESP32Tetris");
    

  380.   
    

  381.   FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds[0], leds.Size());
    

  382.   FastLED.setBrightness(200);
    

  383.   FastLED.clear(true);
    

  384.   FastLED.show();
    


  385. 

  386.   memset(PlayfieldData, 0, sizeof(PlayfieldData));
    

  387.   memset(PlayfieldMask, 0, sizeof(PlayfieldMask));
    

  388.   Playfield.Setup(leds.Width(), leds.Height(), PlayfieldData, 1, _3BIT, TetrisColours, PlayfieldMask);
    

  389.   Playfield.SetPositionFrameMotionOptions(0, 0, 0, 0, 0, 0, 0, 0, 0);
    

  390.   Sprites.AddSprite(&Playfield);
    


  391. 

  392.   memset(CompletedLinesData, 0, sizeof(CompletedLinesData));
    

  393.   CompletedLines.Setup(leds.Width(), TETRIS_SPR_HEIGHT, CompletedLinesData, 1, _1BIT, CompletedLinesColour, CompletedLinesData);
    

  394.   CompletedLines.SetPositionFrameMotionOptions(0, 0, 0, 0, 0, 0, 0, 0, 0);
    


  395. 

  396.   TetrisMsg.SetFont(MatriseFontData);
    

  397.   sprintf((char *)BlankMsg, "%.*s", _min(((leds.Height() + TetrisMsg.FontHeight()) / (TetrisMsg.FontHeight() + 1)), (int)sizeof(BlankMsg) - 1), "                              ");
    

  398.   sprintf((char *)AttractMsg, "%sTETRIS%sSCORE %u%sHIGH %u%sANY BUTTON TO START%s", BlankMsg, BlankMsg, LastScore, BlankMsg, (int)HighScore, BlankMsg, BlankMsg);
    

  399.   TetrisMsg.Init(&leds, TetrisMsg.FontWidth() + 1, leds.Height(), (leds.Width() - TetrisMsg.FontWidth()) / 2, 0);
    

  400.   TetrisMsg.SetBackgroundMode(BACKGND_LEAVE);
    

  401.   TetrisMsg.SetScrollDirection(SCROLL_UP);
    

  402.   TetrisMsg.SetTextDirection(CHAR_UP);
    

  403.   TetrisMsg.SetFrameRate(1);
    

  404.   TetrisMsg.SetOptionsChangeMode(INSTANT_OPTIONS_MODE);
    

  405.   TetrisMsg.SetText(AttractMsg, strlen((const char *)AttractMsg));
    

  406.   AttractMode = true;
    

  407.   LoopDelayMS = TARGET_FRAME_TIME;
    

  408.   LastLoop = millis() - LoopDelayMS;
    

  409.   PlasmaShift = (random8(0, 5) * 32) + 64;
    

  410.   PlasmaTime = 0;
    

  411. }
    


  412. 

  413. void loop()
    

  414. {
    

  415.   if (abs(millis() - LastLoop) >= LoopDelayMS)
    

  416.   {
    

  417.     LastLoop = millis();
    

  418.     FastLED.clear();
    


  419. 

  420.     // Fill background with dim plasma
    

  421.     #define PLASMA_X_FACTOR  24
    

  422.     #define PLASMA_Y_FACTOR  24
    

  423.     for (int16_t x=0; x<MATRIX_WIDTH; x++)
    

  424.     {
    

  425.       for (int16_t y=0; y<MATRIX_HEIGHT; y++)
    

  426.       {
    

  427.         int16_t r = sin16(PlasmaTime) / 256;
    

  428.         int16_t h = sin16(x * r * PLASMA_X_FACTOR + PlasmaTime) + cos16(y * (-r) * PLASMA_Y_FACTOR + PlasmaTime) + sin16(y * x * (cos16(-PlasmaTime) / 256) / 2);
    

  429.         leds(x, y) = CHSV((uint8_t)((h / 256) + 128), 255, 64);
    

  430.       }
    

  431.     }
    

  432.     uint16_t OldPlasmaTime = PlasmaTime;
    

  433.     PlasmaTime += PlasmaShift;
    

  434.     if (OldPlasmaTime > PlasmaTime)
    

  435.       PlasmaShift = (random8(0, 5) * 32) + 64;
    


  436. 

  437.     if (AttractMode)
    

  438.     {
    

  439.       if (currentInput != NONE)
    

  440.       {
    

  441.         AttractMode = false;
    

  442.         memset(PlayfieldData, 0, sizeof(PlayfieldData));
    

  443.         memset(PlayfieldMask, 0, sizeof(PlayfieldMask));
    

  444.         Sprites.RemoveSprite(&CurrentBlock);
    

  445.         LastScore = 0;
    

  446.         TotalLines = 0;
    

  447.         DropDelay = INITIAL_DROP_FRAMES;
    

  448.         CurrentBlock.SetXChange(-1);
    

  449.         NextBlock = true;
    

  450.         currentInput = NONE;
    

  451.       }
    

  452.     }
    

  453.     else
    

  454.     {
    

  455.       if (Sprites.IsSprite(&CompletedLines))  // We have highlighted complete lines, delay for visual effect
    

  456.       {
    

  457.         if (CompletedLines.GetXCounter() > 0)
    

  458.           CompletedLines.SetXCounter(CompletedLines.GetXCounter() - 1);
    

  459.         else
    

  460.         {
    

  461.           Sprites.RemoveSprite(&CompletedLines);
    

  462.           // Remove completed lines from playfield sprite
    

  463.           uint8_t *Data = PlayfieldData;
    

  464.           uint8_t *Mask = PlayfieldMask;
    

  465.           uint16_t Mbpl = (MATRIX_WIDTH + 7) / 8;
    

  466.           uint16_t Dbpl = Mbpl * _3BIT;
    

  467.           int16_t k;
    

  468.           for (int16_t i=(MATRIX_HEIGHT-1)*Dbpl,j=(MATRIX_HEIGHT-1)*Mbpl; i>=0; i-=Dbpl,j-=Mbpl)
    

  469.           {
    

  470.             for (k=0; k<MATRIX_WIDTH; k+=8)
    

  471.             {
    

  472.               if ((uint8_t)(0xff00 >> _min(MATRIX_WIDTH - k, 8)) != Mask[j + (k / 8)])
    

  473.                 break;
    

  474.             }
    

  475.             if (k >= MATRIX_WIDTH)
    

  476.             {
    

  477.               memmove(&Data[Dbpl], &Data[0], i);
    

  478.               memset(&Data[0], 0, Dbpl);
    

  479.               memmove(&Mask[Mbpl], &Mask[0], j);
    

  480.               memset(&Mask[0], 0, Mbpl);
    

  481.               i+=Dbpl;
    

  482.               j+=Mbpl;
    

  483.             }
    

  484.           }
    

  485.         }
    

  486.       }
    

  487.       else
    

  488.       {
    

  489.         if (CurrentBlock.GetXChange() >= 0) // We have a current block
    

  490.         {
    

  491.           // Check for user input
    

  492.           if ( currentInput == ROTATE )
    

  493.           {
    

  494.             currentInput = NONE;
    

  495.             if ((CurrentBlock.GetCurrentFrame() % 2) == 1)
    

  496.             {
    

  497.               if (CurrentBlock.GetXChange() == 0)
    

  498.                 CurrentBlock.m_X = _min(CurrentBlock.m_X, MATRIX_WIDTH - TETRIS_SPR_WIDTH);
    

  499.               else if ((CurrentBlock.GetXChange() != 3) && (CurrentBlock.GetFlags() & SPRITE_EDGE_X_MAX))
    

  500.                 --CurrentBlock.m_X;
    

  501.             }
    

  502.             CurrentBlock.IncreaseFrame();
    

  503.             Sprites.DetectCollisions(&CurrentBlock);
    

  504.             if (CurrentBlock.GetFlags() & SPRITE_COLLISION)
    

  505.               CurrentBlock.DecreaseFrame();
    

  506.           }
    

  507.           
    

  508.           if ( currentInput == LEFT && (! (CurrentBlock.GetFlags() & SPRITE_EDGE_X_MIN)) )
    

  509.           {
    

  510.             currentInput = NONE;
    

  511.             CurrentBlock.m_X--;
    

  512.             Sprites.DetectCollisions(&CurrentBlock);
    

  513.             if (CurrentBlock.GetFlags() & SPRITE_COLLISION)
    

  514.               CurrentBlock.m_X++;
    

  515.           }
    

  516.           
    

  517.           else if ( currentInput == RIGHT && (! (CurrentBlock.GetFlags() & SPRITE_EDGE_X_MAX)) )
    

  518.           {
    

  519.             currentInput = NONE;
    

  520.             CurrentBlock.m_X++;
    

  521.             Sprites.DetectCollisions(&CurrentBlock);
    

  522.             if (CurrentBlock.GetFlags() & SPRITE_COLLISION)
    

  523.               CurrentBlock.m_X--;
    

  524.           }
    

  525.           
    

  526.           if ( currentInput == DOWN )
    

  527.           {
    

  528.             currentInput = NONE;
    

  529.             CurrentBlock.SetYCounter(1);
    

  530.           }
    

  531.             
    

  532.           // Do block checks for bottom or collision
    

  533.           if (CurrentBlock.GetYCounter() <= 1)
    

  534.           {
    

  535.             if (CurrentBlock.GetFlags() & SPRITE_EDGE_Y_MIN)
    

  536.               NextBlock = true;
    

  537.             else
    

  538.             {
    

  539.               --CurrentBlock.m_Y;
    

  540.               Sprites.DetectCollisions(&CurrentBlock);
    

  541.               ++CurrentBlock.m_Y;
    

  542.               if (CurrentBlock.GetFlags() & SPRITE_COLLISION)
    

  543.               {
    

  544.                 // Block has collided check for game over
    

  545.                 int16_t MaxY = MATRIX_HEIGHT - 2;
    

  546.                 if ((CurrentBlock.GetCurrentFrame() % 2) == 1)
    

  547.                 {
    

  548.                   if (CurrentBlock.GetXChange() == 0)
    

  549.                     MaxY -= 2;
    

  550.                   else if (CurrentBlock.GetXChange() != 3)
    

  551.                     MaxY -= 1;
    

  552.                 }
    

  553.                 else if (CurrentBlock.GetXChange() == 0)
    

  554.                     ++MaxY;
    

  555.                 if (CurrentBlock.m_Y < MaxY)
    

  556.                   NextBlock = true;
    

  557.                 else
    

  558.                 {
    

  559.                   // Game over
    

  560.                   CurrentBlock.SetYCounter(2);  // Stop last block moving down!
    

  561.                   AttractMode = true;
    

  562.                   if (LastScore > HighScore)
    

  563.                   {
    

  564.                     HighScore = LastScore;
    

  565.                     sprintf((char *)GameOverMsg, "%sGAME OVER%sNEW HIGH SCORE %u%s", BlankMsg, BlankMsg, LastScore, BlankMsg);
    

  566.                   }
    

  567.                   else
    

  568.                     sprintf((char *)GameOverMsg, "%sGAME OVER%sSCORE %u%s", BlankMsg, BlankMsg, LastScore, BlankMsg);
    

  569.                   sprintf((char *)AttractMsg, "%sTETRIS%sSCORE %u%sHIGH %u%sANY BUTTON TO START%s", BlankMsg, BlankMsg, LastScore, BlankMsg, HighScore, BlankMsg, BlankMsg);
    

  570.                   TetrisMsg.SetText(GameOverMsg, strlen((char *)GameOverMsg));
    

  571.                   TetrisMsg.SetBackgroundMode(BACKGND_DIMMING, 0x40);
    

  572.                 }
    

  573.               }
    

  574.             }
    

  575.           }
    

  576.         }
    

  577.         if (NextBlock)  // Start new block
    

  578.         {
    

  579.           if (CurrentBlock.GetXChange() >= 0) // We have a current block so add to playfield before creating new block
    

  580.           {
    

  581.             Playfield.Combine(CurrentBlock.m_X, CurrentBlock.m_Y, &CurrentBlock);
    

  582.             Sprites.RemoveSprite(&CurrentBlock);
    

  583.             // Make completed lines highlight sprite & score
    

  584.             memset(CompletedLinesData, 0, sizeof(CompletedLinesData));
    

  585.             CompletedLines.m_Y = -1;
    

  586.             uint8_t *Mask = PlayfieldMask;
    

  587.             uint16_t Mbpl = (MATRIX_WIDTH + 7) / 8;
    

  588.             int16_t j, numlines = 0;
    

  589.             for (int16_t i=(MATRIX_HEIGHT-1)*Mbpl, y=0; i>=0; i-=Mbpl,++y)
    

  590.             {
    

  591.               for (j=0; j<MATRIX_WIDTH; j+=8)
    

  592.               {
    

  593.                 if ((uint8_t)(0xff00 >> _min(MATRIX_WIDTH - j, 8)) != Mask[i + (j / 8)])
    

  594.                   break;
    

  595.               }
    

  596.               if (j >= MATRIX_WIDTH)
    

  597.               {
    

  598.                 if (CompletedLines.m_Y == -1)
    

  599.                   CompletedLines.m_Y = y;
    

  600.                 memset(&CompletedLinesData[((TETRIS_SPR_HEIGHT - 1) - (y - CompletedLines.m_Y)) * Mbpl], 0xff, Mbpl);
    

  601.                 numlines++;
    

  602.               }
    

  603.             }
    

  604.             if (numlines > 0)
    

  605.             {
    

  606.               CompletedLines.SetXCounter(15);  // Set delay for highlight display to 15 loops
    

  607.               Sprites.AddSprite(&CompletedLines);
    

  608.             }
    

  609.             LastScore += 1;
    

  610.             if (numlines == 1)
    

  611.               LastScore += 4;
    

  612.             else if (numlines == 2)
    

  613.               LastScore += 12;
    

  614.             else if (numlines == 3)
    

  615.               LastScore += 20;
    

  616.             else if (numlines == 4)
    

  617.               LastScore += 40;
    

  618.             TotalLines += numlines;
    

  619.             DropDelay = _max(1, INITIAL_DROP_FRAMES - (TotalLines / 5));
    

  620.           }
    

  621.           // Start new block
    

  622.           uint8_t j = random8(sizeof(TetrisSprData) / sizeof(TetrisSprData[0]));
    

  623.           CurrentBlock.Setup(TETRIS_SPR_WIDTH, TETRIS_SPR_WIDTH, TetrisSprData[j], 4, _3BIT, TetrisColours, TetrisSprMask[j]);
    

  624.           CurrentBlock.SetPositionFrameMotionOptions((MATRIX_WIDTH/2)-1, MATRIX_HEIGHT, 0, 0, 0, 0, -1, DropDelay, SPRITE_DETECT_COLLISION | SPRITE_DETECT_EDGE);
    

  625.           CurrentBlock.SetXChange(j);
    

  626.           Sprites.AddSprite(&CurrentBlock);
    

  627.           NextBlock = false;
    

  628.         }
    

  629.         Sprites.UpdateSprites();
    

  630.       }
    

  631.     }
    

  632.     Sprites.RenderSprites();
    

  633.     if (AttractMode)
    

  634.     {
    

  635.       if (TetrisMsg.UpdateText() == -1)
    

  636.       {
    

  637.         TetrisMsg.SetText(AttractMsg, strlen((char *)AttractMsg));
    

  638.         TetrisMsg.SetBackgroundMode(BACKGND_LEAVE);
    

  639.         Sprites.RemoveSprite(&CurrentBlock);
    

  640.         memset(PlayfieldData, 0, sizeof(PlayfieldData));
    

  641.         memset(PlayfieldMask, 0, sizeof(PlayfieldMask));
    

  642.       }
    

  643.     }
    

  644.     FastLED.show();
    

  645.   }
    

  646.   if(SerialBT.available()){
    

  647.     char keyPress = (char)SerialBT.read();
    

  648.     switch(keyPress) {
    

  649.       case 'w':
    

  650.         currentInput = ROTATE;
    

  651.         break;
    

  652.       case 'a':
    

  653.         currentInput = LEFT;
    

  654.         break;
    

  655.       case 's':
    

  656.         currentInput = DOWN;
    

  657.         break;
    

  658.       case 'd':
    

  659.         currentInput = RIGHT;
    

  660.         break;
    

  661.     }
    

  662.     Serial.println(currentInput);
    

  663.   }
    

  664. }
回复 赏

举报

相关帖子
 楼主| keer_zu 发表于 2025-5-21 14:35 | 显示全部楼层
只有背景的显示效果：
复制
  1. // TETRIS
    

  2. #include <FastLED.h>
    

  3. #include <LEDMatrix.h>
    

  4. #include <LEDText.h>
    

  5. #include <FontMatrise.h>
    


  6. 

  7. #define LED_PIN        15
    

  8. #define COLOR_ORDER    GRB
    

  9. #define CHIPSET        WS2812B
    

  10. #define MATRIX_WIDTH   30
    

  11. #define MATRIX_HEIGHT  15
    

  12. #define MATRIX_TYPE    HORIZONTAL_MATRIX
    


  13. 

  14. // NOTE the '-' sign before the width, this is due to my leds matrix origin being on the right hand side
    

  15. cLEDMatrix<MATRIX_WIDTH, -MATRIX_HEIGHT, MATRIX_TYPE> leds;
    


  16. 


  17. 

  18. #define TARGET_FRAME_TIME    15  // Desired update rate, though if too many leds it will just run as fast as it can!
    


  19. 

  20. uint16_t PlasmaTime, PlasmaShift;
    


  21. 

  22. void setup()
    

  23. {
    

  24.   FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds[0], leds.Size());
    

  25.   FastLED.setBrightness(200);
    

  26.   FastLED.clear(true);
    

  27.   FastLED.show();
    


  28. 

  29.  PlasmaShift = (random8(0, 5) * 32) + 64;
    

  30.   PlasmaTime = 0;
    

  31. }
    


  32. 

  33. void loop()
    

  34. {
    

  35.     FastLED.clear();
    


  36. 

  37.     // Fill background with dim plasma
    

  38.     #define PLASMA_X_FACTOR  24
    

  39.     #define PLASMA_Y_FACTOR  24
    

  40.     for (int16_t x=0; x<MATRIX_WIDTH; x++)
    

  41.     {
    

  42.       for (int16_t y=0; y<MATRIX_HEIGHT; y++)
    

  43.       {
    

  44.         int16_t r = sin16(PlasmaTime) / 256;
    

  45.         int16_t h = sin16(x * r * PLASMA_X_FACTOR + PlasmaTime) + cos16(y * (-r) * PLASMA_Y_FACTOR + PlasmaTime) + sin16(y * x * (cos16(-PlasmaTime) / 256) / 2);
    

  46.         leds(x, y) = CHSV((uint8_t)((h / 256) + 128), 255, 64);
    

  47.       }
    

  48.     }
    


  49. 

  50.     uint16_t OldPlasmaTime = PlasmaTime;
    

  51.     PlasmaTime += PlasmaShift;
    

  52.     if (OldPlasmaTime > PlasmaTime)
    

  53.       PlasmaShift = (random8(0, 5) * 32) + 64;
    


  54. 

  55.     FastLED.show();
    

  56.     delay(10);
    

  57.   
    

  58. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-21 21:19 | 显示全部楼层
复制
  1. // TETRIS
    

  2. #include <FastLED.h>
    

  3. #include <LEDMatrix.h>
    


  4. 


  5. 

  6. #define LED_PIN        15
    

  7. #define COLOR_ORDER    GRB
    

  8. #define CHIPSET        WS2812B
    

  9. #define MATRIX_WIDTH   30
    

  10. #define MATRIX_HEIGHT  15
    

  11. #define MATRIX_TYPE    HORIZONTAL_MATRIX
    


  12. 

  13. // NOTE the '-' sign before the width, this is due to my leds matrix origin being on the right hand side
    

  14. cLEDMatrix<MATRIX_WIDTH, -MATRIX_HEIGHT, MATRIX_TYPE> leds;
    


  15. 


  16. 

  17. #define TARGET_FRAME_TIME    15  // Desired update rate, though if too many leds it will just run as fast as it can!
    


  18. 

  19. uint16_t PlasmaTime, PlasmaShift;
    


  20. 

  21. void setup()
    

  22. {
    

  23.   FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds[0], leds.Size());
    

  24.   FastLED.setBrightness(200);
    

  25.   FastLED.clear(true);
    

  26.   FastLED.show();
    


  27. 

  28.  PlasmaShift = (random8(0, 5) * 32) + 64;
    

  29.   PlasmaTime = 0;
    

  30. }
    


  31. 

  32. void loop()
    

  33. {
    

  34.     // Fill background with dim plasma
    

  35.     #define PLASMA_X_FACTOR  24
    

  36.     #define PLASMA_Y_FACTOR  24
    

  37.     for (int16_t x=0; x<MATRIX_WIDTH; x++)
    

  38.     {
    

  39.       for (int16_t y=0; y<MATRIX_HEIGHT; y++)
    

  40.       {
    

  41.         int16_t r = sin16(PlasmaTime) / 256;
    

  42.         int16_t h = sin16(x * r * PLASMA_X_FACTOR + PlasmaTime) + cos16(y * (-r) * PLASMA_Y_FACTOR + PlasmaTime) + sin16(y * x * (cos16(-PlasmaTime) / 256) / 2);
    

  43.         leds(x, y) = CHSV((uint8_t)((h / 256) + 128), 255, 64);
    

  44.       }
    

  45.     }
    


  46. 

  47.     uint16_t OldPlasmaTime = PlasmaTime;
    

  48.     PlasmaTime += PlasmaShift;
    

  49.     if (OldPlasmaTime > PlasmaTime)
    

  50.       PlasmaShift = (random8(0, 5) * 32) + 64;
    


  51. 

  52.     FastLED.show();
    

  53.     delay(50);
    

  54.   
    

  55. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-22 08:19 | 显示全部楼层
限制颜色和平滑的效果（不理想）
复制
  1. // TETRIS
    

  2. #include <FastLED.h>
    

  3. #include <LEDMatrix.h>
    


  4. 

  5. #define LED_PIN        15
    

  6. #define COLOR_ORDER    GRB
    

  7. #define CHIPSET        WS2812B
    

  8. #define MATRIX_WIDTH   30
    

  9. #define MATRIX_HEIGHT  15
    

  10. #define MATRIX_TYPE    HORIZONTAL_MATRIX
    


  11. 

  12. cLEDMatrix<MATRIX_WIDTH, -MATRIX_HEIGHT, MATRIX_TYPE> leds;
    


  13. 

  14. #define TARGET_FRAME_TIME    15
    

  15. uint16_t PlasmaTime, PlasmaShift;
    


  16. 

  17. void setup() {
    

  18.   FastLED.addLeds<CHIPSET, LED_PIN, COLOR_ORDER>(leds[0], leds.Size());
    

  19.   FastLED.setBrightness(200);
    

  20.   FastLED.clear(true);
    

  21.   PlasmaShift = (random8(0, 5) * 16) + 32;  // 降低变化速度
    

  22.   PlasmaTime = 0;
    

  23. }
    


  24. 

  25. void loop() {
    

  26.   static uint8_t lastHue = 128;  // 用于色相平滑过渡
    

  27.   FastLED.clear();
    


  28. 

  29.   // 更平滑的波形参数
    

  30.   #define PLASMA_X_FACTOR  16  // 降低X/Y方向波形频率
    

  31.   #define PLASMA_Y_FACTOR  16
    

  32.   #define HUE_START  96       // 青色
    

  33.   #define HUE_END    220       // 紫色
    

  34.   
    

  35.   for (int16_t x=0; x<MATRIX_WIDTH; x++) {
    

  36.     for (int16_t y=0; y<MATRIX_HEIGHT; y++) {
    

  37.       // 使用更平滑的波形组合
    

  38.       int16_t r = sin16(PlasmaTime * 0.7) / 512;  // 降低振幅变化速度
    

  39.       int16_t h = sin16(x * PLASMA_X_FACTOR + PlasmaTime * 0.5) 
    

  40.                 + cos16(y * PLASMA_Y_FACTOR + PlasmaTime * 0.3)
    

  41.                 + sin16((x + y) * 64 + PlasmaTime * 0.4);  // 简化第三项波形
    


  42. 

  43.       // 非线性映射 + 低通滤波平滑色相
    

  44.       uint8_t targetHue = map(h, -32768, 32767, HUE_START, HUE_END);
    

  45.       uint8_t hue = (targetHue * 0.3) + (lastHue * 0.7);  // 指数平滑
    

  46.       lastHue = hue;
    


  47. 

  48.       leds(x, y) = CHSV(hue, 200, 100);
    

  49.     }
    

  50.   }
    


  51. 

  52.   // 更缓慢的时间推进
    

  53.   PlasmaTime += PlasmaShift;
    

  54.   if (PlasmaTime % 512 == 0)  // 定期重置避免溢出
    

  55.     PlasmaShift = random8(0, 5) * 16 + 32;
    

  56.     
    

  57.   FastLED.show();
    

  58.   delay(20);
    

  59. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-22 10:50 | 显示全部楼层
随机变化的效果：

复制
  1. // 风场参数
    

  2. const uint8_t scale = 25;       // 缩小缩放因子扩大波纹范围
    

  3. const uint8_t speed = 2;        // 降低运动速度
    

  4. const int8_t windDirection = 1; 
    

  5. const uint8_t blurAmount = 48;  // 新增模糊系数
    

  6. uint16_t z = 0;
    

  7. // 优化的噪声生成函数
    

  8. void generateNoise(uint8_t *noiseData, uint16_t zOffset) {
    

  9.   for(uint8_t y=0; y<MATRIX_HEIGHT; y++) {
    

  10.     for(uint8_t x=0; x<MATRIX_WIDTH; x++) {
    

  11.       uint8_t xOffset = windDirection * beatsin8(
    

  12.         3,                    // 降低波浪频率
    

  13.         0, 15,               // 减小振幅范围
    

  14.         0, 
    

  15.         (x * 2 + y * 3)      // 优化相位关系
    

  16.       );
    

  17.       
    

  18.       noiseData[XY(x,y)] = inoise8(
    

  19.         (x + xOffset) * scale,
    

  20.         y * scale * 1.2,     // Y轴增加缩放差异
    

  21.         zOffset
    

  22.       );
    

  23.     }
    

  24.   }
    

  25. }
    


  26. 


  27. 

  28. void wind_vision()
    

  29. {
    

  30.   static uint32_t lastUpdate = 0;
    

  31.   static uint8_t blendVal = 0;
    

  32.   
    

  33.   if(millis() - lastUpdate > 30) {
    

  34.     lastUpdate = millis();
    

  35.     
    

  36.     // 双缓冲噪声生成
    

  37.     uint8_t noiseData1[NUM_LEDS];
    

  38.     uint8_t noiseData2[NUM_LEDS];
    

  39.     
    

  40.     // 生成两帧噪声数据
    

  41.     generateNoise(noiseData1, z);
    

  42.     generateNoise(noiseData2, z + 50); // 50个时间单位偏移
    

  43.     
    

  44.     // 混合两帧数据
    

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

  46.       uint8_t finalNoise = blend8(noiseData1[i], noiseData2[i], blendVal);
    

  47.       
    

  48.       // 扩展颜色映射范围
    

  49.       uint8_t hue = map(finalNoise, 40, 210, 180, 255); // 颜色范围180-255
    

  50.       uint8_t val = map(finalNoise, 60, 190, 50, 220);  // 保持亮度动态
    

  51.       
    

  52.       leds[i] = CHSV(hue, 245, val); // 略微降低饱和度
    

  53.     }
    

  54.     
    

  55.     // 应用二维模糊
    

  56.     blur2d(leds, MATRIX_WIDTH, MATRIX_HEIGHT, blurAmount);
    

  57.     
    

  58.     z += speed;
    

  59.     blendVal += 3; // 控制混合速度
    

  60.     FastLED.show();
    

  61.   }
    

  62. }
    


  63. 


  64.
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-23 22:29 | 显示全部楼层

复制
  1. #include <FastLED.h>
    


  2. 

  3. // ========== 硬件配置 ========== 
    

  4. #define LED_PIN       15
    

  5. #define LED_TYPE      WS2812B
    

  6. #define COLOR_ORDER   GRB
    

  7. #define MATRIX_WIDTH  30
    

  8. #define MATRIX_HEIGHT 15
    

  9. #define NUM_LEDS      (MATRIX_WIDTH * MATRIX_HEIGHT)
    

  10. CRGB leds[NUM_LEDS];
    


  11. 

  12. // ========== 动画参数 ==========
    

  13. #define FRAME_RATE    30
    

  14. #define NOISE_SCALE   0.1f
    

  15. #define FLOW_SPEED    0.8f
    

  16. #define HUE_SPEED     0.02f
    

  17. #define BRIGHTNESS    80
    


  18. 

  19. // ========== 全局变量 ==========
    

  20. float z;
    

  21. uint8_t hue_base;
    


  22. 

  23. // ========== 完整的perm数组 ==========
    

  24. const uint8_t perm[256] = {
    

  25.   151, 160, 137, 91, 90, 15, 131, 13, 201, 95, 96, 53, 194, 233, 7, 225,
    

  26.   140, 36, 103, 30, 69, 142, 8, 99, 37, 240, 21, 10, 23, 190, 6, 148,
    

  27.   247, 120, 234, 75, 0, 26, 197, 62, 94, 252, 219, 203, 117, 35, 11, 32,
    

  28.   57, 177, 33, 88, 237, 149, 56, 87, 174, 20, 125, 136, 171, 168, 68, 175,
    

  29.   74, 165, 71, 134, 139, 48, 27, 166, 77, 146, 158, 231, 83, 111, 229, 122,
    

  30.   60, 211, 133, 230, 220, 105, 92, 41, 55, 46, 245, 40, 244, 102, 143, 54,
    

  31.   65, 25, 63, 161, 1, 216, 80, 73, 209, 76, 132, 187, 208, 89, 18, 169,
    

  32.   200, 196, 135, 130, 116, 188, 159, 86, 164, 100, 109, 198, 173, 186, 3, 64,
    

  33.   52, 217, 226, 250, 124, 123, 5, 202, 38, 147, 118, 126, 255, 82, 85, 212,
    

  34.   207, 206, 59, 227, 47, 16, 58, 17, 182, 189, 28, 42, 223, 183, 170, 213,
    

  35.   119, 248, 152, 2, 44, 154, 163, 70, 221, 153, 101, 155, 167, 43, 172, 9,
    

  36.   129, 22, 39, 253, 19, 98, 108, 110, 79, 113, 224, 232, 178, 185, 112, 104,
    

  37.   218, 246, 97, 228, 251, 34, 242, 193, 238, 210, 144, 12, 191, 179, 162, 241,
    

  38.   81, 51, 145, 235, 249, 14, 239, 107, 49, 192, 214, 31, 181, 199, 106, 157,
    

  39.   184, 84, 204, 176, 115, 121, 50, 45, 127, 4, 150, 254, 138, 236, 205, 93,
    

  40.   222, 114, 67, 29, 24, 72, 243, 141, 128, 195, 78, 66, 215, 61, 156, 180
    

  41. };
    


  42. 

  43. // ========== 修改后的噪声函数（重命名避免冲突）==========
    

  44. uint8_t custom_noise(uint16_t x, uint16_t y, uint16_t z) {
    

  45.   uint8_t a  = perm[(x>>8)&0xFF] + (y>>8);
    

  46.   uint8_t b  = perm[(y>>8)&0xFF] + (z>>8);
    

  47.   uint8_t aa = perm[a] + (z>>8);
    

  48.   uint8_t ba = perm[b] + (x>>8);
    

  49.   
    

  50.   uint8_t u = x & 0xFF;
    

  51.   uint8_t v = y & 0xFF;
    

  52.   
    

  53.   return lerp8by8(lerp8by8(perm[aa], perm[ba], u),
    

  54.                 lerp8by8(perm[aa+1], perm[ba+1], u), v);
    

  55. }
    


  56. 

  57. // ========== 坐标映射函数 ==========
    

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

  59.   if(y % 2 == 0) {
    

  60.     return y * MATRIX_WIDTH + x; 
    

  61.   } else {
    

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

  63.   }
    

  64. }
    


  65. 

  66. // ========== 主渲染函数（参数类型修正）==========
    

  67. void renderFrame() {
    

  68.   static float xOffset = 0;
    

  69.   static float yOffset = 0;
    

  70.   
    

  71.   xOffset += FLOW_SPEED * 0.7;
    

  72.   yOffset += FLOW_SPEED * 0.5;
    

  73.   hue_base += HUE_SPEED * 255;
    

  74.   z += 0.05;
    

  75.   
    

  76.   for(uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    

  77.     for(uint8_t x = 0; x < MATRIX_WIDTH; x++) {
    

  78.       // 转换为整数参数
    

  79.       uint16_t nx = (uint16_t)(x * NOISE_SCALE * 256 + xOffset * 256);
    

  80.       uint16_t ny = (uint16_t)(y * NOISE_SCALE * 256 + yOffset * 256);
    

  81.       uint16_t nz = (uint16_t)(z * 256);
    

  82.       
    

  83.       uint8_t noise = (
    

  84.           custom_noise(nx, ny, nz) * 0.6 +
    

  85.           custom_noise(nx*2, ny*2, nz) * 0.4
    

  86.       );
    

  87.       
    

  88.       CRGB color = CHSV(noise + hue_base, 255, noise);
    

  89.       leds[XY(x,y)] = color;
    

  90.     }
    

  91.   }
    

  92. }
    


  93. 

  94. void setup() {
    

  95.   FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
    

  96.   FastLED.setBrightness(BRIGHTNESS);
    

  97.   FastLED.clear();
    

  98.   randomSeed(analogRead(0));
    

  99.   z = random(65536);
    

  100. }
    


  101. 

  102. void loop() {
    

  103.   static uint32_t lastFrame = 0;
    

  104.   uint32_t frameInterval = 1000 / FRAME_RATE;
    

  105.   
    

  106.   if(millis() - lastFrame >= frameInterval) {
    

  107.     renderFrame();
    

  108.     FastLED.show();
    

  109.     lastFrame = millis();
    

  110.   }
    

  111.   yield();
    

  112. }
回复 赏

举报

 楼主| keer_zu 发表于 2025-5-23 22:35 | 显示全部楼层
keer_zu 发表于 2025-5-23 22:29

颜色受到限制的版本：
复制
  1. #include <FastLED.h>
    


  2. 

  3. // ========== 硬件配置 ========== 
    

  4. #define LED_PIN      15
    

  5. #define LED_TYPE      WS2812B
    

  6. #define COLOR_ORDER   GRB
    

  7. #define MATRIX_WIDTH  30
    

  8. #define MATRIX_HEIGHT 15
    

  9. #define NUM_LEDS      (MATRIX_WIDTH * MATRIX_HEIGHT)
    

  10. CRGB leds[NUM_LEDS];
    


  11. 

  12. // ========== 动画参数 ==========
    

  13. #define FRAME_RATE    30
    

  14. #define NOISE_SCALE   0.05f    // 更细腻的噪声图案
    

  15. #define FLOW_SPEED    0.3f     // 慢速流动
    

  16. #define HUE_SPEED     0.005f   // 缓慢色调变化
    

  17. #define BRIGHTNESS    80       // 中等亮度
    


  18. 

  19. // ========== 全局变量 ==========
    

  20. float z;
    

  21. uint8_t hue_base;
    


  22. 

  23. // ========== perm数组（保持不变）==========
    

  24. const uint8_t perm[256] = {
    

  25.   151,160,137,91,90,15,131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,
    

  26.   8,99,37,240,21,10,23,190,6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,
    

  27.   35,11,32,57,177,33,88,237,149,56,87,174,20,125,136,171,168,68,175,74,165,71,
    

  28.   134,139,48,27,166,77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,
    

  29.   55,46,245,40,244,102,143,54,65,25,63,161,1,216,80,73,209,76,132,187,208,89,
    

  30.   18,169,200,196,135,130,116,188,159,86,164,100,109,198,173,186,3,64,52,217,226,
    

  31.   250,124,123,5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,
    

  32.   189,28,42,223,183,170,213,119,248,152,2,44,154,163,70,221,153,101,155,167,43,
    

  33.   172,9,129,22,39,253,19,98,108,110,79,113,224,232,178,185,112,104,218,246,97,
    

  34.   228,251,34,242,193,238,210,144,12,191,179,162,241,81,51,145,235,249,14,239,107,
    

  35.   49,192,214,31,181,199,106,157,184,84,204,176,115,121,50,45,127,4,150,254,138,
    

  36.   236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
    

  37. };
    


  38. 

  39. // ========== 自定义噪声函数 ==========
    

  40. uint8_t custom_noise(uint16_t x, uint16_t y, uint16_t z) {
    

  41.   uint8_t a  = perm[(x>>8)&0xFF] + (y>>8);
    

  42.   uint8_t b  = perm[(y>>8)&0xFF] + (z>>8);
    

  43.   uint8_t aa = perm[a] + (z>>8);
    

  44.   uint8_t ba = perm[b] + (x>>8);
    

  45.   
    

  46.   uint8_t u = x & 0xFF;
    

  47.   uint8_t v = y & 0xFF;
    

  48.   
    

  49.   return lerp8by8(lerp8by8(perm[aa], perm[ba], u),
    

  50.                 lerp8by8(perm[aa+1], perm[ba+1], u), v);
    

  51. }
    


  52. 

  53. // ========== 蛇形映射函数 ==========
    

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

  55.   if(y % 2 == 0) {
    

  56.     return y * MATRIX_WIDTH + x; 
    

  57.   } else {
    

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

  59.   }
    

  60. }
    


  61. 

  62. // ========== 主渲染函数 ==========
    

  63. void renderFrame() {
    

  64.   static float xOffset = 0;
    

  65.   static float yOffset = 0;
    

  66.   
    

  67.   // 缓慢更新位置参数
    

  68.   xOffset += FLOW_SPEED * 0.7;
    

  69.   yOffset += FLOW_SPEED * 0.5;
    

  70.   hue_base += HUE_SPEED * 255;
    

  71.   z += 0.02;
    

  72.   
    

  73.   for(uint8_t y = 0; y < MATRIX_HEIGHT; y++) {
    

  74.     for(uint8_t x = 0; x < MATRIX_WIDTH; x++) {
    

  75.       // 生成噪声参数
    

  76.       uint16_t nx = (uint16_t)(x * NOISE_SCALE * 256 + xOffset * 256);
    

  77.       uint16_t ny = (uint16_t)(y * NOISE_SCALE * 256 + yOffset * 256);
    

  78.       uint16_t nz = (uint16_t)(z * 256);
    

  79.       
    

  80.       // 混合噪声层
    

  81.       uint8_t noise = (
    

  82.           custom_noise(nx, ny, nz) * 0.6 +
    

  83.           custom_noise(nx*2, ny*2, nz) * 0.4
    

  84.       );
    

  85.       
    

  86.       // 颜色处理（限制在100-220 Hue范围）
    

  87.       uint8_t rawHue = noise + hue_base;
    

  88.       uint8_t scaledHue = scale8(rawHue, 120) + 100; // 120 = 60*2
    

  89.       CRGB color = CHSV(scaledHue, 200, noise);      // 适当降低饱和度
    

  90.       
    

  91.       leds[XY(x,y)] = color;
    

  92.     }
    

  93.   }
    

  94. }
    


  95. 

  96. // ========== 初始化 ==========
    

  97. void setup() {
    

  98.   FastLED.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, NUM_LEDS);
    

  99.   FastLED.setBrightness(BRIGHTNESS);
    

  100.   FastLED.clear();
    

  101.   randomSeed(analogRead(0));
    

  102.   z = random(65536);  // 随机初始Z值
    

  103. }
    


  104. 

  105. // ========== 主循环 ==========
    

  106. void loop() {
    

  107.   static uint32_t lastFrame = 0;
    

  108.   uint32_t frameInterval = 1000 / FRAME_RATE;
    

  109.   
    

  110.   if(millis() - lastFrame >= frameInterval) {
    

  111.     renderFrame();
    

  112.     FastLED.show();
    

  113.     lastFrame = millis();
    

  114.   }
    

  115.   yield();
    

  116. }
回复 赏

举报

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

本版积分规则

keer_zu

1477

主题

12909

帖子

55

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