736浏览
查看: 736|回复: 41

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

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


01.jpg

驴友花雕  初级技神
 楼主|

发表于 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. #include <Adafruit_NeoPixel.h>
  11. #include <FastLED.h>
  12. #include <math.h>
  13. #include <SoftwareSerial.h>
  14. #define N_PIXELS  70  
  15. #define N_PIXELS_HALF (N_PIXELS/2)
  16. #define MIC_PIN   A0  
  17. #define LED_PIN    6  
  18. #define SAMPLE_WINDOW   10  
  19. #define PEAK_HANG 24
  20. #define PEAK_FALL 20
  21. #define PEAK_FALL2 8
  22. #define INPUT_FLOOR 10
  23. #define INPUT_CEILING 30
  24. #define DC_OFFSET  0  
  25. #define NOISE     10  
  26. #define SAMPLES   60  
  27. #define TOP       (N_PIXELS + 2)
  28. #define SPEED .20      
  29. #define TOP2      (N_PIXELS + 1)
  30. #define LAST_PIXEL_OFFSET N_PIXELS-1
  31. #define PEAK_FALL_MILLIS 10  
  32. #define POT_PIN    4
  33. #define BG 0
  34. #define LAST_PIXEL_OFFSET N_PIXELS-1
  35. #if FASTLED_VERSION < 3001000
  36. #error "Requires FastLED 3.1 or later; check github for latest code."
  37. #endif
  38. #define BRIGHTNESS  255
  39. #define LED_TYPE    WS2812B     
  40. #define COLOR_ORDER GRB
  41. #define COLOR_MIN           0
  42. #define COLOR_MAX         255
  43. #define DRAW_MAX          100
  44. #define SEGMENTS            4  
  45. #define COLOR_WAIT_CYCLES  10  
  46. #define qsubd(x, b)  ((x>b)?b:0)
  47. #define qsuba(x, b)  ((x>b)?x-b:0)                                             
  48. #define ARRAY_SIZE(A) (sizeof(A) / sizeof((A)[0]))
  49. struct CRGB leds[N_PIXELS];
  50. Adafruit_NeoPixel strip = Adafruit_NeoPixel(N_PIXELS, LED_PIN, NEO_GRB + NEO_KHZ800);
  51. static uint16_t dist;         
  52. uint16_t scale = 30;         
  53. uint8_t maxChanges = 48;      
  54. CRGBPalette16 currentPalette(OceanColors_p);
  55. CRGBPalette16 targetPalette(CloudColors_p);
  56. uint8_t timeval = 20;                                                           
  57. uint16_t loops = 0;                                                            
  58. bool     samplepeak = 0;                                                        
  59. uint16_t oldsample = 0;                                                         
  60. bool thisdir = 0;
  61. enum
  62. {
  63. } MODE;
  64. bool reverse = true;
  65. int BRIGHTNESS_MAX = 80;
  66. int brightness = 20;
  67. byte
  68. //  peak      = 0,      
  69. //  dotCount  = 0,      
  70. volCount  = 0;      
  71. int
  72. reading,
  73. vol[SAMPLES],      
  74. lvl       = 10,      
  75. minLvlAvg = 0,      
  76. maxLvlAvg = 512;
  77. float
  78. greenOffset = 30,
  79. blueOffset = 150;
  80. int CYCLE_MIN_MILLIS = 2;
  81. int CYCLE_MAX_MILLIS = 1000;
  82. int cycleMillis = 20;
  83. bool paused = false;
  84. long lastTime = 0;
  85. bool boring = true;
  86. bool gReverseDirection = false;
  87. int          myhue =   0;
  88. uint8_t colour;
  89. uint8_t myfade = 255;                                         
  90. #define maxsteps 16                                          
  91. int peakspersec = 0;
  92. int peakcount = 0;
  93. uint8_t bgcol = 0;
  94. int thisdelay = 20;
  95. uint8_t max_bright = 255;
  96. unsigned int sample;
  97. #define NSAMPLES 64
  98. unsigned int samplearray[NSAMPLES];
  99. unsigned long samplesum = 0;
  100. unsigned int sampleavg = 0;
  101. int samplecount = 0;
  102. //unsigned int sample = 0;
  103. unsigned long oldtime = 0;
  104. unsigned long newtime = 0;
  105. int color;
  106. int center = 0;
  107. int step = -1;
  108. int maxSteps = 16;
  109. float fadeRate = 0.80;
  110. int diff;
  111. int
  112. origin = 0,
  113. color_wait_count = 0,
  114. scroll_color = COLOR_MIN,
  115. last_intensity = 0,
  116. intensity_max = 0,
  117. origin_at_flip = 0;
  118. uint32_t
  119. draw[DRAW_MAX];
  120. boolean
  121. growing = false,
  122. fall_from_left = true;
  123. uint32_t currentBg = random(256);
  124. uint32_t nextBg = currentBg;
  125. TBlendType    currentBlending;
  126. const int buttonPin = 0;     
  127. int buttonPushCounter = 0;   
  128. int buttonState = 0;         
  129. int lastButtonState = 0;
  130. byte peak = 16;      
  131. byte dotCount = 0;  
  132. byte dotHangCount = 0;
  133. void setup() {
  134.   analogReference(EXTERNAL);
  135.   pinMode(buttonPin, INPUT);
  136.   digitalWrite(buttonPin, HIGH);
  137.   // Serial.begin(9600);
  138.   strip.begin();
  139.   strip.show(); // all pixels to 'off'
  140.   Serial.begin(57600);
  141.   delay(3000);
  142.   LEDS.addLeds<LED_TYPE, LED_PIN, COLOR_ORDER>(leds, N_PIXELS).setCorrection(TypicalLEDStrip);
  143.   LEDS.setBrightness(BRIGHTNESS);
  144.   dist = random16(12345);         
  145. }
  146. float fscale( float originalMin, float originalMax, float newBegin, float newEnd, float inputValue, float curve) {
  147.   float OriginalRange = 0;
  148.   float NewRange = 0;
  149.   float zeroRefCurVal = 0;
  150.   float normalizedCurVal = 0;
  151.   float rangedValue = 0;
  152.   boolean invFlag = 0;
  153.   if (curve > 10) curve = 10;
  154.   if (curve < -10) curve = -10;
  155.   curve = (curve * -.1) ;
  156.   curve = pow(10, curve);
  157.   if (inputValue < originalMin) {
  158.     inputValue = originalMin;
  159.   }
  160.   if (inputValue > originalMax) {
  161.     inputValue = originalMax;
  162.   }
  163.   OriginalRange = originalMax - originalMin;
  164.   if (newEnd > newBegin) {
  165.     NewRange = newEnd - newBegin;
  166.   }
  167.   else
  168.   {
  169.     NewRange = newBegin - newEnd;
  170.     invFlag = 1;
  171.   }
  172.   zeroRefCurVal = inputValue - originalMin;
  173.   normalizedCurVal  =  zeroRefCurVal / OriginalRange;  
  174.   if (originalMin > originalMax ) {
  175.     return 0;
  176.   }
  177.   if (invFlag == 0) {
  178.     rangedValue =  (pow(normalizedCurVal, curve) * NewRange) + newBegin;
  179.   }
  180.   else     
  181.   {
  182.     rangedValue =  newBegin - (pow(normalizedCurVal, curve) * NewRange);
  183.   }
  184.   return rangedValue;
  185. }
  186. void loop() {
  187.   uint8_t  i;
  188.   uint16_t minLvl, maxLvl;
  189.   int      n, height;
  190.   buttonState = digitalRead(buttonPin);
  191.   if (buttonState != lastButtonState) {
  192.     if (buttonState == HIGH) {
  193.       buttonPushCounter++;
  194.       Serial.println("on");
  195.       Serial.print("number of button pushes:  ");
  196.       Serial.println(buttonPushCounter);
  197.       if (buttonPushCounter == 16) {
  198.         buttonPushCounter = 1;
  199.       }
  200.     }
  201.     else {
  202.       Serial.println("off");
  203.     }
  204.   }
  205.   lastButtonState = buttonState;
  206.   switch (buttonPushCounter) {
  207.     case 1:
  208.       buttonPushCounter == 1; {
  209.         All2();
  210.         break;
  211.       }
  212.     case 2:
  213.       buttonPushCounter == 2; {
  214.         vu();
  215.         break;
  216.       }
  217.     case 3:
  218.       buttonPushCounter == 3; {
  219.         vu1();
  220.         break;
  221.       }
  222.     case 4:
  223.       buttonPushCounter == 4; {
  224.         vu2();
  225.         break;
  226.       }
  227.     case 5:
  228.       buttonPushCounter == 5; {
  229.         Vu3();
  230.         break;
  231.       }
  232.     case 6:
  233.       buttonPushCounter == 6; {
  234.         Vu4();
  235.         break;
  236.       }
  237.     case 7:
  238.       buttonPushCounter == 7; {
  239.         Vu5();
  240.         break;
  241.       }
  242.     case 8:
  243.       buttonPushCounter == 8; {
  244.         Vu6();
  245.         break;
  246.       }
  247.     case 9:
  248.       buttonPushCounter == 9; {
  249.         vu7();
  250.         break;
  251.       }
  252.     case 10:
  253.       buttonPushCounter == 10; {
  254.         vu8();
  255.         break;
  256.       }
  257.     case 11:
  258.       buttonPushCounter == 11; {
  259.         vu9();
  260.         break;
  261.       }
  262.     case 12:
  263.       buttonPushCounter == 12; {
  264.         vu10();
  265.         break;
  266.       }
  267.     case 13:
  268.       buttonPushCounter == 13; {
  269.         vu11();
  270.         break;
  271.       }
  272.     case 14:
  273.       buttonPushCounter == 14; {
  274.         vu12();
  275.         break;
  276.       }
  277.     case 15:
  278.       buttonPushCounter == 15; {
  279.         vu13();
  280.         break;
  281.       }
  282.     case 16:
  283.       buttonPushCounter == 16; {
  284.         colorWipe(strip.Color(0, 0, 0), 10);
  285.         break;
  286.       }
  287.   }
  288. }
  289. void colorWipe(uint32_t c, uint8_t wait) {
  290.   for (uint16_t i = 0; i < strip.numPixels(); i++) {
  291.     strip.setPixelColor(i, c);
  292.     strip.show();
  293.     if (digitalRead(buttonPin) != lastButtonState)
  294.       return;         
  295.     delay(wait);
  296.   }
  297. }
  298. void vu() {
  299.   uint8_t  i;
  300.   uint16_t minLvl, maxLvl;
  301.   int      n, height;
  302.   n   = analogRead(MIC_PIN);                        
  303.   n   = abs(n - 512 - DC_OFFSET);
  304.   n   = (n <= NOISE) ? 0 : (n - NOISE);            
  305.   lvl = ((lvl * 7) + n) >> 3;   
  306.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  307.   if (height < 0L)       height = 0;     
  308.   else if (height > TOP) height = TOP;
  309.   if (height > peak)     peak   = height;
  310.   for (i = 0; i < N_PIXELS; i++) {
  311.     if (i >= height)               strip.setPixelColor(i,   0,   0, 0);
  312.     else strip.setPixelColor(i, Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)));
  313.   }
  314.   if (peak > 0 && peak <= N_PIXELS - 1) strip.setPixelColor(peak, Wheel(map(peak, 0, strip.numPixels() - 1, 30, 150)));
  315.   strip.show();
  316.   
  317.   if (++dotCount >= PEAK_FALL) {
  318.     if (peak > 0) peak--;
  319.     dotCount = 0;
  320.   }
  321.   vol[volCount] = n;                     
  322.   if (++volCount >= SAMPLES) volCount = 0;
  323.   minLvl = maxLvl = vol[0];
  324.   for (i = 1; i < SAMPLES; i++) {
  325.     if (vol[i] < minLvl)      minLvl = vol[i];
  326.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  327.   }
  328.   
  329.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
  330.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  331.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  332. }
  333. uint32_t Wheel(byte WheelPos) {
  334.   if (WheelPos < 85) {
  335.     return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  336.   } else if (WheelPos < 170) {
  337.     WheelPos -= 85;
  338.     return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  339.   } else {
  340.     WheelPos -= 170;
  341.     return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  342.   }
  343. }
  344. void vu1() {
  345.   uint8_t  i;
  346.   uint16_t minLvl, maxLvl;
  347.   int      n, height;
  348.   n   = analogRead(MIC_PIN);                        
  349.   n   = abs(n - 512 - DC_OFFSET);
  350.   n   = (n <= NOISE) ? 0 : (n - NOISE);            
  351.   lvl = ((lvl * 7) + n) >> 3;   
  352.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  353.   if (height < 0L)       height = 0;     
  354.   else if (height > TOP) height = TOP;
  355.   if (height > peak)     peak   = height;
  356.   for (i = 0; i < N_PIXELS_HALF; i++) {
  357.     if (i >= height) {
  358.       strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);
  359.       strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);
  360.     }
  361.     else {
  362.       uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, 30, 150));
  363.       strip.setPixelColor(N_PIXELS_HALF - i - 1, color);
  364.       strip.setPixelColor(N_PIXELS_HALF + i, color);
  365.     }
  366.   }
  367.   if (peak > 0 && peak <= N_PIXELS_HALF - 1) {
  368.     uint32_t color = Wheel(map(peak, 0, N_PIXELS_HALF - 1, 30, 150));
  369.     strip.setPixelColor(N_PIXELS_HALF - peak - 1, color);
  370.     strip.setPixelColor(N_PIXELS_HALF + peak, color);
  371.   }
  372.   strip.show();
  373.   if (++dotCount >= PEAK_FALL) { //fall rate
  374.     if (peak > 0) peak--;
  375.     dotCount = 0;
  376.   }
  377.   vol[volCount] = n;                     
  378.   if (++volCount >= SAMPLES) volCount = 0;
  379.   minLvl = maxLvl = vol[0];
  380.   for (i = 1; i < SAMPLES; i++) {
  381.     if (vol[i] < minLvl)      minLvl = vol[i];
  382.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  383.   }
  384.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
  385.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  386.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  387. }
  388. void vu2()
  389. {
  390.   unsigned long startMillis = millis();
  391.   float peakToPeak = 0;   
  392.   unsigned int signalMax = 0;
  393.   unsigned int signalMin = 1023;
  394.   unsigned int c, y;
  395.   while (millis() - startMillis < SAMPLE_WINDOW)
  396.   {
  397.     sample = analogRead(MIC_PIN);
  398.     if (sample < 1024)
  399.     {
  400.       if (sample > signalMax)
  401.       {
  402.         signalMax = sample;
  403.       }
  404.       else if (sample < signalMin)
  405.       {
  406.         signalMin = sample;
  407.       }
  408.     }
  409.   }
  410.   peakToPeak = signalMax - signalMin;
  411.   for (int i = 0; i <= N_PIXELS_HALF - 1; i++) {
  412.     uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, 30, 150));
  413.     strip.setPixelColor(N_PIXELS - i, color);
  414.     strip.setPixelColor(0 + i, color);
  415.   }
  416.   c = fscale(INPUT_FLOOR, INPUT_CEILING, N_PIXELS_HALF, 0, peakToPeak, 2);
  417.   if (c < peak) {
  418.     peak = c;      
  419.     dotHangCount = 0;   
  420.   }
  421.   if (c <= strip.numPixels()) {
  422.     drawLine(N_PIXELS_HALF, N_PIXELS_HALF - c, strip.Color(0, 0, 0));
  423.     drawLine(N_PIXELS_HALF, N_PIXELS_HALF + c, strip.Color(0, 0, 0));
  424.   }
  425.   y = N_PIXELS_HALF - peak;
  426.   uint32_t color1 = Wheel(map(y, 0, N_PIXELS_HALF - 1, 30, 150));
  427.   strip.setPixelColor(y - 1, color1);
  428.   y = N_PIXELS_HALF + peak;
  429.   strip.setPixelColor(y, color1);
  430.   strip.show();
  431.   if (dotHangCount > PEAK_HANG) {
  432.     if (++dotCount >= PEAK_FALL2) {
  433.       peak++;
  434.       dotCount = 0;
  435.     }
  436.   }
  437.   else {
  438.     dotHangCount++;
  439.   }
  440. }
  441. void Vu3() {
  442.   uint8_t i;
  443.   uint16_t minLvl, maxLvl;
  444.   int n, height;
  445.   n = analogRead(MIC_PIN);            
  446.   n = abs(n - 512 - DC_OFFSET);        
  447.   n = (n <= NOISE) ? 0 : (n - NOISE);  
  448.   lvl = ((lvl * 7) + n) >> 3;   
  449.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  450.   if (height < 0L)       height = 0;      
  451.   else if (height > TOP) height = TOP;
  452.   if (height > peak)     peak   = height;
  453.   greenOffset += SPEED;
  454.   blueOffset += SPEED;
  455.   if (greenOffset >= 255) greenOffset = 0;
  456.   if (blueOffset >= 255) blueOffset = 0;
  457.   for (i = 0; i < N_PIXELS; i++) {
  458.     if (i >= height) {
  459.       strip.setPixelColor(i, 0, 0, 0);
  460.     } else {
  461.       strip.setPixelColor(i, Wheel(
  462.                             map(i, 0, strip.numPixels() - 1, (int)greenOffset, (int)blueOffset)
  463.                           ));
  464.     }
  465.   }
  466.   if (peak > 0 && peak <= N_PIXELS - 1) strip.setPixelColor(peak, Wheel(map(peak, 0, strip.numPixels() - 1, 30, 150)));
  467.   strip.show();
  468.   if (++dotCount >= PEAK_FALL) {
  469.     if (peak > 0) peak--;
  470.     dotCount = 0;
  471.   }
  472.   strip.show();  
  473.   vol[volCount] = n;
  474.   if (++volCount >= SAMPLES) {
  475.     volCount = 0;
  476.   }
  477.   minLvl = maxLvl = vol[0];
  478.   for (i = 1; i < SAMPLES; i++) {
  479.     if (vol[i] < minLvl) {
  480.       minLvl = vol[i];
  481.     } else if (vol[i] > maxLvl) {
  482.       maxLvl = vol[i];
  483.     }
  484.   }
  485.   if ((maxLvl - minLvl) < TOP) {
  486.     maxLvl = minLvl + TOP;
  487.   }
  488.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  489.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  490. }
  491. void Vu4() {
  492.   uint8_t  i;
  493.   uint16_t minLvl, maxLvl;
  494.   int      n, height;
  495.   n   = analogRead(MIC_PIN);                        
  496.   n   = abs(n - 512 - DC_OFFSET);
  497.   n   = (n <= NOISE) ? 0 : (n - NOISE);            
  498.   lvl = ((lvl * 7) + n) >> 3;   
  499.   height = TOP * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  500.   if (height < 0L)       height = 0;     
  501.   else if (height > TOP) height = TOP;
  502.   if (height > peak)     peak   = height;
  503.   greenOffset += SPEED;
  504.   blueOffset += SPEED;
  505.   if (greenOffset >= 255) greenOffset = 0;
  506.   if (blueOffset >= 255) blueOffset = 0;
  507.   for (i = 0; i < N_PIXELS_HALF; i++) {
  508.     if (i >= height) {
  509.       strip.setPixelColor(N_PIXELS_HALF - i - 1,   0,   0, 0);
  510.       strip.setPixelColor(N_PIXELS_HALF + i,   0,   0, 0);
  511.     }
  512.     else {
  513.       uint32_t color = Wheel(map(i, 0, N_PIXELS_HALF - 1, (int)greenOffset, (int)blueOffset));
  514.       strip.setPixelColor(N_PIXELS_HALF - i - 1, color);
  515.       strip.setPixelColor(N_PIXELS_HALF + i, color);
  516.     }
  517.   }
  518.   // Draw peak dot
  519.   if (peak > 0 && peak <= N_PIXELS_HALF - 1) {
  520.     uint32_t color = Wheel(map(peak, 0, N_PIXELS_HALF - 1, 30, 150));
  521.     strip.setPixelColor(N_PIXELS_HALF - peak - 1, color);
  522.     strip.setPixelColor(N_PIXELS_HALF + peak, color);
  523.   }
  524.   strip.show(); // Update strip
  525.   // Every few frames, make the peak pixel drop by 1:
  526.   if (++dotCount >= PEAK_FALL) { //fall rate
  527.     if (peak > 0) peak--;
  528.     dotCount = 0;
  529.   }
  530.   vol[volCount] = n;                     
  531.   if (++volCount >= SAMPLES) volCount = 0;
  532.   minLvl = maxLvl = vol[0];
  533.   for (i = 1; i < SAMPLES; i++) {
  534.     if (vol[i] < minLvl)      minLvl = vol[i];
  535.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  536.   }
  537.   if ((maxLvl - minLvl) < TOP) maxLvl = minLvl + TOP;
  538.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  539.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  540. }
  541. void Vu5()
  542. {
  543.   uint8_t  i;
  544.   uint16_t minLvl, maxLvl;
  545.   int      n, height;
  546.   n   = analogRead(MIC_PIN);                        
  547.   n   = abs(n - 512 - DC_OFFSET);
  548.   n   = (n <= NOISE) ? 0 : (n - NOISE);            
  549.   lvl = ((lvl * 7) + n) >> 3;   
  550.   height = TOP2 * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  551.   if (height < 0L)       height = 0;     
  552.   else if (height > TOP2) height = TOP2;
  553.   if (height > peak)     peak   = height;
  554. #ifdef CENTERED
  555.   for (i = 0; i < (N_PIXELS / 2); i++) {
  556.     if (((N_PIXELS / 2) + i) >= height)
  557.     {
  558.       strip.setPixelColor(((N_PIXELS / 2) + i),   0,   0, 0);
  559.       strip.setPixelColor(((N_PIXELS / 2) - i),   0,   0, 0);
  560.     }
  561.     else
  562.     {
  563.       strip.setPixelColor(((N_PIXELS / 2) + i), Wheel(map(((N_PIXELS / 2) + i), 0, strip.numPixels() - 1, 30, 150)));
  564.       strip.setPixelColor(((N_PIXELS / 2) - i), Wheel(map(((N_PIXELS / 2) - i), 0, strip.numPixels() - 1, 30, 150)));
  565.     }
  566.   }
  567.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)
  568.   {
  569.     strip.setPixelColor(((N_PIXELS / 2) + peak), 255, 255, 255);
  570.     strip.setPixelColor(((N_PIXELS / 2) - peak), 255, 255, 255);
  571.   }
  572. #else
  573.   for (i = 0; i < N_PIXELS; i++)
  574.   {
  575.     if (i >= height)
  576.     {
  577.       strip.setPixelColor(i,   0,   0, 0);
  578.     }
  579.     else
  580.     {
  581.       strip.setPixelColor(i, Wheel(map(i, 0, strip.numPixels() - 1, 30, 150)));
  582.     }
  583.   }
  584.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)
  585.   {
  586.     strip.setPixelColor(peak, 255, 255, 255);
  587.   }
  588. #endif
  589.   if (millis() - lastTime >= PEAK_FALL_MILLIS)
  590.   {
  591.     lastTime = millis();
  592.     strip.show();
  593.     if (peak > 0) peak--;
  594.   }
  595.   vol[volCount] = n;                     
  596.   if (++volCount >= SAMPLES) volCount = 0;
  597.   minLvl = maxLvl = vol[0];
  598.   for (i = 1; i < SAMPLES; i++)
  599.   {
  600.     if (vol[i] < minLvl)      minLvl = vol[i];
  601.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  602.   }
  603.   if ((maxLvl - minLvl) < TOP2) maxLvl = minLvl + TOP2;
  604.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  605.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  606. }
  607. void Vu6()
  608. {
  609.   uint8_t  i;
  610.   uint16_t minLvl, maxLvl;
  611.   int      n, height;
  612.   n   = analogRead(MIC_PIN);                       
  613.   n   = abs(n - 512 - DC_OFFSET);
  614.   n   = (n <= NOISE) ? 0 : (n - NOISE);            
  615.   lvl = ((lvl * 7) + n) >> 3;   
  616.   height = TOP2 * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  617.   if (height < 0L)       height = 0;     
  618.   else if (height > TOP2) height = TOP2;
  619.   if (height > peak)     peak   = height;
  620. #ifdef CENTERED
  621.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)
  622.   {
  623.     strip.setPixelColor(((N_PIXELS / 2) + peak), 255, 255, 255);
  624.     strip.setPixelColor(((N_PIXELS / 2) - peak), 255, 255, 255);
  625.   }
  626. #else
  627.   // Color pixels based on rainbow gradient
  628.   for (i = 0; i < N_PIXELS; i++)
  629.   {
  630.     if (i >= height)
  631.     {
  632.       strip.setPixelColor(i,   0,   0, 0);
  633.     }
  634.     else
  635.     {
  636.     }
  637.   }
  638.   // Draw peak dot
  639.   if (peak > 0 && peak <= LAST_PIXEL_OFFSET)
  640.   {
  641.     strip.setPixelColor(peak, 0, 0, 255);
  642.   }
  643. #endif
  644.   // Every few frames, make the peak pixel drop by 1:
  645.   if (millis() - lastTime >= PEAK_FALL_MILLIS)
  646.   {
  647.     lastTime = millis();
  648.     strip.show(); // Update strip
  649.     //fall rate
  650.     if (peak > 0) peak--;
  651.   }
  652.   vol[volCount] = n;                     
  653.   if (++volCount >= SAMPLES) volCount = 0;
  654.   minLvl = maxLvl = vol[0];
  655.   for (i = 1; i < SAMPLES; i++)
  656.   {
  657.     if (vol[i] < minLvl)      minLvl = vol[i];
  658.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  659.   }
  660.   if ((maxLvl - minLvl) < TOP2) maxLvl = minLvl + TOP2;
  661.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  662.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  663. }
  664. void vu7() {
  665.   EVERY_N_MILLISECONDS(1000) {
  666.     peakspersec = peakcount;                                       
  667.     peakcount = 0;                                                
  668.   }
  669.   soundmems();
  670.   EVERY_N_MILLISECONDS(20) {
  671.     ripple3();
  672.   }
  673.   show_at_max_brightness_for_power();
  674. }
  675. void soundmems() {                                                  
  676.   newtime = millis();
  677.   int tmp = analogRead(MIC_PIN) - 512;
  678.   sample = abs(tmp);
  679.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);
  680.   samplesum = samplesum + sample - samplearray[samplecount];        
  681.   sampleavg = samplesum / NSAMPLES;                                 
  682.   samplearray[samplecount] = sample;                                
  683.   samplecount = (samplecount + 1) % NSAMPLES;                     
  684.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);           
  685.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) {
  686.     step = -1;
  687.     peakcount++;
  688.     digitalWrite(13, HIGH);
  689.     oldtime = newtime;
  690.   }
  691. }  
  692. void ripple3() {
  693.   for (int i = 0; i < N_PIXELS; i++) leds[i] = CHSV(bgcol, 255, sampleavg * 2);
  694.   switch (step) {
  695.     case -1:                                                        
  696.       center = random(N_PIXELS);
  697.       colour = (peakspersec * 10) % 255;                                          
  698.       step = 0;
  699.       bgcol = bgcol + 8;
  700.       break;
  701.     case 0:
  702.       leds[center] = CHSV(colour, 255, 255);                          
  703.       step ++;
  704.       break;
  705.     case maxsteps:                                                   
  706.       break;
  707.     default:                                                            
  708.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);  
  709.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);
  710.       step ++;                                                         
  711.       break;
  712.   }
  713. }
  714. void vu8() {
  715.   int intensity = calculateIntensity();
  716.   updateOrigin(intensity);
  717.   assignDrawValues(intensity);
  718.   writeSegmented();
  719.   updateGlobals();
  720. }
  721. int calculateIntensity() {
  722.   int      intensity;
  723.   reading   = analogRead(MIC_PIN);                       
  724.   reading   = abs(reading - 512 - DC_OFFSET);
  725.   reading   = (reading <= NOISE) ? 0 : (reading - NOISE);           
  726.   lvl = ((lvl * 7) + reading) >> 3;   
  727.   intensity = DRAW_MAX * (lvl - minLvlAvg) / (long)(maxLvlAvg - minLvlAvg);
  728.   return constrain(intensity, 0, DRAW_MAX - 1);
  729. }
  730. void updateOrigin(int intensity) {
  731.   if (growing && intensity < last_intensity) {
  732.     growing = false;
  733.     intensity_max = last_intensity;
  734.     fall_from_left = !fall_from_left;
  735.     origin_at_flip = origin;
  736.   } else if (intensity > last_intensity) {
  737.     growing = true;
  738.     origin_at_flip = origin;
  739.   }
  740.   last_intensity = intensity;
  741.   if (!growing) {
  742.     if (fall_from_left) {
  743.       origin = origin_at_flip + ((intensity_max - intensity) / 2);
  744.     } else {
  745.       origin = origin_at_flip - ((intensity_max - intensity) / 2);
  746.     }
  747.     if (origin < 0) {
  748.       origin = DRAW_MAX - abs(origin);
  749.     } else if (origin > DRAW_MAX - 1) {
  750.       origin = origin - DRAW_MAX - 1;
  751.     }
  752.   }
  753. }
  754. void assignDrawValues(int intensity) {
  755.   int min_lit = origin - (intensity / 2);
  756.   int max_lit = origin + (intensity / 2);
  757.   if (min_lit < 0) {
  758.     min_lit = min_lit + DRAW_MAX;
  759.   }
  760.   if (max_lit >= DRAW_MAX) {
  761.     max_lit = max_lit - DRAW_MAX;
  762.   }
  763.   for (int i = 0; i < DRAW_MAX; i++) {
  764.     if (
  765.       (min_lit < max_lit && min_lit < i && i < max_lit)
  766.       || (min_lit > max_lit && (i > min_lit || i < max_lit))
  767.     ) {
  768.       draw[i] = Wheel(scroll_color);
  769.     } else {
  770.       draw[i] = 0;
  771.     }
  772.   }
  773. }
  774. void writeSegmented() {
  775.   int seg_len = N_PIXELS / SEGMENTS;
  776.   for (int s = 0; s < SEGMENTS; s++) {
  777.     for (int i = 0; i < seg_len; i++) {
  778.       strip.setPixelColor(i + (s * seg_len), draw[map(i, 0, seg_len, 0, DRAW_MAX)]);
  779.     }
  780.   }
  781.   strip.show();
  782. }
  783. uint32_t * segmentAndResize(uint32_t* draw) {
  784.   int seg_len = N_PIXELS / SEGMENTS;
  785.   uint32_t segmented[N_PIXELS];
  786.   for (int s = 0; s < SEGMENTS; s++) {
  787.     for (int i = 0; i < seg_len; i++) {
  788.       segmented[i + (s * seg_len) ] = draw[map(i, 0, seg_len, 0, DRAW_MAX)];
  789.     }
  790.   }
  791.   return segmented;
  792. }
  793. void writeToStrip(uint32_t* draw) {
  794.   for (int i = 0; i < N_PIXELS; i++) {
  795.     strip.setPixelColor(i, draw[i]);
  796.   }
  797.   strip.show();
  798. }
  799. void updateGlobals() {
  800.   uint16_t minLvl, maxLvl;
  801.   color_wait_count++;
  802.   if (color_wait_count > COLOR_WAIT_CYCLES) {
  803.     color_wait_count = 0;
  804.     scroll_color++;
  805.     if (scroll_color > COLOR_MAX) {
  806.       scroll_color = COLOR_MIN;
  807.     }
  808.   }
  809.   vol[volCount] = reading;                     
  810.   if (++volCount >= SAMPLES) volCount = 0;
  811.   minLvl = maxLvl = vol[0];
  812.   for (uint8_t i = 1; i < SAMPLES; i++) {
  813.     if (vol[i] < minLvl)      minLvl = vol[i];
  814.     else if (vol[i] > maxLvl) maxLvl = vol[i];
  815.   }
  816.   
  817.   if ((maxLvl - minLvl) < N_PIXELS) maxLvl = minLvl + N_PIXELS;
  818.   minLvlAvg = (minLvlAvg * 63 + minLvl) >> 6;
  819.   maxLvlAvg = (maxLvlAvg * 63 + maxLvl) >> 6;
  820. }
  821. void vu9() {
  822.   currentPalette = OceanColors_p;                           
  823.   currentBlending = LINEARBLEND;
  824.   EVERY_N_SECONDS(5) {                                       
  825.     for (int i = 0; i < 16; i++) {
  826.       targetPalette[i] = CHSV(random8(), 255, 255);
  827.     }
  828.   }
  829.   EVERY_N_MILLISECONDS(100) {                                 
  830.     uint8_t maxChanges = 24;
  831.     nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges);
  832.   }
  833.   EVERY_N_MILLIS_I(thistimer, 20) {                           
  834.     uint8_t timeval = beatsin8(10, 20, 50);                  
  835.     thistimer.setPeriod(timeval);                           
  836.     fadeToBlackBy(leds, N_PIXELS, 16);                       
  837.     sndwave();
  838.     soundble();
  839.   }
  840.   FastLED.setBrightness(max_bright);
  841.   FastLED.show();
  842. }
  843. void soundble() {                                          
  844.   int tmp = analogRead(MIC_PIN) - 512 - DC_OFFSET;
  845.   sample = abs(tmp);
  846. }
  847. void sndwave() {
  848.   leds[N_PIXELS / 2] = ColorFromPalette(currentPalette, sample, sample * 2, currentBlending);
  849.   for (int i = N_PIXELS - 1; i > N_PIXELS / 2; i--) {   
  850.     leds[i] = leds[i - 1];
  851.   }
  852.   for (int i = 0; i < N_PIXELS / 2; i++) {               
  853.     leds[i] = leds[i + 1];
  854.   }
  855.   addGlitter(sampleavg);
  856. }
  857. void vu10() {
  858.   EVERY_N_SECONDS(5) {                                       
  859.     static uint8_t baseC = random8();                        
  860.     for (int i = 0; i < 16; i++) {
  861.       targetPalette[i] = CHSV(random8(), 255, 255);
  862.     }
  863.   }
  864.   EVERY_N_MILLISECONDS(100) {
  865.     uint8_t maxChanges = 24;
  866.     nblendPaletteTowardPalette(currentPalette, targetPalette, maxChanges);   
  867.   }
  868.   EVERY_N_MILLISECONDS(thisdelay) {                           
  869.     soundtun();
  870.     FastLED.setBrightness(max_bright);
  871.     FastLED.show();
  872.   }
  873. }
  874. void soundtun() {
  875.   int n;
  876.   n = analogRead(MIC_PIN);                                    
  877.   n = qsuba(abs(n - 512), 10);                                
  878.   CRGB newcolour = ColorFromPalette(currentPalette, constrain(n, 0, 255), constrain(n, 0, 255), currentBlending);
  879.   nblend(leds[0], newcolour, 128);
  880.   for (int i = N_PIXELS - 1; i > 0; i--) {
  881.     leds[i] = leds[i - 1];
  882.   }
  883. }
  884. void vu11() {
  885.   EVERY_N_MILLISECONDS(1000) {
  886.     peakspersec = peakcount;                                 
  887.     peakcount = 0;                                            
  888.   }
  889.   soundrip();
  890.   EVERY_N_MILLISECONDS(20) {
  891.     rippled();
  892.   }
  893.   FastLED.show();
  894. }
  895. void soundrip() {                                            
  896.   newtime = millis();
  897.   int tmp = analogRead(MIC_PIN) - 512;
  898.   sample = abs(tmp);
  899.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);
  900.   samplesum = samplesum + sample - samplearray[samplecount];  
  901.   sampleavg = samplesum / NSAMPLES;                          
  902.   Serial.println(sampleavg);
  903.   samplearray[samplecount] = sample;                          
  904.   samplecount = (samplecount + 1) % NSAMPLES;               
  905.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);      
  906.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) {
  907.     step = -1;
  908.     peakcount++;
  909.     oldtime = newtime;
  910.   }
  911. }  
  912. void rippled() {
  913.   fadeToBlackBy(leds, N_PIXELS, 64);                          
  914.   switch (step) {
  915.     case -1:                                                  
  916.       center = random(N_PIXELS);
  917.       colour = (peakspersec * 10) % 255;                     
  918.       step = 0;
  919.       break;
  920.     case 0:
  921.       leds[center] = CHSV(colour, 255, 255);                  
  922.       step ++;
  923.       break;
  924.     case maxsteps:                                          
  925.       break;
  926.     default:                                                
  927.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);   
  928.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);
  929.       step ++;                                                
  930.       break;
  931.   }
  932. }
  933. void drawLine(uint8_t from, uint8_t to, uint32_t c) {
  934.   uint8_t fromTemp;
  935.   if (from > to) {
  936.     fromTemp = from;
  937.     from = to;
  938.     to = fromTemp;
  939.   }
  940.   for (int i = from; i <= to; i++) {
  941.     strip.setPixelColor(i, c);
  942.   }
  943. }
  944. void setPixel(int Pixel, byte red, byte green, byte blue) {
  945.   strip.setPixelColor(Pixel, strip.Color(red, green, blue));
  946. }
  947. void setAll(byte red, byte green, byte blue) {
  948.   for (int i = 0; i < N_PIXELS; i++ ) {
  949.     setPixel(i, red, green, blue);
  950.   }
  951.   strip.show();
  952. }
  953. void vu12() {
  954.   EVERY_N_MILLISECONDS(1000) {
  955.     peakspersec = peakcount;                                 
  956.     peakcount = 0;                                            
  957.   }
  958.   soundripped();
  959.   EVERY_N_MILLISECONDS(20) {
  960.     rippvu();
  961.   }
  962.   FastLED.show();
  963. }
  964. void soundripped() {                                            
  965.   newtime = millis();
  966.   int tmp = analogRead(MIC_PIN) - 512;
  967.   sample = abs(tmp);
  968.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);
  969.   samplesum = samplesum + sample - samplearray[samplecount];  
  970.   sampleavg = samplesum / NSAMPLES;                           
  971.   Serial.println(sampleavg);
  972.   samplearray[samplecount] = sample;                          
  973.   samplecount = (samplecount + 1) % NSAMPLES;                 
  974.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);      
  975.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) {
  976.     step = -1;
  977.     peakcount++;
  978.     oldtime = newtime;
  979.   }
  980. }  
  981. void rippvu() {                                                               
  982.   fadeToBlackBy(leds, N_PIXELS, 64);                          
  983.   switch (step) {
  984.     case -1:                                                  
  985.       center = random(N_PIXELS);
  986.       colour = (peakspersec * 10) % 255;                     
  987.       step = 0;
  988.       break;
  989.     case 0:
  990.       leds[center] = CHSV(colour, 255, 255);                  
  991.       step ++;
  992.       break;
  993.     case maxsteps:                                            
  994.       break;
  995.     default:                                                
  996.       leds[(center + step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);   
  997.       leds[(center - step + N_PIXELS) % N_PIXELS] += CHSV(colour, 255, myfade / step * 2);
  998.       step ++;                                                
  999.       break;
  1000.   }
  1001.   addGlitter(sampleavg);
  1002. }
  1003. void vu13() {                                                                  
  1004.   EVERY_N_MILLISECONDS(1000) {
  1005.     peakspersec = peakcount;                                 
  1006.     peakcount = 0;                                          
  1007.   }
  1008.   soundripper();
  1009.   EVERY_N_MILLISECONDS(20) {
  1010.     jugglep();
  1011.   }
  1012.   FastLED.show();
  1013. }
  1014. void soundripper() {                                            
  1015.   newtime = millis();
  1016.   int tmp = analogRead(MIC_PIN) - 512;
  1017.   sample = abs(tmp);
  1018.   int potin = map(analogRead(POT_PIN), 0, 1023, 0, 60);
  1019.   samplesum = samplesum + sample - samplearray[samplecount];  
  1020.   sampleavg = samplesum / NSAMPLES;                           
  1021.   Serial.println(sampleavg);
  1022.   samplearray[samplecount] = sample;                        
  1023.   samplecount = (samplecount + 1) % NSAMPLES;                 
  1024.   if (newtime > (oldtime + 200)) digitalWrite(13, LOW);      
  1025.   if ((sample > (sampleavg + potin)) && (newtime > (oldtime + 60)) ) {
  1026.     step = -1;
  1027.     peakcount++;
  1028.     oldtime = newtime;
  1029.     jugglep();
  1030.   }
  1031. }
  1032. void jugglep() {                                                               
  1033.   static uint8_t thishue = 0;
  1034.   timeval = 40;                                                                 
  1035.   leds[0] = ColorFromPalette(currentPalette, thishue++, sampleavg, LINEARBLEND);
  1036.   for (int i = N_PIXELS - 1; i > 0 ; i-- ) leds[i] = leds[i - 1];
  1037.   addGlitter(sampleavg / 2);                                                   
  1038. }
  1039. uint32_t Wheel(byte WheelPos, float opacity) {
  1040.   if (WheelPos < 85) {
  1041.     return strip.Color((WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity, 0);
  1042.   }
  1043.   else if (WheelPos < 170) {
  1044.     WheelPos -= 85;
  1045.     return strip.Color((255 - WheelPos * 3) * opacity, 0, (WheelPos * 3) * opacity);
  1046.   }
  1047.   else {
  1048.     WheelPos -= 170;
  1049.     return strip.Color(0, (WheelPos * 3) * opacity, (255 - WheelPos * 3) * opacity);
  1050.   }
  1051. }
  1052. void addGlitter( fract8 chanceOfGlitter) {                                    
  1053.   if ( random8() < chanceOfGlitter) {
  1054.     leds[random16(N_PIXELS)] += CRGB::White;
  1055.   }
  1056. }
  1057. typedef void (*SimplePatternList[])();
  1058. SimplePatternList qPatterns = {vu, vu1, vu2, Vu3, Vu4, Vu5, Vu6, vu7, vu8, vu9, vu10, vu11, vu12, vu13};
  1059. uint8_t qCurrentPatternNumber = 0;
  1060. void nextPattern2()
  1061. {
  1062.   qCurrentPatternNumber = (qCurrentPatternNumber + 1) % ARRAY_SIZE( qPatterns);
  1063. }
  1064. void All2()
  1065. {
  1066.   qPatterns[qCurrentPatternNumber]();
  1067.   EVERY_N_SECONDS( 30 ) {
  1068.     nextPattern2();  
  1069.   }
  1070. }
复制代码


回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

彩灯使用WS2812B


02.jpg

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

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



回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

声音模块依旧使用MAX9814(几元钱便宜好用)

01.jpg


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



回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

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

02.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

带气泡的有机棒

03.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

线槽盒子有可拆卸的盖子

04.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

备好项目材料

05.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

06.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

有机棒直径约20mm

07.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

测量划线
08.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

09.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

先钻小孔

10.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

再扩大孔

11.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

打孔完工

12.jpg

回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

WS2812模块电原理图


07.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

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


06.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

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


07-.jpg

07-0.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

07--.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

灯带固定在线槽盖子上


13.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

开始安装有机棒


14.jpg
回复

使用道具 举报

驴友花雕  初级技神
 楼主|

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

Arduno UNO项目接线示意图

15 (1).jpg

回复

使用道具 举报

12下一页
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

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

硬件清单

  • [[d.name]]
btnicon
我也要做!
点击进入购买页面
上海智位机器人股份有限公司 沪ICP备09038501号-4

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

mail