/*
.d8888.  .o88b. db   db  .d8b.  db      d888888b d8888b. db      d888888b d888888b d88888D 
88'  YP d8P  Y8 88   88 d8' `8b 88      `~~88~~' 88  `8D 88        `88'   `~~88~~' YP  d8' 
`8bo.   8P      88ooo88 88ooo88 88         88    88oooY' 88         88       88       d8'  
  `Y8b. 8b      88~~~88 88~~~88 88         88    88~~~b. 88         88       88      d8'   
db   8D Y8b  d8 88   88 88   88 88booo.    88    88   8D 88booo.   .88.      88     d8' db 
`8888Y'  `Y88P' YP   YP YP   YP Y88888P    YP    Y8888P' Y88888P Y888888P    YP    d88888P

|**********************************************************************;
* Project           : Schaltblitz Aprilia RS 125
*
* Program name      : schaltblitzRS125_erweitert.c
*
* Author            : el bodo es loco
*
* Date created      : 20200422
*
* Modified by       : 4PR1L14
*
* Revision History  :
*
* Date modifiied    Vers.   Revision Date  
* 20200425          2.0     20200425
*
|**********************************************************************;
*/
#include <Adafruit_NeoPixel.h>
#include <FreqMeasure.h>
#ifdef __AVR__
  #include <avr/power.h>
#endif

#define NUMPIXELS 8   	// Anzahl an Pixel (LEDs)
#define PIN 11     		// Neopixel PIN
#define PMS_PIN 8 		// Drehzahlsignal-Eingang bei Rotax 122  Lima: 100Hz/1000rpm; Pickup: 16.666 Hz/1000rpm
/*-----------------------------------------------------------------*/
//Funktionsprototypen (bekannt machen der unten aufgeführten Funktionen)
void blinkDelay();
void errorPrint();
void inOutMode();
void outInMode();
void leftToRightMode();
void allAllColors();
void simpleAll();
void inOutModeL2();
void leftToRightModeL2();
void rainbow(); 

/*-----------------------------------------------------------------*/
//Neopixel-Konfiguration
Adafruit_NeoPixel pixels = Adafruit_NeoPixel(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);

/*--------------------FARBEN---------------------------------------*/
//Farbkonfiguration                 // <--- ### HIER FARBEN UND HELLIGKEIT EINSTELLEN ###
uint32_t green    = pixels.Color(0, 100, 0);    //1. Wert rot, 2. Wert gruen, 1. Wert blau - Helligkeit von 0 (dunkel) bis 255 (hell)
uint32_t yellow   = pixels.Color(100, 100, 0);
uint32_t orange   = pixels.Color(200, 100, 0);
uint32_t red      = pixels.Color(100, 0, 0);
uint32_t white    = pixels.Color(100, 100, 100);
uint32_t blue     = pixels.Color(0, 0, 100);
uint32_t black    = pixels.Color(0, 0, 0);
uint32_t violet   = pixels.Color(68, 50, 127);
uint32_t darkblue   = pixels.Color(0, 0, 68);
uint32_t lightblue  = pixels.Color(0, 68, 127);

/*--------------------SCHALTBLITZ-MODI-----------------------------*/
enum Modes {inOut = 0, outIn, left2Right, allAll, simple, inOutL2, left2RightL2, rainb};
const int lightMODE = inOut;      // <--- ### HIER MODUS EINSTELLEN (entweder nach Name z. B. "inOut" oder per Zahl z. B. "0" -> von 0 bis 7 möglich ["7" entspricht "rainb"]) ###
//const int lightMODE = 0;        // alternativ zur vorherigen Zeile 

/*--------------------DREHZAHL-------------------------------------*/
//Motorrad-/Drehzahl-Paramteter 
struct bikeParameters{
  float min_revs = 0.;    	// Minimalwert (um Fehler auszuschließen) 
  float max_revs = 14000.;  // Maximalwert (um Fehler auszuschließen) 
  //(Drehzahlschwellen - genutzt fuer Funktion: inOutMode(), inOutMode(), allAllColors(), simpleAll(), inOutModeL2())
  float threshold_0 = threshold_1 - 1, threshold_1 = 9500., threshold_2 = 10000., threshold_3 = 10500., threshold_4 = 11000., threshold_5 = 11300.;  // <--- ### HIER DREHZAHL EINSTELLEN ###
  //(Drehzahlschwellen - genutzt fuer Funktion: leftToRightMode(), leftToRightModeL2(), rainbow())
  float threshold_lr0 = threshold_lr1 -1, threshold_lr1 = 9500., threshold_lr2 = 9750., threshold_lr3 = 10000., threshold_lr4 = 10250., threshold_lr5 = 10500., threshold_lr6 = 10750., threshold_lr7 = 11000., threshold_lr8 = 11250., threshold_lr9 = 11500.; 
} RS125;                  
                          
/*--------------------VARIABLEN---------------------------------------*/
unsigned long data_unavailable = 0;
unsigned long data_available = 0;
const long interval = 1000;
int blink_interval = 15;        // Blinkintervall des Schaltblitzes <--- ### HIER INTERVALL EINSTELLEN ###
double sum = 0;
int count = 0;
int total_counts = 30;          // Anzahl Messungen, bevor der Mittelwert ausgerechnet wird <--- ### HIER ANZAHL EINSTELLEN ### (standard = 30)
float frequency = 0.;

/*##########################_SETUP_################################*/
void setup() {
	
	#if defined (__AVR_ATtiny85__)
		if (F_CPU == 16000000) clock_prescale_set(clock_div_1);	// Frequenz des Mikrocontrollers
	#endif
	
	pixels.begin();     				// Initialisiere NEOPIXEL.
	pixels.show(); 
	  
	pinMode (PMS_PIN, INPUT_PULLUP); 	// Pullup muss hier stehen
		
	Serial.begin(9600);   			// braucht man nicht (fuer seriellen Monitor, Kontrollausgabe)
	FreqMeasure.begin();
}
/*##########################_LOOP_#################################*/
void loop() {

	if (FreqMeasure.available()) {
		sum = sum + FreqMeasure.read();
		count = count + 1;
		if (count > total_counts) {		// Anzahl Messungen erreicht
			frequency = FreqMeasure.countToFrequency(sum / count); // berechne Mittelwert
			frequency = frequency*60;	// rpm
			
			Serial.print("Rpm=");
			Serial.println(frequency);
			
			data_available = millis();	// Zeitpunkt zu dem Daten zur Verfuegung standen
			sum = 0;
			count = 0;

			if (frequency < RS125.min_revs || frequency >  RS125.max_revs){  //Sicherheitsabfrage, ob rpm innerhalb min<->max
				  Serial.println("Error, frequency out of range or no signal available.");
				  Serial.println(frequency);
				  pixels.clear(); 
				  pixels.show();
				  frequency = 0.;     
			}
			else{
				if (frequency < RS125.threshold_1 || frequency < RS125.threshold_lr1) {   // wenn Drehzahl zu niedrieg, alle Pixel aus
					pixels.clear();
					pixels.show();
				}
				else{                   				// sonst weitermachen
					switch (lightMODE){           		// jeweilige Code-Ausfuehrung, je nach gewaehltem Modus
					  case 0: inOutMode(); 			break;	// gehe zur Funktion "inOutMode()" und setze entsprechende Pixel, je nach Drehzahl
					  case 1: outInMode(); 			break;
					  case 2: leftToRightMode(); 	break;
					  case 3: allAllColors(); 		break;
					  case 4: simpleAll(); 			break;
					  case 5: inOutModeL2(); 		break;
					  case 6: leftToRightModeL2(); 	break;
					  case 7: rainbow(); 			break;
					  default: Serial.println("Mode error!"); break;  
					}
					pixels.show();// gesetzte Pixel ausgeben, nach der fertigen/nach dem Verlassen der Funktion
				} 							
			} 			
		}
	}
	else{								// Logik um bei Signalausfall alles auf 0 zu setzen
		data_unavailable = millis(); 	// Zeitpunkt zu dem keine Daten mehr zur Verfuegung standen
		
		if (data_unavailable - data_available >= interval){ // wenn seit dem letzten Datenverlust mehr als ein Intervall (1 Sek. [1000 millis]) vergangen ist, alles ausschalten
			Serial.print ("Rpm=");
			Serial.println("0");
			
			frequency = 0.; 
			
			pixels.clear();
			pixels.show();
		}
	}
}
/*+++++++++++++++++++BLINK DELAY++++++++++++++++++++++++++++++++++++*/
void blinkDelay(){    // Pixel blinken lassen
  
  pixels.show();
  delay(blink_interval);
  pixels.clear();
  pixels.show();
  delay(blink_interval);
}
/*+++++++++++++++++++ERROR PRINT++++++++++++++++++++++++++++++++++++*/
void errorPrint(){    // etwas schief gelaufen
  
  Serial.print ("Error!\n");
}
/*+++++++++++++++++++inOut MODE+++++++++++++++++++++++++++++++++++++*/
void inOutMode(){   
  
  if (frequency >= RS125.threshold_1 && frequency < RS125.threshold_2) {   		// gruen
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 		// setze Pixel 3 und 4 auf gruen
	for (int i = 0; i < 3; i++) {pixels.setPixelColor(i, black);} 		// restliche Pixel aus
	for (int i = 5; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} 		
  }
  else if (frequency >= RS125.threshold_2 && frequency < RS125.threshold_3) {   // gelb
    for (int i = 2; i < 6; i++) {pixels.setPixelColor(i, yellow);} 		// setze Pixel 2 bis 5 auf gelb
	for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, black);} 		// restliche Pixel aus
	for (int i = 6; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} 
  }
  else if (frequency >= RS125.threshold_3 && frequency < RS125.threshold_4) {   // orange
    for (int i = 1; i < 7; i++) {pixels.setPixelColor(i, orange);} 		// setze Pixel 1 bis 6 auf orange
	pixels.setPixelColor(0, black); pixels.setPixelColor(7, black);	
  }     
  else if (frequency >= RS125.threshold_4 && frequency < RS125.threshold_5) {   // rot
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);} // setze Pixel 0 bis 7 auf rot (alle 8)
  }
  else if (frequency >= RS125.threshold_5 && frequency <= RS125.max_revs) {  	// rot blinkend, ab/ueber diesem Wert geht das Schaltlicht an
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);} // setze Pixel 0 bis 7 auf rot (alle 8)
    blinkDelay();	// rufe Funktion zum Blinken auf
  }
  else if (frequency >= RS125.threshold_0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {			// Sicherheitsabfrage
    errorPrint();
  }
}
/*+++++++++++++++++++outIn MODE+++++++++++++++++++++++++++++++++++++*/
void outInMode(){
  
  if (frequency >= RS125.threshold_1 && frequency < RS125.threshold_2) {  
    pixels.setPixelColor(0, green);                                          
    pixels.setPixelColor(7, green);
	for (int i = 1; i < 7; i++) {pixels.setPixelColor(i, black);} 	
	
  }                                                                                                                                                                                                              
  else if (frequency >= RS125.threshold_2 && frequency < RS125.threshold_3) {
    pixels.setPixelColor(0, green);                                          
    pixels.setPixelColor(7, green);  
    pixels.setPixelColor(1, yellow);                                         
    pixels.setPixelColor(6, yellow);   
	for (int i = 2; i < 6; i++) {pixels.setPixelColor(i, black);}	
   }                                                                                                                                                 
  else if (frequency >= RS125.threshold_3 && frequency < RS125.threshold_4) { 
    pixels.setPixelColor(0, green);                                          
    pixels.setPixelColor(7, green);  
    pixels.setPixelColor(1, yellow);                                         
    pixels.setPixelColor(6, yellow);  
    pixels.setPixelColor(2, orange);                                         
    pixels.setPixelColor(5, orange);    
	for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, black);}		
    }                                                                                                                                          
  else if (frequency >= RS125.threshold_4 && frequency < RS125.threshold_5) {
    pixels.setPixelColor(0, green);                                          
    pixels.setPixelColor(7, green);  
    pixels.setPixelColor(1, yellow);                                         
    pixels.setPixelColor(6, yellow);  
    pixels.setPixelColor(2, orange);                                         
    pixels.setPixelColor(5, orange);    
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, red);}
    } 
  else if (frequency >= RS125.threshold_5 && frequency <= RS125.max_revs) {  
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);}
    blinkDelay();
  }
  else if (frequency >= RS125.threshold_0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++leftToRight MODE+++++++++++++++++++++++++++++++++*/
void leftToRightMode(){
  
  if (frequency >= RS125.threshold_lr1 && frequency < RS125.threshold_lr2) {   
    pixels.setPixelColor(0, green);
	for (int i = 1; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  } 
  else if (frequency >= RS125.threshold_lr2 && frequency < RS125.threshold_lr3) {   
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
	for (int i = 2; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  } 
  else if (frequency >= RS125.threshold_lr3 && frequency < RS125.threshold_lr4) { 
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}  
    pixels.setPixelColor(2, yellow);
	for (int i = 3; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }     
  else if (frequency >= RS125.threshold_lr4 && frequency < RS125.threshold_lr5) {
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
	for (int i = 4; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  } 
  else if (frequency >= RS125.threshold_lr5 && frequency < RS125.threshold_lr6) {   
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
    pixels.setPixelColor(4, orange);
	for (int i = 5; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }       
  else if (frequency >= RS125.threshold_lr6 && frequency < RS125.threshold_lr7) { 
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);} 
	for (int i = 6; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}	
  }
  else if (frequency >= RS125.threshold_lr7 && frequency < RS125.threshold_lr8) { 
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}  
    pixels.setPixelColor(6, red);
	pixels.setPixelColor(7, black);
  }     
  else if (frequency >= RS125.threshold_lr8 && frequency < RS125.threshold_lr9) {  
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);} 
    for (int i = 6; i < 8; i++) {pixels.setPixelColor(i, red);}
  }     
  else if (frequency >= RS125.threshold_lr9 && frequency <= RS125.max_revs) { 
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);}
    blinkDelay();
  }
  else if (frequency >= RS125.threshold_lr0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++allAll MODE++++++++++++++++++++++++++++++++++++*/
void allAllColors(){
  
  if (frequency >= RS125.threshold_1 && frequency < RS125.threshold_2) {   
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, green);} 
  }
  else if (frequency >= RS125.threshold_2 && frequency < RS125.threshold_3) {   
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, yellow);}
  }
  else if (frequency >= RS125.threshold_3 && frequency < RS125.threshold_4) {   
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, orange);} 
  }     
  else if (frequency >= RS125.threshold_4 && frequency < RS125.threshold_5) {   
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);}
  }
  else if (frequency >= RS125.threshold_5 && frequency <= RS125.max_revs) {  
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, red);}
    blinkDelay();
  }
  else if (frequency >= RS125.threshold_0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++simpleAll MODE++++++++++++++++++++++++++++++++++++*/
void simpleAll(){
  
  if (frequency >= RS125.threshold_1 && frequency < RS125.threshold_4) {  
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} 
  }
  if (frequency >= RS125.threshold_4 && frequency < RS125.threshold_5) {   
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, white);} 
  }
  else if (frequency >= RS125.threshold_5 && frequency <= RS125.max_revs) {  
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, white);} 
    blinkDelay();
  }
  else if (frequency >= RS125.threshold_0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++inOutL2 MODE++++++++++++++++++++++++++++++++++++++*/
void inOutModeL2(){
    
  if (frequency >= RS125.threshold_1 && frequency < RS125.threshold_2) {   
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
	for (int i = 0; i < 3; i++) {pixels.setPixelColor(i, black);}
	for (int i = 5; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_2 && frequency < RS125.threshold_3) {
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
    pixels.setPixelColor(5, yellow); 
	for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, black);}	
	for (int i = 6; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_3 && frequency < RS125.threshold_4) {   
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
    pixels.setPixelColor(5, yellow);
    pixels.setPixelColor(1, orange);
    pixels.setPixelColor(6, orange);
	pixels.setPixelColor(0, black);
	pixels.setPixelColor(7, black);
  }     
  else if (frequency >= RS125.threshold_4 && frequency < RS125.threshold_5) {   
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
    pixels.setPixelColor(5, yellow);
    pixels.setPixelColor(1, orange);
    pixels.setPixelColor(6, orange);
    pixels.setPixelColor(0, red);
    pixels.setPixelColor(7, red);
  }
  else if (frequency >= RS125.threshold_5 && frequency <= RS125.max_revs) {  
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
    pixels.setPixelColor(5, yellow);
    pixels.setPixelColor(1, orange);
    pixels.setPixelColor(6, orange);
    pixels.setPixelColor(0, red);
    pixels.setPixelColor(7, red); 
    pixels.show();
    delay(blink_interval);
    for (int i = 3; i < 5; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
    pixels.setPixelColor(5, yellow);
    pixels.setPixelColor(1, orange);
    pixels.setPixelColor(6, orange);
    pixels.setPixelColor(0, black);
    pixels.setPixelColor(7, black);
    pixels.show();
    delay(blink_interval);
  }
  else if (frequency >= RS125.threshold_0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++leftToRightL2 MODE+++++++++++++++++++++++++++++++++*/
void leftToRightModeL2(){
  
  if (frequency >= RS125.threshold_lr1 && frequency < RS125.threshold_lr2) {    
    pixels.setPixelColor(0, green);
	for (int i = 1; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_lr2 && frequency < RS125.threshold_lr3) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);}  
	for (int i = 2; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_lr3 && frequency < RS125.threshold_lr4) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    pixels.setPixelColor(2, yellow);
	for (int i = 3; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }     
  else if (frequency >= RS125.threshold_lr4 && frequency < RS125.threshold_lr5) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}
	for (int i = 4; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_lr5 && frequency < RS125.threshold_lr6) {
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    pixels.setPixelColor(4, orange); 
	for (int i = 5; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }     
  else if (frequency >= RS125.threshold_lr6 && frequency < RS125.threshold_lr7) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}
	for (int i = 6; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} 
  }
  else if (frequency >= RS125.threshold_lr7 && frequency < RS125.threshold_lr8) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}
    pixels.setPixelColor(6, red); 
	pixels.setPixelColor(7, black); 
  }
  else if (frequency >= RS125.threshold_lr8 && frequency < RS125.threshold_lr9) {    
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}
    for (int i = 6; i < 8; i++) {pixels.setPixelColor(i, red);}
  }   
  else if (frequency >= RS125.threshold_lr9 && frequency <= RS125.max_revs) {
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}
    for (int i = 6; i < 8; i++) {pixels.setPixelColor(i, red);} 
    pixels.show();
    delay(blink_interval);
    for (int i = 0; i < 2; i++) {pixels.setPixelColor(i, green);} 
    for (int i = 2; i < 4; i++) {pixels.setPixelColor(i, yellow);}    
    for (int i = 4; i < 6; i++) {pixels.setPixelColor(i, orange);}
    for (int i = 6; i < 8; i++) {pixels.setPixelColor(i, black);} 
    pixels.show();
    delay(blink_interval);
  }
  else if (frequency >= RS125.threshold_lr0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
/*+++++++++++++++++++rainbow MODE+++++++++++++++++++++++++++++++++*/
void rainbow(){
  
  if (frequency >= RS125.threshold_lr1 && frequency < RS125.threshold_lr2) {    
    pixels.setPixelColor(0, violet);
	for (int i = 1; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} 	
  }
  else if (frequency >= RS125.threshold_lr2 && frequency < RS125.threshold_lr3) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue); 
	for (int i = 2; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}	
  }
  else if (frequency >= RS125.threshold_lr3 && frequency < RS125.threshold_lr4) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
	for (int i = 3; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }     
  else if (frequency >= RS125.threshold_lr4 && frequency < RS125.threshold_lr5) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);  
	for (int i = 4; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}	
  }
  else if (frequency >= RS125.threshold_lr5 && frequency < RS125.threshold_lr6) {
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
	for (int i = 5; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }     
  else if (frequency >= RS125.threshold_lr6 && frequency < RS125.threshold_lr7) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
    pixels.setPixelColor(5, orange);
	for (int i = 6; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);}
  }
  else if (frequency >= RS125.threshold_lr7 && frequency < RS125.threshold_lr8) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
    pixels.setPixelColor(5, orange);
    pixels.setPixelColor(6, red);
	pixels.setPixelColor(7, black);
  }
  else if (frequency >= RS125.threshold_lr8 && frequency < RS125.threshold_lr9) {    
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
    pixels.setPixelColor(5, orange);
    pixels.setPixelColor(6, red);
    pixels.setPixelColor(7, white);
  }   
  else if (frequency >= RS125.threshold_lr9 && frequency <= RS125.max_revs) {
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
    pixels.setPixelColor(5, orange);
    pixels.setPixelColor(6, red);
    pixels.setPixelColor(7, white);
    pixels.show();
    delay(blink_interval);
    pixels.setPixelColor(0, violet);
    pixels.setPixelColor(1, darkblue);
    pixels.setPixelColor(2, lightblue);
    pixels.setPixelColor(3, green);
    pixels.setPixelColor(4, yellow);
    pixels.setPixelColor(5, orange);
    pixels.setPixelColor(6, red);
    pixels.setPixelColor(7, black);
    pixels.show();
    delay(blink_interval);
  }
  else if (frequency >= RS125.threshold_lr0 && frequency <= RS125.max_revs) {   // unterhalb der Warnschwelle bleiben alle lichter Schwarz geschalten
    for (int i = 0; i < NUMPIXELS; i++) {pixels.setPixelColor(i, black);} // setze Pixel 0 bis 7 auf schwarz (alle 8)
  }
  else {
    errorPrint();
  }
}
//***************************END of PROGRAM******************************************;