How to make simple Arduino RGB Led strip VU Meter

Despite the many options and customization possibilities, this device is extremely simple to build, and contains a minimal number of components.

Dec 19, 2024

•

11833 views

•

3 respects

•

GPL3+

Devices & Components

Arduino Nano

Adressable WS2812B RGB LED light strip

micro switch

10kOhm potentiometer

Push Button

Resistor 10k

Hardware & Tools

Soldering kit

Software & Tools

Arduino IDE

Project description

Code

Code vu

cpp

...

1/*
2**********************************************************************
3* Stereo VU Meter for 1 or 2 LED rings or strips build by ericBcreator
4* Designed to be used with an Arduino UNO, Nano or compatible device.
5**********************************************************************
6* Notice: search for @EB in the Sketch for important variables to set
7* for the Sketch to work with your setup.
8**********************************************************************
9* Last updated 20180202 by ericBcreator
10*
11* This code is free for personal use, not for commercial purposes.
12* Please leave this header intact.
13*
14* contact: ericBcreator@gmail.com
15**********************************************************************
16*/
17#include <Adafruit_NeoPixel.h>
18#define nonLinearLogAudio 
19
20//#define led_strip_60                                    //uncomment this if you are using a single 60 LED strip (Center to sides mode)
21#define led_2_strip_60                                  //uncomment this if you are using two 60 LED strips (Left-Right bottom to top mode)
22
23//#define led_strip_30                                    //uncomment this if you are using a single 30 LED strip
24//#define led_2_strip_30                                  //uncomment this if you are using two 30 LED strips
25
26//#define led_strip_144                                   //uncomment this if you are using a single 144 LED strip
27//#define led_2_strip_144                                 //uncomment this if you are using two 144 LED strips
28
29const int useSensorValues = true;                         // @EB
30
31
32//
33// setup pins
34//
35
36int leftPin = A0, rightPin = A1;                          // left audio in on analog 0, right on analog 1
37int brightnessPin = A4, sensitivityPin = A5;              // potentiometers for brightness and sensitivity on analog 4 and 5
38int leftStripPin = 5;                                     // DIN of left led strip on digital pin 5
39int rightStripPin = 6;                                    // DIN of right led strip on digital pin 6
40int showPeaksPin = 7;                                     // switch to toggle peaks on or off on digital pin 7 (7, 9 for box version)
41int showPeaksMomentarySwitch = false;                     // set false for an on/off toggle switch
42int reverseShowPeaks = true;                              // reverses the on/off setting in case you made a wiring mistake ;-) @EB
43int selectButton1Pin = 8;                                 // push button for changing settings on digital pin 8
44int useSelectButton1 = true;                              // set to false if no push button1 for selecting the color scheme is connected  @EB
45int selectButton2Pin = 9;                                 // push button for changing settings on digital pin 9
46int useSelectButton2 = true;                              // set to false if no push button2 is connected  @EB
47
48
49#if defined (led_strip_60)
50  //settings for a 60 led strip
51
52  int stripNumOfLeds = 60;                                  // the total number of leds
53  int stripsOn2Pins = false;                                // set to true if the LED strips or rings are connected to 2 input pins
54  uint32_t stripColor[31];                                  // half of the number of leds + 1
55  int displayMiddleLed = true;                              // display the middle led (blue). set to true for one strip, false for two strips or rings
56  int splitStrip = false;                                   // set to true when using 2 strips or rings, false for one strip
57  int middleOffset = 1;                                     // offset for the middle led when using one strip
58  int startupAnimationDelay = 6;                            // delay for the startup animation
59  int orangeLimitAmount = 0;                                // limit the amount of green of the middle LEDs to make them more orange
60  int swapLeftRight = false;                                // swap the left and right input values or not
61  
62  int dropDelay = 5;                                        // hold time before dropping the leds
63  float dropFactor = .94;                                   // value for dropping the leds
64  
65  int peakTimeNoDropDelay = 250;                            // peak hold time when not dropping the peaks (when droppingPeak is false)
66  int peakTimeFirstDropDelay = 70;                          // peak hold time when dropping the first peak
67  int peakTimeDropDelay = 7;                                // peak hold time when dropping the rest of the peaks
68  float peakDropFactor = .94;                               // value for dropping the peaks
69  int droppingPeakFade = false;                             // display the dropping peak fading to black or not
70  
71  int bouncingPeaksNumOfLeds = 6;                           // how many leds to bounce up (max)
72  int bouncingPeaksNumOfLedsMin = 3;                        // how many leds to bounce up (min) when using dynamicBouncingPeaks
73  int bouncingPeakDelay = 4;                                // delay between peak bounce updates
74  int bouncingPeakCounterInc = 10;                          // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing
75
76#elif defined (led_2_strip_60)
77  //settings for 2 60 led strips
78
79  int stripNumOfLeds = 60;
80  int stripsOn2Pins = true;
81  uint32_t stripColor[61];
82  int displayMiddleLed = false;
83  int splitStrip = true;
84  int middleOffset = 0;
85  int startupAnimationDelay = 1;
86  int orangeLimitAmount = 0;
87  int swapLeftRight = false;
88  
89  int dropDelay = 5;
90  float dropFactor = .94;
91  
92  int peakTimeNoDropDelay = 250;
93  int peakTimeFirstDropDelay = 70;
94  int peakTimeDropDelay = 7;
95  float peakDropFactor = .94;
96  int droppingPeakFade = false;
97  
98  int bouncingPeaksNumOfLeds = 12;
99  int bouncingPeaksNumOfLedsMin = 4;
100  int bouncingPeakDelay = 4;
101  int bouncingPeakCounterInc = 10;
102  
103#elif defined (led_strip_30)
104  //settings for a 30 led strip
105
106  int stripNumOfLeds = 30;                                  // the total number of leds
107  int stripsOn2Pins = false;                                // set to true if the LED strips or rings are connected to 2 input pins
108  uint32_t stripColor[16];                                  // half of the number of leds + 1
109  int displayMiddleLed = true;                              // display the middle led (blue). set to true for one strip, false for two strips or rings
110  int splitStrip = false;                                   // set to true when using 2 strips or rings, false for one strip
111  int middleOffset = 1;                                     // offset for the middle led when using one strip
112  int startupAnimationDelay = 10;                           // delay for the startup animation
113  int orangeLimitAmount = 0;                                // limit the amount of green of the middle LEDs to make them more orange
114  int swapLeftRight = false;                                // swap the left and right input values or not
115  
116  int dropDelay = 10;                                       // hold time before dropping the leds
117  float dropFactor = .9;                                    // value for dropping the leds
118  
119  int peakTimeNoDropDelay = 250;                            // peak hold time when not dropping the peaks (set droppingPeak true or false)
120  int peakTimeFirstDropDelay = 150;                         // peak hold time when dropping the first peak
121  int peakTimeDropDelay = 15;                               // peak hold time when dropping the rest of the peaks
122  float peakDropFactor = .94;                               // value for dropping the peaks
123  int droppingPeakFade = false;                             // display the dropping peak fading to black or not
124  
125  int bouncingPeaksNumOfLeds = 4;                           // how many leds to bounce up (max)
126  int bouncingPeaksNumOfLedsMin = 2;                        // how many leds to bounce up (min) when using dynamicBouncingPeaks
127  int bouncingPeakDelay = 4;                                // delay between peak bounce updates
128  int bouncingPeakCounterInc = 9;                           // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing
129
130#elif defined (led_2_strip_30)
131  //settings for 2 30 led strips
132
133  int stripNumOfLeds = 30;
134  int stripsOn2Pins = true;
135  uint32_t stripColor[31];
136  int displayMiddleLed = false;
137  int splitStrip = true;
138  int middleOffset = 0;
139  int startupAnimationDelay = 1;
140  int orangeLimitAmount = 0;
141  int swapLeftRight = false;
142  
143  int dropDelay = 5;
144  float dropFactor = .94;
145  
146  int peakTimeNoDropDelay = 250;
147  int peakTimeFirstDropDelay = 70;
148  int peakTimeDropDelay = 7;
149  float peakDropFactor = .94;
150  int droppingPeakFade = false;
151  
152  int bouncingPeaksNumOfLeds = 12;
153  int bouncingPeaksNumOfLedsMin = 4;
154  int bouncingPeakDelay = 4;
155  int bouncingPeakCounterInc = 10;
156  
157#elif defined (led_strip_144)
158  //settings for a 144 led strip
159
160  int stripNumOfLeds = 145;
161  int stripsOn2Pins = false;
162  uint32_t stripColor[73];
163  int displayMiddleLed = true;
164  int splitStrip = false;
165  int middleOffset = 1;
166  int startupAnimationDelay = 1;
167  int orangeLimitAmount = 0;
168  int swapLeftRight = false;
169  
170  int dropDelay = 4;
171  float dropFactor = .92;
172  
173  int peakTimeNoDropDelay = 250;
174  int peakTimeFirstDropDelay = 100;
175  int peakTimeDropDelay = 5;
176  float peakDropFactor = .94;
177  int droppingPeakFade = false;
178  
179  int bouncingPeaksNumOfLeds = 10;
180  int bouncingPeaksNumOfLedsMin = 4;
181  int bouncingPeakDelay = 2;
182  int bouncingPeakCounterInc = 10;
183
184#elif defined (led_2_strip_144)
185  //settings for 2 144 led strips
186
187  int stripNumOfLeds = 144;
188  int stripsOn2Pins = true;
189  uint32_t stripColor[145];
190  int displayMiddleLed = false;
191  int splitStrip = true;
192  int middleOffset = 0;
193  int startupAnimationDelay = 1;
194  int orangeLimitAmount = 0;
195  int swapLeftRight = false;
196  
197  int dropDelay = 5;
198  float dropFactor = .94;
199  
200  int peakTimeNoDropDelay = 250;
201  int peakTimeFirstDropDelay = 70;
202  int peakTimeDropDelay = 7;
203  float peakDropFactor = .94;
204  int droppingPeakFade = false;
205  
206  int bouncingPeaksNumOfLeds = 12;
207  int bouncingPeaksNumOfLedsMin = 4;
208  int bouncingPeakDelay = 4;
209  int bouncingPeakCounterInc = 10;
210  
211#endif
212//
213// setup other user variables
214//
215
216// basic settings
217int pulsing = false;                                       // pulsing will display from the middle of each strip or ring  @EB
218
219int spinCircle = false;                                    // spin the animation. will not work with stripsOn2Pins  @EB
220
221int animType = 0;                                         // startup animation selection (1 looks nice for 1 ring)  @EB
222int colorScheme = 10;                                     // 0: green-red, 1: blue-green, 2: blue-red, 3: red-blue, 4: green-blue, 5: red-green, 6: blue-white-red
223                                                          // 7: red-white-blue, 8: green-white-red, 9: green-white-blue, 10: color wheel, 11: spinning color wheel,
224                                            // 12: as 11 but spread with factor colorScheme12Factor  @EB
225int maxColorScheme = 12;                                  // used for looping through the color schemes with the switch button
226int colorScheme11SpinDelay = stripNumOfLeds / 4 ;         // delay for spinning scheme 11
227int colorScheme12Factor = 3;                              // wheel spread factor for scheme 12 @EB
228
229int minValue = 10;                                        // min analog input value
230int sensitivityValue = 110;                               // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)
231
232#ifdef highLevelInput
233  int maxValue = 700;                                     // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high
234  int maxSensitivity = 2 * 255;                           // set to a higher setting to amplify low input levels. try 4 * 255 for low level input, 2 * 255 for high
235#else
236  int maxValue = 300;                                     // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high
237  int maxSensitivity = 4 * 255;                           // set to a higher setting to amplify low input levels. try 4 * 255 for low level input, 2 * 255 for high
238#endif
239
240int ledBrightness = 30;                                   // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)
241int sensorDeviationBrightness = 3;                        // eliminate fluctuating values
242int overflowDelay = 10;                                   // overflow hold time
243
244// peak settings @EB
245int displayPeaks = false;                                 // value will be set by the switch if useSensorValues = true
246int displayTopAsPeak = true;                              // always display the top LED in peak color
247int droppingPeak = true;                                  // display dropping peaks or not. note: displayPeaks has to be true 
248int bouncingPeaks = false;                                // display bouncing peaks or not. note: displayPeaks has to be true 
249int dynamicBouncingPeaks = false;                         // bounce less with lower peaks. note: bouncingPeaks has to be true 
250
251//
252// initialize other variables 
253//
254
255int numOfSegments, halfNumOfSegments, stripMiddle, maxDisplaySegments;
256float sensitivityFactor;
257float nonLinearResponseFactor;
258
259int brightnessValue, prevBrightnessValue;
260float ledFactor, ledFactor_div_numOfSegments;
261
262uint32_t stripMiddleColor, stripOverflowColor, stripHoldColor;
263uint32_t colorValue;
264
265int leftValue = 0, rightValue = 0, maxReadValue = 0;
266int leftValueN = 0, rightValueN = 0;
267int leftAnalogValue = 0, rightAnalogValue = 0;
268float log10MaxDisplaySegments;
269
270int prevLeftValue = 0, prevRightValue = 0;
271int prevLeftAnalogValue = 0, prevRightAnalogValue = 0;
272
273int selectButton1PinState = 0, prevSelectButton1PinState = 0;
274int selectButton2PinState = 0, prevSelectButton2PinState = 0;
275
276int selectButton1PinSetting = colorScheme;
277int selectButton2PinSetting = 0;
278
279int i, j;
280int dropLeft, dropRight;
281int leftDropTime, rightDropTime;
282
283int leftPeak = 0, rightPeak = 0;
284int leftPeakTime = 0, rightPeakTime = 0;
285int leftFirstPeak = true, rightFirstPeak = true;
286int showPeaksPinSetting, prevShowPeaksPinSetting;
287
288int stripPulseMiddle = 0;
289int halfLeftValue, halfRightValue, halfPrevLeftValue, halfPrevRightValue;
290
291int leftPeakBouncing = false, rightPeakBouncing = false;
292int leftPeakBounce = 0, rightPeakBounce = 0;
293int prevLeftPeakBounce = 0, prevRightPeakBounce = 0;
294int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0;
295int leftPeakBounceDelayCounter = 0, rightPeakBounceDelayCounter = 0;
296int leftBouncingPeaksNumOfLeds = 0, rightBouncingPeaksNumOfLeds = 0;
297float bounceFactor;
298
299int colorScheme11SpinValue = 0, colorScheme11SpinDelayValue = 0;
300int colorSchemeFactor = 1;
301long selectButton1Timer;
302
303int spinDelayCounter = 0, spinCounter = 0, spinTurnsCounter = 0, spinTurnsMax = 0, spinTurnsDelay = 0, spinTurnsDelayMax = 0;
304int spinCounterInc = 1;
305int spinDelay = 0;
306//
307// initialize the strip or rings
308//
309
310Adafruit_NeoPixel left_strip = Adafruit_NeoPixel(stripNumOfLeds, leftStripPin, NEO_GRB + NEO_KHZ800);
311Adafruit_NeoPixel right_strip = Adafruit_NeoPixel(stripNumOfLeds, rightStripPin, NEO_GRB + NEO_KHZ800);
312
313//
314// setup
315//
316
317void setup() {
318  #ifdef DEBUG
319    Serial.begin(9600);
320  #endif
321
322  randomSeed(analogRead(2));
323
324  if (stripsOn2Pins) {
325    numOfSegments = stripNumOfLeds;
326    maxDisplaySegments = numOfSegments - 1;
327    
328    stripMiddle = stripNumOfLeds;
329    stripPulseMiddle = stripMiddle / 2;
330    spinCircle = false;
331  }
332  else {
333    numOfSegments = stripNumOfLeds / 2;
334    stripMiddle = stripNumOfLeds / 2;
335    maxDisplaySegments = stripMiddle - 1;
336
337    stripPulseMiddle = stripMiddle / 2;
338  }
339
340  halfNumOfSegments = numOfSegments / 2; 
341  bounceFactor = (float) bouncingPeaksNumOfLeds / (maxDisplaySegments - bouncingPeaksNumOfLeds);
342  nonLinearResponseFactor = 90 / (float) maxDisplaySegments;
343  log10MaxDisplaySegments = log10(maxDisplaySegments);
344
345  pinMode(showPeaksPin, INPUT);    
346  
347  if (useSelectButton1)
348    pinMode(selectButton1Pin, INPUT);  
349
350  left_strip.begin();
351  if (stripsOn2Pins) 
352    right_strip.begin();
353
354  if (useSensorValues) {
355    readSensorValues();
356    setInitialDisplayPeaks();
357  }
358  else {
359    setStripColors();
360    setSensitivityFactor();
361  }
362
363  #ifdef DEBUG_TEST_LEDS
364    displayTest();
365  #endif
366
367  startupAnimation();
368}
369
370//
371// main loop
372//
373
374void loop() {
375  #ifdef DEBUG_PRINT_LOOP_TIME
376    long time = millis();
377  #endif
378
379
380  if (useSensorValues) 
381    readSensorValues();
382  
383  readValues();
384
385  #if defined (DEBUG_NO_PEAKS)
386    displayPeaks = false;
387  #endif
388
389  #if defined (DEBUG_PEAKS)
390    displayPeaks = true;
391  #endif
392
393  if (pulsing) {
394    drawPulsingValues();
395  }
396  else {
397    drawValues();
398    if (displayPeaks) {
399      getPeaks();
400      drawPeaks();
401    }
402  }
403
404  left_strip.show();
405  if (stripsOn2Pins)
406    right_strip.show();
407    
408  storePrevValues();
409
410  checkSpinCircle();
411
412  #ifdef DEBUG_PRINT_LOOP_TIME
413    time = millis() - time;
414    Serial.println(time);
415  #endif
416}
417
418// 
419// functions
420//
421
422void setInitialDisplayPeaks() {
423  #if !defined (DEBUG_NO_PEAK_SWITCH)
424    showPeaksPinSetting = digitalRead(showPeaksPin);
425  
426    if (showPeaksPinSetting == HIGH)
427      displayPeaks = false;
428  #endif 
429 
430  if (reverseShowPeaks) {
431    if (!displayPeaks)
432      displayPeaks = true;
433    else
434      displayPeaks = false;
435  }
436  
437  prevShowPeaksPinSetting = showPeaksPinSetting;
438}
439
440void readSensorValues() {
441  //
442  // peaks pin
443  //
444
445  #if !defined (DEBUG_NO_PEAK_SWITCH)
446    showPeaksPinSetting = digitalRead(showPeaksPin);
447  
448    if (showPeaksMomentarySwitch) {
449      if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
450        if (displayPeaks == true) {
451          displayPeaks = false;
452          clearLeftPeak();
453          clearRightPeak();        
454          if (showPeaksMomentarySwitch)
455            while (digitalRead(showPeaksPin) == LOW) {}
456        }
457        else {
458          displayPeaks = true;
459        }
460      }
461    } 
462    else {
463      if (reverseShowPeaks) {
464        if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) 
465          displayPeaks = true;
466        else if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
467          displayPeaks = false;
468          clearLeftPeak();
469          clearRightPeak();        
470        }
471      }
472      else {    
473        if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) 
474          displayPeaks = true;
475        else if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) {
476          displayPeaks = false;
477          clearLeftPeak();
478          clearRightPeak();        
479        }
480      }
481    }
482    if (pulsing) {
483      if (displayPeaks)
484        displayTopAsPeak = true;
485      else
486        displayTopAsPeak = false;
487    }
488
489    prevShowPeaksPinSetting = showPeaksPinSetting;
490  #endif
491  
492
493  //
494  // selectButtonPin 1 and 2
495  //
496  if (useSelectButton1) {      
497    selectButton1PinState = digitalRead(selectButton1Pin);
498    
499    if (selectButton1PinState == HIGH && prevSelectButton1PinState == LOW)
500      selectButton1Timer = millis();
501      
502    if (selectButton1PinState == HIGH && prevSelectButton1PinState == HIGH) {
503      if ((millis() - selectButton1Timer) > 1000) {
504        pulsing = !pulsing;
505        setStripColors();
506        displayNumber(colorScheme, 250);
507
508        while (digitalRead(selectButton1Pin) == HIGH) {}
509        selectButton1PinState = LOW;
510        clearValues();
511      }
512    }
513    else if (selectButton1PinState == LOW && prevSelectButton1PinState == HIGH) {
514      selectButton1PinSetting++;
515      if (selectButton1PinSetting > maxColorScheme) {
516        selectButton1PinSetting = 0;
517      }
518      colorScheme = selectButton1PinSetting;
519
520      if (colorScheme == 12)
521        colorScheme11SpinValue = (colorScheme11SpinValue * colorScheme12Factor);
522
523      setStripColors();
524      displayNumber(colorScheme, 250);
525    }
526    prevSelectButton1PinState = selectButton1PinState;
527  }
528
529  if (useSelectButton2) {
530    selectButton2PinState = digitalRead(selectButton2Pin);
531    
532    if (selectButton2PinState == HIGH && prevSelectButton2PinState == LOW) {
533      selectButton2PinSetting++;
534      
535      switch(selectButton2PinSetting) {
536        case 0:
537        case 1: {   
538          pulsing = true;
539          spinCircle = false;
540          break;
541        }
542        case 2: {
543          pulsing = true;
544          spinCircle = true;
545          break;
546        }
547        case 3: {
548          pulsing = false;
549          spinCircle = false;
550          selectButton2PinSetting = 0;
551          break;
552        }
553      }
554      
555      setStripColors();
556      displayNumber(colorScheme, 250);
557    }
558    
559    prevSelectButton2PinState = selectButton2PinState;
560  }
561  
562  //
563  // brightness
564  //
565  brightnessValue = analogRead(brightnessPin);
566  brightnessValue = map(brightnessValue, 0, 1023, 0, 255);
567  
568  if (abs(brightnessValue - prevBrightnessValue) > sensorDeviationBrightness) {
569    ledBrightness = brightnessValue;
570    setStripColors();
571    prevBrightnessValue = brightnessValue;
572  }
573
574  //
575  // colorscheme 11 spinning wheel
576  //
577
578  if (colorScheme == 11 || colorScheme == 12) {
579    colorScheme11SpinDelayValue++;
580    if (colorScheme11SpinDelayValue == colorScheme11SpinDelay) {
581      colorScheme11SpinDelayValue = 0;
582      colorScheme11SpinValue++;
583      if (colorScheme11SpinValue > maxDisplaySegments * colorSchemeFactor)
584        colorScheme11SpinValue = 0;
585      setStripColors();
586    }
587  }
588
589  //
590  // sensitivity
591  //
592  sensitivityValue = analogRead(sensitivityPin);
593  sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255);
594  setSensitivityFactor();
595}
596
597void setSensitivityFactor() {
598  //sensitivityValue_div_numOfSegments = sensitivityValue / numOfSegments;
599  sensitivityFactor = ((float) sensitivityValue / 255 * (float) maxSensitivity / 255);
600}
601
602void readValues() {
603  #ifdef averageReadings
604    leftAnalogValue = 0;
605    rightAnalogValue = 0;
606    
607    for (i = 0; i <= averageNumOfReadings; i++) {
608      leftAnalogValue += analogRead(leftPin);
609      rightAnalogValue += analogRead(rightPin);
610    }
611
612    leftAnalogValue /= averageNumOfReadings;
613    rightAnalogValue /= averageNumOfReadings;
614    
615  #else  
616    leftAnalogValue = analogRead(leftPin);
617    rightAnalogValue = analogRead(rightPin);
618  #endif
619
620  if (swapLeftRight) {
621    int tempValue = leftAnalogValue;
622    leftAnalogValue = rightAnalogValue;
623    rightAnalogValue = tempValue;
624  }
625
626  if (leftAnalogValue < prevLeftAnalogValue) {
627    leftDropTime++;
628    if (leftDropTime > dropDelay) {
629      leftAnalogValue = prevLeftAnalogValue * dropFactor;
630      leftDropTime = 0;
631    }
632    else
633      leftAnalogValue = prevLeftAnalogValue;
634  }
635   
636  if (rightAnalogValue < prevRightAnalogValue) {
637    rightDropTime++;
638    if (rightDropTime > dropDelay) {
639      rightAnalogValue = prevRightAnalogValue * dropFactor;
640      rightDropTime = 0;
641    }
642    else
643      rightAnalogValue = prevRightAnalogValue;
644  }
645
646  #ifdef DEBUG_PRINT_ANALOGVALUES
647    Serial.print(leftAnalogValue);
648    Serial.print(" ");
649    Serial.println(rightAnalogValue);
650  #endif  
651
652  // map values  
653  leftValue = map(leftAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments);
654  rightValue = map(rightAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments);
655  
656  // if defined, convert to (reverse) non linear response
657  boolean flagNonLinear = false;
658  
659  #if defined (nonLinearSinAudio)
660    flagNonLinear = true;
661    leftValueN = ((sin(((leftValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments);
662    rightValueN = ((sin(((rightValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments);
663    
664  #elif defined (nonLinearReverseSinAudio)
665    flagNonLinear = true;
666    leftValueN = ((sin(((leftValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments);
667    rightValueN = ((sin(((rightValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments);
668
669  #elif defined (nonLinearLogAudio)
670    flagNonLinear = true;
671    leftValueN = ((log10(leftValue  + 1) / log10MaxDisplaySegments * maxDisplaySegments));
672    rightValueN = ((log10(rightValue  + 1) / log10MaxDisplaySegments * maxDisplaySegments));
673  
674  #endif
675  
676  if (flagNonLinear == true) {
677    #if defined (nonLinearAvr2)
678      leftValue = (leftValue + leftValueN) / 2;
679      rightValue = (rightValue + rightValueN) / 2;
680    #else
681      leftValue = leftValueN;
682      rightValue = rightValueN;
683    #endif
684  }
685  
686// @EB_DEBUG
687
688  #ifdef displayOverflow
689    #ifdef compressOverflowPeaks
690      for (i = 1; i <= compressOverflowNumOfTimes; i++) {
691        if (leftValue > maxDisplaySegments) {
692//          Serial.print(i);    
693//          Serial.print("  ");
694//          Serial.print(leftValue);    
695//          Serial.print("  ");
696          leftValue = leftValue - leftValue * compressOverflowFactor * i;
697//          Serial.print(leftValue);
698//          Serial.print("  ");
699//          Serial.println(maxDisplaySegments);
700        }
701      }
702    #endif
703  #endif
704  
705  if (leftValue > maxDisplaySegments) {      
706    leftValue = maxDisplaySegments;
707    #ifdef displayOverflow
708      drawOverflow();
709    #endif
710  }
711
712  #ifdef displayOverflow
713    #ifdef compressOverflowPeaks
714      if (rightValue > maxDisplaySegments)
715        rightValue = rightValue - rightValue * compressOverflowFactor;
716    #endif
717  #endif
718  
719  if (rightValue > maxDisplaySegments) {
720    rightValue = maxDisplaySegments;
721    #ifdef displayOverflow
722      drawOverflow();
723    #endif
724  }
725}
726
727void storePrevValues() {
728  prevLeftAnalogValue = leftAnalogValue;
729  prevRightAnalogValue = rightAnalogValue;
730
731  prevLeftValue = leftValue;
732  prevRightValue = rightValue;
733}
734
735void getPeaks() {
736  if (leftValue > leftPeak) {
737    if (dynamicBouncingPeaks || prevLeftPeakBounce > 0)
738      clearLeftBouncePeak();
739          
740    leftPeak = leftValue;
741    leftPeakTime = 0;
742    leftFirstPeak = true;
743
744    if (bouncingPeaks) {
745      leftPeakBouncing = true;
746      leftPeakBounceCounter = 0;
747      leftPeakBounceDelayCounter = 0;
748      
749      if (dynamicBouncingPeaks)
750        leftBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (leftPeak * bounceFactor));
751      else
752        leftBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
753    }
754  }
755  else {
756    leftPeakTime++;
757    if (droppingPeak) {
758      if (leftFirstPeak) {
759        if (leftPeakTime > peakTimeFirstDropDelay) {
760          clearLeftPeak();
761          leftFirstPeak = false;
762        }
763      }
764      else {
765        if (leftPeakTime > peakTimeDropDelay) {
766          clearLeftPeak();
767        }
768      }
769    }
770    else {
771      if (leftPeakTime > peakTimeNoDropDelay) {
772        clearLeftPeak();
773      }
774    }
775  }
776
777  if (leftPeakBouncing) {
778    if (leftFirstPeak) {
779      leftPeakBounceDelayCounter++;
780      if (leftPeakBounceDelayCounter >= bouncingPeakDelay) {
781        leftPeakBounceDelayCounter = 0;
782        leftPeakBounceCounter += bouncingPeakCounterInc;
783        if (leftPeakBounceCounter >= 180) {
784          clearLeftBouncePeak();
785          clearLeftBounce();
786        }
787        else {        
788          leftPeakBounce = min((sin(leftPeakBounceCounter * 0.0174533) * leftBouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak));
789          if (leftPeakBounce != prevLeftPeakBounce) {
790            clearLeftBouncePeak();
791          }
792          prevLeftPeakBounce = leftPeakBounce;
793        }
794      }
795    }
796  }
797
798  if (rightValue > rightPeak) {
799    if (dynamicBouncingPeaks || prevRightPeakBounce > 0)
800      clearRightBouncePeak();
801
802    rightPeak = rightValue;
803    rightPeakTime = 0;
804    rightFirstPeak = true;
805
806    if (bouncingPeaks) {
807      rightPeakBouncing = true;
808      rightPeakBounceCounter = 0;
809      rightPeakBounceDelayCounter = 0;
810
811      if (dynamicBouncingPeaks)
812        rightBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (rightPeak * bounceFactor));
813      else
814        rightBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
815    }
816  }
817  else {
818    rightPeakTime++;
819    if (droppingPeak) {
820      if (rightFirstPeak) {
821        if (rightPeakTime > peakTimeFirstDropDelay) {
822          clearRightPeak();
823          rightFirstPeak = false;
824        }
825      }
826      else {
827        if (rightPeakTime > peakTimeDropDelay)
828          clearRightPeak();
829      }
830    }
831    else {
832      if (rightPeakTime > peakTimeNoDropDelay)
833        clearRightPeak();
834    }
835  }
836
837  if (rightPeakBouncing) {
838    if (rightFirstPeak) {
839      rightPeakBounceDelayCounter++;
840      if (rightPeakBounceDelayCounter >= bouncingPeakDelay) {
841        rightPeakBounceDelayCounter = 0;
842        rightPeakBounceCounter += bouncingPeakCounterInc;
843  
844        if (rightPeakBounceCounter >= 180) {
845          clearRightBouncePeak();
846          clearRightBounce();
847        }
848        else {        
849          rightPeakBounce = min((sin(rightPeakBounceCounter * 0.0174533) * rightBouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak));
850          if (rightPeakBounce != prevRightPeakBounce) {
851            clearRightBouncePeak();
852          }
853          prevRightPeakBounce = rightPeakBounce;
854        }
855      }
856    }
857  }
858}
859
860void checkSpinCircle () {
861  if (spinCircle) {
862    if (spinTurnsMax == 0) {
863      spinTurnsMax = random(stripNumOfLeds / 4, stripNumOfLeds * 3);  // spin at least a quarter turn, max 3 turns
864      
865      if (random(10) > 4)
866        spinCounterInc = -spinCounterInc;
867      
868      spinTurnsDelayMax = random(100, 1000); // @EB_DEBUG
869
870      spinDelay = random(20, 75); // @EB_DEBUG
871    }
872
873    if (spinTurnsCounter == spinTurnsMax) {
874      spinTurnsDelay++;
875      if (spinTurnsDelay == spinTurnsDelayMax) {
876        spinTurnsDelay = 0;
877        spinTurnsCounter = 0;
878        spinTurnsMax = 0;
879      }
880    }
881    else {
882      spinDelayCounter++;
883  
884      if (spinDelayCounter > spinDelay) {
885        clearZeroAndPeaks();
886
887        spinCounter += spinCounterInc;
888        if (spinCounter > stripNumOfLeds)
889          spinCounter = 0;
890        else if (spinCounter < 0)
891          spinCounter = stripNumOfLeds;
892
893        spinTurnsCounter++;
894        spinDelayCounter = 0;
895      }
896    }
897  }
898}
899
900int getSpinCircleValue(int value) {
901  if (!spinCircle)
902   return value;
903  else {
904    int calcValue = value + spinCounter;
905    if (calcValue >= stripNumOfLeds)
906      calcValue -= stripNumOfLeds;
907    return calcValue;
908  }
909}
910
911void drawValues() {
912  if (splitStrip) {
913    for (i = middleOffset; i < leftValue; i++)
914      left_strip.setPixelColor(getSpinCircleValue(i), stripColor[i]);
915
916    if (!displayPeaks && displayTopAsPeak)
917      left_strip.setPixelColor(getSpinCircleValue(leftValue), stripHoldColor);
918
919    for (i = prevLeftValue; i >= leftValue; i--)
920      left_strip.setPixelColor(getSpinCircleValue(i), 0);
921
922    if (stripsOn2Pins) {
923      for (i = middleOffset; i < rightValue; i++) 
924        right_strip.setPixelColor(i, stripColor[i]);
925
926      if (!displayPeaks && displayTopAsPeak)
927        right_strip.setPixelColor(rightValue, stripHoldColor);
928
929      for (i = prevRightValue; i >= rightValue; i--)
930        right_strip.setPixelColor(i, 0);
931    }
932    else {
933      for (i = middleOffset; i < rightValue; i++)
934        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);
935
936      if (!displayPeaks && displayTopAsPeak)
937        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightValue), stripHoldColor);
938        
939      for (i = prevRightValue; i >= rightValue; i--)
940        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
941    }
942  }
943  else {
944    for (i = middleOffset; i < leftValue; i++)
945      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);
946
947    if (!displayPeaks && displayTopAsPeak)
948      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + leftValue), stripHoldColor);
949
950    for (i = prevLeftValue; i >= leftValue; i--)
951      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
952  
953    for (i = middleOffset; i < rightValue; i++)
954      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripColor[i]);
955
956    if (!displayPeaks && displayTopAsPeak)
957      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - rightValue), stripHoldColor);
958
959    for (i = prevRightValue; i >= rightValue; i--)
960      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0);
961  }
962
963  if (displayMiddleLed) 
964    left_strip.setPixelColor(getSpinCircleValue(stripMiddle), stripMiddleColor);
965}
966
967void drawPulsingValues() {
968  halfLeftValue = (leftValue + 1) / 2;
969  halfRightValue = (rightValue + 1) / 2;
970  halfPrevLeftValue = (prevLeftValue + 1)/ 2;
971  halfPrevRightValue = (prevRightValue + 1) / 2;
972  
973  if (splitStrip) {
974    for (i = 0; i < halfLeftValue; i++) {
975      colorValue = stripColor[i * 2];
976      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), colorValue);
977      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), colorValue);
978    }
979
980    if (displayTopAsPeak) {
981      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), stripHoldColor);
982      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), stripHoldColor);
983    }
984
985    for (i = halfPrevLeftValue; i >= halfLeftValue; i--) {
986      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), 0);
987      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), 0);
988    }
989
990    if (stripsOn2Pins) {
991      for (i = 0; i < halfRightValue; i++) {
992        colorValue = stripColor[i * 2];
993        right_strip.setPixelColor((stripPulseMiddle + i), colorValue);
994        right_strip.setPixelColor((stripPulseMiddle - i), colorValue);
995      }
996
997      if (displayTopAsPeak) {
998        right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfRightValue), stripHoldColor);
999        right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfRightValue), stripHoldColor);
1000      }
1001      
1002      for (i = halfPrevRightValue; i >= halfRightValue; i--) {
1003        right_strip.setPixelColor((stripPulseMiddle + i), 0);
1004        right_strip.setPixelColor((stripPulseMiddle - i), 0);
1005      }
1006    }
1007    else {
1008      for (i = 0; i < halfRightValue; i++) {
1009        colorValue = colorValue = stripColor[i * 2];
1010        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue);
1011        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue);
1012      }
1013
1014      if (displayTopAsPeak) {
1015        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), stripHoldColor);
1016        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), stripHoldColor);
1017      }
1018
1019      for (i = halfPrevRightValue; i >= halfRightValue; i--) {
1020        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
1021        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0);
1022      }
1023    }
1024  }
1025  else {
1026    for (i = 0; i < halfLeftValue; i++) {
1027      colorValue = colorValue = stripColor[i * 2];
1028      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue);
1029      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue);
1030    }
1031
1032    if (displayTopAsPeak) {
1033      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), stripHoldColor);
1034      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), stripHoldColor);
1035    }
1036    
1037    for (i = halfPrevLeftValue; i >= halfLeftValue; i--) {
1038      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
1039      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0);
1040    }
1041  
1042    for (i = 0; i < halfRightValue; i++) {
1043      colorValue = colorValue = stripColor[i * 2];
1044      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), colorValue);
1045      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), colorValue);
1046    }
1047
1048    if (displayTopAsPeak) {
1049      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), stripHoldColor);
1050      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), stripHoldColor);
1051    }
1052    
1053    for (i = halfPrevRightValue; i >= halfRightValue; i--) {
1054      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), 0);
1055      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), 0);
1056    }
1057  }
1058
1059  if (displayMiddleLed) {
1060    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - stripPulseMiddle), stripMiddleColor);
1061    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle), stripMiddleColor);
1062  }
1063}
1064
1065void clearZeroAndPeaks() {
1066  left_strip.setPixelColor(getSpinCircleValue(middleOffset), 0);
1067  left_strip.setPixelColor(getSpinCircleValue(stripMiddle), 0);
1068
1069  if (displayTopAsPeak) {
1070    if (splitStrip) {
1071      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), 0);
1072      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), 0);
1073      
1074      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), 0);
1075      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), 0);
1076    }
1077    else {
1078      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), 0);
1079      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), 0);
1080
1081      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), 0);
1082      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), 0);
1083    }
1084  }
1085}
1086
1087void drawPeaks() {  
1088  if (leftPeak > 0) {
1089    if (droppingPeakFade && leftPeakBouncing == false)
1090      stripHoldColor = left_strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 0, 0);
1091    else
1092      stripHoldColor = stripColor[numOfSegments];
1093
1094    if (splitStrip)
1095      left_strip.setPixelColor(getSpinCircleValue(leftPeak + leftPeakBounce), stripHoldColor);
1096    else
1097      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + leftPeakBounce)), stripHoldColor);
1098  } 
1099  
1100  if (rightPeak > 0) {
1101    if (droppingPeakFade && rightPeakBouncing == false)
1102      stripHoldColor = left_strip.Color(max(1, (255 * rightPeak * ledFactor_div_numOfSegments)), 0, 0);    
1103    else
1104      stripHoldColor = stripColor[numOfSegments];
1105
1106    if (splitStrip) {
1107      if (stripsOn2Pins) {
1108        right_strip.setPixelColor(getSpinCircleValue(rightPeak + rightPeakBounce), stripHoldColor);
1109      }
1110      else {
1111        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + rightPeakBounce), stripHoldColor);
1112      }
1113    }
1114    else {
1115      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + rightPeakBounce)), stripHoldColor);
1116    }
1117  }
1118
1119  //if (leftPeak > 0 || rightPeak > 0)
1120  //  left_strip.show();    
1121}
1122
1123void clearLeftPeak() {  
1124  if (splitStrip)
1125    left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
1126  else
1127    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0);
1128
1129  if (droppingPeak)
1130    leftPeak = leftPeak * peakDropFactor;
1131  else
1132    leftPeak = 0;
1133  leftPeakTime = 0;
1134}
1135
1136void clearRightPeak() {
1137  if (splitStrip) {
1138    if( stripsOn2Pins) {
1139      right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
1140    }
1141    else {
1142      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + prevRightPeakBounce), 0);
1143    }
1144  }
1145  else {
1146    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0);
1147  }
1148  
1149  if (droppingPeak) 
1150    rightPeak = rightPeak * peakDropFactor;
1151  else
1152    rightPeak = 0;
1153  rightPeakTime = 0;
1154}
1155
1156void clearLeftBouncePeak() {
1157  if (splitStrip)
1158    left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
1159  else
1160    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0);
1161}
1162
1163void clearRightBouncePeak() {
1164  if (splitStrip) {
1165    if (stripsOn2Pins) {
1166      right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
1167    }
1168    else {
1169      left_strip.setPixelColor(getSpinCircleValue((stripMiddle + rightPeak + prevRightPeakBounce)), 0);
1170    }
1171  }
1172  else {
1173    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0);
1174  }
1175}
1176
1177void clearLeftBounce() {
1178  leftPeakBouncing = false;
1179  leftPeakBounceCounter = 0;
1180  leftPeakBounce = 0;
1181  prevLeftPeakBounce = 0;
1182  leftBouncingPeaksNumOfLeds = 0;
1183}
1184
1185void clearRightBounce() {
1186  rightPeakBouncing = false;
1187  rightPeakBounceCounter = 0;
1188  rightPeakBounce = 0;
1189  prevRightPeakBounce = 0;
1190  leftBouncingPeaksNumOfLeds = 0;
1191}
1192
1193void clearValues() {
1194  leftAnalogValue = 0;
1195  rightAnalogValue = 0;
1196  prevLeftAnalogValue = 0;
1197  prevRightAnalogValue = 0;
1198  leftPeak = 0;
1199  rightPeak = 0;
1200}
1201
1202
1203void drawOverflow() {
1204  for (i = 0; i <= numOfSegments; i++) {
1205    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripOverflowColor);
1206    if (stripsOn2Pins) {
1207      right_strip.setPixelColor(i, stripOverflowColor);
1208    }
1209    else {
1210      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripOverflowColor);
1211    }
1212  }
1213  left_strip.show();
1214  if (stripsOn2Pins)
1215    right_strip.show();
1216  
1217  delay(overflowDelay);
1218
1219  for (i = 0; i <= numOfSegments; i++) {
1220    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0);
1221    if (stripsOn2Pins) {
1222      right_strip.setPixelColor(i, 0);
1223    }
1224    else {
1225      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
1226    }
1227  }
1228  left_strip.show();
1229  if (stripsOn2Pins)
1230    right_strip.show();
1231}
1232
1233void setStripColors() {
1234  int r, g, b;
1235  int p1, p2;
1236
1237  ledFactor = (float) ledBrightness / 255;
1238  ledFactor_div_numOfSegments = (float) ledFactor / (float) numOfSegments;
1239  stripMiddleColor = left_strip.Color(0, 0, 255 * ledFactor);
1240  
1241  switch (colorScheme) {
1242    case 0: {      
1243      int orangeLimit;
1244      float orangeFactor = orangeLimitAmount / halfNumOfSegments;
1245    
1246      for (i = 0; i <= numOfSegments; i++) {
1247        if (i <= halfNumOfSegments)
1248          orangeLimit = (i * orangeFactor);
1249        else
1250          orangeLimit = ((numOfSegments - i) * orangeFactor);
1251    
1252        stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments - i) * ledFactor_div_numOfSegments), 0); 
1253      }
1254      break;
1255    }
1256
1257    case 1: {
1258      for (i = 0; i <= numOfSegments; i++) {
1259        stripColor[i] = left_strip.Color(0, (255 * i * ledFactor_div_numOfSegments), (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 
1260      }
1261      break;
1262    }
1263
1264    case 2: {
1265      for (i = 0; i <= numOfSegments; i++) {
1266        stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), 0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 
1267      }
1268      break;
1269    }
1270
1271    case 3: {
1272      for (i = 0; i <= numOfSegments; i++) {
1273        stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), 0, (255 * i * ledFactor_div_numOfSegments)); 
1274      }
1275      break;
1276    }
1277
1278    case 4: {
1279      for (i = 0; i <= numOfSegments; i++) {
1280        stripColor[i] = left_strip.Color(0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments)); 
1281      }
1282      break;
1283    }
1284
1285    case 5: {
1286      for (i = 0; i <= numOfSegments; i++) {
1287        stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments), 0); 
1288      }
1289      break;
1290    }
1291
1292    case 6: {
1293      for (i = 0; i <= numOfSegments; i++) {
1294        r = (255 * i * ledFactor_div_numOfSegments);
1295        g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
1296        b = (200 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
1297        stripColor[i] = left_strip.Color(r, g, b); 
1298      }
1299      break;
1300    }
1301
1302    case 7: {
1303      for (i = 0; i <= numOfSegments; i++) {
1304        b = (255 * i * ledFactor_div_numOfSegments);
1305        g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
1306        r = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
1307        stripColor[i] = left_strip.Color(r, g, b); 
1308      }
1309      break;
1310    }
1311
1312    case 8: {
1313      for (i = 0; i <= numOfSegments; i++) {
1314        r = (255 * i * ledFactor_div_numOfSegments);
1315        b = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
1316        g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
1317        stripColor[i] = left_strip.Color(r, g, b); 
1318      }
1319      break;
1320    }
1321
1322    case 9: {
1323      for (i = 0; i <= numOfSegments; i++) {
1324        b = (255 * i * ledFactor_div_numOfSegments);
1325        r = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
1326        g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
1327        stripColor[i] = left_strip.Color(r, g, b); 
1328      }
1329      break;
1330    }
1331
1332    case 10: 
1333      colorScheme11SpinValue = 0;
1334      
1335    case 11:     
1336    
1337    case 12: {
1338      p1 = (85 * numOfSegments / 255);
1339      p2 = (170 * numOfSegments / 255);
1340      int wheel;
1341
1342      if (colorScheme == 12)
1343        colorSchemeFactor = colorScheme12Factor;        
1344      else
1345        colorSchemeFactor = 1;
1346            
1347      for (i = 0; i <= numOfSegments; i++) {  
1348        //wheel = int(float(i + colorScheme11SpinValue) / colorSchemeFactor) % numOfSegments;  // reverse wheel
1349        
1350        wheel = int(float(i - colorScheme11SpinValue) / colorSchemeFactor + numOfSegments) % numOfSegments;
1351
1352        if (wheel < p1) {          
1353          wheel = map(wheel, 0, p1, 0, 255);
1354          r = (wheel * ledFactor);
1355          g = ((255 - wheel) * ledFactor);
1356          b = 0;
1357        } 
1358        else if (wheel < p2) {
1359          wheel = map(wheel, p1, p2, 0, 255);
1360          r = ((255 - wheel) * ledFactor);
1361          g = 0;
1362          b = (wheel * ledFactor);
1363        } 
1364        else {
1365          wheel = map(wheel, p2, numOfSegments, 0, 255);
1366          r = 0;
1367          g = (wheel * ledFactor);
1368          b = ((255 - wheel) * ledFactor);
1369        }        
1370
1371        stripColor[i] = left_strip.Color(r, g, b); 
1372      }
1373      break;
1374    }
1375  }
1376
1377  if (colorScheme >= 10)
1378    stripHoldColor = left_strip.Color(255 * ledFactor, 0, 0); // set to red for the color wheels
1379  else
1380    stripHoldColor = stripColor[numOfSegments];
1381    
1382  stripOverflowColor = stripHoldColor;   // left_strip.Color(min(255, 255 * ledFactor * 1.5), 0, 0);
1383}
1384
1385void startupAnimation() {  
1386  for (j = 0; j < 2; j++) {
1387    for (i = 0; i <= numOfSegments; i++) {
1388      if (animType == 1)
1389        left_strip.setPixelColor(stripMiddle - (numOfSegments - i), stripColor[i]);
1390      else
1391        left_strip.setPixelColor(stripMiddle - i, stripColor[i]);
1392      
1393      if (stripsOn2Pins)
1394        right_strip.setPixelColor(i, stripColor[i]);
1395      else
1396        left_strip.setPixelColor(stripMiddle + i, stripColor[i]);
1397
1398      left_strip.show();
1399      if (stripsOn2Pins)
1400        right_strip.show();  
1401      
1402      delay(startupAnimationDelay);
1403    }
1404    
1405    for (i = 0; i <= numOfSegments; i++) {
1406      if (animType == 1)
1407        left_strip.setPixelColor(stripMiddle - (numOfSegments - i), 0);
1408      else
1409        left_strip.setPixelColor(stripMiddle - i, 0);
1410        
1411      if (stripsOn2Pins)
1412        right_strip.setPixelColor(i, 0);
1413      else
1414        left_strip.setPixelColor(stripMiddle + i, 0);
1415
1416      left_strip.show();
1417      if (stripsOn2Pins)
1418        right_strip.show();  
1419      
1420      delay(startupAnimationDelay);
1421    }
1422  }
1423}
1424
1425void displayNumber (int number, int displayDelay) {
1426  left_strip.clear();
1427  if (stripsOn2Pins)
1428    right_strip.clear();
1429
1430  number++; // @EB_DEBUG : display value 0 at led 1
1431  
1432  for (i = 0; i <= number; i++) {
1433    if (i % 5 == 0) 
1434      colorValue = stripMiddleColor;
1435    else
1436      colorValue = stripColor[0];
1437
1438    left_strip.setPixelColor(middleOffset + i, colorValue);
1439
1440    if (stripsOn2Pins)
1441      right_strip.setPixelColor(middleOffset + i, colorValue);
1442    else
1443      left_strip.setPixelColor(stripMiddle + middleOffset + i, colorValue);
1444
1445    delay(45 - number * 3); // @EB_DEBUG
1446    
1447    left_strip.show();
1448    if (stripsOn2Pins)
1449      right_strip.show();  
1450  }
1451
1452  if (pulsing) {
1453    left_strip.setPixelColor(middleOffset + maxDisplaySegments, stripMiddleColor);
1454
1455    if (stripsOn2Pins)
1456      right_strip.setPixelColor(maxDisplaySegments, stripMiddleColor);
1457    else
1458      left_strip.setPixelColor(stripMiddle + maxDisplaySegments, stripMiddleColor);
1459
1460    left_strip.show();
1461    if (stripsOn2Pins)
1462      right_strip.show();  
1463  }
1464
1465  delay(displayDelay);
1466
1467  left_strip.clear();
1468  if (stripsOn2Pins)
1469    right_strip.clear();
1470}
1471
1472
1473//
1474// for debugging
1475//
1476
1477#ifdef DEBUG_TEST_LEDS
1478  void displayTest() {
1479    for (i = 0; i <= numOfSegments; i++) {
1480      left_strip.setPixelColor(stripMiddle - i, stripColor[i]);
1481
1482      if (stripsOn2Pins)
1483        right_strip.setPixelColor(i, stripColor[i]);
1484      else
1485        left_strip.setPixelColor(stripMiddle + i, stripColor[i]);
1486
1487      left_strip.show();
1488      if (stripsOn2Pins)
1489        right_strip.show();  
1490
1491      delay(50);
1492    }
1493    delay(5000);
1494  
1495    for (i = 0; i <= numOfSegments; i++) {
1496      left_strip.setPixelColor(stripMiddle - i, 0);
1497
1498      if (stripsOn2Pins)
1499        right_strip.setPixelColor(i, 0);
1500      else
1501        left_strip.setPixelColor(stripMiddle + i, 0);
1502
1503      left_strip.show();
1504      if (stripsOn2Pins)
1505        right_strip.show();  
1506    }
1507  }
1508  
1509  void serialDisplayRGB(int r, int g, int b) {
1510    Serial.print(i);
1511    Serial.print(" ");
1512    Serial.print(r);
1513    Serial.print(" ");
1514    Serial.print(g);
1515    Serial.print(" ");
1516    Serial.println(b);
1517  }
1518#endif

/*
**********************************************************************
* Stereo VU Meter for 1 or 2 LED rings or strips build by ericBcreator
* Designed to be used with an Arduino UNO, Nano or compatible device.
**********************************************************************
* Notice: search for @EB in the Sketch for important variables to set
* for the Sketch to work with your setup.
**********************************************************************
* Last updated 20180202 by ericBcreator
*
* This code is free for personal use, not for commercial purposes.
* Please leave this header intact.
*
* contact: ericBcreator@gmail.com
**********************************************************************
*/
#include <Adafruit_NeoPixel.h>
#define nonLinearLogAudio 

//#define led_strip_60                                    //uncomment this if you are using a single 60 LED strip (Center to sides mode)
#define led_2_strip_60                                  //uncomment this if you are using two 60 LED strips (Left-Right bottom to top mode)

//#define led_strip_30                                    //uncomment this if you are using a single 30 LED strip
//#define led_2_strip_30                                  //uncomment this if you are using two 30 LED strips

//#define led_strip_144                                   //uncomment this if you are using a single 144 LED strip
//#define led_2_strip_144                                 //uncomment this if you are using two 144 LED strips

const int useSensorValues = true;                         // @EB


//
// setup pins
//

int leftPin = A0, rightPin = A1;                          // left audio in on analog 0, right on analog 1
int brightnessPin = A4, sensitivityPin = A5;              // potentiometers for brightness and sensitivity on analog 4 and 5
int leftStripPin = 5;                                     // DIN of left led strip on digital pin 5
int rightStripPin = 6;                                    // DIN of right led strip on digital pin 6
int showPeaksPin = 7;                                     // switch to toggle peaks on or off on digital pin 7 (7, 9 for box version)
int showPeaksMomentarySwitch = false;                     // set false for an on/off toggle switch
int reverseShowPeaks = true;                              // reverses the on/off setting in case you made a wiring mistake ;-) @EB
int selectButton1Pin = 8;                                 // push button for changing settings on digital pin 8
int useSelectButton1 = true;                              // set to false if no push button1 for selecting the color scheme is connected  @EB
int selectButton2Pin = 9;                                 // push button for changing settings on digital pin 9
int useSelectButton2 = true;                              // set to false if no push button2 is connected  @EB


#if defined (led_strip_60)
  //settings for a 60 led strip

  int stripNumOfLeds = 60;                                  // the total number of leds
  int stripsOn2Pins = false;                                // set to true if the LED strips or rings are connected to 2 input pins
  uint32_t stripColor[31];                                  // half of the number of leds + 1
  int displayMiddleLed = true;                              // display the middle led (blue). set to true for one strip, false for two strips or rings
  int splitStrip = false;                                   // set to true when using 2 strips or rings, false for one strip
  int middleOffset = 1;                                     // offset for the middle led when using one strip
  int startupAnimationDelay = 6;                            // delay for the startup animation
  int orangeLimitAmount = 0;                                // limit the amount of green of the middle LEDs to make them more orange
  int swapLeftRight = false;                                // swap the left and right input values or not
  
  int dropDelay = 5;                                        // hold time before dropping the leds
  float dropFactor = .94;                                   // value for dropping the leds
  
  int peakTimeNoDropDelay = 250;                            // peak hold time when not dropping the peaks (when droppingPeak is false)
  int peakTimeFirstDropDelay = 70;                          // peak hold time when dropping the first peak
  int peakTimeDropDelay = 7;                                // peak hold time when dropping the rest of the peaks
  float peakDropFactor = .94;                               // value for dropping the peaks
  int droppingPeakFade = false;                             // display the dropping peak fading to black or not
  
  int bouncingPeaksNumOfLeds = 6;                           // how many leds to bounce up (max)
  int bouncingPeaksNumOfLedsMin = 3;                        // how many leds to bounce up (min) when using dynamicBouncingPeaks
  int bouncingPeakDelay = 4;                                // delay between peak bounce updates
  int bouncingPeakCounterInc = 10;                          // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing

#elif defined (led_2_strip_60)
  //settings for 2 60 led strips

  int stripNumOfLeds = 60;
  int stripsOn2Pins = true;
  uint32_t stripColor[61];
  int displayMiddleLed = false;
  int splitStrip = true;
  int middleOffset = 0;
  int startupAnimationDelay = 1;
  int orangeLimitAmount = 0;
  int swapLeftRight = false;
  
  int dropDelay = 5;
  float dropFactor = .94;
  
  int peakTimeNoDropDelay = 250;
  int peakTimeFirstDropDelay = 70;
  int peakTimeDropDelay = 7;
  float peakDropFactor = .94;
  int droppingPeakFade = false;
  
  int bouncingPeaksNumOfLeds = 12;
  int bouncingPeaksNumOfLedsMin = 4;
  int bouncingPeakDelay = 4;
  int bouncingPeakCounterInc = 10;
  
#elif defined (led_strip_30)
  //settings for a 30 led strip

  int stripNumOfLeds = 30;                                  // the total number of leds
  int stripsOn2Pins = false;                                // set to true if the LED strips or rings are connected to 2 input pins
  uint32_t stripColor[16];                                  // half of the number of leds + 1
  int displayMiddleLed = true;                              // display the middle led (blue). set to true for one strip, false for two strips or rings
  int splitStrip = false;                                   // set to true when using 2 strips or rings, false for one strip
  int middleOffset = 1;                                     // offset for the middle led when using one strip
  int startupAnimationDelay = 10;                           // delay for the startup animation
  int orangeLimitAmount = 0;                                // limit the amount of green of the middle LEDs to make them more orange
  int swapLeftRight = false;                                // swap the left and right input values or not
  
  int dropDelay = 10;                                       // hold time before dropping the leds
  float dropFactor = .9;                                    // value for dropping the leds
  
  int peakTimeNoDropDelay = 250;                            // peak hold time when not dropping the peaks (set droppingPeak true or false)
  int peakTimeFirstDropDelay = 150;                         // peak hold time when dropping the first peak
  int peakTimeDropDelay = 15;                               // peak hold time when dropping the rest of the peaks
  float peakDropFactor = .94;                               // value for dropping the peaks
  int droppingPeakFade = false;                             // display the dropping peak fading to black or not
  
  int bouncingPeaksNumOfLeds = 4;                           // how many leds to bounce up (max)
  int bouncingPeaksNumOfLedsMin = 2;                        // how many leds to bounce up (min) when using dynamicBouncingPeaks
  int bouncingPeakDelay = 4;                                // delay between peak bounce updates
  int bouncingPeakCounterInc = 9;                           // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing

#elif defined (led_2_strip_30)
  //settings for 2 30 led strips

  int stripNumOfLeds = 30;
  int stripsOn2Pins = true;
  uint32_t stripColor[31];
  int displayMiddleLed = false;
  int splitStrip = true;
  int middleOffset = 0;
  int startupAnimationDelay = 1;
  int orangeLimitAmount = 0;
  int swapLeftRight = false;
  
  int dropDelay = 5;
  float dropFactor = .94;
  
  int peakTimeNoDropDelay = 250;
  int peakTimeFirstDropDelay = 70;
  int peakTimeDropDelay = 7;
  float peakDropFactor = .94;
  int droppingPeakFade = false;
  
  int bouncingPeaksNumOfLeds = 12;
  int bouncingPeaksNumOfLedsMin = 4;
  int bouncingPeakDelay = 4;
  int bouncingPeakCounterInc = 10;
  
#elif defined (led_strip_144)
  //settings for a 144 led strip

  int stripNumOfLeds = 145;
  int stripsOn2Pins = false;
  uint32_t stripColor[73];
  int displayMiddleLed = true;
  int splitStrip = false;
  int middleOffset = 1;
  int startupAnimationDelay = 1;
  int orangeLimitAmount = 0;
  int swapLeftRight = false;
  
  int dropDelay = 4;
  float dropFactor = .92;
  
  int peakTimeNoDropDelay = 250;
  int peakTimeFirstDropDelay = 100;
  int peakTimeDropDelay = 5;
  float peakDropFactor = .94;
  int droppingPeakFade = false;
  
  int bouncingPeaksNumOfLeds = 10;
  int bouncingPeaksNumOfLedsMin = 4;
  int bouncingPeakDelay = 2;
  int bouncingPeakCounterInc = 10;

#elif defined (led_2_strip_144)
  //settings for 2 144 led strips

  int stripNumOfLeds = 144;
  int stripsOn2Pins = true;
  uint32_t stripColor[145];
  int displayMiddleLed = false;
  int splitStrip = true;
  int middleOffset = 0;
  int startupAnimationDelay = 1;
  int orangeLimitAmount = 0;
  int swapLeftRight = false;
  
  int dropDelay = 5;
  float dropFactor = .94;
  
  int peakTimeNoDropDelay = 250;
  int peakTimeFirstDropDelay = 70;
  int peakTimeDropDelay = 7;
  float peakDropFactor = .94;
  int droppingPeakFade = false;
  
  int bouncingPeaksNumOfLeds = 12;
  int bouncingPeaksNumOfLedsMin = 4;
  int bouncingPeakDelay = 4;
  int bouncingPeakCounterInc = 10;
  
#endif
//
// setup other user variables
//

// basic settings
int pulsing = false;                                       // pulsing will display from the middle of each strip or ring  @EB

int spinCircle = false;                                    // spin the animation. will not work with stripsOn2Pins  @EB

int animType = 0;                                         // startup animation selection (1 looks nice for 1 ring)  @EB
int colorScheme = 10;                                     // 0: green-red, 1: blue-green, 2: blue-red, 3: red-blue, 4: green-blue, 5: red-green, 6: blue-white-red
                                                          // 7: red-white-blue, 8: green-white-red, 9: green-white-blue, 10: color wheel, 11: spinning color wheel,
                                            // 12: as 11 but spread with factor colorScheme12Factor  @EB
int maxColorScheme = 12;                                  // used for looping through the color schemes with the switch button
int colorScheme11SpinDelay = stripNumOfLeds / 4 ;         // delay for spinning scheme 11
int colorScheme12Factor = 3;                              // wheel spread factor for scheme 12 @EB

int minValue = 10;                                        // min analog input value
int sensitivityValue = 110;                               // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)

#ifdef highLevelInput
  int maxValue = 700;                                     // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high
  int maxSensitivity = 2 * 255;                           // set to a higher setting to amplify low input levels. try 4 * 255 for low level input, 2 * 255 for high
#else
  int maxValue = 300;                                     // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high
  int maxSensitivity = 4 * 255;                           // set to a higher setting to amplify low input levels. try 4 * 255 for low level input, 2 * 255 for high
#endif

int ledBrightness = 30;                                   // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true)
int sensorDeviationBrightness = 3;                        // eliminate fluctuating values
int overflowDelay = 10;                                   // overflow hold time

// peak settings @EB
int displayPeaks = false;                                 // value will be set by the switch if useSensorValues = true
int displayTopAsPeak = true;                              // always display the top LED in peak color
int droppingPeak = true;                                  // display dropping peaks or not. note: displayPeaks has to be true 
int bouncingPeaks = false;                                // display bouncing peaks or not. note: displayPeaks has to be true 
int dynamicBouncingPeaks = false;                         // bounce less with lower peaks. note: bouncingPeaks has to be true 

//
// initialize other variables 
//

int numOfSegments, halfNumOfSegments, stripMiddle, maxDisplaySegments;
float sensitivityFactor;
float nonLinearResponseFactor;

int brightnessValue, prevBrightnessValue;
float ledFactor, ledFactor_div_numOfSegments;

uint32_t stripMiddleColor, stripOverflowColor, stripHoldColor;
uint32_t colorValue;

int leftValue = 0, rightValue = 0, maxReadValue = 0;
int leftValueN = 0, rightValueN = 0;
int leftAnalogValue = 0, rightAnalogValue = 0;
float log10MaxDisplaySegments;

int prevLeftValue = 0, prevRightValue = 0;
int prevLeftAnalogValue = 0, prevRightAnalogValue = 0;

int selectButton1PinState = 0, prevSelectButton1PinState = 0;
int selectButton2PinState = 0, prevSelectButton2PinState = 0;

int selectButton1PinSetting = colorScheme;
int selectButton2PinSetting = 0;

int i, j;
int dropLeft, dropRight;
int leftDropTime, rightDropTime;

int leftPeak = 0, rightPeak = 0;
int leftPeakTime = 0, rightPeakTime = 0;
int leftFirstPeak = true, rightFirstPeak = true;
int showPeaksPinSetting, prevShowPeaksPinSetting;

int stripPulseMiddle = 0;
int halfLeftValue, halfRightValue, halfPrevLeftValue, halfPrevRightValue;

int leftPeakBouncing = false, rightPeakBouncing = false;
int leftPeakBounce = 0, rightPeakBounce = 0;
int prevLeftPeakBounce = 0, prevRightPeakBounce = 0;
int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0;
int leftPeakBounceDelayCounter = 0, rightPeakBounceDelayCounter = 0;
int leftBouncingPeaksNumOfLeds = 0, rightBouncingPeaksNumOfLeds = 0;
float bounceFactor;

int colorScheme11SpinValue = 0, colorScheme11SpinDelayValue = 0;
int colorSchemeFactor = 1;
long selectButton1Timer;

int spinDelayCounter = 0, spinCounter = 0, spinTurnsCounter = 0, spinTurnsMax = 0, spinTurnsDelay = 0, spinTurnsDelayMax = 0;
int spinCounterInc = 1;
int spinDelay = 0;
//
// initialize the strip or rings
//

Adafruit_NeoPixel left_strip = Adafruit_NeoPixel(stripNumOfLeds, leftStripPin, NEO_GRB + NEO_KHZ800);
Adafruit_NeoPixel right_strip = Adafruit_NeoPixel(stripNumOfLeds, rightStripPin, NEO_GRB + NEO_KHZ800);

//
// setup
//

void setup() {
  #ifdef DEBUG
    Serial.begin(9600);
  #endif

  randomSeed(analogRead(2));

  if (stripsOn2Pins) {
    numOfSegments = stripNumOfLeds;
    maxDisplaySegments = numOfSegments - 1;
    
    stripMiddle = stripNumOfLeds;
    stripPulseMiddle = stripMiddle / 2;
    spinCircle = false;
  }
  else {
    numOfSegments = stripNumOfLeds / 2;
    stripMiddle = stripNumOfLeds / 2;
    maxDisplaySegments = stripMiddle - 1;

    stripPulseMiddle = stripMiddle / 2;
  }

  halfNumOfSegments = numOfSegments / 2; 
  bounceFactor = (float) bouncingPeaksNumOfLeds / (maxDisplaySegments - bouncingPeaksNumOfLeds);
  nonLinearResponseFactor = 90 / (float) maxDisplaySegments;
  log10MaxDisplaySegments = log10(maxDisplaySegments);

  pinMode(showPeaksPin, INPUT);    
  
  if (useSelectButton1)
    pinMode(selectButton1Pin, INPUT);  

  left_strip.begin();
  if (stripsOn2Pins) 
    right_strip.begin();

  if (useSensorValues) {
    readSensorValues();
    setInitialDisplayPeaks();
  }
  else {
    setStripColors();
    setSensitivityFactor();
  }

  #ifdef DEBUG_TEST_LEDS
    displayTest();
  #endif

  startupAnimation();
}

//
// main loop
//

void loop() {
  #ifdef DEBUG_PRINT_LOOP_TIME
    long time = millis();
  #endif


  if (useSensorValues) 
    readSensorValues();
  
  readValues();

  #if defined (DEBUG_NO_PEAKS)
    displayPeaks = false;
  #endif

  #if defined (DEBUG_PEAKS)
    displayPeaks = true;
  #endif

  if (pulsing) {
    drawPulsingValues();
  }
  else {
    drawValues();
    if (displayPeaks) {
      getPeaks();
      drawPeaks();
    }
  }

  left_strip.show();
  if (stripsOn2Pins)
    right_strip.show();
    
  storePrevValues();

  checkSpinCircle();

  #ifdef DEBUG_PRINT_LOOP_TIME
    time = millis() - time;
    Serial.println(time);
  #endif
}

// 
// functions
//

void setInitialDisplayPeaks() {
  #if !defined (DEBUG_NO_PEAK_SWITCH)
    showPeaksPinSetting = digitalRead(showPeaksPin);
  
    if (showPeaksPinSetting == HIGH)
      displayPeaks = false;
  #endif 
 
  if (reverseShowPeaks) {
    if (!displayPeaks)
      displayPeaks = true;
    else
      displayPeaks = false;
  }
  
  prevShowPeaksPinSetting = showPeaksPinSetting;
}

void readSensorValues() {
  //
  // peaks pin
  //

  #if !defined (DEBUG_NO_PEAK_SWITCH)
    showPeaksPinSetting = digitalRead(showPeaksPin);
  
    if (showPeaksMomentarySwitch) {
      if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
        if (displayPeaks == true) {
          displayPeaks = false;
          clearLeftPeak();
          clearRightPeak();        
          if (showPeaksMomentarySwitch)
            while (digitalRead(showPeaksPin) == LOW) {}
        }
        else {
          displayPeaks = true;
        }
      }
    } 
    else {
      if (reverseShowPeaks) {
        if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) 
          displayPeaks = true;
        else if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) {
          displayPeaks = false;
          clearLeftPeak();
          clearRightPeak();        
        }
      }
      else {    
        if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) 
          displayPeaks = true;
        else if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) {
          displayPeaks = false;
          clearLeftPeak();
          clearRightPeak();        
        }
      }
    }
    if (pulsing) {
      if (displayPeaks)
        displayTopAsPeak = true;
      else
        displayTopAsPeak = false;
    }

    prevShowPeaksPinSetting = showPeaksPinSetting;
  #endif
  

  //
  // selectButtonPin 1 and 2
  //
  if (useSelectButton1) {      
    selectButton1PinState = digitalRead(selectButton1Pin);
    
    if (selectButton1PinState == HIGH && prevSelectButton1PinState == LOW)
      selectButton1Timer = millis();
      
    if (selectButton1PinState == HIGH && prevSelectButton1PinState == HIGH) {
      if ((millis() - selectButton1Timer) > 1000) {
        pulsing = !pulsing;
        setStripColors();
        displayNumber(colorScheme, 250);

        while (digitalRead(selectButton1Pin) == HIGH) {}
        selectButton1PinState = LOW;
        clearValues();
      }
    }
    else if (selectButton1PinState == LOW && prevSelectButton1PinState == HIGH) {
      selectButton1PinSetting++;
      if (selectButton1PinSetting > maxColorScheme) {
        selectButton1PinSetting = 0;
      }
      colorScheme = selectButton1PinSetting;

      if (colorScheme == 12)
        colorScheme11SpinValue = (colorScheme11SpinValue * colorScheme12Factor);

      setStripColors();
      displayNumber(colorScheme, 250);
    }
    prevSelectButton1PinState = selectButton1PinState;
  }

  if (useSelectButton2) {
    selectButton2PinState = digitalRead(selectButton2Pin);
    
    if (selectButton2PinState == HIGH && prevSelectButton2PinState == LOW) {
      selectButton2PinSetting++;
      
      switch(selectButton2PinSetting) {
        case 0:
        case 1: {   
          pulsing = true;
          spinCircle = false;
          break;
        }
        case 2: {
          pulsing = true;
          spinCircle = true;
          break;
        }
        case 3: {
          pulsing = false;
          spinCircle = false;
          selectButton2PinSetting = 0;
          break;
        }
      }
      
      setStripColors();
      displayNumber(colorScheme, 250);
    }
    
    prevSelectButton2PinState = selectButton2PinState;
  }
  
  //
  // brightness
  //
  brightnessValue = analogRead(brightnessPin);
  brightnessValue = map(brightnessValue, 0, 1023, 0, 255);
  
  if (abs(brightnessValue - prevBrightnessValue) > sensorDeviationBrightness) {
    ledBrightness = brightnessValue;
    setStripColors();
    prevBrightnessValue = brightnessValue;
  }

  //
  // colorscheme 11 spinning wheel
  //

  if (colorScheme == 11 || colorScheme == 12) {
    colorScheme11SpinDelayValue++;
    if (colorScheme11SpinDelayValue == colorScheme11SpinDelay) {
      colorScheme11SpinDelayValue = 0;
      colorScheme11SpinValue++;
      if (colorScheme11SpinValue > maxDisplaySegments * colorSchemeFactor)
        colorScheme11SpinValue = 0;
      setStripColors();
    }
  }

  //
  // sensitivity
  //
  sensitivityValue = analogRead(sensitivityPin);
  sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255);
  setSensitivityFactor();
}

void setSensitivityFactor() {
  //sensitivityValue_div_numOfSegments = sensitivityValue / numOfSegments;
  sensitivityFactor = ((float) sensitivityValue / 255 * (float) maxSensitivity / 255);
}

void readValues() {
  #ifdef averageReadings
    leftAnalogValue = 0;
    rightAnalogValue = 0;
    
    for (i = 0; i <= averageNumOfReadings; i++) {
      leftAnalogValue += analogRead(leftPin);
      rightAnalogValue += analogRead(rightPin);
    }

    leftAnalogValue /= averageNumOfReadings;
    rightAnalogValue /= averageNumOfReadings;
    
  #else  
    leftAnalogValue = analogRead(leftPin);
    rightAnalogValue = analogRead(rightPin);
  #endif

  if (swapLeftRight) {
    int tempValue = leftAnalogValue;
    leftAnalogValue = rightAnalogValue;
    rightAnalogValue = tempValue;
  }

  if (leftAnalogValue < prevLeftAnalogValue) {
    leftDropTime++;
    if (leftDropTime > dropDelay) {
      leftAnalogValue = prevLeftAnalogValue * dropFactor;
      leftDropTime = 0;
    }
    else
      leftAnalogValue = prevLeftAnalogValue;
  }
   
  if (rightAnalogValue < prevRightAnalogValue) {
    rightDropTime++;
    if (rightDropTime > dropDelay) {
      rightAnalogValue = prevRightAnalogValue * dropFactor;
      rightDropTime = 0;
    }
    else
      rightAnalogValue = prevRightAnalogValue;
  }

  #ifdef DEBUG_PRINT_ANALOGVALUES
    Serial.print(leftAnalogValue);
    Serial.print(" ");
    Serial.println(rightAnalogValue);
  #endif  

  // map values  
  leftValue = map(leftAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments);
  rightValue = map(rightAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments);
  
  // if defined, convert to (reverse) non linear response
  boolean flagNonLinear = false;
  
  #if defined (nonLinearSinAudio)
    flagNonLinear = true;
    leftValueN = ((sin(((leftValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments);
    rightValueN = ((sin(((rightValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments);
    
  #elif defined (nonLinearReverseSinAudio)
    flagNonLinear = true;
    leftValueN = ((sin(((leftValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments);
    rightValueN = ((sin(((rightValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments);

  #elif defined (nonLinearLogAudio)
    flagNonLinear = true;
    leftValueN = ((log10(leftValue  + 1) / log10MaxDisplaySegments * maxDisplaySegments));
    rightValueN = ((log10(rightValue  + 1) / log10MaxDisplaySegments * maxDisplaySegments));
  
  #endif
  
  if (flagNonLinear == true) {
    #if defined (nonLinearAvr2)
      leftValue = (leftValue + leftValueN) / 2;
      rightValue = (rightValue + rightValueN) / 2;
    #else
      leftValue = leftValueN;
      rightValue = rightValueN;
    #endif
  }
  
// @EB_DEBUG

  #ifdef displayOverflow
    #ifdef compressOverflowPeaks
      for (i = 1; i <= compressOverflowNumOfTimes; i++) {
        if (leftValue > maxDisplaySegments) {
//          Serial.print(i);    
//          Serial.print("  ");
//          Serial.print(leftValue);    
//          Serial.print("  ");
          leftValue = leftValue - leftValue * compressOverflowFactor * i;
//          Serial.print(leftValue);
//          Serial.print("  ");
//          Serial.println(maxDisplaySegments);
        }
      }
    #endif
  #endif
  
  if (leftValue > maxDisplaySegments) {      
    leftValue = maxDisplaySegments;
    #ifdef displayOverflow
      drawOverflow();
    #endif
  }

  #ifdef displayOverflow
    #ifdef compressOverflowPeaks
      if (rightValue > maxDisplaySegments)
        rightValue = rightValue - rightValue * compressOverflowFactor;
    #endif
  #endif
  
  if (rightValue > maxDisplaySegments) {
    rightValue = maxDisplaySegments;
    #ifdef displayOverflow
      drawOverflow();
    #endif
  }
}

void storePrevValues() {
  prevLeftAnalogValue = leftAnalogValue;
  prevRightAnalogValue = rightAnalogValue;

  prevLeftValue = leftValue;
  prevRightValue = rightValue;
}

void getPeaks() {
  if (leftValue > leftPeak) {
    if (dynamicBouncingPeaks || prevLeftPeakBounce > 0)
      clearLeftBouncePeak();
          
    leftPeak = leftValue;
    leftPeakTime = 0;
    leftFirstPeak = true;

    if (bouncingPeaks) {
      leftPeakBouncing = true;
      leftPeakBounceCounter = 0;
      leftPeakBounceDelayCounter = 0;
      
      if (dynamicBouncingPeaks)
        leftBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (leftPeak * bounceFactor));
      else
        leftBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
    }
  }
  else {
    leftPeakTime++;
    if (droppingPeak) {
      if (leftFirstPeak) {
        if (leftPeakTime > peakTimeFirstDropDelay) {
          clearLeftPeak();
          leftFirstPeak = false;
        }
      }
      else {
        if (leftPeakTime > peakTimeDropDelay) {
          clearLeftPeak();
        }
      }
    }
    else {
      if (leftPeakTime > peakTimeNoDropDelay) {
        clearLeftPeak();
      }
    }
  }

  if (leftPeakBouncing) {
    if (leftFirstPeak) {
      leftPeakBounceDelayCounter++;
      if (leftPeakBounceDelayCounter >= bouncingPeakDelay) {
        leftPeakBounceDelayCounter = 0;
        leftPeakBounceCounter += bouncingPeakCounterInc;
        if (leftPeakBounceCounter >= 180) {
          clearLeftBouncePeak();
          clearLeftBounce();
        }
        else {        
          leftPeakBounce = min((sin(leftPeakBounceCounter * 0.0174533) * leftBouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak));
          if (leftPeakBounce != prevLeftPeakBounce) {
            clearLeftBouncePeak();
          }
          prevLeftPeakBounce = leftPeakBounce;
        }
      }
    }
  }

  if (rightValue > rightPeak) {
    if (dynamicBouncingPeaks || prevRightPeakBounce > 0)
      clearRightBouncePeak();

    rightPeak = rightValue;
    rightPeakTime = 0;
    rightFirstPeak = true;

    if (bouncingPeaks) {
      rightPeakBouncing = true;
      rightPeakBounceCounter = 0;
      rightPeakBounceDelayCounter = 0;

      if (dynamicBouncingPeaks)
        rightBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (rightPeak * bounceFactor));
      else
        rightBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds;
    }
  }
  else {
    rightPeakTime++;
    if (droppingPeak) {
      if (rightFirstPeak) {
        if (rightPeakTime > peakTimeFirstDropDelay) {
          clearRightPeak();
          rightFirstPeak = false;
        }
      }
      else {
        if (rightPeakTime > peakTimeDropDelay)
          clearRightPeak();
      }
    }
    else {
      if (rightPeakTime > peakTimeNoDropDelay)
        clearRightPeak();
    }
  }

  if (rightPeakBouncing) {
    if (rightFirstPeak) {
      rightPeakBounceDelayCounter++;
      if (rightPeakBounceDelayCounter >= bouncingPeakDelay) {
        rightPeakBounceDelayCounter = 0;
        rightPeakBounceCounter += bouncingPeakCounterInc;
  
        if (rightPeakBounceCounter >= 180) {
          clearRightBouncePeak();
          clearRightBounce();
        }
        else {        
          rightPeakBounce = min((sin(rightPeakBounceCounter * 0.0174533) * rightBouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak));
          if (rightPeakBounce != prevRightPeakBounce) {
            clearRightBouncePeak();
          }
          prevRightPeakBounce = rightPeakBounce;
        }
      }
    }
  }
}

void checkSpinCircle () {
  if (spinCircle) {
    if (spinTurnsMax == 0) {
      spinTurnsMax = random(stripNumOfLeds / 4, stripNumOfLeds * 3);  // spin at least a quarter turn, max 3 turns
      
      if (random(10) > 4)
        spinCounterInc = -spinCounterInc;
      
      spinTurnsDelayMax = random(100, 1000); // @EB_DEBUG

      spinDelay = random(20, 75); // @EB_DEBUG
    }

    if (spinTurnsCounter == spinTurnsMax) {
      spinTurnsDelay++;
      if (spinTurnsDelay == spinTurnsDelayMax) {
        spinTurnsDelay = 0;
        spinTurnsCounter = 0;
        spinTurnsMax = 0;
      }
    }
    else {
      spinDelayCounter++;
  
      if (spinDelayCounter > spinDelay) {
        clearZeroAndPeaks();

        spinCounter += spinCounterInc;
        if (spinCounter > stripNumOfLeds)
          spinCounter = 0;
        else if (spinCounter < 0)
          spinCounter = stripNumOfLeds;

        spinTurnsCounter++;
        spinDelayCounter = 0;
      }
    }
  }
}

int getSpinCircleValue(int value) {
  if (!spinCircle)
   return value;
  else {
    int calcValue = value + spinCounter;
    if (calcValue >= stripNumOfLeds)
      calcValue -= stripNumOfLeds;
    return calcValue;
  }
}

void drawValues() {
  if (splitStrip) {
    for (i = middleOffset; i < leftValue; i++)
      left_strip.setPixelColor(getSpinCircleValue(i), stripColor[i]);

    if (!displayPeaks && displayTopAsPeak)
      left_strip.setPixelColor(getSpinCircleValue(leftValue), stripHoldColor);

    for (i = prevLeftValue; i >= leftValue; i--)
      left_strip.setPixelColor(getSpinCircleValue(i), 0);

    if (stripsOn2Pins) {
      for (i = middleOffset; i < rightValue; i++) 
        right_strip.setPixelColor(i, stripColor[i]);

      if (!displayPeaks && displayTopAsPeak)
        right_strip.setPixelColor(rightValue, stripHoldColor);

      for (i = prevRightValue; i >= rightValue; i--)
        right_strip.setPixelColor(i, 0);
    }
    else {
      for (i = middleOffset; i < rightValue; i++)
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);

      if (!displayPeaks && displayTopAsPeak)
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightValue), stripHoldColor);
        
      for (i = prevRightValue; i >= rightValue; i--)
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
    }
  }
  else {
    for (i = middleOffset; i < leftValue; i++)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]);

    if (!displayPeaks && displayTopAsPeak)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + leftValue), stripHoldColor);

    for (i = prevLeftValue; i >= leftValue; i--)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
  
    for (i = middleOffset; i < rightValue; i++)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripColor[i]);

    if (!displayPeaks && displayTopAsPeak)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - rightValue), stripHoldColor);

    for (i = prevRightValue; i >= rightValue; i--)
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0);
  }

  if (displayMiddleLed) 
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle), stripMiddleColor);
}

void drawPulsingValues() {
  halfLeftValue = (leftValue + 1) / 2;
  halfRightValue = (rightValue + 1) / 2;
  halfPrevLeftValue = (prevLeftValue + 1)/ 2;
  halfPrevRightValue = (prevRightValue + 1) / 2;
  
  if (splitStrip) {
    for (i = 0; i < halfLeftValue; i++) {
      colorValue = stripColor[i * 2];
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), colorValue);
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), colorValue);
    }

    if (displayTopAsPeak) {
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), stripHoldColor);
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), stripHoldColor);
    }

    for (i = halfPrevLeftValue; i >= halfLeftValue; i--) {
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), 0);
    }

    if (stripsOn2Pins) {
      for (i = 0; i < halfRightValue; i++) {
        colorValue = stripColor[i * 2];
        right_strip.setPixelColor((stripPulseMiddle + i), colorValue);
        right_strip.setPixelColor((stripPulseMiddle - i), colorValue);
      }

      if (displayTopAsPeak) {
        right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfRightValue), stripHoldColor);
        right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfRightValue), stripHoldColor);
      }
      
      for (i = halfPrevRightValue; i >= halfRightValue; i--) {
        right_strip.setPixelColor((stripPulseMiddle + i), 0);
        right_strip.setPixelColor((stripPulseMiddle - i), 0);
      }
    }
    else {
      for (i = 0; i < halfRightValue; i++) {
        colorValue = colorValue = stripColor[i * 2];
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue);
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue);
      }

      if (displayTopAsPeak) {
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), stripHoldColor);
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), stripHoldColor);
      }

      for (i = halfPrevRightValue; i >= halfRightValue; i--) {
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0);
      }
    }
  }
  else {
    for (i = 0; i < halfLeftValue; i++) {
      colorValue = colorValue = stripColor[i * 2];
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue);
    }

    if (displayTopAsPeak) {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), stripHoldColor);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), stripHoldColor);
    }
    
    for (i = halfPrevLeftValue; i >= halfLeftValue; i--) {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0);
    }
  
    for (i = 0; i < halfRightValue; i++) {
      colorValue = colorValue = stripColor[i * 2];
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), colorValue);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), colorValue);
    }

    if (displayTopAsPeak) {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), stripHoldColor);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), stripHoldColor);
    }
    
    for (i = halfPrevRightValue; i >= halfRightValue; i--) {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), 0);
    }
  }

  if (displayMiddleLed) {
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - stripPulseMiddle), stripMiddleColor);
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle), stripMiddleColor);
  }
}

void clearZeroAndPeaks() {
  left_strip.setPixelColor(getSpinCircleValue(middleOffset), 0);
  left_strip.setPixelColor(getSpinCircleValue(stripMiddle), 0);

  if (displayTopAsPeak) {
    if (splitStrip) {
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), 0);
      
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), 0);
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), 0);

      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), 0);
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), 0);
    }
  }
}

void drawPeaks() {  
  if (leftPeak > 0) {
    if (droppingPeakFade && leftPeakBouncing == false)
      stripHoldColor = left_strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 0, 0);
    else
      stripHoldColor = stripColor[numOfSegments];

    if (splitStrip)
      left_strip.setPixelColor(getSpinCircleValue(leftPeak + leftPeakBounce), stripHoldColor);
    else
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + leftPeakBounce)), stripHoldColor);
  } 
  
  if (rightPeak > 0) {
    if (droppingPeakFade && rightPeakBouncing == false)
      stripHoldColor = left_strip.Color(max(1, (255 * rightPeak * ledFactor_div_numOfSegments)), 0, 0);    
    else
      stripHoldColor = stripColor[numOfSegments];

    if (splitStrip) {
      if (stripsOn2Pins) {
        right_strip.setPixelColor(getSpinCircleValue(rightPeak + rightPeakBounce), stripHoldColor);
      }
      else {
        left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + rightPeakBounce), stripHoldColor);
      }
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + rightPeakBounce)), stripHoldColor);
    }
  }

  //if (leftPeak > 0 || rightPeak > 0)
  //  left_strip.show();    
}

void clearLeftPeak() {  
  if (splitStrip)
    left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
  else
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0);

  if (droppingPeak)
    leftPeak = leftPeak * peakDropFactor;
  else
    leftPeak = 0;
  leftPeakTime = 0;
}

void clearRightPeak() {
  if (splitStrip) {
    if( stripsOn2Pins) {
      right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + prevRightPeakBounce), 0);
    }
  }
  else {
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0);
  }
  
  if (droppingPeak) 
    rightPeak = rightPeak * peakDropFactor;
  else
    rightPeak = 0;
  rightPeakTime = 0;
}

void clearLeftBouncePeak() {
  if (splitStrip)
    left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0);
  else
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0);
}

void clearRightBouncePeak() {
  if (splitStrip) {
    if (stripsOn2Pins) {
      right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0);
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue((stripMiddle + rightPeak + prevRightPeakBounce)), 0);
    }
  }
  else {
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0);
  }
}

void clearLeftBounce() {
  leftPeakBouncing = false;
  leftPeakBounceCounter = 0;
  leftPeakBounce = 0;
  prevLeftPeakBounce = 0;
  leftBouncingPeaksNumOfLeds = 0;
}

void clearRightBounce() {
  rightPeakBouncing = false;
  rightPeakBounceCounter = 0;
  rightPeakBounce = 0;
  prevRightPeakBounce = 0;
  leftBouncingPeaksNumOfLeds = 0;
}

void clearValues() {
  leftAnalogValue = 0;
  rightAnalogValue = 0;
  prevLeftAnalogValue = 0;
  prevRightAnalogValue = 0;
  leftPeak = 0;
  rightPeak = 0;
}


void drawOverflow() {
  for (i = 0; i <= numOfSegments; i++) {
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripOverflowColor);
    if (stripsOn2Pins) {
      right_strip.setPixelColor(i, stripOverflowColor);
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripOverflowColor);
    }
  }
  left_strip.show();
  if (stripsOn2Pins)
    right_strip.show();
  
  delay(overflowDelay);

  for (i = 0; i <= numOfSegments; i++) {
    left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0);
    if (stripsOn2Pins) {
      right_strip.setPixelColor(i, 0);
    }
    else {
      left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0);
    }
  }
  left_strip.show();
  if (stripsOn2Pins)
    right_strip.show();
}

void setStripColors() {
  int r, g, b;
  int p1, p2;

  ledFactor = (float) ledBrightness / 255;
  ledFactor_div_numOfSegments = (float) ledFactor / (float) numOfSegments;
  stripMiddleColor = left_strip.Color(0, 0, 255 * ledFactor);
  
  switch (colorScheme) {
    case 0: {      
      int orangeLimit;
      float orangeFactor = orangeLimitAmount / halfNumOfSegments;
    
      for (i = 0; i <= numOfSegments; i++) {
        if (i <= halfNumOfSegments)
          orangeLimit = (i * orangeFactor);
        else
          orangeLimit = ((numOfSegments - i) * orangeFactor);
    
        stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments - i) * ledFactor_div_numOfSegments), 0); 
      }
      break;
    }

    case 1: {
      for (i = 0; i <= numOfSegments; i++) {
        stripColor[i] = left_strip.Color(0, (255 * i * ledFactor_div_numOfSegments), (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 
      }
      break;
    }

    case 2: {
      for (i = 0; i <= numOfSegments; i++) {
        stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), 0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 
      }
      break;
    }

    case 3: {
      for (i = 0; i <= numOfSegments; i++) {
        stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), 0, (255 * i * ledFactor_div_numOfSegments)); 
      }
      break;
    }

    case 4: {
      for (i = 0; i <= numOfSegments; i++) {
        stripColor[i] = left_strip.Color(0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments)); 
      }
      break;
    }

    case 5: {
      for (i = 0; i <= numOfSegments; i++) {
        stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments), 0); 
      }
      break;
    }

    case 6: {
      for (i = 0; i <= numOfSegments; i++) {
        r = (255 * i * ledFactor_div_numOfSegments);
        g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
        b = (200 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
        stripColor[i] = left_strip.Color(r, g, b); 
      }
      break;
    }

    case 7: {
      for (i = 0; i <= numOfSegments; i++) {
        b = (255 * i * ledFactor_div_numOfSegments);
        g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
        r = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
        stripColor[i] = left_strip.Color(r, g, b); 
      }
      break;
    }

    case 8: {
      for (i = 0; i <= numOfSegments; i++) {
        r = (255 * i * ledFactor_div_numOfSegments);
        b = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
        g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
        stripColor[i] = left_strip.Color(r, g, b); 
      }
      break;
    }

    case 9: {
      for (i = 0; i <= numOfSegments; i++) {
        b = (255 * i * ledFactor_div_numOfSegments);
        r = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments);
        g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 
        stripColor[i] = left_strip.Color(r, g, b); 
      }
      break;
    }

    case 10: 
      colorScheme11SpinValue = 0;
      
    case 11:     
    
    case 12: {
      p1 = (85 * numOfSegments / 255);
      p2 = (170 * numOfSegments / 255);
      int wheel;

      if (colorScheme == 12)
        colorSchemeFactor = colorScheme12Factor;        
      else
        colorSchemeFactor = 1;
            
      for (i = 0; i <= numOfSegments; i++) {  
        //wheel = int(float(i + colorScheme11SpinValue) / colorSchemeFactor) % numOfSegments;  // reverse wheel
        
        wheel = int(float(i - colorScheme11SpinValue) / colorSchemeFactor + numOfSegments) % numOfSegments;

        if (wheel < p1) {          
          wheel = map(wheel, 0, p1, 0, 255);
          r = (wheel * ledFactor);
          g = ((255 - wheel) * ledFactor);
          b = 0;
        } 
        else if (wheel < p2) {
          wheel = map(wheel, p1, p2, 0, 255);
          r = ((255 - wheel) * ledFactor);
          g = 0;
          b = (wheel * ledFactor);
        } 
        else {
          wheel = map(wheel, p2, numOfSegments, 0, 255);
          r = 0;
          g = (wheel * ledFactor);
          b = ((255 - wheel) * ledFactor);
        }        

        stripColor[i] = left_strip.Color(r, g, b); 
      }
      break;
    }
  }

  if (colorScheme >= 10)
    stripHoldColor = left_strip.Color(255 * ledFactor, 0, 0); // set to red for the color wheels
  else
    stripHoldColor = stripColor[numOfSegments];
    
  stripOverflowColor = stripHoldColor;   // left_strip.Color(min(255, 255 * ledFactor * 1.5), 0, 0);
}

void startupAnimation() {  
  for (j = 0; j < 2; j++) {
    for (i = 0; i <= numOfSegments; i++) {
      if (animType == 1)
        left_strip.setPixelColor(stripMiddle - (numOfSegments - i), stripColor[i]);
      else
        left_strip.setPixelColor(stripMiddle - i, stripColor[i]);
      
      if (stripsOn2Pins)
        right_strip.setPixelColor(i, stripColor[i]);
      else
        left_strip.setPixelColor(stripMiddle + i, stripColor[i]);

      left_strip.show();
      if (stripsOn2Pins)
        right_strip.show();  
      
      delay(startupAnimationDelay);
    }
    
    for (i = 0; i <= numOfSegments; i++) {
      if (animType == 1)
        left_strip.setPixelColor(stripMiddle - (numOfSegments - i), 0);
      else
        left_strip.setPixelColor(stripMiddle - i, 0);
        
      if (stripsOn2Pins)
        right_strip.setPixelColor(i, 0);
      else
        left_strip.setPixelColor(stripMiddle + i, 0);

      left_strip.show();
      if (stripsOn2Pins)
        right_strip.show();  
      
      delay(startupAnimationDelay);
    }
  }
}

void displayNumber (int number, int displayDelay) {
  left_strip.clear();
  if (stripsOn2Pins)
    right_strip.clear();

  number++; // @EB_DEBUG : display value 0 at led 1
  
  for (i = 0; i <= number; i++) {
    if (i % 5 == 0) 
      colorValue = stripMiddleColor;
    else
      colorValue = stripColor[0];

    left_strip.setPixelColor(middleOffset + i, colorValue);

    if (stripsOn2Pins)
      right_strip.setPixelColor(middleOffset + i, colorValue);
    else
      left_strip.setPixelColor(stripMiddle + middleOffset + i, colorValue);

    delay(45 - number * 3); // @EB_DEBUG
    
    left_strip.show();
    if (stripsOn2Pins)
      right_strip.show();  
  }

  if (pulsing) {
    left_strip.setPixelColor(middleOffset + maxDisplaySegments, stripMiddleColor);

    if (stripsOn2Pins)
      right_strip.setPixelColor(maxDisplaySegments, stripMiddleColor);
    else
      left_strip.setPixelColor(stripMiddle + maxDisplaySegments, stripMiddleColor);

    left_strip.show();
    if (stripsOn2Pins)
      right_strip.show();  
  }

  delay(displayDelay);

  left_strip.clear();
  if (stripsOn2Pins)
    right_strip.clear();
}


//
// for debugging
//

#ifdef DEBUG_TEST_LEDS
  void displayTest() {
    for (i = 0; i <= numOfSegments; i++) {
      left_strip.setPixelColor(stripMiddle - i, stripColor[i]);

      if (stripsOn2Pins)
        right_strip.setPixelColor(i, stripColor[i]);
      else
        left_strip.setPixelColor(stripMiddle + i, stripColor[i]);

      left_strip.show();
      if (stripsOn2Pins)
        right_strip.show();  

      delay(50);
    }
    delay(5000);
  
    for (i = 0; i <= numOfSegments; i++) {
      left_strip.setPixelColor(stripMiddle - i, 0);

      if (stripsOn2Pins)
        right_strip.setPixelColor(i, 0);
      else
        left_strip.setPixelColor(stripMiddle + i, 0);

      left_strip.show();
      if (stripsOn2Pins)
        right_strip.show();  
    }
  }
  
  void serialDisplayRGB(int r, int g, int b) {
    Serial.print(i);
    Serial.print(" ");
    Serial.print(r);
    Serial.print(" ");
    Serial.print(g);
    Serial.print(" ");
    Serial.println(b);
  }
#endif

Documentation

Schematic

...

Schematic.jpg

Comments

Only logged in users can leave comments

mircemk

0 Followers

•

0 Projects

Intro

Trademarks & CopyrightsWhistleblowingDigital Services ActTerms of ServicePrivacy PolicySecurityCookie Settings

Report content