Components and supplies
1
Arduino Nano R3
1
Jumper wires (generic)
1
Resistor 10k ohm
2
NeoPixel Ring: WS2812 5050 RGB LED
1
Button
1
Breadboard (generic)
2
Rotary potentiometer (generic)
1
Capacitor 1 mF 6.3V
1
Resistor 470 ohm
Apps and platforms
1
Arduino IDE
Project description
Code
20180202 VU meter update
arduino
Updated code with a lot of changes. Note: use the updated diagram, there are some changes in pin connections - multiple color schemes - option to connect 2 strip or rings on 2 output pins of the Arduino (the previous code used 1) - option for pulsing and spinning - option for logarithmic audio response
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 18// 19// include the NeoPixel library: 20// 21 22#include <Adafruit_NeoPixel.h> 23 24// 25// debugging settings 26// 27//#define DEBUG // debug: enable serial.print 28//#define DEBUG_NO_PEAK_SWITCH // debug: no peak switch connected @EB 29//#define DEBUG_TEST_LEDS // debug: display each led (color) slowly at startup 30//#define DEBUG_PRINT_LOOP_TIME // debug: serial.print the looptime in ms 31//#define DEBUG_PRINT_ANALOGVALUES // debug: serial.print analog input values 32//#define DEBUG_NO_PEAKS // debug: display no peaks, ignoring other settings 33//#define DEBUG_PEAKS // debug: display peaks, ignoring other settings 34 35// 36// uncomment to average the input levels to the number defined by averageNumOfReadings. increasing the value will make the script less responsive 37// 38//#define averageReadings // average input levels or not 39//#define averageNumOfReadings 3 // num of readings for averaging 40 41// 42// uncomment to map the linear audio input to non-linear response 43// 44//#define nonLinearSinAudio // uncomment to map the linear audio input signal to a non-linear, reverse audio-taper response (sin wave) 45//#define nonLinearReverseSinAudio // uncomment to map the linear audio input signal to a non-linear, audio-taper response (reverse sin wave) 46#define nonLinearLogAudio // uncomment to map the linear audio input signal to a log response 47//#define nonLinearAvr2 // uncomment to average the original input with the non-linear response 48 49// 50// overflow settings 51// 52//#define displayOverflow // display overflow or not 53//#define compressOverflowPeaks // compress overflow peaks or not 54//#define compressOverflowNumOfTimes 2 // num of times to apply the compressOverflowFactor 55//float compressOverflowFactor = .05; // factor for compression 56 57// 58// uncomment when using high level (non-consumer) inputs 59// 60//#define highLevelInput // @EB define for high level inputs 61 62// 63// uncomment the definition for the connected strip or ring(s) @EB 64// 65 66//#define led_matrix_40 67//#define led_ring_60 68//#define led_ring_60_ps 69#define led_rhombus_160_ps 70//#define led_strip_60 71//#define led_strip_60_qr 72//#define led_strip_30 73//#define led_2_rings_24 74//#define led_2_rings_30 75//#define led_strip_200 76//#define led_strip_144 77//#define led_2_strip_63 78//#define led_2_strip_63_qr 79 80// 81// important setting: using potentiometer sensor values or not 82// This setting has to be set right or the script will not work correctly: 83// - set to true if using potentiometers 84// - set to false if not using potentiometers 85// 86 87const int useSensorValues = true; // @EB 88 89// 90// setup pins 91// 92 93int leftPin = A0, rightPin = A1; // left audio in on analog 0, right on analog 1 94int brightnessPin = A4, sensitivityPin = A5; // potentiometers for brightness and sensitivity on analog 4 and 5 95int leftStripPin = 5; // DIN of left led strip on digital pin 5 96int rightStripPin = 6; // DIN of right led strip on digital pin 6 97int showPeaksPin = 7; // switch to toggle peaks on or off on digital pin 7 (7, 9 for box version) 98int showPeaksMomentarySwitch = false; // set false for an on/off toggle switch 99int reverseShowPeaks = true; // reverses the on/off setting in case you made a wiring mistake ;-) @EB 100int selectButton1Pin = 8; // push button for changing settings on digital pin 8 101int useSelectButton1 = true; // set to false if no push button1 for selecting the color scheme is connected @EB 102int selectButton2Pin = 9; // push button for changing settings on digital pin 9 103int useSelectButton2 = true; // set to false if no push button2 is connected @EB 104 105// 106// setup variables for the number of leds and led strip or 2 rings 107// 108 109#if defined (led_matrix_40) 110 //settings for a 40 led matrix 111 112 int stripNumOfLeds = 40; // the total number of leds 113 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 114 uint32_t stripColor[21]; // half of the number of leds + 1 115 int displayMiddleLed = false; // display the middle led (blue). set to true for one strip, false for two strips or rings 116 int splitStrip = true; // set to true when using 2 strips or rings, false for one strip 117 int middleOffset = 0; // offset for the middle led when using one strip 118 int startupAnimationDelay = 6; // delay for the startup animation 119 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 120 int swapLeftRight = false; // swap the left and right input values or not 121 122 int dropDelay = 5; // hold time before dropping the leds 123 float dropFactor = .94; // value for dropping the leds 124 125 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (when droppingPeak is false) 126 int peakTimeFirstDropDelay = 150; // peak hold time when dropping the first peak 127 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 128 float peakDropFactor = .94; // value for dropping the peaks 129 int droppingPeakFade = false; // display the dropping peak fading to black or not 130 131 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 132 int bouncingPeaksNumOfLedsMin = 3; // how many leds to bounce up (min) when using dynamicBouncingPeaks 133 int bouncingPeakDelay = 6; // delay between peak bounce updates 134 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 135 136#elif defined (led_ring_60) 137 //settings for a 60 led ring 138 139 int stripNumOfLeds = 60; // the total number of leds 140 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 141 uint32_t stripColor[31]; // half of the number of leds + 1 142 int displayMiddleLed = false; // display the middle led (blue). set to true for one strip, false for two strips or rings 143 int splitStrip = true; // set to true when using 2 strips or rings, false for one strip 144 int middleOffset = 0; // offset for the middle led when using one strip 145 int startupAnimationDelay = 6; // delay for the startup animation 146 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 147 int swapLeftRight = false; // swap the left and right input values or not 148 149 int dropDelay = 5; // hold time before dropping the leds 150 float dropFactor = .94; // value for dropping the leds 151 152 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (when droppingPeak is false) 153 int peakTimeFirstDropDelay = 70; // peak hold time when dropping the first peak 154 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 155 float peakDropFactor = .94; // value for dropping the peaks 156 int droppingPeakFade = false; // display the dropping peak fading to black or not 157 158 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 159 int bouncingPeaksNumOfLedsMin = 3; // how many leds to bounce up (min) when using dynamicBouncingPeaks 160 int bouncingPeakDelay = 4; // delay between peak bounce updates 161 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 162 163#elif defined (led_ring_60_ps) 164 //settings for a 60 led ring - pulsating and spinning settings 165 166 int stripNumOfLeds = 60; // the total number of leds 167 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 168 uint32_t stripColor[31]; // half of the number of leds + 1 169 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 170 int splitStrip = true; // set to true when using 2 strips or rings, false for one strip 171 int middleOffset = 0; // offset for the middle led when using one strip 172 int startupAnimationDelay = 6; // delay for the startup animation 173 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 174 int swapLeftRight = false; // swap the left and right input values or not 175 176 int dropDelay = 5; // hold time before dropping the leds 177 float dropFactor = .93; // value for dropping the leds 178 179 int peakTimeNoDropDelay = 10; // peak hold time when not dropping the peaks (when droppingPeak is false) 180 int peakTimeFirstDropDelay = 10; // peak hold time when dropping the first peak 181 int peakTimeDropDelay = 6; // peak hold time when dropping the rest of the peaks 182 float peakDropFactor = .92; // value for dropping the peaks 183 int droppingPeakFade = false; // display the dropping peak fading to black or not 184 185 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 186 int bouncingPeaksNumOfLedsMin = 3; // how many leds to bounce up (min) when using dynamicBouncingPeaks 187 int bouncingPeakDelay = 4; // delay between peak bounce updates 188 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 189 190#elif defined (led_rhombus_160_ps) 191 //settings for a 160 led rhombus - pulsating and spinning settings 192 193 int stripNumOfLeds = 160; // the total number of leds 194 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 195 uint32_t stripColor[81]; // half of the number of leds + 1 196 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 197 int splitStrip = true; // set to true when using 2 strips or rings, false for one strip 198 int middleOffset = 0; // offset for the middle led when using one strip 199 int startupAnimationDelay = 0; // delay for the startup animation 200 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 201 int swapLeftRight = false; // swap the left and right input values or not 202 203 int dropDelay = 4; // hold time before dropping the leds 204 float dropFactor = .92; // value for dropping the leds 205 206 int peakTimeNoDropDelay = 150; // peak hold time when not dropping the peaks (when droppingPeak is false) 207 int peakTimeFirstDropDelay = 70; // peak hold time when dropping the first peak 208 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 209 float peakDropFactor = .94; // value for dropping the peaks 210 int droppingPeakFade = false; // display the dropping peak fading to black or not 211 212 int bouncingPeaksNumOfLeds = 10; // how many leds to bounce up (max) 213 int bouncingPeaksNumOfLedsMin = 5; // how many leds to bounce up (min) when using dynamicBouncingPeaks 214 int bouncingPeakDelay = 4; // delay between peak bounce updates 215 int bouncingPeakCounterInc = 6; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 216 217#elif defined (led_strip_60) 218 //settings for a 60 led strip 219 220 int stripNumOfLeds = 60; // the total number of leds 221 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 222 uint32_t stripColor[31]; // half of the number of leds + 1 223 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 224 int splitStrip = false; // set to true when using 2 strips or rings, false for one strip 225 int middleOffset = 1; // offset for the middle led when using one strip 226 int startupAnimationDelay = 6; // delay for the startup animation 227 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 228 int swapLeftRight = false; // swap the left and right input values or not 229 230 int dropDelay = 5; // hold time before dropping the leds 231 float dropFactor = .94; // value for dropping the leds 232 233 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (when droppingPeak is false) 234 int peakTimeFirstDropDelay = 70; // peak hold time when dropping the first peak 235 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 236 float peakDropFactor = .94; // value for dropping the peaks 237 int droppingPeakFade = false; // display the dropping peak fading to black or not 238 239 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 240 int bouncingPeaksNumOfLedsMin = 3; // how many leds to bounce up (min) when using dynamicBouncingPeaks 241 int bouncingPeakDelay = 4; // delay between peak bounce updates 242 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 243 244#elif defined (led_strip_60_qr) 245 //settings for a 60 led strip - quick response 246 247 int stripNumOfLeds = 60; // the total number of leds 248 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 249 uint32_t stripColor[31]; // half of the number of leds + 1 250 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 251 int splitStrip = false; // set to true when using 2 strips or rings, false for one strip 252 int middleOffset = 1; // offset for the middle led when using one strip 253 int startupAnimationDelay = 6; // delay for the startup animation 254 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 255 int swapLeftRight = false; // swap the left and right input values or not 256 257 int dropDelay = 4; // hold time before dropping the leds 258 float dropFactor = .92; // value for dropping the leds 259 260 int peakTimeNoDropDelay = 0; // peak hold time when not dropping the peaks (when droppingPeak is false) 261 int peakTimeFirstDropDelay = 0; // peak hold time when dropping the first peak 262 int peakTimeDropDelay = 0; // peak hold time when dropping the rest of the peaks 263 float peakDropFactor = 1; // value for dropping the peaks 264 int droppingPeakFade = false; // display the dropping peak fading to black or not 265 266 int bouncingPeaksNumOfLeds = 0; // how many leds to bounce up (max) 267 int bouncingPeaksNumOfLedsMin = 0; // how many leds to bounce up (min) when using dynamicBouncingPeaks 268 int bouncingPeakDelay = 0; // delay between peak bounce updates 269 int bouncingPeakCounterInc = 180; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 270 271#elif defined (led_strip_30) 272 //settings for a 30 led strip 273 274 int stripNumOfLeds = 30; // the total number of leds 275 int stripsOn2Pins = false; // set to true if the LED strips or rings are connected to 2 input pins 276 uint32_t stripColor[16]; // half of the number of leds + 1 277 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 278 int splitStrip = false; // set to true when using 2 strips or rings, false for one strip 279 int middleOffset = 1; // offset for the middle led when using one strip 280 int startupAnimationDelay = 10; // delay for the startup animation 281 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 282 int swapLeftRight = false; // swap the left and right input values or not 283 284 int dropDelay = 10; // hold time before dropping the leds 285 float dropFactor = .9; // value for dropping the leds 286 287 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (set droppingPeak true or false) 288 int peakTimeFirstDropDelay = 150; // peak hold time when dropping the first peak 289 int peakTimeDropDelay = 15; // peak hold time when dropping the rest of the peaks 290 float peakDropFactor = .94; // value for dropping the peaks 291 int droppingPeakFade = false; // display the dropping peak fading to black or not 292 293 int bouncingPeaksNumOfLeds = 4; // how many leds to bounce up (max) 294 int bouncingPeaksNumOfLedsMin = 2; // how many leds to bounce up (min) when using dynamicBouncingPeaks 295 int bouncingPeakDelay = 4; // delay between peak bounce updates 296 int bouncingPeakCounterInc = 9; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 297 298#elif defined (led_2_rings_24) 299 //settings for 2 24 led rings 300 301 int stripNumOfLeds = 48; 302 int stripsOn2Pins = false; 303 uint32_t stripColor[25]; 304 int displayMiddleLed = false; 305 int splitStrip = true; 306 int middleOffset = 0; 307 int startupAnimationDelay = 5; 308 int orangeLimitAmount = 0; 309 int swapLeftRight = false; 310 311 int dropDelay = 2; 312 float dropFactor = .96; 313 314 int peakTimeNoDropDelay = 250; 315 int peakTimeFirstDropDelay = 100; 316 int peakTimeDropDelay = 10; 317 float peakDropFactor = .94; 318 int droppingPeakFade = false; 319 320 int bouncingPeaksNumOfLeds = 4; 321 int bouncingPeaksNumOfLedsMin = 2; 322 int bouncingPeakDelay = 4; 323 int bouncingPeakCounterInc = 9; 324 325#elif defined(led_2_rings_30) 326 //settings for 2 30 led rings 327 328 int stripNumOfLeds = 60; 329 int stripsOn2Pins = false; 330 uint32_t stripColor[31]; 331 int displayMiddleLed = false; 332 int splitStrip = true; 333 int middleOffset = 0; 334 int startupAnimationDelay = 5; 335 int orangeLimitAmount = 0; 336 int swapLeftRight = false; 337 338 int dropDelay = 2; 339 float dropFactor = .96; 340 341 int peakTimeNoDropDelay = 250; 342 int peakTimeFirstDropDelay = 100; 343 int peakTimeDropDelay = 10; 344 float peakDropFactor = .94; 345 int droppingPeakFade = false; 346 347 int bouncingPeaksNumOfLeds = 4; 348 int bouncingPeaksNumOfLedsMin = 2; 349 int bouncingPeakDelay = 4; 350 int bouncingPeakCounterInc = 9; 351 352#elif defined (led_strip_200) 353 //settings for a 200 led strip 354 355 int stripNumOfLeds = 200; 356 int stripsOn2Pins = false; 357 uint32_t stripColor[101]; 358 int displayMiddleLed = false; 359 int splitStrip = true; 360 int middleOffset = 0; 361 int startupAnimationDelay = 1; 362 int orangeLimitAmount = 0; 363 int swapLeftRight = false; 364 365 int dropDelay = 10; 366 float dropFactor = .96; 367 368 int peakTimeNoDropDelay = 250; 369 int peakTimeFirstDropDelay = 100; 370 int peakTimeDropDelay = 30; 371 float peakDropFactor = .99; 372 int droppingPeakFade = false; 373 374 int bouncingPeaksNumOfLeds = 8; 375 int bouncingPeaksNumOfLedsMin = 4; 376 int bouncingPeakDelay = 4; 377 int bouncingPeakCounterInc = 9; 378 379#elif defined (led_strip_144) 380 //settings for a 144 led strip 381 382 int stripNumOfLeds = 145; 383 int stripsOn2Pins = false; 384 uint32_t stripColor[73]; 385 int displayMiddleLed = true; 386 int splitStrip = false; 387 int middleOffset = 1; 388 int startupAnimationDelay = 1; 389 int orangeLimitAmount = 0; 390 int swapLeftRight = false; 391 392 int dropDelay = 4; 393 float dropFactor = .92; 394 395 int peakTimeNoDropDelay = 250; 396 int peakTimeFirstDropDelay = 100; 397 int peakTimeDropDelay = 5; 398 float peakDropFactor = .94; 399 int droppingPeakFade = false; 400 401 int bouncingPeaksNumOfLeds = 10; 402 int bouncingPeaksNumOfLedsMin = 4; 403 int bouncingPeakDelay = 2; 404 int bouncingPeakCounterInc = 10; 405 406#elif defined (led_2_strip_63) 407 //settings for 2 63 led strips 408 409 int stripNumOfLeds = 63; 410 int stripsOn2Pins = true; 411 uint32_t stripColor[64]; 412 int displayMiddleLed = true; 413 int splitStrip = true; 414 int middleOffset = 0; 415 int startupAnimationDelay = 1; 416 int orangeLimitAmount = 0; 417 int swapLeftRight = false; 418 419 int dropDelay = 5; 420 float dropFactor = .94; 421 422 int peakTimeNoDropDelay = 250; 423 int peakTimeFirstDropDelay = 70; 424 int peakTimeDropDelay = 7; 425 float peakDropFactor = .94; 426 int droppingPeakFade = false; 427 428 int bouncingPeaksNumOfLeds = 12; 429 int bouncingPeaksNumOfLedsMin = 4; 430 int bouncingPeakDelay = 4; 431 int bouncingPeakCounterInc = 10; 432 433#elif defined (led_2_strip_63_qr) 434 //settings for 2 63 led strips - quick response 435 436 int stripNumOfLeds = 63; 437 int stripsOn2Pins = true; 438 uint32_t stripColor[64]; 439 int displayMiddleLed = false; 440 int splitStrip = true; 441 int middleOffset = 0; 442 int startupAnimationDelay = 1; 443 int orangeLimitAmount = 0; 444 int swapLeftRight = false; 445 446 int dropDelay = 4; 447 float dropFactor = .92; 448 449 int peakTimeNoDropDelay = 200; 450 int peakTimeFirstDropDelay = 60; 451 int peakTimeDropDelay = 6; 452 float peakDropFactor = .92; 453 int droppingPeakFade = false; 454 455 int bouncingPeaksNumOfLeds = 12; 456 int bouncingPeaksNumOfLedsMin = 4; 457 int bouncingPeakDelay = 3; 458 int bouncingPeakCounterInc = 10; 459#endif 460 461// 462// setup other user variables 463// 464 465// basic settings 466int pulsing = true; // pulsing will display from the middle of each strip or ring @EB 467 468int spinCircle = true; // spin the animation. will not work with stripsOn2Pins @EB 469 470int animType = 0; // startup animation selection (1 looks nice for 1 ring) @EB 471int colorScheme = 10; // 0: green-red, 1: blue-green, 2: blue-red, 3: red-blue, 4: green-blue, 5: red-green, 6: blue-white-red 472 // 7: red-white-blue, 8: green-white-red, 9: green-white-blue, 10: color wheel, 11: spinning color wheel, 473 // 12: as 11 but spread with factor colorScheme12Factor @EB 474int maxColorScheme = 12; // used for looping through the color schemes with the switch button 475int colorScheme11SpinDelay = stripNumOfLeds / 4 ; // delay for spinning scheme 11 476int colorScheme12Factor = 3; // wheel spread factor for scheme 12 @EB 477 478int minValue = 10; // min analog input value 479int sensitivityValue = 110; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) 480 481#ifdef highLevelInput 482 int maxValue = 700; // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high 483 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 484#else 485 int maxValue = 300; // max analog input value (0-1023 equals 0-5V). try 300 for low level input, 700 for high 486 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 487#endif 488 489int ledBrightness = 30; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) 490int sensorDeviationBrightness = 3; // eliminate fluctuating values 491int overflowDelay = 10; // overflow hold time 492 493// peak settings @EB 494int displayPeaks = false; // value will be set by the switch if useSensorValues = true 495int displayTopAsPeak = true; // always display the top LED in peak color 496int droppingPeak = true; // display dropping peaks or not. note: displayPeaks has to be true 497int bouncingPeaks = false; // display bouncing peaks or not. note: displayPeaks has to be true 498int dynamicBouncingPeaks = false; // bounce less with lower peaks. note: bouncingPeaks has to be true 499 500// 501// initialize other variables 502// 503 504int numOfSegments, halfNumOfSegments, stripMiddle, maxDisplaySegments; 505float sensitivityFactor; 506float nonLinearResponseFactor; 507 508int brightnessValue, prevBrightnessValue; 509float ledFactor, ledFactor_div_numOfSegments; 510 511uint32_t stripMiddleColor, stripOverflowColor, stripHoldColor; 512uint32_t colorValue; 513 514int leftValue = 0, rightValue = 0, maxReadValue = 0; 515int leftValueN = 0, rightValueN = 0; 516int leftAnalogValue = 0, rightAnalogValue = 0; 517float log10MaxDisplaySegments; 518 519int prevLeftValue = 0, prevRightValue = 0; 520int prevLeftAnalogValue = 0, prevRightAnalogValue = 0; 521 522int selectButton1PinState = 0, prevSelectButton1PinState = 0; 523int selectButton2PinState = 0, prevSelectButton2PinState = 0; 524 525int selectButton1PinSetting = colorScheme; 526int selectButton2PinSetting = 0; 527 528int i, j; 529int dropLeft, dropRight; 530int leftDropTime, rightDropTime; 531 532int leftPeak = 0, rightPeak = 0; 533int leftPeakTime = 0, rightPeakTime = 0; 534int leftFirstPeak = true, rightFirstPeak = true; 535int showPeaksPinSetting, prevShowPeaksPinSetting; 536 537int stripPulseMiddle = 0; 538int halfLeftValue, halfRightValue, halfPrevLeftValue, halfPrevRightValue; 539 540int leftPeakBouncing = false, rightPeakBouncing = false; 541int leftPeakBounce = 0, rightPeakBounce = 0; 542int prevLeftPeakBounce = 0, prevRightPeakBounce = 0; 543int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0; 544int leftPeakBounceDelayCounter = 0, rightPeakBounceDelayCounter = 0; 545int leftBouncingPeaksNumOfLeds = 0, rightBouncingPeaksNumOfLeds = 0; 546float bounceFactor; 547 548int colorScheme11SpinValue = 0, colorScheme11SpinDelayValue = 0; 549int colorSchemeFactor = 1; 550long selectButton1Timer; 551 552int spinDelayCounter = 0, spinCounter = 0, spinTurnsCounter = 0, spinTurnsMax = 0, spinTurnsDelay = 0, spinTurnsDelayMax = 0; 553int spinCounterInc = 1; 554int spinDelay = 0; 555// 556// initialize the strip or rings 557// 558 559Adafruit_NeoPixel left_strip = Adafruit_NeoPixel(stripNumOfLeds, leftStripPin, NEO_GRB + NEO_KHZ800); 560Adafruit_NeoPixel right_strip = Adafruit_NeoPixel(stripNumOfLeds, rightStripPin, NEO_GRB + NEO_KHZ800); 561 562// 563// setup 564// 565 566void setup() { 567 #ifdef DEBUG 568 Serial.begin(9600); 569 #endif 570 571 randomSeed(analogRead(2)); 572 573 if (stripsOn2Pins) { 574 numOfSegments = stripNumOfLeds; 575 maxDisplaySegments = numOfSegments - 1; 576 577 stripMiddle = stripNumOfLeds; 578 stripPulseMiddle = stripMiddle / 2; 579 spinCircle = false; 580 } 581 else { 582 numOfSegments = stripNumOfLeds / 2; 583 stripMiddle = stripNumOfLeds / 2; 584 maxDisplaySegments = stripMiddle - 1; 585 586 stripPulseMiddle = stripMiddle / 2; 587 } 588 589 halfNumOfSegments = numOfSegments / 2; 590 bounceFactor = (float) bouncingPeaksNumOfLeds / (maxDisplaySegments - bouncingPeaksNumOfLeds); 591 nonLinearResponseFactor = 90 / (float) maxDisplaySegments; 592 log10MaxDisplaySegments = log10(maxDisplaySegments); 593 594 pinMode(showPeaksPin, INPUT); 595 596 if (useSelectButton1) 597 pinMode(selectButton1Pin, INPUT); 598 599 left_strip.begin(); 600 if (stripsOn2Pins) 601 right_strip.begin(); 602 603 if (useSensorValues) { 604 readSensorValues(); 605 setInitialDisplayPeaks(); 606 } 607 else { 608 setStripColors(); 609 setSensitivityFactor(); 610 } 611 612 #ifdef DEBUG_TEST_LEDS 613 displayTest(); 614 #endif 615 616 startupAnimation(); 617} 618 619// 620// main loop 621// 622 623void loop() { 624 #ifdef DEBUG_PRINT_LOOP_TIME 625 long time = millis(); 626 #endif 627 628 629 if (useSensorValues) 630 readSensorValues(); 631 632 readValues(); 633 634 #if defined (DEBUG_NO_PEAKS) 635 displayPeaks = false; 636 #endif 637 638 #if defined (DEBUG_PEAKS) 639 displayPeaks = true; 640 #endif 641 642 if (pulsing) { 643 drawPulsingValues(); 644 } 645 else { 646 drawValues(); 647 if (displayPeaks) { 648 getPeaks(); 649 drawPeaks(); 650 } 651 } 652 653 left_strip.show(); 654 if (stripsOn2Pins) 655 right_strip.show(); 656 657 storePrevValues(); 658 659 checkSpinCircle(); 660 661 #ifdef DEBUG_PRINT_LOOP_TIME 662 time = millis() - time; 663 Serial.println(time); 664 #endif 665} 666 667// 668// functions 669// 670 671void setInitialDisplayPeaks() { 672 #if !defined (DEBUG_NO_PEAK_SWITCH) 673 showPeaksPinSetting = digitalRead(showPeaksPin); 674 675 if (showPeaksPinSetting == HIGH) 676 displayPeaks = false; 677 #endif 678 679 if (reverseShowPeaks) { 680 if (!displayPeaks) 681 displayPeaks = true; 682 else 683 displayPeaks = false; 684 } 685 686 prevShowPeaksPinSetting = showPeaksPinSetting; 687} 688 689void readSensorValues() { 690 // 691 // peaks pin 692 // 693 694 #if !defined (DEBUG_NO_PEAK_SWITCH) 695 showPeaksPinSetting = digitalRead(showPeaksPin); 696 697 if (showPeaksMomentarySwitch) { 698 if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) { 699 if (displayPeaks == true) { 700 displayPeaks = false; 701 clearLeftPeak(); 702 clearRightPeak(); 703 if (showPeaksMomentarySwitch) 704 while (digitalRead(showPeaksPin) == LOW) {} 705 } 706 else { 707 displayPeaks = true; 708 } 709 } 710 } 711 else { 712 if (reverseShowPeaks) { 713 if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) 714 displayPeaks = true; 715 else if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) { 716 displayPeaks = false; 717 clearLeftPeak(); 718 clearRightPeak(); 719 } 720 } 721 else { 722 if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) 723 displayPeaks = true; 724 else if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) { 725 displayPeaks = false; 726 clearLeftPeak(); 727 clearRightPeak(); 728 } 729 } 730 } 731 if (pulsing) { 732 if (displayPeaks) 733 displayTopAsPeak = true; 734 else 735 displayTopAsPeak = false; 736 } 737 738 prevShowPeaksPinSetting = showPeaksPinSetting; 739 #endif 740 741 742 // 743 // selectButtonPin 1 and 2 744 // 745 if (useSelectButton1) { 746 selectButton1PinState = digitalRead(selectButton1Pin); 747 748 if (selectButton1PinState == HIGH && prevSelectButton1PinState == LOW) 749 selectButton1Timer = millis(); 750 751 if (selectButton1PinState == HIGH && prevSelectButton1PinState == HIGH) { 752 if ((millis() - selectButton1Timer) > 1000) { 753 pulsing = !pulsing; 754 setStripColors(); 755 displayNumber(colorScheme, 250); 756 757 while (digitalRead(selectButton1Pin) == HIGH) {} 758 selectButton1PinState = LOW; 759 clearValues(); 760 } 761 } 762 else if (selectButton1PinState == LOW && prevSelectButton1PinState == HIGH) { 763 selectButton1PinSetting++; 764 if (selectButton1PinSetting > maxColorScheme) { 765 selectButton1PinSetting = 0; 766 } 767 colorScheme = selectButton1PinSetting; 768 769 if (colorScheme == 12) 770 colorScheme11SpinValue = (colorScheme11SpinValue * colorScheme12Factor); 771 772 setStripColors(); 773 displayNumber(colorScheme, 250); 774 } 775 prevSelectButton1PinState = selectButton1PinState; 776 } 777 778 if (useSelectButton2) { 779 selectButton2PinState = digitalRead(selectButton2Pin); 780 781 if (selectButton2PinState == HIGH && prevSelectButton2PinState == LOW) { 782 selectButton2PinSetting++; 783 784 switch(selectButton2PinSetting) { 785 case 0: 786 case 3: { 787 pulsing = false; 788 spinCircle = false; 789 selectButton2PinSetting = 0; 790 break; 791 } 792 case 1: { 793 pulsing = true; 794 spinCircle= false; 795 break; 796 } 797 case 2: { 798 pulsing = true; 799 spinCircle = true; 800 break; 801 } 802 } 803 804 setStripColors(); 805 displayNumber(colorScheme, 250); 806 } 807 808 prevSelectButton2PinState = selectButton2PinState; 809 } 810 811 // 812 // brightness 813 // 814 brightnessValue = analogRead(brightnessPin); 815 brightnessValue = map(brightnessValue, 0, 1023, 0, 255); 816 817 if (abs(brightnessValue - prevBrightnessValue) > sensorDeviationBrightness) { 818 ledBrightness = brightnessValue; 819 setStripColors(); 820 prevBrightnessValue = brightnessValue; 821 } 822 823 // 824 // colorscheme 11 spinning wheel 825 // 826 827 if (colorScheme == 11 || colorScheme == 12) { 828 colorScheme11SpinDelayValue++; 829 if (colorScheme11SpinDelayValue == colorScheme11SpinDelay) { 830 colorScheme11SpinDelayValue = 0; 831 colorScheme11SpinValue++; 832 if (colorScheme11SpinValue > maxDisplaySegments * colorSchemeFactor) 833 colorScheme11SpinValue = 0; 834 setStripColors(); 835 } 836 } 837 838 // 839 // sensitivity 840 // 841 sensitivityValue = analogRead(sensitivityPin); 842 sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255); 843 setSensitivityFactor(); 844} 845 846void setSensitivityFactor() { 847 //sensitivityValue_div_numOfSegments = sensitivityValue / numOfSegments; 848 sensitivityFactor = ((float) sensitivityValue / 255 * (float) maxSensitivity / 255); 849} 850 851void readValues() { 852 #ifdef averageReadings 853 leftAnalogValue = 0; 854 rightAnalogValue = 0; 855 856 for (i = 0; i <= averageNumOfReadings; i++) { 857 leftAnalogValue += analogRead(leftPin); 858 rightAnalogValue += analogRead(rightPin); 859 } 860 861 leftAnalogValue /= averageNumOfReadings; 862 rightAnalogValue /= averageNumOfReadings; 863 864 #else 865 leftAnalogValue = analogRead(leftPin); 866 rightAnalogValue = analogRead(rightPin); 867 #endif 868 869 if (swapLeftRight) { 870 int tempValue = leftAnalogValue; 871 leftAnalogValue = rightAnalogValue; 872 rightAnalogValue = tempValue; 873 } 874 875 if (leftAnalogValue < prevLeftAnalogValue) { 876 leftDropTime++; 877 if (leftDropTime > dropDelay) { 878 leftAnalogValue = prevLeftAnalogValue * dropFactor; 879 leftDropTime = 0; 880 } 881 else 882 leftAnalogValue = prevLeftAnalogValue; 883 } 884 885 if (rightAnalogValue < prevRightAnalogValue) { 886 rightDropTime++; 887 if (rightDropTime > dropDelay) { 888 rightAnalogValue = prevRightAnalogValue * dropFactor; 889 rightDropTime = 0; 890 } 891 else 892 rightAnalogValue = prevRightAnalogValue; 893 } 894 895 #ifdef DEBUG_PRINT_ANALOGVALUES 896 Serial.print(leftAnalogValue); 897 Serial.print(" "); 898 Serial.println(rightAnalogValue); 899 #endif 900 901 // map values 902 leftValue = map(leftAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 903 rightValue = map(rightAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 904 905 // if defined, convert to (reverse) non linear response 906 boolean flagNonLinear = false; 907 908 #if defined (nonLinearSinAudio) 909 flagNonLinear = true; 910 leftValueN = ((sin(((leftValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments); 911 rightValueN = ((sin(((rightValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments); 912 913 #elif defined (nonLinearReverseSinAudio) 914 flagNonLinear = true; 915 leftValueN = ((sin(((leftValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments); 916 rightValueN = ((sin(((rightValue * nonLinearResponseFactor)) * 0.0174533)) * maxDisplaySegments); 917 918 #elif defined (nonLinearLogAudio) 919 flagNonLinear = true; 920 leftValueN = ((log10(leftValue + 1) / log10MaxDisplaySegments * maxDisplaySegments)); 921 rightValueN = ((log10(rightValue + 1) / log10MaxDisplaySegments * maxDisplaySegments)); 922 923 #endif 924 925 if (flagNonLinear == true) { 926 #if defined (nonLinearAvr2) 927 leftValue = (leftValue + leftValueN) / 2; 928 rightValue = (rightValue + rightValueN) / 2; 929 #else 930 leftValue = leftValueN; 931 rightValue = rightValueN; 932 #endif 933 } 934 935// @EB_DEBUG 936 937 #ifdef displayOverflow 938 #ifdef compressOverflowPeaks 939 for (i = 1; i <= compressOverflowNumOfTimes; i++) { 940 if (leftValue > maxDisplaySegments) { 941// Serial.print(i); 942// Serial.print(" "); 943// Serial.print(leftValue); 944// Serial.print(" "); 945 leftValue = leftValue - leftValue * compressOverflowFactor * i; 946// Serial.print(leftValue); 947// Serial.print(" "); 948// Serial.println(maxDisplaySegments); 949 } 950 } 951 #endif 952 #endif 953 954 if (leftValue > maxDisplaySegments) { 955 leftValue = maxDisplaySegments; 956 #ifdef displayOverflow 957 drawOverflow(); 958 #endif 959 } 960 961 #ifdef displayOverflow 962 #ifdef compressOverflowPeaks 963 if (rightValue > maxDisplaySegments) 964 rightValue = rightValue - rightValue * compressOverflowFactor; 965 #endif 966 #endif 967 968 if (rightValue > maxDisplaySegments) { 969 rightValue = maxDisplaySegments; 970 #ifdef displayOverflow 971 drawOverflow(); 972 #endif 973 } 974} 975 976void storePrevValues() { 977 prevLeftAnalogValue = leftAnalogValue; 978 prevRightAnalogValue = rightAnalogValue; 979 980 prevLeftValue = leftValue; 981 prevRightValue = rightValue; 982} 983 984void getPeaks() { 985 if (leftValue > leftPeak) { 986 if (dynamicBouncingPeaks || prevLeftPeakBounce > 0) 987 clearLeftBouncePeak(); 988 989 leftPeak = leftValue; 990 leftPeakTime = 0; 991 leftFirstPeak = true; 992 993 if (bouncingPeaks) { 994 leftPeakBouncing = true; 995 leftPeakBounceCounter = 0; 996 leftPeakBounceDelayCounter = 0; 997 998 if (dynamicBouncingPeaks) 999 leftBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (leftPeak * bounceFactor)); 1000 else 1001 leftBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds; 1002 } 1003 } 1004 else { 1005 leftPeakTime++; 1006 if (droppingPeak) { 1007 if (leftFirstPeak) { 1008 if (leftPeakTime > peakTimeFirstDropDelay) { 1009 clearLeftPeak(); 1010 leftFirstPeak = false; 1011 } 1012 } 1013 else { 1014 if (leftPeakTime > peakTimeDropDelay) { 1015 clearLeftPeak(); 1016 } 1017 } 1018 } 1019 else { 1020 if (leftPeakTime > peakTimeNoDropDelay) { 1021 clearLeftPeak(); 1022 } 1023 } 1024 } 1025 1026 if (leftPeakBouncing) { 1027 if (leftFirstPeak) { 1028 leftPeakBounceDelayCounter++; 1029 if (leftPeakBounceDelayCounter >= bouncingPeakDelay) { 1030 leftPeakBounceDelayCounter = 0; 1031 leftPeakBounceCounter += bouncingPeakCounterInc; 1032 if (leftPeakBounceCounter >= 180) { 1033 clearLeftBouncePeak(); 1034 clearLeftBounce(); 1035 } 1036 else { 1037 leftPeakBounce = min((sin(leftPeakBounceCounter * 0.0174533) * leftBouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak)); 1038 if (leftPeakBounce != prevLeftPeakBounce) { 1039 clearLeftBouncePeak(); 1040 } 1041 prevLeftPeakBounce = leftPeakBounce; 1042 } 1043 } 1044 } 1045 } 1046 1047 if (rightValue > rightPeak) { 1048 if (dynamicBouncingPeaks || prevRightPeakBounce > 0) 1049 clearRightBouncePeak(); 1050 1051 rightPeak = rightValue; 1052 rightPeakTime = 0; 1053 rightFirstPeak = true; 1054 1055 if (bouncingPeaks) { 1056 rightPeakBouncing = true; 1057 rightPeakBounceCounter = 0; 1058 rightPeakBounceDelayCounter = 0; 1059 1060 if (dynamicBouncingPeaks) 1061 rightBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (rightPeak * bounceFactor)); 1062 else 1063 rightBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds; 1064 } 1065 } 1066 else { 1067 rightPeakTime++; 1068 if (droppingPeak) { 1069 if (rightFirstPeak) { 1070 if (rightPeakTime > peakTimeFirstDropDelay) { 1071 clearRightPeak(); 1072 rightFirstPeak = false; 1073 } 1074 } 1075 else { 1076 if (rightPeakTime > peakTimeDropDelay) 1077 clearRightPeak(); 1078 } 1079 } 1080 else { 1081 if (rightPeakTime > peakTimeNoDropDelay) 1082 clearRightPeak(); 1083 } 1084 } 1085 1086 if (rightPeakBouncing) { 1087 if (rightFirstPeak) { 1088 rightPeakBounceDelayCounter++; 1089 if (rightPeakBounceDelayCounter >= bouncingPeakDelay) { 1090 rightPeakBounceDelayCounter = 0; 1091 rightPeakBounceCounter += bouncingPeakCounterInc; 1092 1093 if (rightPeakBounceCounter >= 180) { 1094 clearRightBouncePeak(); 1095 clearRightBounce(); 1096 } 1097 else { 1098 rightPeakBounce = min((sin(rightPeakBounceCounter * 0.0174533) * rightBouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak)); 1099 if (rightPeakBounce != prevRightPeakBounce) { 1100 clearRightBouncePeak(); 1101 } 1102 prevRightPeakBounce = rightPeakBounce; 1103 } 1104 } 1105 } 1106 } 1107} 1108 1109void checkSpinCircle () { 1110 if (spinCircle) { 1111 if (spinTurnsMax == 0) { 1112 spinTurnsMax = random(stripNumOfLeds / 4, stripNumOfLeds * 3); // spin at least a quarter turn, max 3 turns 1113 1114 if (random(10) > 4) 1115 spinCounterInc = -spinCounterInc; 1116 1117 spinTurnsDelayMax = random(100, 1000); // @EB_DEBUG 1118 1119 spinDelay = random(20, 75); // @EB_DEBUG 1120 } 1121 1122 if (spinTurnsCounter == spinTurnsMax) { 1123 spinTurnsDelay++; 1124 if (spinTurnsDelay == spinTurnsDelayMax) { 1125 spinTurnsDelay = 0; 1126 spinTurnsCounter = 0; 1127 spinTurnsMax = 0; 1128 } 1129 } 1130 else { 1131 spinDelayCounter++; 1132 1133 if (spinDelayCounter > spinDelay) { 1134 clearZeroAndPeaks(); 1135 1136 spinCounter += spinCounterInc; 1137 if (spinCounter > stripNumOfLeds) 1138 spinCounter = 0; 1139 else if (spinCounter < 0) 1140 spinCounter = stripNumOfLeds; 1141 1142 spinTurnsCounter++; 1143 spinDelayCounter = 0; 1144 } 1145 } 1146 } 1147} 1148 1149int getSpinCircleValue(int value) { 1150 if (!spinCircle) 1151 return value; 1152 else { 1153 int calcValue = value + spinCounter; 1154 if (calcValue >= stripNumOfLeds) 1155 calcValue -= stripNumOfLeds; 1156 return calcValue; 1157 } 1158} 1159 1160void drawValues() { 1161 if (splitStrip) { 1162 for (i = middleOffset; i < leftValue; i++) 1163 left_strip.setPixelColor(getSpinCircleValue(i), stripColor[i]); 1164 1165 if (!displayPeaks && displayTopAsPeak) 1166 left_strip.setPixelColor(getSpinCircleValue(leftValue), stripHoldColor); 1167 1168 for (i = prevLeftValue; i >= leftValue; i--) 1169 left_strip.setPixelColor(getSpinCircleValue(i), 0); 1170 1171 if (stripsOn2Pins) { 1172 for (i = middleOffset; i < rightValue; i++) 1173 right_strip.setPixelColor(i, stripColor[i]); 1174 1175 if (!displayPeaks && displayTopAsPeak) 1176 right_strip.setPixelColor(rightValue, stripHoldColor); 1177 1178 for (i = prevRightValue; i >= rightValue; i--) 1179 right_strip.setPixelColor(i, 0); 1180 } 1181 else { 1182 for (i = middleOffset; i < rightValue; i++) 1183 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]); 1184 1185 if (!displayPeaks && displayTopAsPeak) 1186 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightValue), stripHoldColor); 1187 1188 for (i = prevRightValue; i >= rightValue; i--) 1189 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0); 1190 } 1191 } 1192 else { 1193 for (i = middleOffset; i < leftValue; i++) 1194 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]); 1195 1196 if (!displayPeaks && displayTopAsPeak) 1197 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + leftValue), stripHoldColor); 1198 1199 for (i = prevLeftValue; i >= leftValue; i--) 1200 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0); 1201 1202 for (i = middleOffset; i < rightValue; i++) 1203 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripColor[i]); 1204 1205 if (!displayPeaks && displayTopAsPeak) 1206 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - rightValue), stripHoldColor); 1207 1208 for (i = prevRightValue; i >= rightValue; i--) 1209 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0); 1210 } 1211 1212 if (displayMiddleLed) 1213 left_strip.setPixelColor(getSpinCircleValue(stripMiddle), stripMiddleColor); 1214} 1215 1216void drawPulsingValues() { 1217 halfLeftValue = (leftValue + 1) / 2; 1218 halfRightValue = (rightValue + 1) / 2; 1219 halfPrevLeftValue = (prevLeftValue + 1)/ 2; 1220 halfPrevRightValue = (prevRightValue + 1) / 2; 1221 1222 if (splitStrip) { 1223 for (i = 0; i < halfLeftValue; i++) { 1224 colorValue = stripColor[i * 2]; 1225 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), colorValue); 1226 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), colorValue); 1227 } 1228 1229 if (displayTopAsPeak) { 1230 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), stripHoldColor); 1231 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), stripHoldColor); 1232 } 1233 1234 for (i = halfPrevLeftValue; i >= halfLeftValue; i--) { 1235 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), 0); 1236 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - i), 0); 1237 } 1238 1239 if (stripsOn2Pins) { 1240 for (i = 0; i < halfRightValue; i++) { 1241 colorValue = stripColor[i * 2]; 1242 right_strip.setPixelColor((stripPulseMiddle + i), colorValue); 1243 right_strip.setPixelColor((stripPulseMiddle - i), colorValue); 1244 } 1245 1246 if (displayTopAsPeak) { 1247 right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfRightValue), stripHoldColor); 1248 right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfRightValue), stripHoldColor); 1249 } 1250 1251 for (i = halfPrevRightValue; i >= halfRightValue; i--) { 1252 right_strip.setPixelColor((stripPulseMiddle + i), 0); 1253 right_strip.setPixelColor((stripPulseMiddle - i), 0); 1254 } 1255 } 1256 else { 1257 for (i = 0; i < halfRightValue; i++) { 1258 colorValue = colorValue = stripColor[i * 2]; 1259 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue); 1260 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue); 1261 } 1262 1263 if (displayTopAsPeak) { 1264 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), stripHoldColor); 1265 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), stripHoldColor); 1266 } 1267 1268 for (i = halfPrevRightValue; i >= halfRightValue; i--) { 1269 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0); 1270 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0); 1271 } 1272 } 1273 } 1274 else { 1275 for (i = 0; i < halfLeftValue; i++) { 1276 colorValue = colorValue = stripColor[i * 2]; 1277 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), colorValue); 1278 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), colorValue); 1279 } 1280 1281 if (displayTopAsPeak) { 1282 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), stripHoldColor); 1283 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), stripHoldColor); 1284 } 1285 1286 for (i = halfPrevLeftValue; i >= halfLeftValue; i--) { 1287 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + i), 0); 1288 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - i), 0); 1289 } 1290 1291 for (i = 0; i < halfRightValue; i++) { 1292 colorValue = colorValue = stripColor[i * 2]; 1293 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), colorValue); 1294 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), colorValue); 1295 } 1296 1297 if (displayTopAsPeak) { 1298 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), stripHoldColor); 1299 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), stripHoldColor); 1300 } 1301 1302 for (i = halfPrevRightValue; i >= halfRightValue; i--) { 1303 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + i)), 0); 1304 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - i)), 0); 1305 } 1306 } 1307 1308 if (displayMiddleLed) { 1309 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - stripPulseMiddle), stripMiddleColor); 1310 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle), stripMiddleColor); 1311 } 1312} 1313 1314void clearZeroAndPeaks() { 1315 left_strip.setPixelColor(getSpinCircleValue(middleOffset), 0); 1316 left_strip.setPixelColor(getSpinCircleValue(stripMiddle), 0); 1317 1318 if (displayTopAsPeak) { 1319 if (splitStrip) { 1320 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + halfLeftValue), 0); 1321 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle - halfLeftValue), 0); 1322 1323 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfRightValue), 0); 1324 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfRightValue), 0); 1325 } 1326 else { 1327 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle + halfLeftValue), 0); 1328 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle - halfLeftValue), 0); 1329 1330 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle + halfRightValue)), 0); 1331 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle - halfRightValue)), 0); 1332 } 1333 } 1334} 1335 1336void drawPeaks() { 1337 if (leftPeak > 0) { 1338 if (droppingPeakFade && leftPeakBouncing == false) 1339 stripHoldColor = left_strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 0, 0); 1340 else 1341 stripHoldColor = stripColor[numOfSegments]; 1342 1343 if (splitStrip) 1344 left_strip.setPixelColor(getSpinCircleValue(leftPeak + leftPeakBounce), stripHoldColor); 1345 else 1346 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + leftPeakBounce)), stripHoldColor); 1347 } 1348 1349 if (rightPeak > 0) { 1350 if (droppingPeakFade && rightPeakBouncing == false) 1351 stripHoldColor = left_strip.Color(max(1, (255 * rightPeak * ledFactor_div_numOfSegments)), 0, 0); 1352 else 1353 stripHoldColor = stripColor[numOfSegments]; 1354 1355 if (splitStrip) { 1356 if (stripsOn2Pins) { 1357 right_strip.setPixelColor(getSpinCircleValue(rightPeak + rightPeakBounce), stripHoldColor); 1358 } 1359 else { 1360 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + rightPeakBounce), stripHoldColor); 1361 } 1362 } 1363 else { 1364 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + rightPeakBounce)), stripHoldColor); 1365 } 1366 } 1367 1368 //if (leftPeak > 0 || rightPeak > 0) 1369 // left_strip.show(); 1370} 1371 1372void clearLeftPeak() { 1373 if (splitStrip) 1374 left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0); 1375 else 1376 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0); 1377 1378 if (droppingPeak) 1379 leftPeak = leftPeak * peakDropFactor; 1380 else 1381 leftPeak = 0; 1382 leftPeakTime = 0; 1383} 1384 1385void clearRightPeak() { 1386 if (splitStrip) { 1387 if( stripsOn2Pins) { 1388 right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0); 1389 } 1390 else { 1391 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + rightPeak + prevRightPeakBounce), 0); 1392 } 1393 } 1394 else { 1395 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0); 1396 } 1397 1398 if (droppingPeak) 1399 rightPeak = rightPeak * peakDropFactor; 1400 else 1401 rightPeak = 0; 1402 rightPeakTime = 0; 1403} 1404 1405void clearLeftBouncePeak() { 1406 if (splitStrip) 1407 left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 0); 1408 else 1409 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak + prevLeftPeakBounce)), 0); 1410} 1411 1412void clearRightBouncePeak() { 1413 if (splitStrip) { 1414 if (stripsOn2Pins) { 1415 right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 0); 1416 } 1417 else { 1418 left_strip.setPixelColor(getSpinCircleValue((stripMiddle + rightPeak + prevRightPeakBounce)), 0); 1419 } 1420 } 1421 else { 1422 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak + prevRightPeakBounce)), 0); 1423 } 1424} 1425 1426void clearLeftBounce() { 1427 leftPeakBouncing = false; 1428 leftPeakBounceCounter = 0; 1429 leftPeakBounce = 0; 1430 prevLeftPeakBounce = 0; 1431 leftBouncingPeaksNumOfLeds = 0; 1432} 1433 1434void clearRightBounce() { 1435 rightPeakBouncing = false; 1436 rightPeakBounceCounter = 0; 1437 rightPeakBounce = 0; 1438 prevRightPeakBounce = 0; 1439 leftBouncingPeaksNumOfLeds = 0; 1440} 1441 1442void clearValues() { 1443 leftAnalogValue = 0; 1444 rightAnalogValue = 0; 1445 prevLeftAnalogValue = 0; 1446 prevRightAnalogValue = 0; 1447 leftPeak = 0; 1448 rightPeak = 0; 1449} 1450 1451 1452void drawOverflow() { 1453 for (i = 0; i <= numOfSegments; i++) { 1454 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), stripOverflowColor); 1455 if (stripsOn2Pins) { 1456 right_strip.setPixelColor(i, stripOverflowColor); 1457 } 1458 else { 1459 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripOverflowColor); 1460 } 1461 } 1462 left_strip.show(); 1463 if (stripsOn2Pins) 1464 right_strip.show(); 1465 1466 delay(overflowDelay); 1467 1468 for (i = 0; i <= numOfSegments; i++) { 1469 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0); 1470 if (stripsOn2Pins) { 1471 right_strip.setPixelColor(i, 0); 1472 } 1473 else { 1474 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0); 1475 } 1476 } 1477 left_strip.show(); 1478 if (stripsOn2Pins) 1479 right_strip.show(); 1480} 1481 1482void setStripColors() { 1483 int r, g, b; 1484 int p1, p2; 1485 1486 ledFactor = (float) ledBrightness / 255; 1487 ledFactor_div_numOfSegments = (float) ledFactor / (float) numOfSegments; 1488 stripMiddleColor = left_strip.Color(0, 0, 255 * ledFactor); 1489 1490 switch (colorScheme) { 1491 case 0: { 1492 int orangeLimit; 1493 float orangeFactor = orangeLimitAmount / halfNumOfSegments; 1494 1495 for (i = 0; i <= numOfSegments; i++) { 1496 if (i <= halfNumOfSegments) 1497 orangeLimit = (i * orangeFactor); 1498 else 1499 orangeLimit = ((numOfSegments - i) * orangeFactor); 1500 1501 stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments - i) * ledFactor_div_numOfSegments), 0); 1502 } 1503 break; 1504 } 1505 1506 case 1: { 1507 for (i = 0; i <= numOfSegments; i++) { 1508 stripColor[i] = left_strip.Color(0, (255 * i * ledFactor_div_numOfSegments), (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 1509 } 1510 break; 1511 } 1512 1513 case 2: { 1514 for (i = 0; i <= numOfSegments; i++) { 1515 stripColor[i] = left_strip.Color((255 * i * ledFactor_div_numOfSegments), 0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 1516 } 1517 break; 1518 } 1519 1520 case 3: { 1521 for (i = 0; i <= numOfSegments; i++) { 1522 stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), 0, (255 * i * ledFactor_div_numOfSegments)); 1523 } 1524 break; 1525 } 1526 1527 case 4: { 1528 for (i = 0; i <= numOfSegments; i++) { 1529 stripColor[i] = left_strip.Color(0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments)); 1530 } 1531 break; 1532 } 1533 1534 case 5: { 1535 for (i = 0; i <= numOfSegments; i++) { 1536 stripColor[i] = left_strip.Color((255 * (numOfSegments - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments), 0); 1537 } 1538 break; 1539 } 1540 1541 case 6: { 1542 for (i = 0; i <= numOfSegments; i++) { 1543 r = (255 * i * ledFactor_div_numOfSegments); 1544 g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 1545 b = (200 * (numOfSegments - i) * ledFactor_div_numOfSegments); 1546 stripColor[i] = left_strip.Color(r, g, b); 1547 } 1548 break; 1549 } 1550 1551 case 7: { 1552 for (i = 0; i <= numOfSegments; i++) { 1553 b = (255 * i * ledFactor_div_numOfSegments); 1554 g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 1555 r = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 1556 stripColor[i] = left_strip.Color(r, g, b); 1557 } 1558 break; 1559 } 1560 1561 case 8: { 1562 for (i = 0; i <= numOfSegments; i++) { 1563 r = (255 * i * ledFactor_div_numOfSegments); 1564 b = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 1565 g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 1566 stripColor[i] = left_strip.Color(r, g, b); 1567 } 1568 break; 1569 } 1570 1571 case 9: { 1572 for (i = 0; i <= numOfSegments; i++) { 1573 b = (255 * i * ledFactor_div_numOfSegments); 1574 r = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 1575 g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 1576 stripColor[i] = left_strip.Color(r, g, b); 1577 } 1578 break; 1579 } 1580 1581 case 10: 1582 colorScheme11SpinValue = 0; 1583 1584 case 11: 1585 1586 case 12: { 1587 p1 = (85 * numOfSegments / 255); 1588 p2 = (170 * numOfSegments / 255); 1589 int wheel; 1590 1591 if (colorScheme == 12) 1592 colorSchemeFactor = colorScheme12Factor; 1593 else 1594 colorSchemeFactor = 1; 1595 1596 for (i = 0; i <= numOfSegments; i++) { 1597 //wheel = int(float(i + colorScheme11SpinValue) / colorSchemeFactor) % numOfSegments; // reverse wheel 1598 1599 wheel = int(float(i - colorScheme11SpinValue) / colorSchemeFactor + numOfSegments) % numOfSegments; 1600 1601 if (wheel < p1) { 1602 wheel = map(wheel, 0, p1, 0, 255); 1603 r = (wheel * ledFactor); 1604 g = ((255 - wheel) * ledFactor); 1605 b = 0; 1606 } 1607 else if (wheel < p2) { 1608 wheel = map(wheel, p1, p2, 0, 255); 1609 r = ((255 - wheel) * ledFactor); 1610 g = 0; 1611 b = (wheel * ledFactor); 1612 } 1613 else { 1614 wheel = map(wheel, p2, numOfSegments, 0, 255); 1615 r = 0; 1616 g = (wheel * ledFactor); 1617 b = ((255 - wheel) * ledFactor); 1618 } 1619 1620 stripColor[i] = left_strip.Color(r, g, b); 1621 } 1622 break; 1623 } 1624 } 1625 1626 if (colorScheme >= 10) 1627 stripHoldColor = left_strip.Color(255 * ledFactor, 0, 0); // set to red for the color wheels 1628 else 1629 stripHoldColor = stripColor[numOfSegments]; 1630 1631 stripOverflowColor = stripHoldColor; // left_strip.Color(min(255, 255 * ledFactor * 1.5), 0, 0); 1632} 1633 1634void startupAnimation() { 1635 for (j = 0; j < 2; j++) { 1636 for (i = 0; i <= numOfSegments; i++) { 1637 if (animType == 1) 1638 left_strip.setPixelColor(stripMiddle - (numOfSegments - i), stripColor[i]); 1639 else 1640 left_strip.setPixelColor(stripMiddle - i, stripColor[i]); 1641 1642 if (stripsOn2Pins) 1643 right_strip.setPixelColor(i, stripColor[i]); 1644 else 1645 left_strip.setPixelColor(stripMiddle + i, stripColor[i]); 1646 1647 left_strip.show(); 1648 if (stripsOn2Pins) 1649 right_strip.show(); 1650 1651 delay(startupAnimationDelay); 1652 } 1653 1654 for (i = 0; i <= numOfSegments; i++) { 1655 if (animType == 1) 1656 left_strip.setPixelColor(stripMiddle - (numOfSegments - i), 0); 1657 else 1658 left_strip.setPixelColor(stripMiddle - i, 0); 1659 1660 if (stripsOn2Pins) 1661 right_strip.setPixelColor(i, 0); 1662 else 1663 left_strip.setPixelColor(stripMiddle + i, 0); 1664 1665 left_strip.show(); 1666 if (stripsOn2Pins) 1667 right_strip.show(); 1668 1669 delay(startupAnimationDelay); 1670 } 1671 } 1672} 1673 1674void displayNumber (int number, int displayDelay) { 1675 left_strip.clear(); 1676 if (stripsOn2Pins) 1677 right_strip.clear(); 1678 1679 number++; // @EB_DEBUG : display value 0 at led 1 1680 1681 for (i = 0; i <= number; i++) { 1682 if (i % 5 == 0) 1683 colorValue = stripMiddleColor; 1684 else 1685 colorValue = stripColor[0]; 1686 1687 left_strip.setPixelColor(middleOffset + i, colorValue); 1688 1689 if (stripsOn2Pins) 1690 right_strip.setPixelColor(middleOffset + i, colorValue); 1691 else 1692 left_strip.setPixelColor(stripMiddle + middleOffset + i, colorValue); 1693 1694 delay(45 - number * 3); // @EB_DEBUG 1695 1696 left_strip.show(); 1697 if (stripsOn2Pins) 1698 right_strip.show(); 1699 } 1700 1701 if (pulsing) { 1702 left_strip.setPixelColor(middleOffset + maxDisplaySegments, stripMiddleColor); 1703 1704 if (stripsOn2Pins) 1705 right_strip.setPixelColor(maxDisplaySegments, stripMiddleColor); 1706 else 1707 left_strip.setPixelColor(stripMiddle + maxDisplaySegments, stripMiddleColor); 1708 1709 left_strip.show(); 1710 if (stripsOn2Pins) 1711 right_strip.show(); 1712 } 1713 1714 delay(displayDelay); 1715 1716 left_strip.clear(); 1717 if (stripsOn2Pins) 1718 right_strip.clear(); 1719} 1720 1721 1722// 1723// for debugging 1724// 1725 1726#ifdef DEBUG_TEST_LEDS 1727 void displayTest() { 1728 for (i = 0; i <= numOfSegments; i++) { 1729 left_strip.setPixelColor(stripMiddle - i, stripColor[i]); 1730 1731 if (stripsOn2Pins) 1732 right_strip.setPixelColor(i, stripColor[i]); 1733 else 1734 left_strip.setPixelColor(stripMiddle + i, stripColor[i]); 1735 1736 left_strip.show(); 1737 if (stripsOn2Pins) 1738 right_strip.show(); 1739 1740 delay(50); 1741 } 1742 delay(5000); 1743 1744 for (i = 0; i <= numOfSegments; i++) { 1745 left_strip.setPixelColor(stripMiddle - i, 0); 1746 1747 if (stripsOn2Pins) 1748 right_strip.setPixelColor(i, 0); 1749 else 1750 left_strip.setPixelColor(stripMiddle + i, 0); 1751 1752 left_strip.show(); 1753 if (stripsOn2Pins) 1754 right_strip.show(); 1755 } 1756 } 1757 1758 void serialDisplayRGB(int r, int g, int b) { 1759 Serial.print(i); 1760 Serial.print(" "); 1761 Serial.print(r); 1762 Serial.print(" "); 1763 Serial.print(g); 1764 Serial.print(" "); 1765 Serial.println(b); 1766 } 1767#endif 1768
20171105 VU meter
arduino
Updated code with optional dropping and bouncing peaks and several other settings.
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* Last updated 20171105 by ericBcreator 7* 8* This code is free for personal use, not for commercial purposes. 9* Please leave this header intact. 10* 11* contact: ericBcreator@gmail.com 12********************************************************************** 13*/ 14 15//#define DEBUG // for debugging 16 17// 18// include the NeoPixel library: 19// 20 21#include <Adafruit_NeoPixel.h> 22 23// 24// uncomment the definition for the connected strip or ring(s) 25// 26 27//#define led_ring_60 28//#define led_strip_60 29//#define led_strip_30 30#define led_2_rings_24 31//#define led_2_rings_30 32//#define led_strip_200 33//#define led_strip_144 34 35// 36// important setting: using potentiometer sensor values or not 37// This setting has to be set right or the script will not work correctly: 38// - set this to true if using potentiometers 39// - set this to false if not using potentiometers 40// 41 42const int useSensorValues = true; 43 44// 45// setup pins 46// 47 48int leftPin = A0, rightPin = A1; // left audio in on analog 0, right on analog 1 49int brightnessPin = A4, sensitivityPin = A5; // potentiometers for brightness and sensitivity on analog 4 and 5 50int stripPin = 6; // DIN of leds on digital pin 6 51int showPeaksPin = 7; // switch to toggle peaks on or off on digital pin 7 52int momentarySwitch = false; // set false for an on/off toggle switch 53 54// 55// setup variables for the number of leds and led strip or 2 rings 56// 57 58#if defined (led_ring_60) 59 //settings for a 60 led ring 60 61 int stripNumOfLeds = 60; // the total number of leds 62 uint32_t stripColor[31]; // half of the number of leds + 1 63 int displayMiddleLed = false; // display the middle led (blue). set to true for one strip, false for two strips or rings 64 int splitStrip = true; // set to true when using 2 strips or rings, false for one strip 65 int middleOffset = 0; // offset for the middle led when using one strip 66 int startupAnimationDelay = 6; // delay for the startup animation 67 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 68 int swapLeftRight = false; // swap the left and right input values or not 69 70 int dropDelay = 4; // hold time before dropping the leds 71 float dropFactor = .92; // value for dropping the leds 72 73 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (set droppingPeak true or false) 74 int peakTimeFirstDropDelay = 130; // peak hold time when dropping the first peak 75 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 76 float peakDropFactor = .93; // value for dropping the peaks 77 int droppingPeakFade = false; // display the dropping peak fading to black or not 78 79 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 80 int bouncingPeakDelay = 4; // delay between peak bounce updates 81 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 82 83#elif defined (led_strip_60) 84 //settings for a 60 led ring 85 86 int stripNumOfLeds = 60; // the total number of leds 87 uint32_t stripColor[31]; // half of the number of leds + 1 88 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 89 int splitStrip = false; // set to true when using 2 strips or rings, false for one strip 90 int middleOffset = 1; // offset for the middle led when using one strip 91 int startupAnimationDelay = 6; // delay for the startup animation 92 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 93 int swapLeftRight = false; // swap the left and right input values or not 94 95 int dropDelay = 4; // hold time before dropping the leds 96 float dropFactor = .92; // value for dropping the leds 97 98 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (set droppingPeak true or false) 99 int peakTimeFirstDropDelay = 130; // peak hold time when dropping the first peak 100 int peakTimeDropDelay = 7; // peak hold time when dropping the rest of the peaks 101 float peakDropFactor = .93; // value for dropping the peaks 102 int droppingPeakFade = false; // display the dropping peak fading to black or not 103 104 int bouncingPeaksNumOfLeds = 6; // how many leds to bounce up (max) 105 int bouncingPeakDelay = 4; // delay between peak bounce updates 106 int bouncingPeakCounterInc = 10; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 107 108#elif defined (led_strip_30) 109 //settings for a 30 led strip 110 111 int stripNumOfLeds = 30; // the total number of leds 112 uint32_t stripColor[16]; // half of the number of leds + 1 113 int displayMiddleLed = true; // display the middle led (blue). set to true for one strip, false for two strips or rings 114 int splitStrip = false; // set to true when using 2 strips or rings, false for one strip 115 int middleOffset = 1; // offset for the middle led when using one strip 116 int startupAnimationDelay = 10; // delay for the startup animation 117 int orangeLimitAmount = 0; // limit the amount of green of the middle LEDs to make them more orange 118 int swapLeftRight = false; // swap the left and right input values or not 119 120 int dropDelay = 10; // hold time before dropping the leds 121 float dropFactor = .9; // value for dropping the leds 122 123 int peakTimeNoDropDelay = 250; // peak hold time when not dropping the peaks (set droppingPeak true or false) 124 int peakTimeFirstDropDelay = 150; // peak hold time when dropping the first peak 125 int peakTimeDropDelay = 15; // peak hold time when dropping the rest of the peaks 126 float peakDropFactor = .94; // value for dropping the peaks 127 int droppingPeakFade = false; // display the dropping peak fading to black or not 128 129 int bouncingPeaksNumOfLeds = 3; // how many leds to bounce up (max) 130 int bouncingPeakDelay = 4; // delay between peak bounce updates 131 int bouncingPeakCounterInc = 9; // increase counter for each bounce update. note: it uses a 0-180 sin function for the bouncing 132 133#elif defined (led_2_rings_24) 134 //settings for 2 24 led rings 135 136 int stripNumOfLeds = 48; 137 uint32_t stripColor[25]; 138 int displayMiddleLed = false; 139 int splitStrip = true; 140 int middleOffset = 0; 141 int startupAnimationDelay = 5; 142 int orangeLimitAmount = 0; 143 int swapLeftRight = false; 144 145 int dropDelay = 2; 146 float dropFactor = .96; 147 148 int peakTimeNoDropDelay = 250; 149 int peakTimeFirstDropDelay = 100; 150 int peakTimeDropDelay = 10; 151 float peakDropFactor = .94; 152 int droppingPeakFade = false; 153 154 int bouncingPeaksNumOfLeds = 3; 155 int bouncingPeakDelay = 4; 156 int bouncingPeakCounterInc = 9; 157 158#elif defined(led_2_rings_30) 159 //settings for 2 30 led rings 160 161 int stripNumOfLeds = 60; 162 uint32_t stripColor[31]; 163 int displayMiddleLed = false; 164 int splitStrip = true; 165 int middleOffset = 0; 166 int startupAnimationDelay = 5; 167 int orangeLimitAmount = 0; 168 int swapLeftRight = false; 169 170 int dropDelay = 2; 171 float dropFactor = .96; 172 173 int peakTimeNoDropDelay = 250; 174 int peakTimeFirstDropDelay = 100; 175 int peakTimeDropDelay = 10; 176 float peakDropFactor = .94; 177 int droppingPeakFade = false; 178 179 int bouncingPeaksNumOfLeds = 3; 180 int bouncingPeakDelay = 4; 181 int bouncingPeakCounterInc = 9; 182 183#elif defined (led_strip_200) 184 //settings for a 200 led strip 185 186 int stripNumOfLeds = 200; 187 uint32_t stripColor[101]; 188 int displayMiddleLed = false; 189 int splitStrip = true; 190 int middleOffset = 0; 191 int startupAnimationDelay = 1; 192 int orangeLimitAmount = 0; 193 int swapLeftRight = false; 194 195 int dropDelay = 10; 196 float dropFactor = .96; 197 198 int peakTimeNoDropDelay = 250; 199 int peakTimeFirstDropDelay = 100; 200 int peakTimeDropDelay = 30; 201 float peakDropFactor = .99; 202 int droppingPeakFade = false; 203 204 int bouncingPeaksNumOfLeds = 8; 205 int bouncingPeakDelay = 4; 206 int bouncingPeakCounterInc = 9; 207 208#elif defined (led_strip_144) 209 //settings for a 200 led strip 210 211 int stripNumOfLeds = 145; 212 uint32_t stripColor[73]; 213 int displayMiddleLed = true; 214 int splitStrip = false; 215 int middleOffset = 1; 216 int startupAnimationDelay = 1; 217 int orangeLimitAmount = 0; 218 int swapLeftRight = false; 219 220 int dropDelay = 10; 221 float dropFactor = .85; 222 223 int peakTimeNoDropDelay = 250; 224 int peakTimeFirstDropDelay = 100; 225 int peakTimeDropDelay = 5; 226 float peakDropFactor = .94; 227 int droppingPeakFade = false; 228 229 int bouncingPeaksNumOfLeds = 10; 230 int bouncingPeakDelay = 2; 231 int bouncingPeakCounterInc = 10; 232#endif 233 234// 235// setup other variables, user editable 236// 237 238// basic settings 239int minValue = 10; // min analog input value 240int maxValue = 350; // max analog input value (0-1023 equals 0-5V) 241int sensitivityValue = 128; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) 242int maxSensitivity = 2 * 255; // let the 'volume' go up to 200%! 243int ledBrightness = 30; // 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) 244int sensorDeviationBrightness = 1; // eliminate fluctuating values 245int overflowDelay = 20; // overflow hold time 246 247// peak settings 248int displayPeaks = true; // value will be set by the switch if useSensorValues = true 249int droppingPeak = true; // display dropping peaks or not. note: displayPeaks has to be true 250int bouncingPeaks = true; // display bouncing peaks or not. note: displayPeaks has to be true 251 252// 253// initialize other variables needed for the sketch 254// 255 256int numOfSegments = stripNumOfLeds / 2; 257int halfNumOfSegments = numOfSegments / 2; 258int stripMiddle = stripNumOfLeds / 2; 259int maxDisplaySegments = stripMiddle - 1; 260float sensitivityFactor; 261 262int brightnessValue, prevBrightnessValue; 263float ledFactor, ledFactor_div_numOfSegments; 264 265int leftValue = 0, rightValue = 0, maxReadValue = 0; 266int leftAnalogValue = 0, rightAnalogValue = 0; 267 268int prevLeftValue = 0, prevRightValue = 0; 269int prevLeftAnalogValue = 0, prevRightAnalogValue = 0; 270 271int i, j; 272int dropLeft, dropRight; 273int leftDropTime, rightDropTime; 274 275int leftPeak = 0, rightPeak = 0; 276int leftPeakTime = 0, rightPeakTime = 0; 277int leftFirstPeak = true, rightFirstPeak = true; 278int readShowPeaksPin, prevReadShowPeaksPin; 279 280uint32_t stripMiddleColor, stripOverflowColor, stripHoldColor; 281 282int leftPeakBouncing = false, rightPeakBouncing = false; 283int leftPeakBounce = 0, rightPeakBounce = 0; 284int prevLeftPeakBounce = 0, prevRightPeakBounce = 0; 285int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0; 286int leftPeakBounceDelayCounter = 0, rightPeakBounceDelayCounter = 0; 287 288// 289// initialize the strip or rings 290// 291 292Adafruit_NeoPixel strip = Adafruit_NeoPixel(stripNumOfLeds, stripPin, NEO_GRB + NEO_KHZ800); 293 294// 295// setup 296// 297 298void setup() { 299 #ifdef DEBUG 300 Serial.begin(9600); 301 #endif 302 303 pinMode(showPeaksPin, INPUT); 304 305 strip.begin(); 306 307 setStripColors(); 308 startupAnimation(); 309 310 if (useSensorValues) 311 setInitialDisplayPeaks(); 312 else 313 setSensitivityFactor(); 314} 315 316// 317// main loop 318// 319 320void loop() { 321 if (useSensorValues) 322 readSensorValues(); 323 324 readValues(); 325 drawValues(); 326 327 if (displayPeaks) { 328 getPeaks(); 329 drawPeaks(); 330 } 331 332 storePrevValues(); 333} 334 335// 336// functions 337// 338 339void setInitialDisplayPeaks() { 340 readShowPeaksPin = digitalRead(showPeaksPin); 341 if (readShowPeaksPin == HIGH) 342 displayPeaks = false; 343 else 344 displayPeaks = true; 345 prevReadShowPeaksPin = readShowPeaksPin; 346} 347 348void readSensorValues() { 349 readShowPeaksPin = digitalRead(showPeaksPin); 350 351 if (momentarySwitch) { 352 if (readShowPeaksPin == LOW && prevReadShowPeaksPin == HIGH) { 353 if (displayPeaks == true) { 354 displayPeaks = false; 355 clearLeftPeak(); 356 clearRightPeak(); 357 if (momentarySwitch) 358 while (digitalRead(showPeaksPin) == LOW) {} 359 } 360 else { 361 displayPeaks = true; 362 } 363 } 364 } 365 else { 366 if (readShowPeaksPin == LOW && prevReadShowPeaksPin == HIGH) 367 displayPeaks = true; 368 else if (readShowPeaksPin == HIGH && prevReadShowPeaksPin == LOW) { 369 displayPeaks = false; 370 clearLeftPeak(); 371 clearRightPeak(); 372 } 373 } 374 prevReadShowPeaksPin = readShowPeaksPin; 375 376 brightnessValue = analogRead(brightnessPin); 377 brightnessValue = map(brightnessValue, 0, 1023, 0, 255); 378 379 if (abs(brightnessValue - prevBrightnessValue) > sensorDeviationBrightness) { 380 ledBrightness = brightnessValue; 381 setStripColors(); 382 prevBrightnessValue = brightnessValue; 383 } 384 385 sensitivityValue = analogRead(sensitivityPin); 386 sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255); 387 setSensitivityFactor(); 388} 389 390void setSensitivityFactor() { 391 //sensitivityValue_div_numOfSegments = sensitivityValue / numOfSegments; 392 sensitivityFactor = ((float) sensitivityValue / 255 * (float) maxSensitivity / 255); 393} 394 395void readValues() { 396 leftAnalogValue = analogRead(leftPin); 397 rightAnalogValue = analogRead(rightPin); 398 399 if (swapLeftRight) { 400 int tempValue = leftAnalogValue; 401 leftAnalogValue = rightAnalogValue; 402 rightAnalogValue = tempValue; 403 } 404 405 if (leftAnalogValue < prevLeftAnalogValue) { 406 leftDropTime++; 407 if (leftDropTime > dropDelay) { 408 leftAnalogValue = prevLeftAnalogValue * dropFactor; 409 leftDropTime = 0; 410 } 411 else 412 leftAnalogValue = prevLeftAnalogValue; 413 } 414 415 if (rightAnalogValue < prevRightAnalogValue) { 416 rightDropTime++; 417 if (rightDropTime > dropDelay) { 418 rightAnalogValue = prevRightAnalogValue * dropFactor; 419 rightDropTime = 0; 420 } 421 else 422 rightAnalogValue = prevRightAnalogValue; 423 } 424 425 #ifdef DEBUG 426 Serial.print(leftAnalogValue); 427 Serial.print(" "); 428 Serial.println(rightAnalogValue); 429 #endif 430 431 // map values 432 leftValue = map(leftAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 433 rightValue = map(rightAnalogValue * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 434 435 if (leftValue > maxDisplaySegments) { 436 leftValue = maxDisplaySegments; 437 drawOverflow(); 438 } 439 440 if (rightValue > maxDisplaySegments) { 441 rightValue = maxDisplaySegments; 442 drawOverflow(); 443 } 444} 445 446void storePrevValues() { 447 prevLeftAnalogValue = leftAnalogValue; 448 prevRightAnalogValue = rightAnalogValue; 449 450 prevLeftValue = leftValue; 451 prevRightValue = rightValue; 452} 453 454void getPeaks() { 455 if (leftValue > leftPeak) { 456 leftPeak = leftValue; 457 leftPeakTime = 0; 458 leftFirstPeak = true; 459 460 if (bouncingPeaks) { 461 leftPeakBouncing = true; 462 leftPeakBounceCounter = 0; 463 leftPeakBounceDelayCounter = 0; 464 } 465 } 466 else { 467 leftPeakTime++; 468 if (droppingPeak) { 469 if (leftFirstPeak) { 470 if (leftPeakTime > peakTimeFirstDropDelay) { 471 clearLeftPeak(); 472 leftFirstPeak = false; 473 } 474 } 475 else { 476 if (leftPeakTime > peakTimeDropDelay) { 477 clearLeftPeak(); 478 } 479 } 480 } 481 else { 482 if (leftPeakTime > peakTimeNoDropDelay) { 483 clearLeftPeak(); 484 } 485 } 486 } 487 488 if (leftPeakBouncing) { 489 if (leftFirstPeak) { 490 leftPeakBounceDelayCounter++; 491 if (leftPeakBounceDelayCounter >= bouncingPeakDelay) { 492 leftPeakBounceDelayCounter = 0; 493 leftPeakBounceCounter += bouncingPeakCounterInc; 494 495 if (leftPeakBounceCounter >= 180) { 496 clearLeftBouncePeak(); 497 clearLeftBounce(); 498 } 499 else { 500 leftPeakBounce = min((sin(leftPeakBounceCounter * 0.0174532925) * bouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak)); 501 if (leftPeakBounce != prevLeftPeakBounce) { 502 clearLeftBouncePeak(); 503 } 504 prevLeftPeakBounce = leftPeakBounce; 505 } 506 } 507 } 508 } 509 510 if (rightValue > rightPeak) { 511 rightPeak = rightValue; 512 rightPeakTime = 0; 513 rightFirstPeak = true; 514 515 if (bouncingPeaks) { 516 rightPeakBouncing = true; 517 rightPeakBounceCounter = 0; 518 rightPeakBounceDelayCounter = 0; 519 } 520 } 521 else { 522 rightPeakTime++; 523 if (droppingPeak) { 524 if (rightFirstPeak) { 525 if (rightPeakTime > peakTimeFirstDropDelay) { 526 clearRightPeak(); 527 rightFirstPeak = false; 528 } 529 } 530 else { 531 if (rightPeakTime > peakTimeDropDelay) 532 clearRightPeak(); 533 } 534 } 535 else { 536 if (rightPeakTime > peakTimeNoDropDelay) 537 clearRightPeak(); 538 } 539 } 540 541 if (rightPeakBouncing) { 542 if (rightFirstPeak) { 543 rightPeakBounceDelayCounter++; 544 if (rightPeakBounceDelayCounter >= bouncingPeakDelay) { 545 rightPeakBounceDelayCounter = 0; 546 rightPeakBounceCounter += bouncingPeakCounterInc; 547 548 if (rightPeakBounceCounter >= 180) { 549 clearRightBouncePeak(); 550 clearRightBounce(); 551 } 552 else { 553 rightPeakBounce = min((sin(rightPeakBounceCounter * 0.0174532925) * bouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak)); 554 if (rightPeakBounce != prevRightPeakBounce) { 555 clearRightBouncePeak(); 556 } 557 prevRightPeakBounce = rightPeakBounce; 558 } 559 } 560 } 561 } 562} 563 564void drawValues() { 565 if (splitStrip) { 566 for (i = middleOffset; i < leftValue; i++) 567 strip.setPixelColor(i, stripColor[i]); 568 569 for (i = prevLeftValue; i > leftValue; i--) 570 strip.setPixelColor(i, 0); 571 572 for (i = middleOffset; i < rightValue; i++) 573 strip.setPixelColor(stripMiddle + i, stripColor[i]); 574 575 for (i = prevRightValue; i > rightValue; i--) 576 strip.setPixelColor(stripMiddle + i, 0); 577 } 578 else { 579 for (i = middleOffset; i < leftValue; i++) 580 strip.setPixelColor(stripMiddle + i, stripColor[i]); 581 582 for (i = prevLeftValue; i > leftValue; i--) 583 strip.setPixelColor(stripMiddle + i, 0); 584 585 for (i = middleOffset; i < rightValue; i++) 586 strip.setPixelColor(stripMiddle - i, stripColor[i]); 587 588 for (i = prevRightValue; i > rightValue; i--) 589 strip.setPixelColor(stripMiddle - i, 0); 590 } 591 592 if (displayMiddleLed) strip.setPixelColor(stripMiddle, stripMiddleColor); 593 strip.show(); 594} 595 596void drawPeaks() { 597 if (leftPeak > 0) { 598 if (droppingPeakFade && leftPeakBouncing == false) 599 stripHoldColor = strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 0, 0); 600 else 601 stripHoldColor = stripColor[numOfSegments]; 602 603 if (splitStrip) 604 strip.setPixelColor((leftPeak + leftPeakBounce), stripHoldColor); 605 else 606 strip.setPixelColor(stripMiddle + (leftPeak + leftPeakBounce), stripHoldColor); 607 } 608 609 if (rightPeak > 0) { 610 if (droppingPeakFade && rightPeakBouncing == false) 611 stripHoldColor = strip.Color(max(1, (255 * rightPeak * ledFactor_div_numOfSegments)), 0, 0); 612 else 613 stripHoldColor = stripColor[numOfSegments]; 614 615 if (splitStrip) 616 strip.setPixelColor(stripMiddle + rightPeak + prevRightPeakBounce, stripHoldColor); 617 else 618 strip.setPixelColor(stripMiddle - (rightPeak + prevRightPeakBounce), stripHoldColor); 619 } 620 621 if (leftPeak > 0 || rightPeak > 0) 622 strip.show(); 623} 624 625void clearLeftPeak() { 626 if (splitStrip) 627 strip.setPixelColor((leftPeak + prevLeftPeakBounce), 0); 628 else 629 strip.setPixelColor(stripMiddle + (leftPeak + prevLeftPeakBounce), 0); 630 631 if (droppingPeak) 632 leftPeak = leftPeak * peakDropFactor; 633 else 634 leftPeak = 0; 635 leftPeakTime = 0; 636} 637 638void clearLeftBounce() { 639 leftPeakBouncing = false; 640 leftPeakBounceCounter = 0; 641 leftPeakBounce = 0; 642 prevLeftPeakBounce = 0; 643} 644 645void clearLeftBouncePeak() { 646 if (splitStrip) 647 strip.setPixelColor((leftPeak + prevLeftPeakBounce), 0); 648 else 649 strip.setPixelColor(stripMiddle + (leftPeak + prevLeftPeakBounce), 0); 650} 651 652void clearRightPeak() { 653 if (splitStrip) 654 strip.setPixelColor(stripMiddle + rightPeak + prevRightPeakBounce, 0); 655 else 656 strip.setPixelColor(stripMiddle - (rightPeak + prevRightPeakBounce), 0); 657 658 if (droppingPeak) 659 rightPeak = rightPeak * peakDropFactor; 660 else 661 rightPeak = 0; 662 rightPeakTime = 0; 663} 664 665void clearRightBounce() { 666 rightPeakBouncing = false; 667 rightPeakBounceCounter = 0; 668 rightPeakBounce = 0; 669 prevRightPeakBounce = 0; 670} 671 672void clearRightBouncePeak() { 673 if (splitStrip) 674 strip.setPixelColor((stripMiddle + rightPeak + prevRightPeakBounce), 0); 675 else 676 strip.setPixelColor(stripMiddle - (rightPeak + prevRightPeakBounce), 0); 677} 678 679void drawOverflow() { 680 for (i = 0; i <= numOfSegments; i++) { 681 strip.setPixelColor(stripMiddle + i, stripOverflowColor); 682 strip.setPixelColor(stripMiddle - i, stripOverflowColor); 683 } 684 strip.show(); 685 delay(overflowDelay); 686 687 for (i = 0; i <= numOfSegments; i++) { 688 strip.setPixelColor(stripMiddle + i, 0); 689 strip.setPixelColor(stripMiddle - i, 0); 690 } 691 strip.show(); 692} 693 694void setStripColors() { 695 int orangeLimit; 696 ledFactor = (float)ledBrightness / 255; 697 698 float orangeFactor = orangeLimitAmount / halfNumOfSegments; 699 ledFactor_div_numOfSegments = ledFactor / numOfSegments; 700 701 stripOverflowColor = strip.Color(min(255, 255 * ledFactor * 1.5), 0, 0); 702 stripMiddleColor = strip.Color(0, 0, 255 * ledFactor); 703 704 stripColor[0] = strip.Color(0, 255 * ledFactor, 0); 705 for (i = 1; i <= numOfSegments; i++) { 706 if (i <= halfNumOfSegments) 707 orangeLimit = (i * orangeFactor); 708 else 709 orangeLimit = ((numOfSegments - i) * orangeFactor); 710 711 stripColor[i] = strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments - i) * ledFactor_div_numOfSegments), 0); 712 } 713 714 stripHoldColor = stripColor[numOfSegments]; 715} 716 717void startupAnimation() { 718 for (j = 0; j < 2; j++) { 719 for (i = 0; i <= numOfSegments; i++) { 720 strip.setPixelColor(stripMiddle - i, stripColor[i]); 721 strip.setPixelColor(stripMiddle + i, stripColor[i]); 722 strip.show(); 723 delay(startupAnimationDelay); 724 } 725 726 for (i = 0; i <= numOfSegments; i++) { 727 strip.setPixelColor(stripMiddle + i, 0); 728 strip.setPixelColor(stripMiddle - i, 0); 729 strip.show(); 730 delay(startupAnimationDelay); 731 } 732 } 733} 734 735
Old LCD, LED and LED strip test version.
arduino
1// include the library code: 2#include <LiquidCrystal.h> 3#include "LedControlMS.h" 4#include <Adafruit_NeoPixel.h> 5 6/* 7 LiquidCrystal Library 8 9 The circuit: 10 * LCD RS pin to digital pin 12 11 * LCD Enable pin to digital pin 11 12 * LCD D4 pin to digital pin 5 13 * LCD D5 pin to digital pin 4 14 * LCD D6 pin to digital pin 3 15 * LCD D7 pin to digital pin 2 16 * LCD R/W pin to ground 17 * LCD VSS pin to ground 18 * LCD VCC pin to 5V 19 * 10K resistor: 20 * ends to +5V and ground 21 * wiper to LCD VO pin (pin 3) 22 23*/ 24// initialize the library by associating any needed LCD interface pin 25// with the arduino pin number it is connected to 26const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2; 27LiquidCrystal lcd(rs, en, d4, d5, d6, d7); 28 29// led matrix 30// DataIN, CLK, LOAD, # of matrix 31#define NUMOFMATRIX 4 32LedControl led = LedControl(10,8,9,NUMOFMATRIX); 33 34// led strip 35#define PIN 6 36#define NUMOFLEDS 31 37Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMOFLEDS, PIN, NEO_GRB + NEO_KHZ800); 38 39// setup values 40const int outputType = 1; // lcd = 0, led = 1, led strip = 2 41 42const int minValue = 20; 43const int maxValue = 500; 44 45int updateDelay, maxSegments; 46float ledIntensity; 47 48int leftPin = A0, rightPin = A1; 49int leftValue = 0, rightValue = 0, averageValue = 0, maxReadValue = 0; 50int leftAnalogValue = 0, rightAnalogValue = 0, averageAnalogValue = 0; 51 52int prevLeftValue = 0, prevRightValue = 0, prevAverageValue = 0; 53int prevLeftAnalogValue = 0, prevRightAnalogValue = 0, prevAverageAnalogValue = 0; 54 55float dropFactor; 56 57int i, j; 58 59int holdShow = true; 60int holdZeroShow = true; 61int leftHold = 0, rightHold = 0; 62int leftHoldTime = 0, rightHoldTime = 0; 63int holdTime; 64 65int stripMiddle; 66uint32_t stripRed, stripGreen, stripBlue; 67uint32_t stripColor[16]; 68 69void setup() { 70 switch (outputType) { 71 case 0: 72 // set up the LCD's number of columns and rows: 73 updateDelay = 50; 74 maxSegments = 16; 75 holdTime = 20; 76 dropFactor = .9; 77 78 lcd.begin(16, 2); 79 break; 80 81 case 1: 82 // set up led 83 updateDelay = 0; 84 maxSegments = 7; 85 holdTime = 50; 86 ledIntensity = 1.2; 87 dropFactor = .7; 88 89 for (i = 0; i < NUMOFMATRIX; i++) { 90 led.shutdown(i, false); 91 //led.setIntensity(i, 4); 92 led.clearDisplay(i); 93 } 94 95 // setup: identify left & right matrix 96 led.writeString(0,"#1 - LEFT"); 97 led.writeString(1,"#2 - RIGHT"); 98 led.writeString(2,"#3 - THREE"); 99 led.writeString(3,"#4 - FOUR"); 100 break; 101 102 case 2: 103 // set up led strip 104 updateDelay = 0; 105 maxSegments = NUMOFLEDS / 2; 106 stripMiddle = maxSegments; 107 holdTime = 250; 108 ledIntensity = .1; 109 dropFactor = .991; 110 111 strip.begin(); 112 113 stripRed = strip.Color(255 * ledIntensity, 0, 0); 114 stripGreen = strip.Color(0, 255 * ledIntensity, 0); 115 stripBlue = strip.Color(0, 0, 255 * ledIntensity); 116 117 // set colors green to fellow to red 118 for (i = 0; i <= maxSegments; i++) 119 stripColor[i] = strip.Color(255 / maxSegments * i * ledIntensity , 255 / maxSegments * (maxSegments - i) * ledIntensity, 0); 120 121 // startup animation 122 for (j = 0; j < 2; j ++) { 123 for (i = 0; i <= maxSegments; i++) { 124 strip.setPixelColor(stripMiddle - i, stripColor[i]); 125 strip.setPixelColor(stripMiddle + i, stripColor[i]); 126 strip.show(); 127 delay(20); 128 } 129 130 for (i = 0; i <= maxSegments; i++) { 131 strip.setPixelColor(stripMiddle + i, 0); 132 strip.setPixelColor(stripMiddle - i, 0); 133 strip.show(); 134 delay(20); 135 } 136 } 137 } 138 139 // for debugging 140 Serial.begin(9600); 141} 142 143void loop() { 144 readValues(); 145 if (holdShow) getHolds(); 146 147 switch(outputType) { 148 case 0: 149 LCDdisplayValues(); 150 if (holdShow) LCDdisplayHolds(); 151 break; 152 153 case 1: 154 LEDdisplayValues(); 155 if (holdShow) LEDdisplayHolds(); 156 break; 157 158 case 2: 159 STRIPdisplayValues(); 160 if (holdShow) STRIPdisplayHolds(); 161 } 162 163 storePrevValues(); 164 delay(updateDelay); 165} 166 167void readValues() { 168 leftAnalogValue = analogRead(leftPin); 169 rightAnalogValue = analogRead(rightPin); 170 //averageAnalogValue = (leftValue + rightValue) / 2; 171 172 if (leftAnalogValue < prevLeftAnalogValue) 173 leftAnalogValue = prevLeftAnalogValue * dropFactor; 174 175 if (rightAnalogValue < prevRightAnalogValue) 176 rightAnalogValue = prevRightAnalogValue * dropFactor; 177 178 //if (averageAnalogValue < prevAverageAnalogValue) 179 // averageAnalogValue = averageAnalogValue * dropFactor; 180 181 // debug to check read values 182 /* 183 if (leftValue > maxReadValue) maxReadValue = leftValue; 184 if (rightValue > maxReadValue) maxReadValue = rightValue; 185 Serial.print(maxReadValue); 186 Serial.print(" "); 187 Serial.print(leftValue); 188 Serial.print(" "); 189 Serial.println(rightValue); 190 */ 191 192 // check if left or right value exceeds max and print the value 193 if (leftValue > maxValue) Serial.println (leftValue); 194 if (rightValue > maxValue) Serial.println (rightValue); 195 196 // map values 197 leftValue = map(leftAnalogValue, minValue, maxValue, 0, maxSegments); 198 rightValue = map(rightAnalogValue, minValue, maxValue, 0, maxSegments); 199 //averageValue = map(averageAnalogValue, minValue, maxValue, 0, maxSegments); 200 201} 202 203void storePrevValues() { 204 prevLeftAnalogValue = leftAnalogValue; 205 prevRightAnalogValue = rightAnalogValue; 206 //prevAverageValue = averageAnalogValue; 207 208 prevLeftValue = leftValue; 209 prevRightValue = rightValue; 210 //prevAverageValue = averageValue; 211} 212 213void LEDdisplayValues() { 214 led.clearDisplay(0); 215 led.clearDisplay(1); 216 217 for (i=0; i <= leftValue; i++) 218 for (j=0; j <= leftValue; j++) 219 led.setLed(0, maxSegments - i, j, true); 220 led.setIntensity(0, leftValue * ledIntensity); 221 222 for (i=0; i <= rightValue; i++) 223 for (j=0; j <= rightValue; j++) 224 led.setLed(1, i, j, true); 225 led.setIntensity(1, rightValue * ledIntensity); 226} 227 228void LEDdisplayHolds() { 229 if (leftHold || holdZeroShow) { 230 //for (j=0; j <= leftHold; j++) 231 // led.setLed(0, leftHold, j, true); 232 233 //for (j=0; j <= leftHold; j++) 234 // led.setLed(0, j, leftHold, true); 235 led.setLed(0, maxSegments - leftHold, leftHold, true); 236 } 237 238 if (rightHold || holdZeroShow) { 239 //for (j=0; j < rightHold; j++) 240 // led.setLed(1, rightHold, j, true); 241 242 //for (j=0; j <= rightHold; j++) 243 // led.setLed(1, j, rightHold, true); 244 led.setLed(1, rightHold, rightHold, true); 245 } 246} 247 248void LCDdisplayValues() { 249 lcd.clear(); 250 for (i=0; i < leftValue; i++) 251 lcd.print("="); 252 253 lcd.setCursor(0, 1); 254 for (i=0; i < rightValue; i++) 255 lcd.print("="); 256} 257 258void LCDdisplayHolds() { 259 if (leftHold || holdZeroShow) { 260 lcd.setCursor(leftHold, 0); 261 lcd.print(">"); 262 } 263 264 if (rightHold || holdZeroShow) { 265 lcd.setCursor(rightHold, 1); 266 lcd.print(">"); 267 } 268} 269 270void STRIPdisplayValues() { 271 272 strip.clear(); 273 //for (i=0; i <= averageValue; i++) 274 // strip.setPixelColor(i, stripGreen); 275 //strip.show(); 276 277 for (i=0; i <= leftValue; i++) 278 strip.setPixelColor(stripMiddle + i, stripColor[i]); 279 280 for (i=0; i <= rightValue; i++) 281 strip.setPixelColor(stripMiddle - i, stripColor[i]); 282 283/* 284 for (i=prevLeftValue; i <= leftValue; i++) 285 strip.setPixelColor(stripMiddle + i, stripGreen); 286 287 for (i=prevLeftValue; i > leftValue; i--) 288 strip.setPixelColor(stripMiddle + i, 0); 289 290 for (i=prevRightValue; i <= rightValue; i++) 291 strip.setPixelColor(stripMiddle - i, stripGreen); 292 293 for (i=prevRightValue; i > rightValue; i--) 294 strip.setPixelColor(stripMiddle - i, 0); 295*/ 296 297 strip.show(); 298} 299 300void STRIPdisplayHolds() { 301 //strip.setPixelColor((leftHold + rightHold) / 2, stripRed); 302 303 strip.setPixelColor(stripMiddle + leftHold, stripColor[maxSegments]); 304 strip.setPixelColor(stripMiddle - rightHold, stripColor[maxSegments]); 305 strip.setPixelColor(stripMiddle, stripBlue); 306 strip.show(); 307} 308 309void getHolds() { 310 if (leftValue > leftHold) { 311 leftHold = leftValue; 312 leftHoldTime = 0; 313 } 314 else { 315 leftHoldTime++; 316 if (leftHoldTime > holdTime) { 317 //if (outputType == 2) 318 // strip.setPixelColor(stripMiddle + leftHold, 0); 319 leftHold = 0; 320 leftHoldTime = 0; 321 } 322 } 323 324 if (rightValue > rightHold) { 325 rightHold = rightValue; 326 rightHoldTime = 0; 327 } 328 else { 329 rightHoldTime++; 330 if (rightHoldTime > holdTime) { 331 //if (outputType == 2) 332 // strip.setPixelColor(stripMiddle - rightHold, 0); 333 rightHold = 0; 334 rightHoldTime = 0; 335 } 336 } 337} 338
20180202 VU meter update
arduino
Updated code with a lot of changes. Note: use the updated diagram, there are some changes in pin connections - multiple color schemes - option to connect 2 strip or rings on 2 output pins of the Arduino (the previous code used 1) - option for pulsing and spinning - option for logarithmic audio response
1/* 2********************************************************************** 3* 4 Stereo VU Meter for 1 or 2 LED rings or strips build by ericBcreator 5* Designed 6 to be used with an Arduino UNO, Nano or compatible device. 7********************************************************************** 8* 9 Notice: search for @EB in the Sketch for important variables to set 10* for the 11 Sketch to work with your setup. 12********************************************************************** 13* 14 Last updated 20180202 by ericBcreator 15* 16* This code is free for personal use, 17 not for commercial purposes. 18* Please leave this header intact. 19* 20* contact: 21 ericBcreator@gmail.com 22********************************************************************** 23*/ 24 25// 26// 27 include the NeoPixel library: 28// 29 30#include <Adafruit_NeoPixel.h> 31 32// 33// 34 debugging settings 35// 36//#define DEBUG // 37 debug: enable serial.print 38//#define DEBUG_NO_PEAK_SWITCH // 39 debug: no peak switch connected @EB 40//#define DEBUG_TEST_LEDS // 41 debug: display each led (color) slowly at startup 42//#define DEBUG_PRINT_LOOP_TIME 43 // debug: serial.print the looptime in ms 44//#define 45 DEBUG_PRINT_ANALOGVALUES // debug: serial.print analog 46 input values 47//#define DEBUG_NO_PEAKS // debug: 48 display no peaks, ignoring other settings 49//#define DEBUG_PEAKS // 50 debug: display peaks, ignoring other settings 51 52// 53// uncomment to average 54 the input levels to the number defined by averageNumOfReadings. increasing the value 55 will make the script less responsive 56// 57//#define averageReadings // 58 average input levels or not 59//#define averageNumOfReadings 3 // 60 num of readings for averaging 61 62// 63// uncomment to map the linear audio 64 input to non-linear response 65// 66//#define nonLinearSinAudio // 67 uncomment to map the linear audio input signal to a non-linear, reverse audio-taper 68 response (sin wave) 69//#define nonLinearReverseSinAudio // 70 uncomment to map the linear audio input signal to a non-linear, audio-taper response 71 (reverse sin wave) 72#define nonLinearLogAudio // 73 uncomment to map the linear audio input signal to a log response 74//#define nonLinearAvr2 75 // uncomment to average the original input 76 with the non-linear response 77 78// 79// overflow settings 80// 81//#define 82 displayOverflow // display overflow or not 83//#define 84 compressOverflowPeaks // compress overflow peaks or 85 not 86//#define compressOverflowNumOfTimes 2 // num of times 87 to apply the compressOverflowFactor 88//float compressOverflowFactor = .05; // 89 factor for compression 90 91// 92// uncomment when using high level (non-consumer) 93 inputs 94// 95//#define highLevelInput // 96 @EB define for high level inputs 97 98// 99// uncomment the definition for the 100 connected strip or ring(s) @EB 101// 102 103//#define led_matrix_40 104//#define 105 led_ring_60 106//#define led_ring_60_ps 107#define led_rhombus_160_ps 108//#define 109 led_strip_60 110//#define led_strip_60_qr 111//#define led_strip_30 112//#define 113 led_2_rings_24 114//#define led_2_rings_30 115//#define led_strip_200 116//#define 117 led_strip_144 118//#define led_2_strip_63 119//#define led_2_strip_63_qr 120 121// 122// 123 important setting: using potentiometer sensor values or not 124// This setting has 125 to be set right or the script will not work correctly: 126// - set to true if using 127 potentiometers 128// - set to false if not using potentiometers 129// 130 131const 132 int useSensorValues = true; // @EB 133 134// 135// setup 136 pins 137// 138 139int leftPin = A0, rightPin = A1; // left 140 audio in on analog 0, right on analog 1 141int brightnessPin = A4, sensitivityPin 142 = A5; // potentiometers for brightness and sensitivity on analog 4 143 and 5 144int leftStripPin = 5; // DIN of left 145 led strip on digital pin 5 146int rightStripPin = 6; // 147 DIN of right led strip on digital pin 6 148int showPeaksPin = 7; // 149 switch to toggle peaks on or off on digital pin 7 (7, 9 for box version) 150int 151 showPeaksMomentarySwitch = false; // set false for an on/off 152 toggle switch 153int reverseShowPeaks = true; // reverses 154 the on/off setting in case you made a wiring mistake ;-) @EB 155int selectButton1Pin 156 = 8; // push button for changing settings on digital 157 pin 8 158int useSelectButton1 = true; // set to false 159 if no push button1 for selecting the color scheme is connected @EB 160int selectButton2Pin 161 = 9; // push button for changing settings on digital 162 pin 9 163int useSelectButton2 = true; // set to false 164 if no push button2 is connected @EB 165 166// 167// setup variables for the number 168 of leds and led strip or 2 rings 169// 170 171#if defined (led_matrix_40) 172 //settings 173 for a 40 led matrix 174 175 int stripNumOfLeds = 40; // 176 the total number of leds 177 int stripsOn2Pins = false; // 178 set to true if the LED strips or rings are connected to 2 input pins 179 uint32_t 180 stripColor[21]; // half of the number of leds + 181 1 182 int displayMiddleLed = false; // display the 183 middle led (blue). set to true for one strip, false for two strips or rings 184 185 int splitStrip = true; // set to true when 186 using 2 strips or rings, false for one strip 187 int middleOffset = 0; // 188 offset for the middle led when using one strip 189 int startupAnimationDelay = 190 6; // delay for the startup animation 191 int orangeLimitAmount 192 = 0; // limit the amount of green of the middle LEDs 193 to make them more orange 194 int swapLeftRight = false; // 195 swap the left and right input values or not 196 197 int dropDelay = 5; // 198 hold time before dropping the leds 199 float dropFactor = .94; // 200 value for dropping the leds 201 202 int peakTimeNoDropDelay = 250; // 203 peak hold time when not dropping the peaks (when droppingPeak is false) 204 int 205 peakTimeFirstDropDelay = 150; // peak hold time when dropping 206 the first peak 207 int peakTimeDropDelay = 7; // 208 peak hold time when dropping the rest of the peaks 209 float peakDropFactor = .94; 210 // value for dropping the peaks 211 int droppingPeakFade 212 = false; // display the dropping peak fading to black 213 or not 214 215 int bouncingPeaksNumOfLeds = 6; // how 216 many leds to bounce up (max) 217 int bouncingPeaksNumOfLedsMin = 3; // 218 how many leds to bounce up (min) when using dynamicBouncingPeaks 219 int bouncingPeakDelay 220 = 6; // delay between peak bounce updates 221 int 222 bouncingPeakCounterInc = 10; // increase counter for each 223 bounce update. note: it uses a 0-180 sin function for the bouncing 224 225#elif 226 defined (led_ring_60) 227 //settings for a 60 led ring 228 229 int stripNumOfLeds 230 = 60; // the total number of leds 231 int stripsOn2Pins 232 = false; // set to true if the LED strips or rings 233 are connected to 2 input pins 234 uint32_t stripColor[31]; // 235 half of the number of leds + 1 236 int displayMiddleLed = false; // 237 display the middle led (blue). set to true for one strip, false for two strips or 238 rings 239 int splitStrip = true; // set to true 240 when using 2 strips or rings, false for one strip 241 int middleOffset = 0; // 242 offset for the middle led when using one strip 243 int startupAnimationDelay = 244 6; // delay for the startup animation 245 int orangeLimitAmount 246 = 0; // limit the amount of green of the middle LEDs 247 to make them more orange 248 int swapLeftRight = false; // 249 swap the left and right input values or not 250 251 int dropDelay = 5; // 252 hold time before dropping the leds 253 float dropFactor = .94; // 254 value for dropping the leds 255 256 int peakTimeNoDropDelay = 250; // 257 peak hold time when not dropping the peaks (when droppingPeak is false) 258 int 259 peakTimeFirstDropDelay = 70; // peak hold time when dropping 260 the first peak 261 int peakTimeDropDelay = 7; // 262 peak hold time when dropping the rest of the peaks 263 float peakDropFactor = .94; 264 // value for dropping the peaks 265 int droppingPeakFade 266 = false; // display the dropping peak fading to black 267 or not 268 269 int bouncingPeaksNumOfLeds = 6; // how 270 many leds to bounce up (max) 271 int bouncingPeaksNumOfLedsMin = 3; // 272 how many leds to bounce up (min) when using dynamicBouncingPeaks 273 int bouncingPeakDelay 274 = 4; // delay between peak bounce updates 275 int 276 bouncingPeakCounterInc = 10; // increase counter for each 277 bounce update. note: it uses a 0-180 sin function for the bouncing 278 279#elif 280 defined (led_ring_60_ps) 281 //settings for a 60 led ring - pulsating and spinning 282 settings 283 284 int stripNumOfLeds = 60; // the 285 total number of leds 286 int stripsOn2Pins = false; // 287 set to true if the LED strips or rings are connected to 2 input pins 288 uint32_t 289 stripColor[31]; // half of the number of leds + 290 1 291 int displayMiddleLed = true; // display the 292 middle led (blue). set to true for one strip, false for two strips or rings 293 294 int splitStrip = true; // set to true when 295 using 2 strips or rings, false for one strip 296 int middleOffset = 0; // 297 offset for the middle led when using one strip 298 int startupAnimationDelay = 299 6; // delay for the startup animation 300 int orangeLimitAmount 301 = 0; // limit the amount of green of the middle LEDs 302 to make them more orange 303 int swapLeftRight = false; // 304 swap the left and right input values or not 305 306 int dropDelay = 5; // 307 hold time before dropping the leds 308 float dropFactor = .93; // 309 value for dropping the leds 310 311 int peakTimeNoDropDelay = 10; // 312 peak hold time when not dropping the peaks (when droppingPeak is false) 313 int 314 peakTimeFirstDropDelay = 10; // peak hold time when dropping 315 the first peak 316 int peakTimeDropDelay = 6; // 317 peak hold time when dropping the rest of the peaks 318 float peakDropFactor = .92; 319 // value for dropping the peaks 320 int droppingPeakFade 321 = false; // display the dropping peak fading to black 322 or not 323 324 int bouncingPeaksNumOfLeds = 6; // how 325 many leds to bounce up (max) 326 int bouncingPeaksNumOfLedsMin = 3; // 327 how many leds to bounce up (min) when using dynamicBouncingPeaks 328 int bouncingPeakDelay 329 = 4; // delay between peak bounce updates 330 int 331 bouncingPeakCounterInc = 10; // increase counter for each 332 bounce update. note: it uses a 0-180 sin function for the bouncing 333 334#elif 335 defined (led_rhombus_160_ps) 336 //settings for a 160 led rhombus - pulsating and 337 spinning settings 338 339 int stripNumOfLeds = 160; // 340 the total number of leds 341 int stripsOn2Pins = false; // 342 set to true if the LED strips or rings are connected to 2 input pins 343 uint32_t 344 stripColor[81]; // half of the number of leds + 345 1 346 int displayMiddleLed = true; // display the 347 middle led (blue). set to true for one strip, false for two strips or rings 348 349 int splitStrip = true; // set to true when 350 using 2 strips or rings, false for one strip 351 int middleOffset = 0; // 352 offset for the middle led when using one strip 353 int startupAnimationDelay = 354 0; // delay for the startup animation 355 int orangeLimitAmount 356 = 0; // limit the amount of green of the middle LEDs 357 to make them more orange 358 int swapLeftRight = false; // 359 swap the left and right input values or not 360 361 int dropDelay = 4; // 362 hold time before dropping the leds 363 float dropFactor = .92; // 364 value for dropping the leds 365 366 int peakTimeNoDropDelay = 150; // 367 peak hold time when not dropping the peaks (when droppingPeak is false) 368 int 369 peakTimeFirstDropDelay = 70; // peak hold time when dropping 370 the first peak 371 int peakTimeDropDelay = 7; // 372 peak hold time when dropping the rest of the peaks 373 float peakDropFactor = .94; 374 // value for dropping the peaks 375 int droppingPeakFade 376 = false; // display the dropping peak fading to black 377 or not 378 379 int bouncingPeaksNumOfLeds = 10; // how 380 many leds to bounce up (max) 381 int bouncingPeaksNumOfLedsMin = 5; // 382 how many leds to bounce up (min) when using dynamicBouncingPeaks 383 int bouncingPeakDelay 384 = 4; // delay between peak bounce updates 385 int 386 bouncingPeakCounterInc = 6; // increase counter for each 387 bounce update. note: it uses a 0-180 sin function for the bouncing 388 389#elif 390 defined (led_strip_60) 391 //settings for a 60 led strip 392 393 int stripNumOfLeds 394 = 60; // the total number of leds 395 int stripsOn2Pins 396 = false; // set to true if the LED strips or rings 397 are connected to 2 input pins 398 uint32_t stripColor[31]; // 399 half of the number of leds + 1 400 int displayMiddleLed = true; // 401 display the middle led (blue). set to true for one strip, false for two strips or 402 rings 403 int splitStrip = false; // set to true 404 when using 2 strips or rings, false for one strip 405 int middleOffset = 1; // 406 offset for the middle led when using one strip 407 int startupAnimationDelay = 408 6; // delay for the startup animation 409 int orangeLimitAmount 410 = 0; // limit the amount of green of the middle LEDs 411 to make them more orange 412 int swapLeftRight = false; // 413 swap the left and right input values or not 414 415 int dropDelay = 5; // 416 hold time before dropping the leds 417 float dropFactor = .94; // 418 value for dropping the leds 419 420 int peakTimeNoDropDelay = 250; // 421 peak hold time when not dropping the peaks (when droppingPeak is false) 422 int 423 peakTimeFirstDropDelay = 70; // peak hold time when dropping 424 the first peak 425 int peakTimeDropDelay = 7; // 426 peak hold time when dropping the rest of the peaks 427 float peakDropFactor = .94; 428 // value for dropping the peaks 429 int droppingPeakFade 430 = false; // display the dropping peak fading to black 431 or not 432 433 int bouncingPeaksNumOfLeds = 6; // how 434 many leds to bounce up (max) 435 int bouncingPeaksNumOfLedsMin = 3; // 436 how many leds to bounce up (min) when using dynamicBouncingPeaks 437 int bouncingPeakDelay 438 = 4; // delay between peak bounce updates 439 int 440 bouncingPeakCounterInc = 10; // increase counter for each 441 bounce update. note: it uses a 0-180 sin function for the bouncing 442 443#elif 444 defined (led_strip_60_qr) 445 //settings for a 60 led strip - quick response 446 447 448 int stripNumOfLeds = 60; // the total number 449 of leds 450 int stripsOn2Pins = false; // set to 451 true if the LED strips or rings are connected to 2 input pins 452 uint32_t stripColor[31]; 453 // half of the number of leds + 1 454 int displayMiddleLed 455 = true; // display the middle led (blue). set to true 456 for one strip, false for two strips or rings 457 int splitStrip = false; // 458 set to true when using 2 strips or rings, false for one strip 459 int middleOffset 460 = 1; // offset for the middle led when using 461 one strip 462 int startupAnimationDelay = 6; // delay 463 for the startup animation 464 int orangeLimitAmount = 0; // 465 limit the amount of green of the middle LEDs to make them more orange 466 int swapLeftRight 467 = false; // swap the left and right input values 468 or not 469 470 int dropDelay = 4; // hold 471 time before dropping the leds 472 float dropFactor = .92; // 473 value for dropping the leds 474 475 int peakTimeNoDropDelay = 0; // 476 peak hold time when not dropping the peaks (when droppingPeak is false) 477 int 478 peakTimeFirstDropDelay = 0; // peak hold time when dropping 479 the first peak 480 int peakTimeDropDelay = 0; // 481 peak hold time when dropping the rest of the peaks 482 float peakDropFactor = 1; 483 // value for dropping the peaks 484 int droppingPeakFade 485 = false; // display the dropping peak fading to black 486 or not 487 488 int bouncingPeaksNumOfLeds = 0; // how 489 many leds to bounce up (max) 490 int bouncingPeaksNumOfLedsMin = 0; // 491 how many leds to bounce up (min) when using dynamicBouncingPeaks 492 int bouncingPeakDelay 493 = 0; // delay between peak bounce updates 494 int 495 bouncingPeakCounterInc = 180; // increase counter for each 496 bounce update. note: it uses a 0-180 sin function for the bouncing 497 498#elif 499 defined (led_strip_30) 500 //settings for a 30 led strip 501 502 int stripNumOfLeds 503 = 30; // the total number of leds 504 int stripsOn2Pins 505 = false; // set to true if the LED strips or rings 506 are connected to 2 input pins 507 uint32_t stripColor[16]; // 508 half of the number of leds + 1 509 int displayMiddleLed = true; // 510 display the middle led (blue). set to true for one strip, false for two strips or 511 rings 512 int splitStrip = false; // set to true 513 when using 2 strips or rings, false for one strip 514 int middleOffset = 1; // 515 offset for the middle led when using one strip 516 int startupAnimationDelay = 517 10; // delay for the startup animation 518 int orangeLimitAmount 519 = 0; // limit the amount of green of the middle LEDs 520 to make them more orange 521 int swapLeftRight = false; // 522 swap the left and right input values or not 523 524 int dropDelay = 10; // 525 hold time before dropping the leds 526 float dropFactor = .9; // 527 value for dropping the leds 528 529 int peakTimeNoDropDelay = 250; // 530 peak hold time when not dropping the peaks (set droppingPeak true or false) 531 532 int peakTimeFirstDropDelay = 150; // peak hold time when 533 dropping the first peak 534 int peakTimeDropDelay = 15; // 535 peak hold time when dropping the rest of the peaks 536 float peakDropFactor = .94; 537 // value for dropping the peaks 538 int droppingPeakFade 539 = false; // display the dropping peak fading to black 540 or not 541 542 int bouncingPeaksNumOfLeds = 4; // how 543 many leds to bounce up (max) 544 int bouncingPeaksNumOfLedsMin = 2; // 545 how many leds to bounce up (min) when using dynamicBouncingPeaks 546 int bouncingPeakDelay 547 = 4; // delay between peak bounce updates 548 int 549 bouncingPeakCounterInc = 9; // increase counter for each 550 bounce update. note: it uses a 0-180 sin function for the bouncing 551 552#elif 553 defined (led_2_rings_24) 554 //settings for 2 24 led rings 555 556 int stripNumOfLeds 557 = 48; 558 int stripsOn2Pins = false; 559 uint32_t stripColor[25]; 560 int displayMiddleLed 561 = false; 562 int splitStrip = true; 563 int middleOffset = 0; 564 int startupAnimationDelay 565 = 5; 566 int orangeLimitAmount = 0; 567 int swapLeftRight = false; 568 569 int 570 dropDelay = 2; 571 float dropFactor = .96; 572 573 int peakTimeNoDropDelay = 574 250; 575 int peakTimeFirstDropDelay = 100; 576 int peakTimeDropDelay = 10; 577 578 float peakDropFactor = .94; 579 int droppingPeakFade = false; 580 581 int 582 bouncingPeaksNumOfLeds = 4; 583 int bouncingPeaksNumOfLedsMin = 2; 584 int bouncingPeakDelay 585 = 4; 586 int bouncingPeakCounterInc = 9; 587 588#elif defined(led_2_rings_30) 589 590 //settings for 2 30 led rings 591 592 int stripNumOfLeds = 60; 593 int stripsOn2Pins 594 = false; 595 uint32_t stripColor[31]; 596 int displayMiddleLed = false; 597 int 598 splitStrip = true; 599 int middleOffset = 0; 600 int startupAnimationDelay = 5; 601 602 int orangeLimitAmount = 0; 603 int swapLeftRight = false; 604 605 int dropDelay 606 = 2; 607 float dropFactor = .96; 608 609 int peakTimeNoDropDelay = 250; 610 611 int peakTimeFirstDropDelay = 100; 612 int peakTimeDropDelay = 10; 613 float 614 peakDropFactor = .94; 615 int droppingPeakFade = false; 616 617 int bouncingPeaksNumOfLeds 618 = 4; 619 int bouncingPeaksNumOfLedsMin = 2; 620 int bouncingPeakDelay = 4; 621 622 int bouncingPeakCounterInc = 9; 623 624#elif defined (led_strip_200) 625 //settings 626 for a 200 led strip 627 628 int stripNumOfLeds = 200; 629 int stripsOn2Pins = 630 false; 631 uint32_t stripColor[101]; 632 int displayMiddleLed = false; 633 int 634 splitStrip = true; 635 int middleOffset = 0; 636 int startupAnimationDelay = 1; 637 638 int orangeLimitAmount = 0; 639 int swapLeftRight = false; 640 641 int dropDelay 642 = 10; 643 float dropFactor = .96; 644 645 int peakTimeNoDropDelay = 250; 646 647 int peakTimeFirstDropDelay = 100; 648 int peakTimeDropDelay = 30; 649 float 650 peakDropFactor = .99; 651 int droppingPeakFade = false; 652 653 int bouncingPeaksNumOfLeds 654 = 8; 655 int bouncingPeaksNumOfLedsMin = 4; 656 int bouncingPeakDelay = 4; 657 658 int bouncingPeakCounterInc = 9; 659 660#elif defined (led_strip_144) 661 //settings 662 for a 144 led strip 663 664 int stripNumOfLeds = 145; 665 int stripsOn2Pins = 666 false; 667 uint32_t stripColor[73]; 668 int displayMiddleLed = true; 669 int 670 splitStrip = false; 671 int middleOffset = 1; 672 int startupAnimationDelay = 673 1; 674 int orangeLimitAmount = 0; 675 int swapLeftRight = false; 676 677 int 678 dropDelay = 4; 679 float dropFactor = .92; 680 681 int peakTimeNoDropDelay = 682 250; 683 int peakTimeFirstDropDelay = 100; 684 int peakTimeDropDelay = 5; 685 686 float peakDropFactor = .94; 687 int droppingPeakFade = false; 688 689 int 690 bouncingPeaksNumOfLeds = 10; 691 int bouncingPeaksNumOfLedsMin = 4; 692 int bouncingPeakDelay 693 = 2; 694 int bouncingPeakCounterInc = 10; 695 696#elif defined (led_2_strip_63) 697 698 //settings for 2 63 led strips 699 700 int stripNumOfLeds = 63; 701 int stripsOn2Pins 702 = true; 703 uint32_t stripColor[64]; 704 int displayMiddleLed = true; 705 int 706 splitStrip = true; 707 int middleOffset = 0; 708 int startupAnimationDelay = 1; 709 710 int orangeLimitAmount = 0; 711 int swapLeftRight = false; 712 713 int dropDelay 714 = 5; 715 float dropFactor = .94; 716 717 int peakTimeNoDropDelay = 250; 718 719 int peakTimeFirstDropDelay = 70; 720 int peakTimeDropDelay = 7; 721 float peakDropFactor 722 = .94; 723 int droppingPeakFade = false; 724 725 int bouncingPeaksNumOfLeds 726 = 12; 727 int bouncingPeaksNumOfLedsMin = 4; 728 int bouncingPeakDelay = 4; 729 730 int bouncingPeakCounterInc = 10; 731 732#elif defined (led_2_strip_63_qr) 733 734 //settings for 2 63 led strips - quick response 735 736 int stripNumOfLeds = 737 63; 738 int stripsOn2Pins = true; 739 uint32_t stripColor[64]; 740 int displayMiddleLed 741 = false; 742 int splitStrip = true; 743 int middleOffset = 0; 744 int startupAnimationDelay 745 = 1; 746 int orangeLimitAmount = 0; 747 int swapLeftRight = false; 748 749 int 750 dropDelay = 4; 751 float dropFactor = .92; 752 753 int peakTimeNoDropDelay = 754 200; 755 int peakTimeFirstDropDelay = 60; 756 int peakTimeDropDelay = 6; 757 float 758 peakDropFactor = .92; 759 int droppingPeakFade = false; 760 761 int bouncingPeaksNumOfLeds 762 = 12; 763 int bouncingPeaksNumOfLedsMin = 4; 764 int bouncingPeakDelay = 3; 765 766 int bouncingPeakCounterInc = 10; 767#endif 768 769// 770// setup other user variables 771// 772 773// 774 basic settings 775int pulsing = true; // pulsing 776 will display from the middle of each strip or ring @EB 777 778int spinCircle = 779 true; // spin the animation. will not work with 780 stripsOn2Pins @EB 781 782int animType = 0; // 783 startup animation selection (1 looks nice for 1 ring) @EB 784int colorScheme = 785 10; // 0: green-red, 1: blue-green, 2: blue-red, 786 3: red-blue, 4: green-blue, 5: red-green, 6: blue-white-red 787 // 788 7: red-white-blue, 8: green-white-red, 9: green-white-blue, 10: color wheel, 11: 789 spinning color wheel, 790 // 12: as 11 791 but spread with factor colorScheme12Factor @EB 792int maxColorScheme = 12; // 793 used for looping through the color schemes with the switch button 794int colorScheme11SpinDelay 795 = stripNumOfLeds / 4 ; // delay for spinning scheme 11 796int colorScheme12Factor 797 = 3; // wheel spread factor for scheme 12 @EB 798 799int 800 minValue = 10; // min analog input value 801int 802 sensitivityValue = 110; // 0 - 255, initial value 803 (value read from the potentiometer if useSensorValues = true) 804 805#ifdef highLevelInput 806 807 int maxValue = 700; // max analog input value 808 (0-1023 equals 0-5V). try 300 for low level input, 700 for high 809 int maxSensitivity 810 = 2 * 255; // set to a higher setting to amplify low input 811 levels. try 4 * 255 for low level input, 2 * 255 for high 812#else 813 int maxValue 814 = 300; // max analog input value (0-1023 equals 815 0-5V). try 300 for low level input, 700 for high 816 int maxSensitivity = 4 * 255; 817 // set to a higher setting to amplify low input levels. 818 try 4 * 255 for low level input, 2 * 255 for high 819#endif 820 821int ledBrightness 822 = 30; // 0 - 255, initial value (value read from 823 the potentiometer if useSensorValues = true) 824int sensorDeviationBrightness = 825 3; // eliminate fluctuating values 826int overflowDelay = 827 10; // overflow hold time 828 829// peak settings 830 @EB 831int displayPeaks = false; // value will be 832 set by the switch if useSensorValues = true 833int displayTopAsPeak = true; // 834 always display the top LED in peak color 835int droppingPeak = true; // 836 display dropping peaks or not. note: displayPeaks has to be true 837int bouncingPeaks 838 = false; // display bouncing peaks or not. note: 839 displayPeaks has to be true 840int dynamicBouncingPeaks = false; // 841 bounce less with lower peaks. note: bouncingPeaks has to be true 842 843// 844// 845 initialize other variables 846// 847 848int numOfSegments, halfNumOfSegments, stripMiddle, 849 maxDisplaySegments; 850float sensitivityFactor; 851float nonLinearResponseFactor; 852 853int 854 brightnessValue, prevBrightnessValue; 855float ledFactor, ledFactor_div_numOfSegments; 856 857uint32_t 858 stripMiddleColor, stripOverflowColor, stripHoldColor; 859uint32_t colorValue; 860 861int 862 leftValue = 0, rightValue = 0, maxReadValue = 0; 863int leftValueN = 0, rightValueN 864 = 0; 865int leftAnalogValue = 0, rightAnalogValue = 0; 866float log10MaxDisplaySegments; 867 868int 869 prevLeftValue = 0, prevRightValue = 0; 870int prevLeftAnalogValue = 0, prevRightAnalogValue 871 = 0; 872 873int selectButton1PinState = 0, prevSelectButton1PinState = 0; 874int 875 selectButton2PinState = 0, prevSelectButton2PinState = 0; 876 877int selectButton1PinSetting 878 = colorScheme; 879int selectButton2PinSetting = 0; 880 881int i, j; 882int dropLeft, 883 dropRight; 884int leftDropTime, rightDropTime; 885 886int leftPeak = 0, rightPeak 887 = 0; 888int leftPeakTime = 0, rightPeakTime = 0; 889int leftFirstPeak = true, rightFirstPeak 890 = true; 891int showPeaksPinSetting, prevShowPeaksPinSetting; 892 893int stripPulseMiddle 894 = 0; 895int halfLeftValue, halfRightValue, halfPrevLeftValue, halfPrevRightValue; 896 897int 898 leftPeakBouncing = false, rightPeakBouncing = false; 899int leftPeakBounce = 0, 900 rightPeakBounce = 0; 901int prevLeftPeakBounce = 0, prevRightPeakBounce = 0; 902int 903 leftPeakBounceCounter = 0, rightPeakBounceCounter = 0; 904int leftPeakBounceDelayCounter 905 = 0, rightPeakBounceDelayCounter = 0; 906int leftBouncingPeaksNumOfLeds = 0, rightBouncingPeaksNumOfLeds 907 = 0; 908float bounceFactor; 909 910int colorScheme11SpinValue = 0, colorScheme11SpinDelayValue 911 = 0; 912int colorSchemeFactor = 1; 913long selectButton1Timer; 914 915int spinDelayCounter 916 = 0, spinCounter = 0, spinTurnsCounter = 0, spinTurnsMax = 0, spinTurnsDelay = 0, 917 spinTurnsDelayMax = 0; 918int spinCounterInc = 1; 919int spinDelay = 0; 920// 921// 922 initialize the strip or rings 923// 924 925Adafruit_NeoPixel left_strip = Adafruit_NeoPixel(stripNumOfLeds, 926 leftStripPin, NEO_GRB + NEO_KHZ800); 927Adafruit_NeoPixel right_strip = Adafruit_NeoPixel(stripNumOfLeds, 928 rightStripPin, NEO_GRB + NEO_KHZ800); 929 930// 931// setup 932// 933 934void setup() 935 { 936 #ifdef DEBUG 937 Serial.begin(9600); 938 #endif 939 940 randomSeed(analogRead(2)); 941 942 943 if (stripsOn2Pins) { 944 numOfSegments = stripNumOfLeds; 945 maxDisplaySegments 946 = numOfSegments - 1; 947 948 stripMiddle = stripNumOfLeds; 949 stripPulseMiddle 950 = stripMiddle / 2; 951 spinCircle = false; 952 } 953 else { 954 numOfSegments 955 = stripNumOfLeds / 2; 956 stripMiddle = stripNumOfLeds / 2; 957 maxDisplaySegments 958 = stripMiddle - 1; 959 960 stripPulseMiddle = stripMiddle / 2; 961 } 962 963 964 halfNumOfSegments = numOfSegments / 2; 965 bounceFactor = (float) bouncingPeaksNumOfLeds 966 / (maxDisplaySegments - bouncingPeaksNumOfLeds); 967 nonLinearResponseFactor = 968 90 / (float) maxDisplaySegments; 969 log10MaxDisplaySegments = log10(maxDisplaySegments); 970 971 972 pinMode(showPeaksPin, INPUT); 973 974 if (useSelectButton1) 975 pinMode(selectButton1Pin, 976 INPUT); 977 978 left_strip.begin(); 979 if (stripsOn2Pins) 980 right_strip.begin(); 981 982 983 if (useSensorValues) { 984 readSensorValues(); 985 setInitialDisplayPeaks(); 986 987 } 988 else { 989 setStripColors(); 990 setSensitivityFactor(); 991 } 992 993 994 #ifdef DEBUG_TEST_LEDS 995 displayTest(); 996 #endif 997 998 startupAnimation(); 999} 1000 1001// 1002// 1003 main loop 1004// 1005 1006void loop() { 1007 #ifdef DEBUG_PRINT_LOOP_TIME 1008 long 1009 time = millis(); 1010 #endif 1011 1012 1013 if (useSensorValues) 1014 readSensorValues(); 1015 1016 1017 readValues(); 1018 1019 #if defined (DEBUG_NO_PEAKS) 1020 displayPeaks 1021 = false; 1022 #endif 1023 1024 #if defined (DEBUG_PEAKS) 1025 displayPeaks = true; 1026 1027 #endif 1028 1029 if (pulsing) { 1030 drawPulsingValues(); 1031 } 1032 else { 1033 1034 drawValues(); 1035 if (displayPeaks) { 1036 getPeaks(); 1037 drawPeaks(); 1038 1039 } 1040 } 1041 1042 left_strip.show(); 1043 if (stripsOn2Pins) 1044 right_strip.show(); 1045 1046 1047 storePrevValues(); 1048 1049 checkSpinCircle(); 1050 1051 #ifdef DEBUG_PRINT_LOOP_TIME 1052 1053 time = millis() - time; 1054 Serial.println(time); 1055 #endif 1056} 1057 1058// 1059 1060// functions 1061// 1062 1063void setInitialDisplayPeaks() { 1064 #if !defined 1065 (DEBUG_NO_PEAK_SWITCH) 1066 showPeaksPinSetting = digitalRead(showPeaksPin); 1067 1068 1069 if (showPeaksPinSetting == HIGH) 1070 displayPeaks = false; 1071 #endif 1072 1073 1074 if (reverseShowPeaks) { 1075 if (!displayPeaks) 1076 displayPeaks 1077 = true; 1078 else 1079 displayPeaks = false; 1080 } 1081 1082 prevShowPeaksPinSetting 1083 = showPeaksPinSetting; 1084} 1085 1086void readSensorValues() { 1087 // 1088 // peaks 1089 pin 1090 // 1091 1092 #if !defined (DEBUG_NO_PEAK_SWITCH) 1093 showPeaksPinSetting 1094 = digitalRead(showPeaksPin); 1095 1096 if (showPeaksMomentarySwitch) { 1097 if 1098 (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) { 1099 if 1100 (displayPeaks == true) { 1101 displayPeaks = false; 1102 clearLeftPeak(); 1103 1104 clearRightPeak(); 1105 if (showPeaksMomentarySwitch) 1106 1107 while (digitalRead(showPeaksPin) == LOW) {} 1108 } 1109 else 1110 { 1111 displayPeaks = true; 1112 } 1113 } 1114 } 1115 else 1116 { 1117 if (reverseShowPeaks) { 1118 if (showPeaksPinSetting == HIGH && 1119 prevShowPeaksPinSetting == LOW) 1120 displayPeaks = true; 1121 else 1122 if (showPeaksPinSetting == LOW && prevShowPeaksPinSetting == HIGH) { 1123 displayPeaks 1124 = false; 1125 clearLeftPeak(); 1126 clearRightPeak(); 1127 1128 } 1129 } 1130 else { 1131 if (showPeaksPinSetting == LOW 1132 && prevShowPeaksPinSetting == HIGH) 1133 displayPeaks = true; 1134 else 1135 if (showPeaksPinSetting == HIGH && prevShowPeaksPinSetting == LOW) { 1136 displayPeaks 1137 = false; 1138 clearLeftPeak(); 1139 clearRightPeak(); 1140 1141 } 1142 } 1143 } 1144 if (pulsing) { 1145 if (displayPeaks) 1146 1147 displayTopAsPeak = true; 1148 else 1149 displayTopAsPeak = false; 1150 1151 } 1152 1153 prevShowPeaksPinSetting = showPeaksPinSetting; 1154 #endif 1155 1156 1157 1158 // 1159 // selectButtonPin 1 and 2 1160 // 1161 if (useSelectButton1) 1162 { 1163 selectButton1PinState = digitalRead(selectButton1Pin); 1164 1165 1166 if (selectButton1PinState == HIGH && prevSelectButton1PinState == LOW) 1167 selectButton1Timer 1168 = millis(); 1169 1170 if (selectButton1PinState == HIGH && prevSelectButton1PinState 1171 == HIGH) { 1172 if ((millis() - selectButton1Timer) > 1000) { 1173 pulsing 1174 = !pulsing; 1175 setStripColors(); 1176 displayNumber(colorScheme, 250); 1177 1178 1179 while (digitalRead(selectButton1Pin) == HIGH) {} 1180 selectButton1PinState 1181 = LOW; 1182 clearValues(); 1183 } 1184 } 1185 else if (selectButton1PinState 1186 == LOW && prevSelectButton1PinState == HIGH) { 1187 selectButton1PinSetting++; 1188 1189 if (selectButton1PinSetting > maxColorScheme) { 1190 selectButton1PinSetting 1191 = 0; 1192 } 1193 colorScheme = selectButton1PinSetting; 1194 1195 if 1196 (colorScheme == 12) 1197 colorScheme11SpinValue = (colorScheme11SpinValue 1198 * colorScheme12Factor); 1199 1200 setStripColors(); 1201 displayNumber(colorScheme, 1202 250); 1203 } 1204 prevSelectButton1PinState = selectButton1PinState; 1205 } 1206 1207 1208 if (useSelectButton2) { 1209 selectButton2PinState = digitalRead(selectButton2Pin); 1210 1211 1212 if (selectButton2PinState == HIGH && prevSelectButton2PinState == LOW) 1213 { 1214 selectButton2PinSetting++; 1215 1216 switch(selectButton2PinSetting) 1217 { 1218 case 0: 1219 case 3: { 1220 pulsing = false; 1221 spinCircle 1222 = false; 1223 selectButton2PinSetting = 0; 1224 break; 1225 } 1226 1227 case 1: { 1228 pulsing = true; 1229 spinCircle= false; 1230 1231 break; 1232 } 1233 case 2: { 1234 pulsing = true; 1235 1236 spinCircle = true; 1237 break; 1238 } 1239 } 1240 1241 1242 setStripColors(); 1243 displayNumber(colorScheme, 250); 1244 } 1245 1246 1247 prevSelectButton2PinState = selectButton2PinState; 1248 } 1249 1250 // 1251 1252 // brightness 1253 // 1254 brightnessValue = analogRead(brightnessPin); 1255 brightnessValue 1256 = map(brightnessValue, 0, 1023, 0, 255); 1257 1258 if (abs(brightnessValue - prevBrightnessValue) 1259 > sensorDeviationBrightness) { 1260 ledBrightness = brightnessValue; 1261 setStripColors(); 1262 1263 prevBrightnessValue = brightnessValue; 1264 } 1265 1266 // 1267 // colorscheme 1268 11 spinning wheel 1269 // 1270 1271 if (colorScheme == 11 || colorScheme == 12) { 1272 1273 colorScheme11SpinDelayValue++; 1274 if (colorScheme11SpinDelayValue == colorScheme11SpinDelay) 1275 { 1276 colorScheme11SpinDelayValue = 0; 1277 colorScheme11SpinValue++; 1278 1279 if (colorScheme11SpinValue > maxDisplaySegments * colorSchemeFactor) 1280 colorScheme11SpinValue 1281 = 0; 1282 setStripColors(); 1283 } 1284 } 1285 1286 // 1287 // sensitivity 1288 1289 // 1290 sensitivityValue = analogRead(sensitivityPin); 1291 sensitivityValue = 1292 map(sensitivityValue, 0, 1023, 0, 255); 1293 setSensitivityFactor(); 1294} 1295 1296void 1297 setSensitivityFactor() { 1298 //sensitivityValue_div_numOfSegments = sensitivityValue 1299 / numOfSegments; 1300 sensitivityFactor = ((float) sensitivityValue / 255 * (float) 1301 maxSensitivity / 255); 1302} 1303 1304void readValues() { 1305 #ifdef averageReadings 1306 1307 leftAnalogValue = 0; 1308 rightAnalogValue = 0; 1309 1310 for (i = 0; 1311 i <= averageNumOfReadings; i++) { 1312 leftAnalogValue += analogRead(leftPin); 1313 1314 rightAnalogValue += analogRead(rightPin); 1315 } 1316 1317 leftAnalogValue 1318 /= averageNumOfReadings; 1319 rightAnalogValue /= averageNumOfReadings; 1320 1321 1322 #else 1323 leftAnalogValue = analogRead(leftPin); 1324 rightAnalogValue 1325 = analogRead(rightPin); 1326 #endif 1327 1328 if (swapLeftRight) { 1329 int tempValue 1330 = leftAnalogValue; 1331 leftAnalogValue = rightAnalogValue; 1332 rightAnalogValue 1333 = tempValue; 1334 } 1335 1336 if (leftAnalogValue < prevLeftAnalogValue) { 1337 leftDropTime++; 1338 1339 if (leftDropTime > dropDelay) { 1340 leftAnalogValue = prevLeftAnalogValue 1341 * dropFactor; 1342 leftDropTime = 0; 1343 } 1344 else 1345 leftAnalogValue 1346 = prevLeftAnalogValue; 1347 } 1348 1349 if (rightAnalogValue < prevRightAnalogValue) 1350 { 1351 rightDropTime++; 1352 if (rightDropTime > dropDelay) { 1353 rightAnalogValue 1354 = prevRightAnalogValue * dropFactor; 1355 rightDropTime = 0; 1356 } 1357 else 1358 1359 rightAnalogValue = prevRightAnalogValue; 1360 } 1361 1362 #ifdef DEBUG_PRINT_ANALOGVALUES 1363 1364 Serial.print(leftAnalogValue); 1365 Serial.print(" "); 1366 Serial.println(rightAnalogValue); 1367 1368 #endif 1369 1370 // map values 1371 leftValue = map(leftAnalogValue * sensitivityFactor, 1372 minValue, maxValue, 0, maxDisplaySegments); 1373 rightValue = map(rightAnalogValue 1374 * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 1375 1376 // if 1377 defined, convert to (reverse) non linear response 1378 boolean flagNonLinear = false; 1379 1380 1381 #if defined (nonLinearSinAudio) 1382 flagNonLinear = true; 1383 leftValueN 1384 = ((sin(((leftValue * nonLinearResponseFactor) + 270) * 0.0174533) + 1) * maxDisplaySegments); 1385 1386 rightValueN = ((sin(((rightValue * nonLinearResponseFactor) + 270) * 0.0174533) 1387 + 1) * maxDisplaySegments); 1388 1389 #elif defined (nonLinearReverseSinAudio) 1390 1391 flagNonLinear = true; 1392 leftValueN = ((sin(((leftValue * nonLinearResponseFactor)) 1393 * 0.0174533)) * maxDisplaySegments); 1394 rightValueN = ((sin(((rightValue * nonLinearResponseFactor)) 1395 * 0.0174533)) * maxDisplaySegments); 1396 1397 #elif defined (nonLinearLogAudio) 1398 1399 flagNonLinear = true; 1400 leftValueN = ((log10(leftValue + 1) / log10MaxDisplaySegments 1401 * maxDisplaySegments)); 1402 rightValueN = ((log10(rightValue + 1) / log10MaxDisplaySegments 1403 * maxDisplaySegments)); 1404 1405 #endif 1406 1407 if (flagNonLinear == true) 1408 { 1409 #if defined (nonLinearAvr2) 1410 leftValue = (leftValue + leftValueN) 1411 / 2; 1412 rightValue = (rightValue + rightValueN) / 2; 1413 #else 1414 leftValue 1415 = leftValueN; 1416 rightValue = rightValueN; 1417 #endif 1418 } 1419 1420// 1421 @EB_DEBUG 1422 1423 #ifdef displayOverflow 1424 #ifdef compressOverflowPeaks 1425 1426 for (i = 1; i <= compressOverflowNumOfTimes; i++) { 1427 if (leftValue 1428 > maxDisplaySegments) { 1429// Serial.print(i); 1430// Serial.print(" 1431 "); 1432// Serial.print(leftValue); 1433// Serial.print(" 1434 "); 1435 leftValue = leftValue - leftValue * compressOverflowFactor * 1436 i; 1437// Serial.print(leftValue); 1438// Serial.print(" "); 1439// 1440 Serial.println(maxDisplaySegments); 1441 } 1442 } 1443 #endif 1444 1445 #endif 1446 1447 if (leftValue > maxDisplaySegments) { 1448 leftValue 1449 = maxDisplaySegments; 1450 #ifdef displayOverflow 1451 drawOverflow(); 1452 1453 #endif 1454 } 1455 1456 #ifdef displayOverflow 1457 #ifdef compressOverflowPeaks 1458 1459 if (rightValue > maxDisplaySegments) 1460 rightValue = rightValue - 1461 rightValue * compressOverflowFactor; 1462 #endif 1463 #endif 1464 1465 if (rightValue 1466 > maxDisplaySegments) { 1467 rightValue = maxDisplaySegments; 1468 #ifdef displayOverflow 1469 1470 drawOverflow(); 1471 #endif 1472 } 1473} 1474 1475void storePrevValues() { 1476 1477 prevLeftAnalogValue = leftAnalogValue; 1478 prevRightAnalogValue = rightAnalogValue; 1479 1480 1481 prevLeftValue = leftValue; 1482 prevRightValue = rightValue; 1483} 1484 1485void 1486 getPeaks() { 1487 if (leftValue > leftPeak) { 1488 if (dynamicBouncingPeaks || 1489 prevLeftPeakBounce > 0) 1490 clearLeftBouncePeak(); 1491 1492 leftPeak 1493 = leftValue; 1494 leftPeakTime = 0; 1495 leftFirstPeak = true; 1496 1497 if 1498 (bouncingPeaks) { 1499 leftPeakBouncing = true; 1500 leftPeakBounceCounter 1501 = 0; 1502 leftPeakBounceDelayCounter = 0; 1503 1504 if (dynamicBouncingPeaks) 1505 1506 leftBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (leftPeak * 1507 bounceFactor)); 1508 else 1509 leftBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds; 1510 1511 } 1512 } 1513 else { 1514 leftPeakTime++; 1515 if (droppingPeak) { 1516 if 1517 (leftFirstPeak) { 1518 if (leftPeakTime > peakTimeFirstDropDelay) { 1519 clearLeftPeak(); 1520 1521 leftFirstPeak = false; 1522 } 1523 } 1524 else { 1525 if 1526 (leftPeakTime > peakTimeDropDelay) { 1527 clearLeftPeak(); 1528 } 1529 1530 } 1531 } 1532 else { 1533 if (leftPeakTime > peakTimeNoDropDelay) 1534 { 1535 clearLeftPeak(); 1536 } 1537 } 1538 } 1539 1540 if (leftPeakBouncing) 1541 { 1542 if (leftFirstPeak) { 1543 leftPeakBounceDelayCounter++; 1544 if 1545 (leftPeakBounceDelayCounter >= bouncingPeakDelay) { 1546 leftPeakBounceDelayCounter 1547 = 0; 1548 leftPeakBounceCounter += bouncingPeakCounterInc; 1549 if (leftPeakBounceCounter 1550 >= 180) { 1551 clearLeftBouncePeak(); 1552 clearLeftBounce(); 1553 1554 } 1555 else { 1556 leftPeakBounce = min((sin(leftPeakBounceCounter 1557 * 0.0174533) * leftBouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak)); 1558 1559 if (leftPeakBounce != prevLeftPeakBounce) { 1560 clearLeftBouncePeak(); 1561 1562 } 1563 prevLeftPeakBounce = leftPeakBounce; 1564 } 1565 } 1566 1567 } 1568 } 1569 1570 if (rightValue > rightPeak) { 1571 if (dynamicBouncingPeaks 1572 || prevRightPeakBounce > 0) 1573 clearRightBouncePeak(); 1574 1575 rightPeak 1576 = rightValue; 1577 rightPeakTime = 0; 1578 rightFirstPeak = true; 1579 1580 if 1581 (bouncingPeaks) { 1582 rightPeakBouncing = true; 1583 rightPeakBounceCounter 1584 = 0; 1585 rightPeakBounceDelayCounter = 0; 1586 1587 if (dynamicBouncingPeaks) 1588 1589 rightBouncingPeaksNumOfLeds = max(bouncingPeaksNumOfLedsMin, (rightPeak 1590 * bounceFactor)); 1591 else 1592 rightBouncingPeaksNumOfLeds = bouncingPeaksNumOfLeds; 1593 1594 } 1595 } 1596 else { 1597 rightPeakTime++; 1598 if (droppingPeak) { 1599 1600 if (rightFirstPeak) { 1601 if (rightPeakTime > peakTimeFirstDropDelay) 1602 { 1603 clearRightPeak(); 1604 rightFirstPeak = false; 1605 } 1606 1607 } 1608 else { 1609 if (rightPeakTime > peakTimeDropDelay) 1610 clearRightPeak(); 1611 1612 } 1613 } 1614 else { 1615 if (rightPeakTime > peakTimeNoDropDelay) 1616 1617 clearRightPeak(); 1618 } 1619 } 1620 1621 if (rightPeakBouncing) { 1622 1623 if (rightFirstPeak) { 1624 rightPeakBounceDelayCounter++; 1625 if (rightPeakBounceDelayCounter 1626 >= bouncingPeakDelay) { 1627 rightPeakBounceDelayCounter = 0; 1628 rightPeakBounceCounter 1629 += bouncingPeakCounterInc; 1630 1631 if (rightPeakBounceCounter >= 180) { 1632 1633 clearRightBouncePeak(); 1634 clearRightBounce(); 1635 } 1636 1637 else { 1638 rightPeakBounce = min((sin(rightPeakBounceCounter 1639 * 0.0174533) * rightBouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak)); 1640 1641 if (rightPeakBounce != prevRightPeakBounce) { 1642 clearRightBouncePeak(); 1643 1644 } 1645 prevRightPeakBounce = rightPeakBounce; 1646 } 1647 1648 } 1649 } 1650 } 1651} 1652 1653void checkSpinCircle () { 1654 if (spinCircle) 1655 { 1656 if (spinTurnsMax == 0) { 1657 spinTurnsMax = random(stripNumOfLeds 1658 / 4, stripNumOfLeds * 3); // spin at least a quarter turn, max 3 turns 1659 1660 1661 if (random(10) > 4) 1662 spinCounterInc = -spinCounterInc; 1663 1664 1665 spinTurnsDelayMax = random(100, 1000); // @EB_DEBUG 1666 1667 spinDelay 1668 = random(20, 75); // @EB_DEBUG 1669 } 1670 1671 if (spinTurnsCounter == spinTurnsMax) 1672 { 1673 spinTurnsDelay++; 1674 if (spinTurnsDelay == spinTurnsDelayMax) { 1675 1676 spinTurnsDelay = 0; 1677 spinTurnsCounter = 0; 1678 spinTurnsMax 1679 = 0; 1680 } 1681 } 1682 else { 1683 spinDelayCounter++; 1684 1685 if 1686 (spinDelayCounter > spinDelay) { 1687 clearZeroAndPeaks(); 1688 1689 spinCounter 1690 += spinCounterInc; 1691 if (spinCounter > stripNumOfLeds) 1692 spinCounter 1693 = 0; 1694 else if (spinCounter < 0) 1695 spinCounter = stripNumOfLeds; 1696 1697 1698 spinTurnsCounter++; 1699 spinDelayCounter = 0; 1700 } 1701 } 1702 1703 } 1704} 1705 1706int getSpinCircleValue(int value) { 1707 if (!spinCircle) 1708 return 1709 value; 1710 else { 1711 int calcValue = value + spinCounter; 1712 if (calcValue 1713 >= stripNumOfLeds) 1714 calcValue -= stripNumOfLeds; 1715 return calcValue; 1716 1717 } 1718} 1719 1720void drawValues() { 1721 if (splitStrip) { 1722 for (i = middleOffset; 1723 i < leftValue; i++) 1724 left_strip.setPixelColor(getSpinCircleValue(i), stripColor[i]); 1725 1726 1727 if (!displayPeaks && displayTopAsPeak) 1728 left_strip.setPixelColor(getSpinCircleValue(leftValue), 1729 stripHoldColor); 1730 1731 for (i = prevLeftValue; i >= leftValue; i--) 1732 left_strip.setPixelColor(getSpinCircleValue(i), 1733 0); 1734 1735 if (stripsOn2Pins) { 1736 for (i = middleOffset; i < rightValue; 1737 i++) 1738 right_strip.setPixelColor(i, stripColor[i]); 1739 1740 if (!displayPeaks 1741 && displayTopAsPeak) 1742 right_strip.setPixelColor(rightValue, stripHoldColor); 1743 1744 1745 for (i = prevRightValue; i >= rightValue; i--) 1746 right_strip.setPixelColor(i, 1747 0); 1748 } 1749 else { 1750 for (i = middleOffset; i < rightValue; i++) 1751 1752 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]); 1753 1754 1755 if (!displayPeaks && displayTopAsPeak) 1756 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1757 + rightValue), stripHoldColor); 1758 1759 for (i = prevRightValue; i 1760 >= rightValue; i--) 1761 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1762 + i), 0); 1763 } 1764 } 1765 else { 1766 for (i = middleOffset; i < leftValue; 1767 i++) 1768 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), stripColor[i]); 1769 1770 1771 if (!displayPeaks && displayTopAsPeak) 1772 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1773 + leftValue), stripHoldColor); 1774 1775 for (i = prevLeftValue; i >= leftValue; 1776 i--) 1777 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + i), 0); 1778 1779 1780 for (i = middleOffset; i < rightValue; i++) 1781 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1782 - i), stripColor[i]); 1783 1784 if (!displayPeaks && displayTopAsPeak) 1785 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1786 - rightValue), stripHoldColor); 1787 1788 for (i = prevRightValue; i >= rightValue; 1789 i--) 1790 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - i), 0); 1791 1792 } 1793 1794 if (displayMiddleLed) 1795 left_strip.setPixelColor(getSpinCircleValue(stripMiddle), 1796 stripMiddleColor); 1797} 1798 1799void drawPulsingValues() { 1800 halfLeftValue = (leftValue 1801 + 1) / 2; 1802 halfRightValue = (rightValue + 1) / 2; 1803 halfPrevLeftValue = (prevLeftValue 1804 + 1)/ 2; 1805 halfPrevRightValue = (prevRightValue + 1) / 2; 1806 1807 if (splitStrip) 1808 { 1809 for (i = 0; i < halfLeftValue; i++) { 1810 colorValue = stripColor[i 1811 * 2]; 1812 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle + i), 1813 colorValue); 1814 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1815 - i), colorValue); 1816 } 1817 1818 if (displayTopAsPeak) { 1819 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1820 + halfLeftValue), stripHoldColor); 1821 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1822 - halfLeftValue), stripHoldColor); 1823 } 1824 1825 for (i = halfPrevLeftValue; 1826 i >= halfLeftValue; i--) { 1827 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1828 + i), 0); 1829 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1830 - i), 0); 1831 } 1832 1833 if (stripsOn2Pins) { 1834 for (i = 0; i < halfRightValue; 1835 i++) { 1836 colorValue = stripColor[i * 2]; 1837 right_strip.setPixelColor((stripPulseMiddle 1838 + i), colorValue); 1839 right_strip.setPixelColor((stripPulseMiddle - i), 1840 colorValue); 1841 } 1842 1843 if (displayTopAsPeak) { 1844 right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1845 + halfRightValue), stripHoldColor); 1846 right_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1847 - halfRightValue), stripHoldColor); 1848 } 1849 1850 for (i = halfPrevRightValue; 1851 i >= halfRightValue; i--) { 1852 right_strip.setPixelColor((stripPulseMiddle 1853 + i), 0); 1854 right_strip.setPixelColor((stripPulseMiddle - i), 0); 1855 } 1856 1857 } 1858 else { 1859 for (i = 0; i < halfRightValue; i++) { 1860 colorValue 1861 = colorValue = stripColor[i * 2]; 1862 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1863 + stripPulseMiddle + i), colorValue); 1864 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1865 + stripPulseMiddle - i), colorValue); 1866 } 1867 1868 if (displayTopAsPeak) 1869 { 1870 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle 1871 + halfRightValue), stripHoldColor); 1872 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1873 + stripPulseMiddle - halfRightValue), stripHoldColor); 1874 } 1875 1876 for 1877 (i = halfPrevRightValue; i >= halfRightValue; i--) { 1878 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1879 + stripPulseMiddle + i), 0); 1880 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1881 + stripPulseMiddle - i), 0); 1882 } 1883 } 1884 } 1885 else { 1886 for (i 1887 = 0; i < halfLeftValue; i++) { 1888 colorValue = colorValue = stripColor[i * 1889 2]; 1890 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle 1891 + i), colorValue); 1892 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1893 + stripPulseMiddle - i), colorValue); 1894 } 1895 1896 if (displayTopAsPeak) 1897 { 1898 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + stripPulseMiddle 1899 + halfLeftValue), stripHoldColor); 1900 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1901 + stripPulseMiddle - halfLeftValue), stripHoldColor); 1902 } 1903 1904 for 1905 (i = halfPrevLeftValue; i >= halfLeftValue; i--) { 1906 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1907 + stripPulseMiddle + i), 0); 1908 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1909 + stripPulseMiddle - i), 0); 1910 } 1911 1912 for (i = 0; i < halfRightValue; 1913 i++) { 1914 colorValue = colorValue = stripColor[i * 2]; 1915 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1916 - (stripPulseMiddle + i)), colorValue); 1917 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1918 - (stripPulseMiddle - i)), colorValue); 1919 } 1920 1921 if (displayTopAsPeak) 1922 { 1923 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (stripPulseMiddle 1924 + halfRightValue)), stripHoldColor); 1925 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1926 - (stripPulseMiddle - halfRightValue)), stripHoldColor); 1927 } 1928 1929 for 1930 (i = halfPrevRightValue; i >= halfRightValue; i--) { 1931 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1932 - (stripPulseMiddle + i)), 0); 1933 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1934 - (stripPulseMiddle - i)), 0); 1935 } 1936 } 1937 1938 if (displayMiddleLed) { 1939 1940 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - stripPulseMiddle), 1941 stripMiddleColor); 1942 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1943 + stripPulseMiddle), stripMiddleColor); 1944 } 1945} 1946 1947void clearZeroAndPeaks() 1948 { 1949 left_strip.setPixelColor(getSpinCircleValue(middleOffset), 0); 1950 left_strip.setPixelColor(getSpinCircleValue(stripMiddle), 1951 0); 1952 1953 if (displayTopAsPeak) { 1954 if (splitStrip) { 1955 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1956 + halfLeftValue), 0); 1957 left_strip.setPixelColor(getSpinCircleValue(stripPulseMiddle 1958 - halfLeftValue), 0); 1959 1960 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1961 + stripPulseMiddle + halfRightValue), 0); 1962 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1963 + stripPulseMiddle - halfRightValue), 0); 1964 } 1965 else { 1966 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1967 + stripPulseMiddle + halfLeftValue), 0); 1968 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1969 + stripPulseMiddle - halfLeftValue), 0); 1970 1971 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1972 - (stripPulseMiddle + halfRightValue)), 0); 1973 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1974 - (stripPulseMiddle - halfRightValue)), 0); 1975 } 1976 } 1977} 1978 1979void drawPeaks() 1980 { 1981 if (leftPeak > 0) { 1982 if (droppingPeakFade && leftPeakBouncing == 1983 false) 1984 stripHoldColor = left_strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 1985 0, 0); 1986 else 1987 stripHoldColor = stripColor[numOfSegments]; 1988 1989 1990 if (splitStrip) 1991 left_strip.setPixelColor(getSpinCircleValue(leftPeak 1992 + leftPeakBounce), stripHoldColor); 1993 else 1994 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 1995 + (leftPeak + leftPeakBounce)), stripHoldColor); 1996 } 1997 1998 if (rightPeak 1999 > 0) { 2000 if (droppingPeakFade && rightPeakBouncing == false) 2001 stripHoldColor 2002 = left_strip.Color(max(1, (255 * rightPeak * ledFactor_div_numOfSegments)), 0, 0); 2003 2004 else 2005 stripHoldColor = stripColor[numOfSegments]; 2006 2007 if 2008 (splitStrip) { 2009 if (stripsOn2Pins) { 2010 right_strip.setPixelColor(getSpinCircleValue(rightPeak 2011 + rightPeakBounce), stripHoldColor); 2012 } 2013 else { 2014 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2015 + rightPeak + rightPeakBounce), stripHoldColor); 2016 } 2017 } 2018 else 2019 { 2020 left_strip.setPixelColor(getSpinCircleValue(stripMiddle - (rightPeak 2021 + rightPeakBounce)), stripHoldColor); 2022 } 2023 } 2024 2025 //if (leftPeak > 2026 0 || rightPeak > 0) 2027 // left_strip.show(); 2028} 2029 2030void clearLeftPeak() 2031 { 2032 if (splitStrip) 2033 left_strip.setPixelColor(getSpinCircleValue(leftPeak 2034 + prevLeftPeakBounce), 0); 2035 else 2036 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2037 + (leftPeak + prevLeftPeakBounce)), 0); 2038 2039 if (droppingPeak) 2040 leftPeak 2041 = leftPeak * peakDropFactor; 2042 else 2043 leftPeak = 0; 2044 leftPeakTime = 2045 0; 2046} 2047 2048void clearRightPeak() { 2049 if (splitStrip) { 2050 if( stripsOn2Pins) 2051 { 2052 right_strip.setPixelColor(getSpinCircleValue(rightPeak + prevRightPeakBounce), 2053 0); 2054 } 2055 else { 2056 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2057 + rightPeak + prevRightPeakBounce), 0); 2058 } 2059 } 2060 else { 2061 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2062 - (rightPeak + prevRightPeakBounce)), 0); 2063 } 2064 2065 if (droppingPeak) 2066 2067 rightPeak = rightPeak * peakDropFactor; 2068 else 2069 rightPeak = 0; 2070 2071 rightPeakTime = 0; 2072} 2073 2074void clearLeftBouncePeak() { 2075 if (splitStrip) 2076 2077 left_strip.setPixelColor(getSpinCircleValue(leftPeak + prevLeftPeakBounce), 2078 0); 2079 else 2080 left_strip.setPixelColor(getSpinCircleValue(stripMiddle + (leftPeak 2081 + prevLeftPeakBounce)), 0); 2082} 2083 2084void clearRightBouncePeak() { 2085 if (splitStrip) 2086 { 2087 if (stripsOn2Pins) { 2088 right_strip.setPixelColor(getSpinCircleValue(rightPeak 2089 + prevRightPeakBounce), 0); 2090 } 2091 else { 2092 left_strip.setPixelColor(getSpinCircleValue((stripMiddle 2093 + rightPeak + prevRightPeakBounce)), 0); 2094 } 2095 } 2096 else { 2097 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2098 - (rightPeak + prevRightPeakBounce)), 0); 2099 } 2100} 2101 2102void clearLeftBounce() 2103 { 2104 leftPeakBouncing = false; 2105 leftPeakBounceCounter = 0; 2106 leftPeakBounce 2107 = 0; 2108 prevLeftPeakBounce = 0; 2109 leftBouncingPeaksNumOfLeds = 0; 2110} 2111 2112void 2113 clearRightBounce() { 2114 rightPeakBouncing = false; 2115 rightPeakBounceCounter 2116 = 0; 2117 rightPeakBounce = 0; 2118 prevRightPeakBounce = 0; 2119 leftBouncingPeaksNumOfLeds 2120 = 0; 2121} 2122 2123void clearValues() { 2124 leftAnalogValue = 0; 2125 rightAnalogValue 2126 = 0; 2127 prevLeftAnalogValue = 0; 2128 prevRightAnalogValue = 0; 2129 leftPeak 2130 = 0; 2131 rightPeak = 0; 2132} 2133 2134 2135void drawOverflow() { 2136 for (i = 0; 2137 i <= numOfSegments; i++) { 2138 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2139 - i), stripOverflowColor); 2140 if (stripsOn2Pins) { 2141 right_strip.setPixelColor(i, 2142 stripOverflowColor); 2143 } 2144 else { 2145 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2146 + i), stripOverflowColor); 2147 } 2148 } 2149 left_strip.show(); 2150 if (stripsOn2Pins) 2151 2152 right_strip.show(); 2153 2154 delay(overflowDelay); 2155 2156 for (i = 0; i 2157 <= numOfSegments; i++) { 2158 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2159 - i), 0); 2160 if (stripsOn2Pins) { 2161 right_strip.setPixelColor(i, 0); 2162 2163 } 2164 else { 2165 left_strip.setPixelColor(getSpinCircleValue(stripMiddle 2166 + i), 0); 2167 } 2168 } 2169 left_strip.show(); 2170 if (stripsOn2Pins) 2171 right_strip.show(); 2172} 2173 2174void 2175 setStripColors() { 2176 int r, g, b; 2177 int p1, p2; 2178 2179 ledFactor = (float) 2180 ledBrightness / 255; 2181 ledFactor_div_numOfSegments = (float) ledFactor / (float) 2182 numOfSegments; 2183 stripMiddleColor = left_strip.Color(0, 0, 255 * ledFactor); 2184 2185 2186 switch (colorScheme) { 2187 case 0: { 2188 int orangeLimit; 2189 2190 float orangeFactor = orangeLimitAmount / halfNumOfSegments; 2191 2192 for 2193 (i = 0; i <= numOfSegments; i++) { 2194 if (i <= halfNumOfSegments) 2195 orangeLimit 2196 = (i * orangeFactor); 2197 else 2198 orangeLimit = ((numOfSegments 2199 - i) * orangeFactor); 2200 2201 stripColor[i] = left_strip.Color((255 * 2202 i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments - i) * ledFactor_div_numOfSegments), 2203 0); 2204 } 2205 break; 2206 } 2207 2208 case 1: { 2209 for (i = 2210 0; i <= numOfSegments; i++) { 2211 stripColor[i] = left_strip.Color(0, (255 2212 * i * ledFactor_div_numOfSegments), (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 2213 2214 } 2215 break; 2216 } 2217 2218 case 2: { 2219 for (i = 0; i 2220 <= numOfSegments; i++) { 2221 stripColor[i] = left_strip.Color((255 * i * 2222 ledFactor_div_numOfSegments), 0, (255 * (numOfSegments - i) * ledFactor_div_numOfSegments)); 2223 2224 } 2225 break; 2226 } 2227 2228 case 3: { 2229 for (i = 0; i 2230 <= numOfSegments; i++) { 2231 stripColor[i] = left_strip.Color((255 * (numOfSegments 2232 - i) * ledFactor_div_numOfSegments), 0, (255 * i * ledFactor_div_numOfSegments)); 2233 2234 } 2235 break; 2236 } 2237 2238 case 4: { 2239 for (i = 0; i 2240 <= numOfSegments; i++) { 2241 stripColor[i] = left_strip.Color(0, (255 * (numOfSegments 2242 - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments)); 2243 2244 } 2245 break; 2246 } 2247 2248 case 5: { 2249 for (i = 0; i <= 2250 numOfSegments; i++) { 2251 stripColor[i] = left_strip.Color((255 * (numOfSegments 2252 - i) * ledFactor_div_numOfSegments), (255 * i * ledFactor_div_numOfSegments), 0); 2253 2254 } 2255 break; 2256 } 2257 2258 case 6: { 2259 for (i = 0; i 2260 <= numOfSegments; i++) { 2261 r = (255 * i * ledFactor_div_numOfSegments); 2262 2263 g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 2264 2265 b = (200 * (numOfSegments - i) * ledFactor_div_numOfSegments); 2266 stripColor[i] 2267 = left_strip.Color(r, g, b); 2268 } 2269 break; 2270 } 2271 2272 case 2273 7: { 2274 for (i = 0; i <= numOfSegments; i++) { 2275 b = (255 * i * ledFactor_div_numOfSegments); 2276 2277 g = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 2278 2279 r = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 2280 stripColor[i] 2281 = left_strip.Color(r, g, b); 2282 } 2283 break; 2284 } 2285 2286 case 2287 8: { 2288 for (i = 0; i <= numOfSegments; i++) { 2289 r = (255 * i * ledFactor_div_numOfSegments); 2290 2291 b = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 2292 2293 g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 2294 stripColor[i] 2295 = left_strip.Color(r, g, b); 2296 } 2297 break; 2298 } 2299 2300 case 2301 9: { 2302 for (i = 0; i <= numOfSegments; i++) { 2303 b = (255 * i * ledFactor_div_numOfSegments); 2304 2305 r = (255 * min(i, numOfSegments - i) * ledFactor_div_numOfSegments); 2306 2307 g = (255 * (numOfSegments - i) * ledFactor_div_numOfSegments); 2308 stripColor[i] 2309 = left_strip.Color(r, g, b); 2310 } 2311 break; 2312 } 2313 2314 case 2315 10: 2316 colorScheme11SpinValue = 0; 2317 2318 case 11: 2319 2320 2321 case 12: { 2322 p1 = (85 * numOfSegments / 255); 2323 p2 = (170 * numOfSegments 2324 / 255); 2325 int wheel; 2326 2327 if (colorScheme == 12) 2328 colorSchemeFactor 2329 = colorScheme12Factor; 2330 else 2331 colorSchemeFactor = 1; 2332 2333 2334 for (i = 0; i <= numOfSegments; i++) { 2335 //wheel 2336 = int(float(i + colorScheme11SpinValue) / colorSchemeFactor) % numOfSegments; // 2337 reverse wheel 2338 2339 wheel = int(float(i - colorScheme11SpinValue) 2340 / colorSchemeFactor + numOfSegments) % numOfSegments; 2341 2342 if (wheel < 2343 p1) { 2344 wheel = map(wheel, 0, p1, 0, 255); 2345 r = 2346 (wheel * ledFactor); 2347 g = ((255 - wheel) * ledFactor); 2348 b 2349 = 0; 2350 } 2351 else if (wheel < p2) { 2352 wheel = map(wheel, 2353 p1, p2, 0, 255); 2354 r = ((255 - wheel) * ledFactor); 2355 g = 2356 0; 2357 b = (wheel * ledFactor); 2358 } 2359 else { 2360 wheel 2361 = map(wheel, p2, numOfSegments, 0, 255); 2362 r = 0; 2363 g = (wheel 2364 * ledFactor); 2365 b = ((255 - wheel) * ledFactor); 2366 } 2367 2368 2369 stripColor[i] = left_strip.Color(r, g, b); 2370 } 2371 break; 2372 2373 } 2374 } 2375 2376 if (colorScheme >= 10) 2377 stripHoldColor = left_strip.Color(255 2378 * ledFactor, 0, 0); // set to red for the color wheels 2379 else 2380 stripHoldColor 2381 = stripColor[numOfSegments]; 2382 2383 stripOverflowColor = stripHoldColor; // 2384 left_strip.Color(min(255, 255 * ledFactor * 1.5), 0, 0); 2385} 2386 2387void startupAnimation() 2388 { 2389 for (j = 0; j < 2; j++) { 2390 for (i = 0; i <= numOfSegments; i++) { 2391 2392 if (animType == 1) 2393 left_strip.setPixelColor(stripMiddle - (numOfSegments 2394 - i), stripColor[i]); 2395 else 2396 left_strip.setPixelColor(stripMiddle 2397 - i, stripColor[i]); 2398 2399 if (stripsOn2Pins) 2400 right_strip.setPixelColor(i, 2401 stripColor[i]); 2402 else 2403 left_strip.setPixelColor(stripMiddle + 2404 i, stripColor[i]); 2405 2406 left_strip.show(); 2407 if (stripsOn2Pins) 2408 2409 right_strip.show(); 2410 2411 delay(startupAnimationDelay); 2412 2413 } 2414 2415 for (i = 0; i <= numOfSegments; i++) { 2416 if (animType 2417 == 1) 2418 left_strip.setPixelColor(stripMiddle - (numOfSegments - i), 0); 2419 2420 else 2421 left_strip.setPixelColor(stripMiddle - i, 0); 2422 2423 2424 if (stripsOn2Pins) 2425 right_strip.setPixelColor(i, 0); 2426 else 2427 2428 left_strip.setPixelColor(stripMiddle + i, 0); 2429 2430 left_strip.show(); 2431 2432 if (stripsOn2Pins) 2433 right_strip.show(); 2434 2435 delay(startupAnimationDelay); 2436 2437 } 2438 } 2439} 2440 2441void displayNumber (int number, int displayDelay) { 2442 2443 left_strip.clear(); 2444 if (stripsOn2Pins) 2445 right_strip.clear(); 2446 2447 2448 number++; // @EB_DEBUG : display value 0 at led 1 2449 2450 for (i = 0; i <= 2451 number; i++) { 2452 if (i % 5 == 0) 2453 colorValue = stripMiddleColor; 2454 2455 else 2456 colorValue = stripColor[0]; 2457 2458 left_strip.setPixelColor(middleOffset 2459 + i, colorValue); 2460 2461 if (stripsOn2Pins) 2462 right_strip.setPixelColor(middleOffset 2463 + i, colorValue); 2464 else 2465 left_strip.setPixelColor(stripMiddle + middleOffset 2466 + i, colorValue); 2467 2468 delay(45 - number * 3); // @EB_DEBUG 2469 2470 left_strip.show(); 2471 2472 if (stripsOn2Pins) 2473 right_strip.show(); 2474 } 2475 2476 if (pulsing) 2477 { 2478 left_strip.setPixelColor(middleOffset + maxDisplaySegments, stripMiddleColor); 2479 2480 2481 if (stripsOn2Pins) 2482 right_strip.setPixelColor(maxDisplaySegments, stripMiddleColor); 2483 2484 else 2485 left_strip.setPixelColor(stripMiddle + maxDisplaySegments, stripMiddleColor); 2486 2487 2488 left_strip.show(); 2489 if (stripsOn2Pins) 2490 right_strip.show(); 2491 2492 } 2493 2494 delay(displayDelay); 2495 2496 left_strip.clear(); 2497 if (stripsOn2Pins) 2498 2499 right_strip.clear(); 2500} 2501 2502 2503// 2504// for debugging 2505// 2506 2507#ifdef 2508 DEBUG_TEST_LEDS 2509 void displayTest() { 2510 for (i = 0; i <= numOfSegments; 2511 i++) { 2512 left_strip.setPixelColor(stripMiddle - i, stripColor[i]); 2513 2514 2515 if (stripsOn2Pins) 2516 right_strip.setPixelColor(i, stripColor[i]); 2517 2518 else 2519 left_strip.setPixelColor(stripMiddle + i, stripColor[i]); 2520 2521 2522 left_strip.show(); 2523 if (stripsOn2Pins) 2524 right_strip.show(); 2525 2526 2527 delay(50); 2528 } 2529 delay(5000); 2530 2531 for (i = 0; 2532 i <= numOfSegments; i++) { 2533 left_strip.setPixelColor(stripMiddle - i, 0); 2534 2535 2536 if (stripsOn2Pins) 2537 right_strip.setPixelColor(i, 0); 2538 else 2539 2540 left_strip.setPixelColor(stripMiddle + i, 0); 2541 2542 left_strip.show(); 2543 2544 if (stripsOn2Pins) 2545 right_strip.show(); 2546 } 2547 } 2548 2549 2550 void serialDisplayRGB(int r, int g, int b) { 2551 Serial.print(i); 2552 Serial.print(" 2553 "); 2554 Serial.print(r); 2555 Serial.print(" "); 2556 Serial.print(g); 2557 2558 Serial.print(" "); 2559 Serial.println(b); 2560 } 2561#endif 2562
Old LCD, LED and LED strip test version.
arduino
1// include the library code: 2#include <LiquidCrystal.h> 3#include "LedControlMS.h" 4#include <Adafruit_NeoPixel.h> 5 6/* 7 LiquidCrystal Library 8 9 The circuit: 10 * LCD RS pin to digital pin 12 11 * LCD Enable pin to digital pin 11 12 * LCD D4 pin to digital pin 5 13 * LCD D5 pin to digital pin 4 14 * LCD D6 pin to digital pin 3 15 * LCD D7 pin to digital pin 2 16 * LCD R/W pin to ground 17 * LCD VSS pin to ground 18 * LCD VCC pin to 5V 19 * 10K resistor: 20 * ends to +5V and ground 21 * wiper to LCD VO pin (pin 3) 22 23*/ 24// initialize the library by associating any needed LCD interface pin 25// with the arduino pin number it is connected to 26const int rs = 12, en = 11, d4 = 5, d5 = 4, d6 = 3, d7 = 2; 27LiquidCrystal lcd(rs, en, d4, d5, d6, d7); 28 29// led matrix 30// DataIN, CLK, LOAD, # of matrix 31#define NUMOFMATRIX 4 32LedControl led = LedControl(10,8,9,NUMOFMATRIX); 33 34// led strip 35#define PIN 6 36#define NUMOFLEDS 31 37Adafruit_NeoPixel strip = Adafruit_NeoPixel(NUMOFLEDS, PIN, NEO_GRB + NEO_KHZ800); 38 39// setup values 40const int outputType = 1; // lcd = 0, led = 1, led strip = 2 41 42const int minValue = 20; 43const int maxValue = 500; 44 45int updateDelay, maxSegments; 46float ledIntensity; 47 48int leftPin = A0, rightPin = A1; 49int leftValue = 0, rightValue = 0, averageValue = 0, maxReadValue = 0; 50int leftAnalogValue = 0, rightAnalogValue = 0, averageAnalogValue = 0; 51 52int prevLeftValue = 0, prevRightValue = 0, prevAverageValue = 0; 53int prevLeftAnalogValue = 0, prevRightAnalogValue = 0, prevAverageAnalogValue = 0; 54 55float dropFactor; 56 57int i, j; 58 59int holdShow = true; 60int holdZeroShow = true; 61int leftHold = 0, rightHold = 0; 62int leftHoldTime = 0, rightHoldTime = 0; 63int holdTime; 64 65int stripMiddle; 66uint32_t stripRed, stripGreen, stripBlue; 67uint32_t stripColor[16]; 68 69void setup() { 70 switch (outputType) { 71 case 0: 72 // set up the LCD's number of columns and rows: 73 updateDelay = 50; 74 maxSegments = 16; 75 holdTime = 20; 76 dropFactor = .9; 77 78 lcd.begin(16, 2); 79 break; 80 81 case 1: 82 // set up led 83 updateDelay = 0; 84 maxSegments = 7; 85 holdTime = 50; 86 ledIntensity = 1.2; 87 dropFactor = .7; 88 89 for (i = 0; i < NUMOFMATRIX; i++) { 90 led.shutdown(i, false); 91 //led.setIntensity(i, 4); 92 led.clearDisplay(i); 93 } 94 95 // setup: identify left & right matrix 96 led.writeString(0,"#1 - LEFT"); 97 led.writeString(1,"#2 - RIGHT"); 98 led.writeString(2,"#3 - THREE"); 99 led.writeString(3,"#4 - FOUR"); 100 break; 101 102 case 2: 103 // set up led strip 104 updateDelay = 0; 105 maxSegments = NUMOFLEDS / 2; 106 stripMiddle = maxSegments; 107 holdTime = 250; 108 ledIntensity = .1; 109 dropFactor = .991; 110 111 strip.begin(); 112 113 stripRed = strip.Color(255 * ledIntensity, 0, 0); 114 stripGreen = strip.Color(0, 255 * ledIntensity, 0); 115 stripBlue = strip.Color(0, 0, 255 * ledIntensity); 116 117 // set colors green to fellow to red 118 for (i = 0; i <= maxSegments; i++) 119 stripColor[i] = strip.Color(255 / maxSegments * i * ledIntensity , 255 / maxSegments * (maxSegments - i) * ledIntensity, 0); 120 121 // startup animation 122 for (j = 0; j < 2; j ++) { 123 for (i = 0; i <= maxSegments; i++) { 124 strip.setPixelColor(stripMiddle - i, stripColor[i]); 125 strip.setPixelColor(stripMiddle + i, stripColor[i]); 126 strip.show(); 127 delay(20); 128 } 129 130 for (i = 0; i <= maxSegments; i++) { 131 strip.setPixelColor(stripMiddle + i, 0); 132 strip.setPixelColor(stripMiddle - i, 0); 133 strip.show(); 134 delay(20); 135 } 136 } 137 } 138 139 // for debugging 140 Serial.begin(9600); 141} 142 143void loop() { 144 readValues(); 145 if (holdShow) getHolds(); 146 147 switch(outputType) { 148 case 0: 149 LCDdisplayValues(); 150 if (holdShow) LCDdisplayHolds(); 151 break; 152 153 case 1: 154 LEDdisplayValues(); 155 if (holdShow) LEDdisplayHolds(); 156 break; 157 158 case 2: 159 STRIPdisplayValues(); 160 if (holdShow) STRIPdisplayHolds(); 161 } 162 163 storePrevValues(); 164 delay(updateDelay); 165} 166 167void readValues() { 168 leftAnalogValue = analogRead(leftPin); 169 rightAnalogValue = analogRead(rightPin); 170 //averageAnalogValue = (leftValue + rightValue) / 2; 171 172 if (leftAnalogValue < prevLeftAnalogValue) 173 leftAnalogValue = prevLeftAnalogValue * dropFactor; 174 175 if (rightAnalogValue < prevRightAnalogValue) 176 rightAnalogValue = prevRightAnalogValue * dropFactor; 177 178 //if (averageAnalogValue < prevAverageAnalogValue) 179 // averageAnalogValue = averageAnalogValue * dropFactor; 180 181 // debug to check read values 182 /* 183 if (leftValue > maxReadValue) maxReadValue = leftValue; 184 if (rightValue > maxReadValue) maxReadValue = rightValue; 185 Serial.print(maxReadValue); 186 Serial.print(" "); 187 Serial.print(leftValue); 188 Serial.print(" "); 189 Serial.println(rightValue); 190 */ 191 192 // check if left or right value exceeds max and print the value 193 if (leftValue > maxValue) Serial.println (leftValue); 194 if (rightValue > maxValue) Serial.println (rightValue); 195 196 // map values 197 leftValue = map(leftAnalogValue, minValue, maxValue, 0, maxSegments); 198 rightValue = map(rightAnalogValue, minValue, maxValue, 0, maxSegments); 199 //averageValue = map(averageAnalogValue, minValue, maxValue, 0, maxSegments); 200 201} 202 203void storePrevValues() { 204 prevLeftAnalogValue = leftAnalogValue; 205 prevRightAnalogValue = rightAnalogValue; 206 //prevAverageValue = averageAnalogValue; 207 208 prevLeftValue = leftValue; 209 prevRightValue = rightValue; 210 //prevAverageValue = averageValue; 211} 212 213void LEDdisplayValues() { 214 led.clearDisplay(0); 215 led.clearDisplay(1); 216 217 for (i=0; i <= leftValue; i++) 218 for (j=0; j <= leftValue; j++) 219 led.setLed(0, maxSegments - i, j, true); 220 led.setIntensity(0, leftValue * ledIntensity); 221 222 for (i=0; i <= rightValue; i++) 223 for (j=0; j <= rightValue; j++) 224 led.setLed(1, i, j, true); 225 led.setIntensity(1, rightValue * ledIntensity); 226} 227 228void LEDdisplayHolds() { 229 if (leftHold || holdZeroShow) { 230 //for (j=0; j <= leftHold; j++) 231 // led.setLed(0, leftHold, j, true); 232 233 //for (j=0; j <= leftHold; j++) 234 // led.setLed(0, j, leftHold, true); 235 led.setLed(0, maxSegments - leftHold, leftHold, true); 236 } 237 238 if (rightHold || holdZeroShow) { 239 //for (j=0; j < rightHold; j++) 240 // led.setLed(1, rightHold, j, true); 241 242 //for (j=0; j <= rightHold; j++) 243 // led.setLed(1, j, rightHold, true); 244 led.setLed(1, rightHold, rightHold, true); 245 } 246} 247 248void LCDdisplayValues() { 249 lcd.clear(); 250 for (i=0; i < leftValue; i++) 251 lcd.print("="); 252 253 lcd.setCursor(0, 1); 254 for (i=0; i < rightValue; i++) 255 lcd.print("="); 256} 257 258void LCDdisplayHolds() { 259 if (leftHold || holdZeroShow) { 260 lcd.setCursor(leftHold, 0); 261 lcd.print(">"); 262 } 263 264 if (rightHold || holdZeroShow) { 265 lcd.setCursor(rightHold, 1); 266 lcd.print(">"); 267 } 268} 269 270void STRIPdisplayValues() { 271 272 strip.clear(); 273 //for (i=0; i <= averageValue; i++) 274 // strip.setPixelColor(i, stripGreen); 275 //strip.show(); 276 277 for (i=0; i <= leftValue; i++) 278 strip.setPixelColor(stripMiddle + i, stripColor[i]); 279 280 for (i=0; i <= rightValue; i++) 281 strip.setPixelColor(stripMiddle - i, stripColor[i]); 282 283/* 284 for (i=prevLeftValue; i <= leftValue; i++) 285 strip.setPixelColor(stripMiddle + i, stripGreen); 286 287 for (i=prevLeftValue; i > leftValue; i--) 288 strip.setPixelColor(stripMiddle + i, 0); 289 290 for (i=prevRightValue; i <= rightValue; i++) 291 strip.setPixelColor(stripMiddle - i, stripGreen); 292 293 for (i=prevRightValue; i > rightValue; i--) 294 strip.setPixelColor(stripMiddle - i, 0); 295*/ 296 297 strip.show(); 298} 299 300void STRIPdisplayHolds() { 301 //strip.setPixelColor((leftHold + rightHold) / 2, stripRed); 302 303 strip.setPixelColor(stripMiddle + leftHold, stripColor[maxSegments]); 304 strip.setPixelColor(stripMiddle - rightHold, stripColor[maxSegments]); 305 strip.setPixelColor(stripMiddle, stripBlue); 306 strip.show(); 307} 308 309void getHolds() { 310 if (leftValue > leftHold) { 311 leftHold = leftValue; 312 leftHoldTime = 0; 313 } 314 else { 315 leftHoldTime++; 316 if (leftHoldTime > holdTime) { 317 //if (outputType == 2) 318 // strip.setPixelColor(stripMiddle + leftHold, 0); 319 leftHold = 0; 320 leftHoldTime = 0; 321 } 322 } 323 324 if (rightValue > rightHold) { 325 rightHold = rightValue; 326 rightHoldTime = 0; 327 } 328 else { 329 rightHoldTime++; 330 if (rightHoldTime > holdTime) { 331 //if (outputType == 2) 332 // strip.setPixelColor(stripMiddle - rightHold, 0); 333 rightHold = 0; 334 rightHoldTime = 0; 335 } 336 } 337} 338
20171105 VU meter
arduino
Updated code with optional dropping and bouncing peaks and several other settings.
1/* 2********************************************************************** 3* 4 Stereo VU Meter for 1 or 2 LED rings or strips build by ericBcreator 5* Designed 6 to be used with an Arduino UNO, Nano or compatible device. 7********************************************************************** 8* 9 Last updated 20171105 by ericBcreator 10* 11* This code is free for personal use, 12 not for commercial purposes. 13* Please leave this header intact. 14* 15* contact: 16 ericBcreator@gmail.com 17********************************************************************** 18*/ 19 20//#define 21 DEBUG // for debugging 22 23// 24// 25 include the NeoPixel library: 26// 27 28#include <Adafruit_NeoPixel.h> 29 30// 31// 32 uncomment the definition for the connected strip or ring(s) 33// 34 35//#define 36 led_ring_60 37//#define led_strip_60 38//#define led_strip_30 39#define led_2_rings_24 40//#define 41 led_2_rings_30 42//#define led_strip_200 43//#define led_strip_144 44 45// 46// 47 important setting: using potentiometer sensor values or not 48// This setting has 49 to be set right or the script will not work correctly: 50// - set this to true 51 if using potentiometers 52// - set this to false if not using potentiometers 53// 54 55const 56 int useSensorValues = true; 57 58// 59// setup pins 60// 61 62int 63 leftPin = A0, rightPin = A1; // left audio in on analog 64 0, right on analog 1 65int brightnessPin = A4, sensitivityPin = A5; // 66 potentiometers for brightness and sensitivity on analog 4 and 5 67int stripPin 68 = 6; // DIN of leds on digital pin 6 69int 70 showPeaksPin = 7; // switch to toggle peaks 71 on or off on digital pin 7 72int momentarySwitch = false; // 73 set false for an on/off toggle switch 74 75// 76// setup variables for the number 77 of leds and led strip or 2 rings 78// 79 80#if defined (led_ring_60) 81 //settings 82 for a 60 led ring 83 84 int stripNumOfLeds = 60; // 85 the total number of leds 86 uint32_t stripColor[31]; // 87 half of the number of leds + 1 88 int displayMiddleLed = false; // 89 display the middle led (blue). set to true for one strip, false for two strips or 90 rings 91 int splitStrip = true; // set to true 92 when using 2 strips or rings, false for one strip 93 int middleOffset = 0; // 94 offset for the middle led when using one strip 95 int startupAnimationDelay = 96 6; // delay for the startup animation 97 int orangeLimitAmount 98 = 0; // limit the amount of green of the middle LEDs 99 to make them more orange 100 int swapLeftRight = false; // 101 swap the left and right input values or not 102 103 int dropDelay = 4; // 104 hold time before dropping the leds 105 float dropFactor = .92; // 106 value for dropping the leds 107 108 int peakTimeNoDropDelay = 250; // 109 peak hold time when not dropping the peaks (set droppingPeak true or false) 110 111 int peakTimeFirstDropDelay = 130; // peak hold time when 112 dropping the first peak 113 int peakTimeDropDelay = 7; // 114 peak hold time when dropping the rest of the peaks 115 float peakDropFactor = .93; 116 // value for dropping the peaks 117 int droppingPeakFade 118 = false; // display the dropping peak fading to black 119 or not 120 121 int bouncingPeaksNumOfLeds = 6; // how 122 many leds to bounce up (max) 123 int bouncingPeakDelay = 4; // 124 delay between peak bounce updates 125 int bouncingPeakCounterInc = 10; // 126 increase counter for each bounce update. note: it uses a 0-180 sin function for 127 the bouncing 128 129#elif defined (led_strip_60) 130 //settings for a 60 led ring 131 132 133 int stripNumOfLeds = 60; // the total number 134 of leds 135 uint32_t stripColor[31]; // half of 136 the number of leds + 1 137 int displayMiddleLed = true; // 138 display the middle led (blue). set to true for one strip, false for two strips or 139 rings 140 int splitStrip = false; // set to true 141 when using 2 strips or rings, false for one strip 142 int middleOffset = 1; // 143 offset for the middle led when using one strip 144 int startupAnimationDelay = 145 6; // delay for the startup animation 146 int orangeLimitAmount 147 = 0; // limit the amount of green of the middle LEDs 148 to make them more orange 149 int swapLeftRight = false; // 150 swap the left and right input values or not 151 152 int dropDelay = 4; // 153 hold time before dropping the leds 154 float dropFactor = .92; // 155 value for dropping the leds 156 157 int peakTimeNoDropDelay = 250; // 158 peak hold time when not dropping the peaks (set droppingPeak true or false) 159 160 int peakTimeFirstDropDelay = 130; // peak hold time when 161 dropping the first peak 162 int peakTimeDropDelay = 7; // 163 peak hold time when dropping the rest of the peaks 164 float peakDropFactor = .93; 165 // value for dropping the peaks 166 int droppingPeakFade 167 = false; // display the dropping peak fading to black 168 or not 169 170 int bouncingPeaksNumOfLeds = 6; // how 171 many leds to bounce up (max) 172 int bouncingPeakDelay = 4; // 173 delay between peak bounce updates 174 int bouncingPeakCounterInc = 10; // 175 increase counter for each bounce update. note: it uses a 0-180 sin function for 176 the bouncing 177 178#elif defined (led_strip_30) 179 //settings for a 30 led strip 180 181 182 int stripNumOfLeds = 30; // the total number 183 of leds 184 uint32_t stripColor[16]; // half of 185 the number of leds + 1 186 int displayMiddleLed = true; // 187 display the middle led (blue). set to true for one strip, false for two strips or 188 rings 189 int splitStrip = false; // set to true 190 when using 2 strips or rings, false for one strip 191 int middleOffset = 1; // 192 offset for the middle led when using one strip 193 int startupAnimationDelay = 194 10; // delay for the startup animation 195 int orangeLimitAmount 196 = 0; // limit the amount of green of the middle LEDs 197 to make them more orange 198 int swapLeftRight = false; // 199 swap the left and right input values or not 200 201 int dropDelay = 10; // 202 hold time before dropping the leds 203 float dropFactor = .9; // 204 value for dropping the leds 205 206 int peakTimeNoDropDelay = 250; // 207 peak hold time when not dropping the peaks (set droppingPeak true or false) 208 209 int peakTimeFirstDropDelay = 150; // peak hold time when 210 dropping the first peak 211 int peakTimeDropDelay = 15; // 212 peak hold time when dropping the rest of the peaks 213 float peakDropFactor = .94; 214 // value for dropping the peaks 215 int droppingPeakFade 216 = false; // display the dropping peak fading to black 217 or not 218 219 int bouncingPeaksNumOfLeds = 3; // how 220 many leds to bounce up (max) 221 int bouncingPeakDelay = 4; // 222 delay between peak bounce updates 223 int bouncingPeakCounterInc = 9; // 224 increase counter for each bounce update. note: it uses a 0-180 sin function for 225 the bouncing 226 227#elif defined (led_2_rings_24) 228 //settings for 2 24 led 229 rings 230 231 int stripNumOfLeds = 48; 232 uint32_t stripColor[25]; 233 int displayMiddleLed 234 = false; 235 int splitStrip = true; 236 int middleOffset = 0; 237 int startupAnimationDelay 238 = 5; 239 int orangeLimitAmount = 0; 240 int swapLeftRight = false; 241 242 int 243 dropDelay = 2; 244 float dropFactor = .96; 245 246 int peakTimeNoDropDelay = 247 250; 248 int peakTimeFirstDropDelay = 100; 249 int peakTimeDropDelay = 10; 250 251 float peakDropFactor = .94; 252 int droppingPeakFade = false; 253 254 int 255 bouncingPeaksNumOfLeds = 3; 256 int bouncingPeakDelay = 4; 257 int bouncingPeakCounterInc 258 = 9; 259 260#elif defined(led_2_rings_30) 261 //settings for 2 30 led rings 262 263 264 int stripNumOfLeds = 60; 265 uint32_t stripColor[31]; 266 int displayMiddleLed 267 = false; 268 int splitStrip = true; 269 int middleOffset = 0; 270 int startupAnimationDelay 271 = 5; 272 int orangeLimitAmount = 0; 273 int swapLeftRight = false; 274 275 int 276 dropDelay = 2; 277 float dropFactor = .96; 278 279 int peakTimeNoDropDelay = 280 250; 281 int peakTimeFirstDropDelay = 100; 282 int peakTimeDropDelay = 10; 283 284 float peakDropFactor = .94; 285 int droppingPeakFade = false; 286 287 int 288 bouncingPeaksNumOfLeds = 3; 289 int bouncingPeakDelay = 4; 290 int bouncingPeakCounterInc 291 = 9; 292 293#elif defined (led_strip_200) 294 //settings for a 200 led strip 295 296 297 int stripNumOfLeds = 200; 298 uint32_t stripColor[101]; 299 int displayMiddleLed 300 = false; 301 int splitStrip = true; 302 int middleOffset = 0; 303 int startupAnimationDelay 304 = 1; 305 int orangeLimitAmount = 0; 306 int swapLeftRight = false; 307 308 int 309 dropDelay = 10; 310 float dropFactor = .96; 311 312 int peakTimeNoDropDelay 313 = 250; 314 int peakTimeFirstDropDelay = 100; 315 int peakTimeDropDelay = 30; 316 317 float peakDropFactor = .99; 318 int droppingPeakFade = false; 319 320 int 321 bouncingPeaksNumOfLeds = 8; 322 int bouncingPeakDelay = 4; 323 int bouncingPeakCounterInc 324 = 9; 325 326#elif defined (led_strip_144) 327 //settings for a 200 led strip 328 329 330 int stripNumOfLeds = 145; 331 uint32_t stripColor[73]; 332 int displayMiddleLed 333 = true; 334 int splitStrip = false; 335 int middleOffset = 1; 336 int startupAnimationDelay 337 = 1; 338 int orangeLimitAmount = 0; 339 int swapLeftRight = false; 340 341 int 342 dropDelay = 10; 343 float dropFactor = .85; 344 345 int peakTimeNoDropDelay 346 = 250; 347 int peakTimeFirstDropDelay = 100; 348 int peakTimeDropDelay = 5; 349 350 float peakDropFactor = .94; 351 int droppingPeakFade = false; 352 353 int 354 bouncingPeaksNumOfLeds = 10; 355 int bouncingPeakDelay = 2; 356 int bouncingPeakCounterInc 357 = 10; 358#endif 359 360// 361// setup other variables, user editable 362// 363 364// 365 basic settings 366int minValue = 10; // min 367 analog input value 368int maxValue = 350; // 369 max analog input value (0-1023 equals 0-5V) 370int sensitivityValue = 128; // 371 0 - 255, initial value (value read from the potentiometer if useSensorValues = true) 372int 373 maxSensitivity = 2 * 255; // let the 'volume' go up 374 to 200%! 375int ledBrightness = 30; // 0 - 255, 376 initial value (value read from the potentiometer if useSensorValues = true) 377int 378 sensorDeviationBrightness = 1; // eliminate fluctuating values 379int 380 overflowDelay = 20; // overflow hold time 381 382// 383 peak settings 384int displayPeaks = true; // value 385 will be set by the switch if useSensorValues = true 386int droppingPeak = true; 387 // display dropping peaks or not. note: displayPeaks 388 has to be true 389int bouncingPeaks = true; // 390 display bouncing peaks or not. note: displayPeaks has to be true 391 392// 393// 394 initialize other variables needed for the sketch 395// 396 397int numOfSegments 398 = stripNumOfLeds / 2; 399int halfNumOfSegments = numOfSegments / 2; 400int stripMiddle 401 = stripNumOfLeds / 2; 402int maxDisplaySegments = stripMiddle - 1; 403float sensitivityFactor; 404 405int 406 brightnessValue, prevBrightnessValue; 407float ledFactor, ledFactor_div_numOfSegments; 408 409int 410 leftValue = 0, rightValue = 0, maxReadValue = 0; 411int leftAnalogValue = 0, rightAnalogValue 412 = 0; 413 414int prevLeftValue = 0, prevRightValue = 0; 415int prevLeftAnalogValue 416 = 0, prevRightAnalogValue = 0; 417 418int i, j; 419int dropLeft, dropRight; 420int 421 leftDropTime, rightDropTime; 422 423int leftPeak = 0, rightPeak = 0; 424int leftPeakTime 425 = 0, rightPeakTime = 0; 426int leftFirstPeak = true, rightFirstPeak = true; 427int 428 readShowPeaksPin, prevReadShowPeaksPin; 429 430uint32_t stripMiddleColor, stripOverflowColor, 431 stripHoldColor; 432 433int leftPeakBouncing = false, rightPeakBouncing = false; 434int 435 leftPeakBounce = 0, rightPeakBounce = 0; 436int prevLeftPeakBounce = 0, prevRightPeakBounce 437 = 0; 438int leftPeakBounceCounter = 0, rightPeakBounceCounter = 0; 439int leftPeakBounceDelayCounter 440 = 0, rightPeakBounceDelayCounter = 0; 441 442// 443// initialize the strip or rings 444// 445 446Adafruit_NeoPixel 447 strip = Adafruit_NeoPixel(stripNumOfLeds, stripPin, NEO_GRB + NEO_KHZ800); 448 449// 450// 451 setup 452// 453 454void setup() { 455 #ifdef DEBUG 456 Serial.begin(9600); 457 458 #endif 459 460 pinMode(showPeaksPin, INPUT); 461 462 strip.begin(); 463 464 465 setStripColors(); 466 startupAnimation(); 467 468 if (useSensorValues) 469 470 setInitialDisplayPeaks(); 471 else 472 setSensitivityFactor(); 473} 474 475// 476// 477 main loop 478// 479 480void loop() { 481 if (useSensorValues) 482 readSensorValues(); 483 484 485 readValues(); 486 drawValues(); 487 488 if (displayPeaks) { 489 getPeaks(); 490 491 drawPeaks(); 492 } 493 494 storePrevValues(); 495} 496 497// 498// functions 499// 500 501void 502 setInitialDisplayPeaks() { 503 readShowPeaksPin = digitalRead(showPeaksPin); 504 505 if (readShowPeaksPin == HIGH) 506 displayPeaks = false; 507 else 508 displayPeaks 509 = true; 510 prevReadShowPeaksPin = readShowPeaksPin; 511} 512 513void readSensorValues() 514 { 515 readShowPeaksPin = digitalRead(showPeaksPin); 516 517 if (momentarySwitch) 518 { 519 if (readShowPeaksPin == LOW && prevReadShowPeaksPin == HIGH) { 520 if 521 (displayPeaks == true) { 522 displayPeaks = false; 523 clearLeftPeak(); 524 525 clearRightPeak(); 526 if (momentarySwitch) 527 while 528 (digitalRead(showPeaksPin) == LOW) {} 529 } 530 else { 531 displayPeaks 532 = true; 533 } 534 } 535 } 536 else { 537 if (readShowPeaksPin == LOW 538 && prevReadShowPeaksPin == HIGH) 539 displayPeaks = true; 540 else if (readShowPeaksPin 541 == HIGH && prevReadShowPeaksPin == LOW) { 542 displayPeaks = false; 543 clearLeftPeak(); 544 545 clearRightPeak(); 546 } 547 } 548 prevReadShowPeaksPin = readShowPeaksPin; 549 550 551 brightnessValue = analogRead(brightnessPin); 552 brightnessValue = map(brightnessValue, 553 0, 1023, 0, 255); 554 555 if (abs(brightnessValue - prevBrightnessValue) > sensorDeviationBrightness) 556 { 557 ledBrightness = brightnessValue; 558 setStripColors(); 559 prevBrightnessValue 560 = brightnessValue; 561 } 562 563 sensitivityValue = analogRead(sensitivityPin); 564 565 sensitivityValue = map(sensitivityValue, 0, 1023, 0, 255); 566 setSensitivityFactor(); 567} 568 569void 570 setSensitivityFactor() { 571 //sensitivityValue_div_numOfSegments = sensitivityValue 572 / numOfSegments; 573 sensitivityFactor = ((float) sensitivityValue / 255 * (float) 574 maxSensitivity / 255); 575} 576 577void readValues() { 578 leftAnalogValue = analogRead(leftPin); 579 580 rightAnalogValue = analogRead(rightPin); 581 582 if (swapLeftRight) { 583 int 584 tempValue = leftAnalogValue; 585 leftAnalogValue = rightAnalogValue; 586 rightAnalogValue 587 = tempValue; 588 } 589 590 if (leftAnalogValue < prevLeftAnalogValue) { 591 leftDropTime++; 592 593 if (leftDropTime > dropDelay) { 594 leftAnalogValue = prevLeftAnalogValue 595 * dropFactor; 596 leftDropTime = 0; 597 } 598 else 599 leftAnalogValue 600 = prevLeftAnalogValue; 601 } 602 603 if (rightAnalogValue < prevRightAnalogValue) 604 { 605 rightDropTime++; 606 if (rightDropTime > dropDelay) { 607 rightAnalogValue 608 = prevRightAnalogValue * dropFactor; 609 rightDropTime = 0; 610 } 611 else 612 613 rightAnalogValue = prevRightAnalogValue; 614 } 615 616 #ifdef DEBUG 617 618 Serial.print(leftAnalogValue); 619 Serial.print(" "); 620 Serial.println(rightAnalogValue); 621 622 #endif 623 624 // map values 625 leftValue = map(leftAnalogValue * sensitivityFactor, 626 minValue, maxValue, 0, maxDisplaySegments); 627 rightValue = map(rightAnalogValue 628 * sensitivityFactor, minValue, maxValue, 0, maxDisplaySegments); 629 630 if (leftValue 631 > maxDisplaySegments) { 632 leftValue = maxDisplaySegments; 633 drawOverflow(); 634 635 } 636 637 if (rightValue > maxDisplaySegments) { 638 rightValue = maxDisplaySegments; 639 640 drawOverflow(); 641 } 642} 643 644void storePrevValues() { 645 prevLeftAnalogValue 646 = leftAnalogValue; 647 prevRightAnalogValue = rightAnalogValue; 648 649 prevLeftValue 650 = leftValue; 651 prevRightValue = rightValue; 652} 653 654void getPeaks() { 655 656 if (leftValue > leftPeak) { 657 leftPeak = leftValue; 658 leftPeakTime = 659 0; 660 leftFirstPeak = true; 661 662 if (bouncingPeaks) { 663 leftPeakBouncing 664 = true; 665 leftPeakBounceCounter = 0; 666 leftPeakBounceDelayCounter 667 = 0; 668 } 669 } 670 else { 671 leftPeakTime++; 672 if (droppingPeak) 673 { 674 if (leftFirstPeak) { 675 if (leftPeakTime > peakTimeFirstDropDelay) 676 { 677 clearLeftPeak(); 678 leftFirstPeak = false; 679 } 680 681 } 682 else { 683 if (leftPeakTime > peakTimeDropDelay) { 684 clearLeftPeak(); 685 686 } 687 } 688 } 689 else { 690 if (leftPeakTime > peakTimeNoDropDelay) 691 { 692 clearLeftPeak(); 693 } 694 } 695 } 696 697 if (leftPeakBouncing) 698 { 699 if (leftFirstPeak) { 700 leftPeakBounceDelayCounter++; 701 if 702 (leftPeakBounceDelayCounter >= bouncingPeakDelay) { 703 leftPeakBounceDelayCounter 704 = 0; 705 leftPeakBounceCounter += bouncingPeakCounterInc; 706 707 if 708 (leftPeakBounceCounter >= 180) { 709 clearLeftBouncePeak(); 710 clearLeftBounce(); 711 712 } 713 else { 714 leftPeakBounce = min((sin(leftPeakBounceCounter 715 * 0.0174532925) * bouncingPeaksNumOfLeds), (maxDisplaySegments - leftPeak)); 716 717 if (leftPeakBounce != prevLeftPeakBounce) { 718 clearLeftBouncePeak(); 719 720 } 721 prevLeftPeakBounce = leftPeakBounce; 722 } 723 } 724 725 } 726 } 727 728 if (rightValue > rightPeak) { 729 rightPeak = rightValue; 730 731 rightPeakTime = 0; 732 rightFirstPeak = true; 733 734 if (bouncingPeaks) 735 { 736 rightPeakBouncing = true; 737 rightPeakBounceCounter = 0; 738 rightPeakBounceDelayCounter 739 = 0; 740 } 741 } 742 else { 743 rightPeakTime++; 744 if (droppingPeak) 745 { 746 if (rightFirstPeak) { 747 if (rightPeakTime > peakTimeFirstDropDelay) 748 { 749 clearRightPeak(); 750 rightFirstPeak = false; 751 } 752 753 } 754 else { 755 if (rightPeakTime > peakTimeDropDelay) 756 clearRightPeak(); 757 758 } 759 } 760 else { 761 if (rightPeakTime > peakTimeNoDropDelay) 762 763 clearRightPeak(); 764 } 765 } 766 767 if (rightPeakBouncing) { 768 769 if (rightFirstPeak) { 770 rightPeakBounceDelayCounter++; 771 if (rightPeakBounceDelayCounter 772 >= bouncingPeakDelay) { 773 rightPeakBounceDelayCounter = 0; 774 rightPeakBounceCounter 775 += bouncingPeakCounterInc; 776 777 if (rightPeakBounceCounter >= 180) { 778 779 clearRightBouncePeak(); 780 clearRightBounce(); 781 } 782 783 else { 784 rightPeakBounce = min((sin(rightPeakBounceCounter 785 * 0.0174532925) * bouncingPeaksNumOfLeds), (maxDisplaySegments - rightPeak)); 786 787 if (rightPeakBounce != prevRightPeakBounce) { 788 clearRightBouncePeak(); 789 790 } 791 prevRightPeakBounce = rightPeakBounce; 792 } 793 794 } 795 } 796 } 797} 798 799void drawValues() { 800 if (splitStrip) { 801 802 for (i = middleOffset; i < leftValue; i++) 803 strip.setPixelColor(i, stripColor[i]); 804 805 806 for (i = prevLeftValue; i > leftValue; i--) 807 strip.setPixelColor(i, 808 0); 809 810 for (i = middleOffset; i < rightValue; i++) 811 strip.setPixelColor(stripMiddle 812 + i, stripColor[i]); 813 814 for (i = prevRightValue; i > rightValue; i--) 815 816 strip.setPixelColor(stripMiddle + i, 0); 817 } 818 else { 819 for (i 820 = middleOffset; i < leftValue; i++) 821 strip.setPixelColor(stripMiddle + i, 822 stripColor[i]); 823 824 for (i = prevLeftValue; i > leftValue; i--) 825 strip.setPixelColor(stripMiddle 826 + i, 0); 827 828 for (i = middleOffset; i < rightValue; i++) 829 strip.setPixelColor(stripMiddle 830 - i, stripColor[i]); 831 832 for (i = prevRightValue; i > rightValue; i--) 833 834 strip.setPixelColor(stripMiddle - i, 0); 835 } 836 837 if (displayMiddleLed) 838 strip.setPixelColor(stripMiddle, stripMiddleColor); 839 strip.show(); 840} 841 842void 843 drawPeaks() { 844 if (leftPeak > 0) { 845 if (droppingPeakFade && leftPeakBouncing 846 == false) 847 stripHoldColor = strip.Color(max(1, (255 * leftPeak * ledFactor_div_numOfSegments)), 848 0, 0); 849 else 850 stripHoldColor = stripColor[numOfSegments]; 851 852 853 if (splitStrip) 854 strip.setPixelColor((leftPeak + leftPeakBounce), stripHoldColor); 855 856 else 857 strip.setPixelColor(stripMiddle + (leftPeak + leftPeakBounce), 858 stripHoldColor); 859 } 860 861 if (rightPeak > 0) { 862 if (droppingPeakFade 863 && rightPeakBouncing == false) 864 stripHoldColor = strip.Color(max(1, (255 865 * rightPeak * ledFactor_div_numOfSegments)), 0, 0); 866 else 867 stripHoldColor 868 = stripColor[numOfSegments]; 869 870 if (splitStrip) 871 strip.setPixelColor(stripMiddle 872 + rightPeak + prevRightPeakBounce, stripHoldColor); 873 else 874 strip.setPixelColor(stripMiddle 875 - (rightPeak + prevRightPeakBounce), stripHoldColor); 876 } 877 878 if (leftPeak 879 > 0 || rightPeak > 0) 880 strip.show(); 881} 882 883void clearLeftPeak() 884 { 885 if (splitStrip) 886 strip.setPixelColor((leftPeak + prevLeftPeakBounce), 887 0); 888 else 889 strip.setPixelColor(stripMiddle + (leftPeak + prevLeftPeakBounce), 890 0); 891 892 if (droppingPeak) 893 leftPeak = leftPeak * peakDropFactor; 894 895 else 896 leftPeak = 0; 897 leftPeakTime = 0; 898} 899 900void clearLeftBounce() 901 { 902 leftPeakBouncing = false; 903 leftPeakBounceCounter = 0; 904 leftPeakBounce 905 = 0; 906 prevLeftPeakBounce = 0; 907} 908 909void clearLeftBouncePeak() { 910 if 911 (splitStrip) 912 strip.setPixelColor((leftPeak + prevLeftPeakBounce), 0); 913 914 else 915 strip.setPixelColor(stripMiddle + (leftPeak + prevLeftPeakBounce), 916 0); 917} 918 919void clearRightPeak() { 920 if (splitStrip) 921 strip.setPixelColor(stripMiddle 922 + rightPeak + prevRightPeakBounce, 0); 923 else 924 strip.setPixelColor(stripMiddle 925 - (rightPeak + prevRightPeakBounce), 0); 926 927 if (droppingPeak) 928 rightPeak 929 = rightPeak * peakDropFactor; 930 else 931 rightPeak = 0; 932 rightPeakTime 933 = 0; 934} 935 936void clearRightBounce() { 937 rightPeakBouncing = false; 938 rightPeakBounceCounter 939 = 0; 940 rightPeakBounce = 0; 941 prevRightPeakBounce = 0; 942} 943 944void clearRightBouncePeak() 945 { 946 if (splitStrip) 947 strip.setPixelColor((stripMiddle + rightPeak + prevRightPeakBounce), 948 0); 949 else 950 strip.setPixelColor(stripMiddle - (rightPeak + prevRightPeakBounce), 951 0); 952} 953 954void drawOverflow() { 955 for (i = 0; i <= numOfSegments; i++) 956 { 957 strip.setPixelColor(stripMiddle + i, stripOverflowColor); 958 strip.setPixelColor(stripMiddle 959 - i, stripOverflowColor); 960 } 961 strip.show(); 962 delay(overflowDelay); 963 964 965 for (i = 0; i <= numOfSegments; i++) { 966 strip.setPixelColor(stripMiddle 967 + i, 0); 968 strip.setPixelColor(stripMiddle - i, 0); 969 } 970 strip.show(); 971} 972 973void 974 setStripColors() { 975 int orangeLimit; 976 ledFactor = (float)ledBrightness / 977 255; 978 979 float orangeFactor = orangeLimitAmount / halfNumOfSegments; 980 ledFactor_div_numOfSegments 981 = ledFactor / numOfSegments; 982 983 stripOverflowColor = strip.Color(min(255, 984 255 * ledFactor * 1.5), 0, 0); 985 stripMiddleColor = strip.Color(0, 0, 255 * ledFactor); 986 987 988 stripColor[0] = strip.Color(0, 255 * ledFactor, 0); 989 for (i = 1; i <= numOfSegments; 990 i++) { 991 if (i <= halfNumOfSegments) 992 orangeLimit = (i * orangeFactor); 993 994 else 995 orangeLimit = ((numOfSegments - i) * orangeFactor); 996 997 stripColor[i] 998 = strip.Color((255 * i * ledFactor_div_numOfSegments), ((255 - orangeLimit) * (numOfSegments 999 - i) * ledFactor_div_numOfSegments), 0); 1000 } 1001 1002 stripHoldColor = stripColor[numOfSegments]; 1003} 1004 1005void 1006 startupAnimation() { 1007 for (j = 0; j < 2; j++) { 1008 for (i = 0; i <= numOfSegments; 1009 i++) { 1010 strip.setPixelColor(stripMiddle - i, stripColor[i]); 1011 strip.setPixelColor(stripMiddle 1012 + i, stripColor[i]); 1013 strip.show(); 1014 delay(startupAnimationDelay); 1015 1016 } 1017 1018 for (i = 0; i <= numOfSegments; i++) { 1019 strip.setPixelColor(stripMiddle 1020 + i, 0); 1021 strip.setPixelColor(stripMiddle - i, 0); 1022 strip.show(); 1023 1024 delay(startupAnimationDelay); 1025 } 1026 } 1027} 1028 1029
Downloadable files
VU meter schematic for code version 20171105
VU meter schematic
VU meter schematic for code version 20171105
VU meter schematic for code version 20180202
Several changes, check the story for details
VU meter schematic for code version 20180202
VU meter schematic for code version 20171105
VU meter schematic
VU meter schematic for code version 20171105
Comments
Only logged in users can leave comments