设为首页收藏本站
首页 > 论坛 > Arduino

[项目]【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）

驴友花雕 | 中级技神 | 创造力： | 帖子： | 发消息 | 串个门 | 加好友 | 打招呼
2022-7-25 17:30:56 [显示全部楼层]
8477浏览
42回复
1收藏
查看: 8477|回复: 42

[项目] 【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）

[复制链接]
徒步的路上，在草丛里面捡到一些报废的有机棒


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 17:56:30

本帖最后由 驴友花雕 于 2022-7-29 10:29 编辑

  【花雕动手做】有趣好玩的音乐可视化系列小项目（13）---有机棒立柱灯
  实验程序：15种循环灯光模式
  模块接线：WS2812B接D6
  MAX9814      UNO
  VCC          5V
  GND         GND
  OUT          A0
  1. /*

  2.   【花雕动手做】有趣好玩的音乐可视化系列小项目（13）---有机排比立柱灯

  3.   相关程序之：SoftwareSerial有机排比立柱灯

  4.   模块接线：WS2812B接D6

  5.   MAX9814      UNO

  6.   VCC          5V

  7.   GND         GND

  8.   OUT          A0

  9. */

  10. 

  11. #include <Adafruit_NeoPixel.h>

  12. #include <FastLED.h>

  13. #include <math.h>

  14. #include <SoftwareSerial.h>

  15. #define N_PIXELS  70  

  16. #define N_PIXELS_HALF (N_PIXELS/2)

  17. #define MIC_PIN   A0  

  18. #define LED_PIN    6  

  19. #define SAMPLE_WINDOW   10  

  20. #define PEAK_HANG 24 

  21. #define PEAK_FALL 20 

  22. #define PEAK_FALL2 8 

  23. #define INPUT_FLOOR 10 

  24. #define INPUT_CEILING 30 

  25. #define DC_OFFSET  0  

  26. #define NOISE     10  

  27. #define SAMPLES   60  

  28. #define TOP       (N_PIXELS + 2)

  29. #define SPEED .20       

  30. #define TOP2      (N_PIXELS + 1) 

  31. #define LAST_PIXEL_OFFSET N_PIXELS-1

  32. #define PEAK_FALL_MILLIS 10  

  33. #define POT_PIN    4

  34. #define BG 0

  35. #define LAST_PIXEL_OFFSET N_PIXELS-1

  36. #if FASTLED_VERSION < 3001000

  37. #error "Requires FastLED 3.1 or later; check github for latest code."

  38. #endif

  39. #define BRIGHTNESS  255

  40. #define LED_TYPE    WS2812B     

  41. #define COLOR_ORDER GRB

  42. #define COLOR_MIN           0

  43. #define COLOR_MAX         255

  44. #define DRAW_MAX          100

  45. #define SEGMENTS            4  

  46. #define COLOR_WAIT_CYCLES  10  

  47. #define qsubd(x, b)  ((x>b)?b:0)

  48. #define qsuba(x, b)  ((x>b)?x-b:0)                                              

  49. #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))

  50. 

  51. struct CRGB leds[N_PIXELS];

  52. 

  53. Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);

  54. 

  55. static uint16_t dist;         

  56. uint16_t scale = 30;          

  57. uint8_t maxChanges = 48;      

  58. 

  59. CRGBPalette16 currentPalette(OceanColors_p);

  60. CRGBPalette16 targetPalette(CloudColors_p);

  61. 

  62. uint8_t timeval = 20;                                                           

  63. uint16_t loops = 0;                                                             

  64. bool     samplepeak = 0;                                                        

  65. uint16_t oldsample = 0;                                                         

  66. bool thisdir = 0;

  67. 

  68. enum

  69. {

  70. } MODE;

  71. bool reverse = true;

  72. int BRIGHTNESS_MAX = 80;

  73. int brightness = 20;

  74. 

  75. 

  76. byte

  77. //  peak      = 0,      

  78. //  dotCount  = 0,      

  79. volCount  = 0;      

  80. int

  81. reading,

  82. vol[SAMPLES],       

  83. lvl       = 10,      

  84. minLvlAvg = 0,      

  85. maxLvlAvg = 512;

  86. float

  87. greenOffset = 30,

  88. blueOffset = 150;

  89. 

  90. int CYCLE_MIN_MILLIS = 2;

  91. int CYCLE_MAX_MILLIS = 1000;

  92. int cycleMillis = 20;

  93. bool paused = false;

  94. long lastTime = 0;

  95. bool boring = true;

  96. bool gReverseDirection = false;

  97. int          myhue =   0;

  98. 

  99. uint8_t colour;

  100. uint8_t myfade = 255;                                         

  101. #define maxsteps 16                                           

  102. int peakspersec = 0;

  103. int peakcount = 0;

  104. uint8_t bgcol = 0;

  105. int thisdelay = 20;

  106. uint8_t max_bright = 255;

  107. 

  108. unsigned int sample;

  109. 

  110. #define NSAMPLES 64

  111. unsigned int samplearray[NSAMPLES];

  112. unsigned long samplesum = 0;

  113. unsigned int sampleavg = 0;

  114. int samplecount = 0;

  115. //unsigned int sample = 0;

  116. unsigned long oldtime = 0;

  117. unsigned long newtime = 0;

  118. 

  119. int color;

  120. int center = 0;

  121. int step = -1;

  122. int maxSteps = 16;

  123. float fadeRate = 0.80;

  124. int diff;

  125. 

  126. int

  127. origin = 0,

  128. color_wait_count = 0,

  129. scroll_color = COLOR_MIN,

  130. last_intensity = 0,

  131. intensity_max = 0,

  132. origin_at_flip = 0;

  133. uint32_t

  134. draw[DRAW_MAX];

  135. boolean

  136. growing = false,

  137. fall_from_left = true;

  138. 

  139. uint32_t currentBg = random(256);

  140. uint32_t nextBg = currentBg;

  141. TBlendType    currentBlending;

  142. 

  143. const int buttonPin = 0;     

  144. 

  145. int buttonPushCounter = 0;   

  146. int buttonState = 0;         

  147. int lastButtonState = 0;

  148. 

  149. 

  150. byte peak = 16;      

  151. 

  152. byte dotCount = 0;  

  153. byte dotHangCount = 0; 

  154. 

  155. void setup() {

  156. 

  157.   analogReference(EXTERNAL);

  158. 

  159.   pinMode(buttonPin, INPUT);

  160.   digitalWrite(buttonPin, HIGH);

  161. 

  162.   // Serial.begin(9600);

  163.   strip.begin();

  164.   strip.show(); // all pixels to 'off'

  165. 

  166.   Serial.begin(57600);

  167.   delay(3000);

  168. 

  169.   LEDS.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, N_PIXELS).setCorrection(TypicalLEDStrip);

  170.   LEDS.setBrightness(BRIGHTNESS);

  171.   dist = random16(12345);          

  172. }

  173. 

  174. float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve) {

  175. 

  176.   float OriginalRange = 0;

  177.   float NewRange = 0;

  178.   float zeroRefCurVal = 0;

  179.   float normalizedCurVal = 0;

  180.   float rangedValue = 0;

  181.   boolean invFlag = 0;

  182. 

  183.   if (curve > 10) curve = 10;

  184.   if (curve < -10) curve = -10;

  185. 

  186.   curve = (curve * -.1) ; 

  187.   curve = pow(10, curve); 

  188. 

  189.   if (inputValue < originalMin) {

  190.     inputValue = originalMin;

  191.   }

  192.   if (inputValue > originalMax) {

  193.     inputValue = originalMax;

  194.   }

  195. 

  196.   OriginalRange = originalMax - originalMin;

  197. 

  198.   if (newEnd > newBegin) {

  199.     NewRange = newEnd - newBegin;

  200.   }

  201.   else

  202.   {

  203.     NewRange = newBegin - newEnd;

  204.     invFlag = 1;

  205.   }

  206. 

  207.   zeroRefCurVal = inputValue - originalMin;

  208.   normalizedCurVal  =  zeroRefCurVal / OriginalRange;  

  209. 

  210.   if (originalMin > originalMax ) {

  211.     return 0;

  212.   }

  213. 

  214.   if (invFlag == 0) {

  215.     rangedValue =  (pow(normalizedCurVal, curve) * NewRange) + newBegin;

  216. 

  217.   }

  218.   else     

  219.   {

  220.     rangedValue =  newBegin - (pow(normalizedCurVal, curve) * NewRange);

  221.   }

  222.   return rangedValue;

  223. }

  224. 

  225. void loop() {

  226.   uint8_t  i;

  227.   uint16_t minLvl, maxLvl;

  228.   int      n, height;

  229.   buttonState = digitalRead(buttonPin);

  230.   if (buttonState != lastButtonState) {

  231.     if (buttonState == HIGH) {

  232.       buttonPushCounter++;

  233.       Serial.println("on");

  234.       Serial.print("number of button pushes:  ");

  235.       Serial.println(buttonPushCounter);

  236.       if (buttonPushCounter == 16) {

  237.         buttonPushCounter = 1;

  238.       }

  239.     }

  240.     else {

  241.       Serial.println("off");

  242.     }

  243.   }

  244.   lastButtonState = buttonState;

  245. 

  246.   switch (buttonPushCounter) {

  247. 

  248.     case 1:

  249.       buttonPushCounter == 1; {

  250.         All2(); 

  251.         break;

  252.       }

  253. 

  254.     case 2:

  255.       buttonPushCounter == 2; {

  256.         vu(); 

  257.         break;

  258.       }

  259. 

  260.     case 3:

  261.       buttonPushCounter == 3; {

  262.         vu1(); 

  263.         break;

  264.       }

  265. 

  266.     case 4:

  267.       buttonPushCounter == 4; {

  268.         vu2(); 

  269.         break;

  270.       }

  271. 

  272.     case 5:

  273.       buttonPushCounter == 5; {

  274.         Vu3(); 

  275.         break;

  276.       }

  277. 

  278.     case 6:

  279.       buttonPushCounter == 6; {

  280.         Vu4(); 

  281.         break;

  282.       }

  283. 

  284.     case 7:

  285.       buttonPushCounter == 7; {

  286.         Vu5(); 

  287.         break;

  288.       }

  289. 

  290.     case 8:

  291.       buttonPushCounter == 8; {

  292.         Vu6(); 

  293.         break;

  294.       }

  295. 

  296.     case 9:

  297.       buttonPushCounter == 9; {

  298.         vu7(); 

  299.         break;

  300.       }

  301. 

  302.     case 10:

  303.       buttonPushCounter == 10; {

  304.         vu8(); 

  305.         break;

  306.       }

  307. 

  308.     case 11:

  309.       buttonPushCounter == 11; {

  310.         vu9(); 

  311.         break;

  312.       }

  313. 

  314.     case 12:

  315.       buttonPushCounter == 12; {

  316.         vu10();

  317.         break;

  318.       }

  319.     case 13:

  320.       buttonPushCounter == 13; {

  321.         vu11(); 

  322.         break;

  323.       }

  324. 

  325.     case 14:

  326.       buttonPushCounter == 14; {

  327.         vu12(); 

  328.         break;

  329.       }

  330. 

  331.     case 15:

  332.       buttonPushCounter == 15; {

  333.         vu13(); 

  334.         break;

  335.       }

  336. 

  337. 

  338.     case 16:

  339.       buttonPushCounter == 16; {

  340.         colorWipe(strip.Color(0, 0, 0), 10);

  341.         break;

  342.       }

  343.   }

  344. }

  345. 

  346. void colorWipe(uint32_t c, uint8_t wait) {

  347.   for (uint16_t i = 0; i < strip.numPixels(); i++) {

  348.     strip.setPixelColor(i, c);

  349.     strip.show();

  350.     if (digitalRead(buttonPin) != lastButtonState) 

  351.       return;         

  352.     delay(wait);

  353.   }

  354. }

  355. 

  356. void vu() {

  357.   uint8_t  i;

  358.   uint16_t minLvl, maxLvl;

  359.   int      n, height;

  360.   n   = analogRead(MIC_PIN);                        

  361.   n   = abs(n - 512 - DC_OFFSET); 

  362.   n   = (n <= NOISE) ? 0 : (n - NOISE);             

  363.   lvl = ((lvl * 7) + n) >> 3;    

  364. 

  365.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  366. 

  367.   if (height < 0L)       height = 0;     

  368.   else if (height > TOP) height = TOP;

  369.   if (height > peak)     peak   = height; 

  370. 

  371.   for (i = 0; i < N_PIXELS; i++) {

  372.     if (i >= height)               strip.setPixelColor(i,   0,   0, 0);

  373.     else strip.setPixelColor(i, Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)));

  374.   }

  375.  

  376.   if (peak > 0 && peak <= N_PIXELS - 1) strip.setPixelColor(peak, Wheel(map(peak, 0, strip.numPixels() - 1, 30, 150)));

  377. 

  378.   strip.show(); 

  379.   

  380.   if (++dotCount >= PEAK_FALL) {

  381. 

  382.     if (peak > 0) peak--;

  383.     dotCount = 0;

  384.   }

  385. 

  386.   vol[volCount] = n;                      

  387.   if (++volCount >= SAMPLES) volCount = 0; 

  388. 

  389.   minLvl = maxLvl = vol[0];

  390.   for (i = 1; i < SAMPLES; i++) {

  391.     if (vol[i] < minLvl)      minLvl = vol[i];

  392.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  393.   }

  394.   

  395.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;

  396.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  397.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  398. }

  399. 

  400. uint32_t Wheel(byte WheelPos) {

  401.   if (WheelPos < 85) {

  402.     return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);

  403.   } else if (WheelPos < 170) {

  404.     WheelPos -= 85;

  405.     return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);

  406.   } else {

  407.     WheelPos -= 170;

  408.     return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);

  409.   }

  410. }

  411. 

  412. void vu1() {

  413.   uint8_t  i;

  414.   uint16_t minLvl, maxLvl;

  415.   int      n, height;

  416. 

  417.   n   = analogRead(MIC_PIN);                        

  418.   n   = abs(n - 512 - DC_OFFSET); 

  419.   n   = (n <= NOISE) ? 0 : (n - NOISE);            

  420.   lvl = ((lvl * 7) + n) >> 3;    

  421. 

  422.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  423. 

  424.   if (height < 0L)       height = 0;     

  425.   else if (height > TOP) height = TOP;

  426.   if (height > peak)     peak   = height; 

  427. 

  428.   for (i = 0; i < N_PIXELS_HALF; i++) {

  429.     if (i >= height) {

  430.       strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);

  431.       strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);

  432.     }

  433.     else {

  434.       uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, 30, 150));

  435.       strip.setPixelColor(N_PIXELS_HALF - i - 1, color);

  436.       strip.setPixelColor(N_PIXELS_HALF + i, color);

  437.     }

  438.   }

  439. 

  440.   if (peak > 0 && peak <= N_PIXELS_HALF - 1) {

  441.     uint32_t color = Wheel(map(peak, 0, N_PIXELS_HALF - 1, 30, 150));

  442.     strip.setPixelColor(N_PIXELS_HALF - peak - 1, color);

  443.     strip.setPixelColor(N_PIXELS_HALF + peak, color);

  444.   }

  445. 

  446.   strip.show(); 

  447. 

  448.   if (++dotCount >= PEAK_FALL) { //fall rate

  449. 

  450.     if (peak > 0) peak--;

  451.     dotCount = 0;

  452.   }

  453. 

  454.   vol[volCount] = n;                      

  455.   if (++volCount >= SAMPLES) volCount = 0; 

  456. 

  457.   minLvl = maxLvl = vol[0];

  458.   for (i = 1; i < SAMPLES; i++) {

  459.     if (vol[i] < minLvl)      minLvl = vol[i];

  460.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  461.   }

  462. 

  463.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;

  464.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;

  465.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  466. }

  467. 

  468. void vu2()

  469. {

  470.   unsigned long startMillis = millis(); 

  471.   float peakToPeak = 0;   

  472. 

  473.   unsigned int signalMax = 0;

  474.   unsigned int signalMin = 1023;

  475.   unsigned int c, y;

  476. 

  477.   while (millis() - startMillis < SAMPLE_WINDOW)

  478.   {

  479.     sample = analogRead(MIC_PIN);

  480.     if (sample < 1024)

  481.     {

  482.       if (sample > signalMax)

  483.       {

  484.         signalMax = sample;

  485.       }

  486.       else if (sample < signalMin)

  487.       {

  488.         signalMin = sample;

  489.       }

  490.     }

  491.   }

  492.   peakToPeak = signalMax - signalMin;

  493. 

  494.   for (int i = 0; i <= N_PIXELS_HALF - 1; i++) {

  495.     uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, 30, 150));

  496.     strip.setPixelColor(N_PIXELS - i, color);

  497.     strip.setPixelColor(0 + i, color);

  498.   }

  499. 

  500.   c = fscale(INPUT_FLOOR, INPUT_CEILING, N_PIXELS_HALF, 0, peakToPeak, 2);

  501. 

  502.   if (c < peak) {

  503.     peak = c;       

  504.     dotHangCount = 0;   

  505.   }

  506.   if (c <= strip.numPixels()) { 

  507.     drawLine(N_PIXELS_HALF, N_PIXELS_HALF - c, strip.Color(0, 0, 0));

  508.     drawLine(N_PIXELS_HALF, N_PIXELS_HALF + c, strip.Color(0, 0, 0));

  509.   }

  510. 

  511.   y = N_PIXELS_HALF - peak;

  512.   uint32_t color1 = Wheel(map(y, 0, N_PIXELS_HALF - 1, 30, 150));

  513.   strip.setPixelColor(y - 1, color1);

  514. 

  515.   y = N_PIXELS_HALF + peak;

  516.   strip.setPixelColor(y, color1);

  517. 

  518.   strip.show();

  519. 

  520.   if (dotHangCount > PEAK_HANG) { 

  521.     if (++dotCount >= PEAK_FALL2) { 

  522.       peak++;

  523.       dotCount = 0;

  524.     }

  525.   }

  526.   else {

  527.     dotHangCount++;

  528.   }

  529. }

  530. 

  531. 

  532. void Vu3() {

  533.   uint8_t i;

  534.   uint16_t minLvl, maxLvl;

  535.   int n, height;

  536. 

  537.   n = analogRead(MIC_PIN);             

  538.   n = abs(n - 512 - DC_OFFSET);        

  539.   n = (n <= NOISE) ? 0 : (n - NOISE);  

  540.   lvl = ((lvl * 7) + n) >> 3;    

  541. 

  542.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  543. 

  544.   if (height < 0L)       height = 0;      

  545.   else if (height > TOP) height = TOP;

  546.   if (height > peak)     peak   = height; 

  547. 

  548.   greenOffset += SPEED;

  549.   blueOffset += SPEED;

  550.   if (greenOffset >= 255) greenOffset = 0;

  551.   if (blueOffset >= 255) blueOffset = 0;

  552. 

  553.   for (i = 0; i < N_PIXELS; i++) {

  554.     if (i >= height) {

  555.       strip.setPixelColor(i, 0, 0, 0);

  556.     } else {

  557.       strip.setPixelColor(i, Wheel(

  558.                             map(i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)

  559.                           ));

  560.     }

  561.   }

  562.   if (peak > 0 && peak <= N_PIXELS - 1) strip.setPixelColor(peak, Wheel(map(peak, 0, strip.numPixels() - 1, 30, 150)));

  563. 

  564.   strip.show(); 

  565. 

  566.   if (++dotCount >= PEAK_FALL) { 

  567. 

  568.     if (peak > 0) peak--;

  569.     dotCount = 0;

  570.   }

  571.   strip.show();  

  572. 

  573.   vol[volCount] = n;

  574.   if (++volCount >= SAMPLES) {

  575.     volCount = 0;

  576.   }

  577. 

  578.   minLvl = maxLvl = vol[0];

  579.   for (i = 1; i < SAMPLES; i++) {

  580.     if (vol[i] < minLvl) {

  581.       minLvl = vol[i];

  582.     } else if (vol[i] > maxLvl) {

  583.       maxLvl = vol[i];

  584.     }

  585.   }

  586. 

  587.   if ((maxLvl - minLvl) < TOP) {

  588.     maxLvl = minLvl + TOP;

  589.   }

  590.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  591.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  592. }

  593. 

  594. 

  595. void Vu4() {

  596.   uint8_t  i;

  597.   uint16_t minLvl, maxLvl;

  598.   int      n, height;

  599. 

  600.   n   = analogRead(MIC_PIN);                        

  601.   n   = abs(n - 512 - DC_OFFSET); 

  602.   n   = (n <= NOISE) ? 0 : (n - NOISE);             

  603.   lvl = ((lvl * 7) + n) >> 3;    

  604. 

  605.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  606. 

  607.   if (height < 0L)       height = 0;     

  608.   else if (height > TOP) height = TOP;

  609.   if (height > peak)     peak   = height; 

  610.   greenOffset += SPEED;

  611.   blueOffset += SPEED;

  612.   if (greenOffset >= 255) greenOffset = 0;

  613.   if (blueOffset >= 255) blueOffset = 0;

  614. 

  615.   for (i = 0; i < N_PIXELS_HALF; i++) {

  616.     if (i >= height) {

  617.       strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);

  618.       strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);

  619.     }

  620.     else {

  621.       uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, (int)greenOffset, (int)blueOffset));

  622.       strip.setPixelColor(N_PIXELS_HALF - i - 1, color);

  623.       strip.setPixelColor(N_PIXELS_HALF + i, color);

  624.     }

  625. 

  626.   }

  627. 

  628.   // Draw peak dot

  629.   if (peak > 0 && peak <= N_PIXELS_HALF - 1) {

  630.     uint32_t color = Wheel(map(peak, 0, N_PIXELS_HALF - 1, 30, 150));

  631.     strip.setPixelColor(N_PIXELS_HALF - peak - 1, color);

  632.     strip.setPixelColor(N_PIXELS_HALF + peak, color);

  633.   }

  634. 

  635.   strip.show(); // Update strip

  636. 

  637.   // Every few frames, make the peak pixel drop by 1:

  638. 

  639.   if (++dotCount >= PEAK_FALL) { //fall rate

  640. 

  641.     if (peak > 0) peak--;

  642.     dotCount = 0;

  643.   }

  644. 

  645. 

  646.   vol[volCount] = n;                     

  647.   if (++volCount >= SAMPLES) volCount = 0; 

  648. 

  649. 

  650.   minLvl = maxLvl = vol[0];

  651.   for (i = 1; i < SAMPLES; i++) {

  652.     if (vol[i] < minLvl)      minLvl = vol[i];

  653.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  654.   }

  655. 

  656.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;

  657.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  658.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;

  659. }

  660. 

  661. void Vu5()

  662. {

  663.   uint8_t  i;

  664.   uint16_t minLvl, maxLvl;

  665.   int      n, height;

  666. 

  667.   n   = analogRead(MIC_PIN);                        

  668.   n   = abs(n - 512 - DC_OFFSET); 

  669.   n   = (n <= NOISE) ? 0 : (n - NOISE);             

  670.   lvl = ((lvl * 7) + n) >> 3;   

  671. 

  672.   height = TOP2 * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  673. 

  674.   if (height < 0L)       height = 0;     

  675.   else if (height > TOP2) height = TOP2;

  676.   if (height > peak)     peak   = height; 

  677. 

  678. 

  679. #ifdef CENTERED

  680.   for (i = 0; i < (N_PIXELS / 2); i++) {

  681.     if (((N_PIXELS / 2) + i) >= height)

  682.     {

  683.       strip.setPixelColor(((N_PIXELS / 2) + i),   0,   0, 0);

  684.       strip.setPixelColor(((N_PIXELS / 2) - i),   0,   0, 0);

  685.     }

  686.     else

  687.     {

  688.       strip.setPixelColor(((N_PIXELS / 2) + i), Wheel(map(((N_PIXELS / 2) + i), 0, strip.numPixels() - 1, 30, 150)));

  689.       strip.setPixelColor(((N_PIXELS / 2) - i), Wheel(map(((N_PIXELS / 2) - i), 0, strip.numPixels() - 1, 30, 150)));

  690.     }

  691.   }

  692. 

  693.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)

  694.   {

  695.     strip.setPixelColor(((N_PIXELS / 2) + peak), 255, 255, 255); 

  696.     strip.setPixelColor(((N_PIXELS / 2) - peak), 255, 255, 255); 

  697.   }

  698. #else

  699.   for (i = 0; i < N_PIXELS; i++)

  700.   {

  701.     if (i >= height)

  702.     {

  703.       strip.setPixelColor(i,   0,   0, 0);

  704.     }

  705.     else

  706.     {

  707.       strip.setPixelColor(i, Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)));

  708.     }

  709.   }

  710. 

  711.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)

  712.   {

  713.     strip.setPixelColor(peak, 255, 255, 255); 

  714.   }

  715. 

  716. #endif

  717. 

  718.   if (millis() - lastTime >= PEAK_FALL_MILLIS)

  719.   {

  720.     lastTime = millis();

  721. 

  722.     strip.show(); 

  723. 

  724.     if (peak > 0) peak--;

  725.   }

  726. 

  727.   vol[volCount] = n;                      

  728.   if (++volCount >= SAMPLES) volCount = 0; 

  729. 

  730.  

  731.   minLvl = maxLvl = vol[0];

  732.   for (i = 1; i < SAMPLES; i++)

  733.   {

  734.     if (vol[i] < minLvl)      minLvl = vol[i];

  735.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  736.   }

  737. 

  738.   if ((maxLvl - minLvl) < TOP2) maxLvl = minLvl + TOP2;

  739.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  740.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  741. }

  742. 

  743. void Vu6()

  744. {

  745.   uint8_t  i;

  746.   uint16_t minLvl, maxLvl;

  747.   int      n, height;

  748. 

  749.   n   = analogRead(MIC_PIN);                       

  750.   n   = abs(n - 512 - DC_OFFSET); 

  751.   n   = (n <= NOISE) ? 0 : (n - NOISE);            

  752.   lvl = ((lvl * 7) + n) >> 3;   

  753. 

  754.   height = TOP2 * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  755. 

  756.   if (height < 0L)       height = 0;     

  757.   else if (height > TOP2) height = TOP2;

  758.   if (height > peak)     peak   = height; 

  759. 

  760. 

  761. #ifdef CENTERED

  762.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)

  763.   {

  764.     strip.setPixelColor(((N_PIXELS / 2) + peak), 255, 255, 255); 

  765.     strip.setPixelColor(((N_PIXELS / 2) - peak), 255, 255, 255); 

  766.   }

  767. #else

  768.   // Color pixels based on rainbow gradient

  769.   for (i = 0; i < N_PIXELS; i++)

  770.   {

  771.     if (i >= height)

  772.     {

  773.       strip.setPixelColor(i,   0,   0, 0);

  774.     }

  775.     else

  776.     {

  777.     }

  778.   }

  779. 

  780.   // Draw peak dot

  781.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)

  782.   {

  783.     strip.setPixelColor(peak, 0, 0, 255); 

  784.   }

  785. 

  786. #endif

  787. 

  788.   // Every few frames, make the peak pixel drop by 1:

  789. 

  790.   if (millis() - lastTime >= PEAK_FALL_MILLIS)

  791.   {

  792.     lastTime = millis();

  793. 

  794.     strip.show(); // Update strip

  795. 

  796.     //fall rate

  797.     if (peak > 0) peak--;

  798.   }

  799. 

  800.   vol[volCount] = n;                      

  801.   if (++volCount >= SAMPLES) volCount = 0; 

  802. 

  803.   minLvl = maxLvl = vol[0];

  804.   for (i = 1; i < SAMPLES; i++)

  805.   {

  806.     if (vol[i] < minLvl)      minLvl = vol[i];

  807.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  808.   }

  809.  

  810.   if ((maxLvl - minLvl) < TOP2) maxLvl = minLvl + TOP2;

  811.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  812.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  813. }

  814. 

  815. void vu7() {

  816. 

  817.   EVERY_N_MILLISECONDS(1000) {

  818.     peakspersec = peakcount;                                       

  819.     peakcount = 0;                                                 

  820.   }

  821. 

  822.   soundmems();

  823. 

  824.   EVERY_N_MILLISECONDS(20) {

  825.     ripple3();

  826.   }

  827.   show_at_max_brightness_for_power();

  828. } 

  829. 

  830. void soundmems() {                                                  

  831.   newtime = millis();

  832.   int tmp = analogRead(MIC_PIN) - 512;

  833.   sample = abs(tmp);

  834. 

  835.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);

  836. 

  837.   samplesum = samplesum + sample - samplearray[samplecount];        

  838.   sampleavg = samplesum / NSAMPLES;                                 

  839.   samplearray[samplecount] = sample;                                

  840.   samplecount = (samplecount + 1) % NSAMPLES;                     

  841. 

  842.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);           

  843. 

  844.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) { 

  845.     step = -1;

  846.     peakcount++;

  847.     digitalWrite(13, HIGH);

  848.     oldtime = newtime;

  849.   }

  850. }  

  851. 

  852. void ripple3() {

  853.   for (int i = 0; i < N_PIXELS; i++) leds[i] = CHSV(bgcol, 255, sampleavg * 2); 

  854. 

  855.   switch (step) {

  856. 

  857.     case -1:                                                        

  858.       center = random(N_PIXELS);

  859.       colour = (peakspersec * 10) % 255;                                           

  860.       step = 0;

  861.       bgcol = bgcol + 8;

  862.       break;

  863. 

  864.     case 0:

  865.       leds[center] = CHSV(colour, 255, 255);                          

  866.       step ++;

  867.       break;

  868. 

  869.     case maxsteps:                                                    

  870.       break;

  871. 

  872.     default:                                                            

  873.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);  

  874.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);

  875.       step ++;                                                         

  876.       break;

  877.   } 

  878. } 

  879. 

  880. void vu8() {

  881.   int intensity = calculateIntensity();

  882.   updateOrigin(intensity);

  883.   assignDrawValues(intensity);

  884.   writeSegmented();

  885.   updateGlobals();

  886. }

  887. 

  888. int calculateIntensity() {

  889.   int      intensity;

  890. 

  891.   reading   = analogRead(MIC_PIN);                       

  892.   reading   = abs(reading - 512 - DC_OFFSET); 

  893.   reading   = (reading <= NOISE) ? 0 : (reading - NOISE);           

  894.   lvl = ((lvl * 7) + reading) >> 3;    

  895. 

  896.   intensity = DRAW_MAX * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);

  897. 

  898.   return constrain(intensity, 0, DRAW_MAX - 1);

  899. }

  900. 

  901. void updateOrigin(int intensity) {

  902.   if (growing && intensity < last_intensity) {

  903.     growing = false;

  904.     intensity_max = last_intensity;

  905.     fall_from_left = !fall_from_left;

  906.     origin_at_flip = origin;

  907.   } else if (intensity > last_intensity) {

  908.     growing = true;

  909.     origin_at_flip = origin;

  910.   }

  911.   last_intensity = intensity;

  912. 

  913.   if (!growing) {

  914.     if (fall_from_left) {

  915.       origin = origin_at_flip + ((intensity_max - intensity) / 2);

  916.     } else {

  917.       origin = origin_at_flip - ((intensity_max - intensity) / 2);

  918.     }

  919.     if (origin < 0) {

  920.       origin = DRAW_MAX - abs(origin);

  921.     } else if (origin > DRAW_MAX - 1) {

  922.       origin = origin - DRAW_MAX - 1;

  923.     }

  924.   }

  925. }

  926. 

  927. void assignDrawValues(int intensity) {

  928.   int min_lit = origin - (intensity / 2);

  929.   int max_lit = origin + (intensity / 2);

  930.   if (min_lit < 0) {

  931.     min_lit = min_lit + DRAW_MAX;

  932.   }

  933.   if (max_lit >= DRAW_MAX) {

  934.     max_lit = max_lit - DRAW_MAX;

  935.   }

  936.   for (int i = 0; i < DRAW_MAX; i++) {

  937. 

  938.     if (

  939.       (min_lit < max_lit && min_lit < i && i < max_lit) 

  940.       || (min_lit > max_lit && (i > min_lit || i < max_lit)) 

  941.     ) {

  942.       draw[i] = Wheel(scroll_color);

  943.     } else {

  944.       draw[i] = 0;

  945.     }

  946.   }

  947. }

  948. 

  949. void writeSegmented() {

  950.   int seg_len = N_PIXELS / SEGMENTS;

  951. 

  952.   for (int s = 0; s < SEGMENTS; s++) {

  953.     for (int i = 0; i < seg_len; i++) {

  954.       strip.setPixelColor(i + (s * seg_len), draw[map(i, 0, seg_len, 0, DRAW_MAX)]);

  955.     }

  956.   }

  957.   strip.show();

  958. }

  959. 

  960. uint32_t * segmentAndResize(uint32_t* draw) {

  961.   int seg_len = N_PIXELS / SEGMENTS;

  962. 

  963.   uint32_t segmented[N_PIXELS];

  964.   for (int s = 0; s < SEGMENTS; s++) {

  965.     for (int i = 0; i < seg_len; i++) {

  966.       segmented[i + (s * seg_len) ] = draw[map(i, 0, seg_len, 0, DRAW_MAX)];

  967.     }

  968.   }

  969.   return segmented;

  970. }

  971. 

  972. void writeToStrip(uint32_t* draw) {

  973.   for (int i = 0; i < N_PIXELS; i++) {

  974.     strip.setPixelColor(i, draw[i]);

  975.   }

  976.   strip.show();

  977. }

  978. 

  979. void updateGlobals() {

  980.   uint16_t minLvl, maxLvl;

  981. 

  982.   color_wait_count++;

  983.   if (color_wait_count > COLOR_WAIT_CYCLES) {

  984.     color_wait_count = 0;

  985.     scroll_color++;

  986.     if (scroll_color > COLOR_MAX) {

  987.       scroll_color = COLOR_MIN;

  988.     }

  989.   }

  990. 

  991.   vol[volCount] = reading;                      

  992.   if (++volCount >= SAMPLES) volCount = 0; 

  993. 

  994.   minLvl = maxLvl = vol[0];

  995.   for (uint8_t i = 1; i < SAMPLES; i++) {

  996.     if (vol[i] < minLvl)      minLvl = vol[i];

  997.     else if (vol[i] > maxLvl) maxLvl = vol[i];

  998.   }

  999.   

  1000.   if ((maxLvl - minLvl) < N_PIXELS) maxLvl = minLvl + N_PIXELS;

  1001.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6; 

  1002.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6; 

  1003. }

  1004. 

  1005. void vu9() {

  1006.   currentPalette = OceanColors_p;                            

  1007.   currentBlending = LINEARBLEND;

  1008.   EVERY_N_SECONDS(5) {                                        

  1009.     for (int i = 0; i < 16; i++) {

  1010.       targetPalette[i] = CHSV(random8(), 255, 255);

  1011.     }

  1012.   }

  1013. 

  1014.   EVERY_N_MILLISECONDS(100) {                                 

  1015.     uint8_t maxChanges = 24;

  1016.     nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges);

  1017.   }

  1018. 

  1019.   EVERY_N_MILLIS_I(thistimer, 20) {                           

  1020.     uint8_t timeval = beatsin8(10, 20, 50);                  

  1021.     thistimer.setPeriod(timeval);                            

  1022.     fadeToBlackBy(leds, N_PIXELS, 16);                       

  1023.     sndwave();

  1024.     soundble();

  1025.   }

  1026.   FastLED.setBrightness(max_bright);

  1027.   FastLED.show();

  1028. } 

  1029. 

  1030. void soundble() {                                           

  1031.   int tmp = analogRead(MIC_PIN) - 512 - DC_OFFSET;

  1032.   sample = abs(tmp);

  1033. } 

  1034. 

  1035. void sndwave() {

  1036.   leds[N_PIXELS / 2] = ColorFromPalette(currentPalette, sample, sample * 2, currentBlending); 

  1037.   for (int i = N_PIXELS - 1; i > N_PIXELS / 2; i--) {    

  1038.     leds[i] = leds[i - 1];

  1039.   }

  1040. 

  1041.   for (int i = 0; i < N_PIXELS / 2; i++) {                

  1042.     leds[i] = leds[i + 1];

  1043.   }

  1044.   addGlitter(sampleavg);

  1045. }

  1046. 

  1047. void vu10() {

  1048.   EVERY_N_SECONDS(5) {                                       

  1049.     static uint8_t baseC = random8();                         

  1050. 

  1051.     for (int i = 0; i < 16; i++) {

  1052.       targetPalette[i] = CHSV(random8(), 255, 255);

  1053.     }

  1054.   }

  1055. 

  1056.   EVERY_N_MILLISECONDS(100) {

  1057.     uint8_t maxChanges = 24;

  1058.     nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges);   

  1059.   }

  1060. 

  1061.   EVERY_N_MILLISECONDS(thisdelay) {                           

  1062.     soundtun();

  1063.     FastLED.setBrightness(max_bright);

  1064.     FastLED.show();

  1065.   }

  1066. } 

  1067. 

  1068. void soundtun() {

  1069.   int n;

  1070.   n = analogRead(MIC_PIN);                                    

  1071.   n = qsuba(abs(n - 512), 10);                                

  1072.   CRGB newcolour = ColorFromPalette(currentPalette, constrain(n, 0, 255), constrain(n, 0, 255), currentBlending);

  1073.   nblend(leds[0], newcolour, 128);

  1074. 

  1075.   for (int i = N_PIXELS - 1; i > 0; i--) {

  1076.     leds[i] = leds[i - 1];

  1077.   }

  1078. 

  1079. } 

  1080. 

  1081. void vu11() {

  1082.   EVERY_N_MILLISECONDS(1000) {

  1083.     peakspersec = peakcount;                                  

  1084.     peakcount = 0;                                            

  1085.   }

  1086. 

  1087.   soundrip();

  1088. 

  1089.   EVERY_N_MILLISECONDS(20) {

  1090.     rippled();

  1091.   }

  1092.   FastLED.show();

  1093. } 

  1094. 

  1095. void soundrip() {                                            

  1096.   newtime = millis();

  1097.   int tmp = analogRead(MIC_PIN) - 512;

  1098.   sample = abs(tmp);

  1099. 

  1100.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);

  1101. 

  1102.   samplesum = samplesum + sample - samplearray[samplecount];  

  1103.   sampleavg = samplesum / NSAMPLES;                          

  1104. 

  1105.   Serial.println(sampleavg);

  1106. 

  1107.   samplearray[samplecount] = sample;                          

  1108.   samplecount = (samplecount + 1) % NSAMPLES;                

  1109. 

  1110.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);       

  1111. 

  1112.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) { 

  1113.     step = -1;

  1114.     peakcount++;

  1115.     oldtime = newtime;

  1116.   }

  1117. }  

  1118. 

  1119. void rippled() {

  1120. 

  1121.   fadeToBlackBy(leds, N_PIXELS, 64);                          

  1122. 

  1123.   switch (step) {

  1124. 

  1125.     case -1:                                                  

  1126.       center = random(N_PIXELS);

  1127.       colour = (peakspersec * 10) % 255;                      

  1128.       step = 0;

  1129.       break;

  1130. 

  1131.     case 0:

  1132.       leds[center] = CHSV(colour, 255, 255);                  

  1133.       step ++;

  1134.       break;

  1135. 

  1136.     case maxsteps:                                           

  1137.       break;

  1138. 

  1139.     default:                                                 

  1140.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);   

  1141.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);

  1142.       step ++;                                                

  1143.       break;

  1144.   } 

  1145. 

  1146. } 

  1147. 

  1148. void drawLine(uint8_t from, uint8_t to, uint32_t c) {

  1149.   uint8_t fromTemp;

  1150.   if (from > to) {

  1151.     fromTemp = from;

  1152.     from = to;

  1153.     to = fromTemp;

  1154.   }

  1155.   for (int i = from; i <= to; i++) {

  1156.     strip.setPixelColor(i, c);

  1157.   }

  1158. }

  1159. 

  1160. void setPixel(int Pixel, byte red, byte green, byte blue) {

  1161.   strip.setPixelColor(Pixel, strip.Color(red, green, blue));

  1162. }

  1163. 

  1164. void setAll(byte red, byte green, byte blue) {

  1165. 

  1166.   for (int i = 0; i < N_PIXELS; i++ ) {

  1167. 

  1168.     setPixel(i, red, green, blue);

  1169.   }

  1170.   strip.show();

  1171. }

  1172. void vu12() {

  1173. 

  1174.   EVERY_N_MILLISECONDS(1000) {

  1175.     peakspersec = peakcount;                                  

  1176.     peakcount = 0;                                            

  1177.   }

  1178. 

  1179.   soundripped();

  1180. 

  1181.   EVERY_N_MILLISECONDS(20) {

  1182.     rippvu();

  1183.   }

  1184.   FastLED.show();

  1185. }

  1186. 

  1187. void soundripped() {                                            

  1188.   newtime = millis();

  1189.   int tmp = analogRead(MIC_PIN) - 512;

  1190.   sample = abs(tmp);

  1191. 

  1192.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);

  1193. 

  1194.   samplesum = samplesum + sample - samplearray[samplecount];  

  1195.   sampleavg = samplesum / NSAMPLES;                           

  1196. 

  1197.   Serial.println(sampleavg);

  1198. 

  1199.   samplearray[samplecount] = sample;                          

  1200.   samplecount = (samplecount + 1) % NSAMPLES;                 

  1201. 

  1202.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);      

  1203. 

  1204.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) { 

  1205.     step = -1;

  1206.     peakcount++;

  1207.     oldtime = newtime;

  1208.   }

  1209. 

  1210. }  

  1211. void rippvu() {                                                                

  1212. 

  1213.   fadeToBlackBy(leds, N_PIXELS, 64);                          

  1214. 

  1215.   switch (step) {

  1216. 

  1217.     case -1:                                                  

  1218.       center = random(N_PIXELS);

  1219.       colour = (peakspersec * 10) % 255;                      

  1220.       step = 0;

  1221.       break;

  1222. 

  1223.     case 0:

  1224.       leds[center] = CHSV(colour, 255, 255);                  

  1225.       step ++;

  1226.       break;

  1227. 

  1228.     case maxsteps:                                            

  1229.       break;

  1230. 

  1231.     default:                                                 

  1232.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);   

  1233.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);

  1234.       step ++;                                                

  1235.       break;

  1236.   } 

  1237.   addGlitter(sampleavg);

  1238. } 

  1239. 

  1240. void vu13() {                                                                   

  1241.   EVERY_N_MILLISECONDS(1000) {

  1242.     peakspersec = peakcount;                                  

  1243.     peakcount = 0;                                           

  1244.   }

  1245. 

  1246.   soundripper();

  1247. 

  1248.   EVERY_N_MILLISECONDS(20) {

  1249.     jugglep();

  1250.   }

  1251.   FastLED.show();

  1252. } 

  1253. 

  1254. void soundripper() {                                            

  1255. 

  1256.   newtime = millis();

  1257.   int tmp = analogRead(MIC_PIN) - 512;

  1258.   sample = abs(tmp);

  1259. 

  1260.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);

  1261. 

  1262.   samplesum = samplesum + sample - samplearray[samplecount];  

  1263.   sampleavg = samplesum / NSAMPLES;                           

  1264. 

  1265.   Serial.println(sampleavg);

  1266. 

  1267.   samplearray[samplecount] = sample;                         

  1268.   samplecount = (samplecount + 1) % NSAMPLES;                 

  1269. 

  1270.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);       

  1271. 

  1272.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) { 

  1273.     step = -1;

  1274.     peakcount++;

  1275.     oldtime = newtime;

  1276.     jugglep();

  1277.   }

  1278. } 

  1279. 

  1280. void jugglep() {                                                                

  1281. 

  1282.   static uint8_t thishue = 0;

  1283.   timeval = 40;                                                                 

  1284.   leds[0] = ColorFromPalette(currentPalette, thishue++, sampleavg, LINEARBLEND);

  1285.   for (int i = N_PIXELS - 1; i > 0 ; i-- ) leds[i] = leds[i - 1];

  1286.   addGlitter(sampleavg / 2);                                                   

  1287. } 

  1288. 

  1289. uint32_t Wheel(byte WheelPos, float opacity) {

  1290. 

  1291.   if (WheelPos < 85) {

  1292.     return strip.Color((WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity, 0);

  1293.   }

  1294.   else if (WheelPos < 170) {

  1295.     WheelPos -= 85;

  1296.     return strip.Color((255 - WheelPos * 3) * opacity, 0, (WheelPos * 3) * opacity);

  1297.   }

  1298.   else {

  1299.     WheelPos -= 170;

  1300.     return strip.Color(0, (WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity);

  1301.   }

  1302. }

  1303. 

  1304. void addGlitter( fract8 chanceOfGlitter) {                                     

  1305. 

  1306.   if ( random8() < chanceOfGlitter) {

  1307.     leds[random16(N_PIXELS)] += CRGB::White;

  1308.   }

  1309. } 

  1310. 

  1311. typedef void (*SimplePatternList[])();

  1312. SimplePatternList qPatterns = {vu, vu1, vu2, Vu3, Vu4, Vu5, Vu6, vu7, vu8, vu9, vu10, vu11, vu12, vu13};

  1313. uint8_t qCurrentPatternNumber = 0; 

  1314. 

  1315. void nextPattern2()

  1316. {

  1317.   qCurrentPatternNumber = (qCurrentPatternNumber + 1) % ARRAY_SIZE( qPatterns);

  1318. }

  1319. 

  1320. void All2()

  1321. {

  1322.   qPatterns[qCurrentPatternNumber]();

  1323.   EVERY_N_SECONDS( 30 ) {

  1324.     nextPattern2();  

  1325.   }

  1326. }
复制代码


回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-10-5 10:01:19

【花雕动手做】看见声音，基于Arduino系列音乐可视器（1）---LED节奏灯
https://mc.dfrobot.com.cn/thread-311167-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（2）---OLED频谱灯
https://mc.dfrobot.com.cn/thread-311174-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（3）---RGB律动灯
https://mc.dfrobot.com.cn/thread-311183-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（4）---WS2812条灯
https://mc.dfrobot.com.cn/thread-311190-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（5）---WS2812柱跳灯
https://mc.dfrobot.com.cn/thread-311192-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（6）---点阵频谱灯
https://mc.dfrobot.com.cn/thread-311201-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（7）---大方格频谱灯
https://mc.dfrobot.com.cn/thread-311364-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（8）---四位32段点阵屏
https://mc.dfrobot.com.cn/thread-311490-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（9）---X Music Spectrum
https://mc.dfrobot.com.cn/thread-311627-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（10）---WS2812硬板屏
https://mc.dfrobot.com.cn/thread-311641-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（11）---WS2812幻彩灯带
https://mc.dfrobot.com.cn/thread-313648-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（12）---米管快速节奏灯
https://mc.dfrobot.com.cn/thread-313708-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）---有机棒立柱灯
https://mc.dfrobot.com.cn/thread-313723-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（14）---水杯水瓶灯
https://mc.dfrobot.com.cn/thread-313803-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（15）--横排LED方管灯
https://mc.dfrobot.com.cn/thread-313811-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（16）--热干胶棒棒灯
https://mc.dfrobot.com.cn/thread-313844-1-1.html
【花雕动手做】有趣好玩音乐可视化系列（17）--光导纤维灯
https://mc.dfrobot.com.cn/thread-313867-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（18）--LED平面板灯
https://mc.dfrobot.com.cn/thread-313951-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（19）--通体光纤灯
https://mc.dfrobot.com.cn/thread-313962-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（20）--首饰盒镜子灯
https://mc.dfrobot.com.cn/thread-313969-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（21）--CD 光盘灯
https://mc.dfrobot.com.cn/thread-313984-1-1.html
【花雕动手做】看见声音，基于Arduino系列音乐可视器（22）--LED无限魔方
https://mc.dfrobot.com.cn/thread-313994-1-1.html
【花雕动手做】有趣好玩的音乐可视化（23）--3合1闪点光纤
https://mc.dfrobot.com.cn/thread-314168-1-1.html
【花雕动手做】有趣好玩的音乐可视化（24）--无限LED镜子灯
https://mc.dfrobot.com.cn/thread-314180-1-1.html
【花雕动手做】有趣好玩音乐可视化（25）--水龙卷旋涡灯
https://mc.dfrobot.com.cn/thread-314231-1-1.html
【花雕动手做】有趣好玩音乐可视化系列（26）--LED 超立方体
https://mc.dfrobot.com.cn/thread-314244-1-1.html
【花雕动手做】有趣好玩的音乐可视化（27）--磁搅LED水旋灯
https://mc.dfrobot.com.cn/thread-314273-1-1.html


回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:13:44

彩灯使用WS2812B


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

其主要特点
智能反接保护，电源反接不会损坏IC。
IC控制电路与LED点光源公用一个电源。
控制电路与RGB芯片集成在一个5050封装的元器件中，构成一个完整的外控像素点。
内置信号整形电路，任何一个像素点收到信号后经过波形整形再输出，保证线路波形畸变不会累加。
内置上电复位和掉电复位电路。
每个像素点的三基色颜色可实现256级亮度显示，完成16777216种颜色的全真色彩显示，扫描频率不低于400Hz/s。
串行级联接口，能通过一根信号线完成数据的接收与解码。
任意两点传传输距离在不超过5米时无需增加任何电路。
当刷新速率30帧/秒时，级联数不小于1024点。
数据发送速度可达800Kbps。
光的颜色高度一致，性价比高。

主要应用领域
LED全彩发光字灯串,LED全彩模组， LED全彩软灯条硬灯条,LED护栏管。
LED点光源,LED像素屏,LED异形屏，各种电子产品，电器设备跑马灯。



回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 17:34:44

在路边五金店里，买了一米装修用的墙上线槽盒子

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 17:39:07

带气泡的有机棒

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 17:42:20

线槽盒子有可拆卸的盖子

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 17:46:37

备好项目材料

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 17:49:30

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 20:56:37

有机棒直径约20mm

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 21:01:17

测量划线
【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 21:03:59

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 21:06:37

先钻小孔

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 21:09:18

再扩大孔

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-25 21:11:46

打孔完工

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:09:10

声音模块依旧使用MAX9814（几元钱便宜好用）

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1


MAX9814是一款低成本高性能麦克风放大器，具有自动增益控制(AGC)和低噪声麦克风偏置。器件具有低噪声前端放大器、可变增益放大(VGA)、输出放大器、麦克风偏置电压发生器和AGC控制电路。
●自动增益控制(AGC)
●3种增益设置(40dB、50dB、60dB)
●可编程动作时间
●可编程动作和释放时间比
●电源电压范围2.7V～5.5V  
●低THD：0.04% (典型值)
●低功耗关断模式
●内置2V低噪声麦克风偏置


回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:17:28

WS2812模块电原理图


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:20:57

WS2812B灯带选用的是每米60灯黑底裸板


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:24:42

WS2812B是集控制电路和发光电路于一体的LED光源元件，其控制IC为WS2812B，发光元件是5050RGBLED，电压为5V，每个单位的峰值电流为60ma，灯带为三线制，VCC GND DIN分别为电源+、电源-、信号，当使用外部电源时，外部电源-需要与单片机的GND相连。


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图2
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 05:28:11

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 09:30:08

灯带固定在线槽盖子上


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 09:33:56

开始安装有机棒


【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1
回复

使用道具 举报

驴友花雕  中级技神
 楼主|

发表于 2022-7-26 09:37:44

Arduno UNO项目接线示意图

【花雕动手做】看见声音，基于Arduino系列音乐可视器（13）图1

回复

使用道具 举报

123下一页
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

为本项目制作心愿单
购买心愿单
心愿单 编辑
[[wsData.name]]

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
撰写新帖
关于楼主
勋章墙
萌萌哒新人 活跃会员 宣传大使 牛X认证 创作达人 ARD DAY 摸鱼团员 志“童”道合 编辑选择奖

楼主的其它帖子

background 创造力兑换 background 心愿单 background 创客导航
上海智位机器人股份有限公司 沪ICP备09038501号-4

© 2013-2024 Comsenz Inc. Powered by Discuz! X3.4 Licensed

mail