#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <Arduino.h>
//#include <U8g2_for_Adafruit_GFX.h>

Adafruit_SSD1306 OLED(128, 64, &Wire, -1);

const float Wersja = 1.02;
const float Board = 7.0;
const float MCU = 4.0;

const byte Resistors[11] PROGMEM = { 47, 49, 60, 70, 100, 15, 20, 25, 30, 35, 40 };
const int Resistors_MC[13] PROGMEM = { 100, 170, 200, 230, 300, 400, 680, 1, 60, 67, 75, 80, 90 };
const int Capacitors[8] PROGMEM = { 0, 100, 150, 220, 250, 320, 370, 470 };
const byte Gain[4] PROGMEM = {40, 45, 60, 65};

const char MM[3] PROGMEM = "MM";
const char MC[3] PROGMEM = "MC";

const char *const gain_table[4] PROGMEM = { MM, MM, MC, MC };

const char ON[4] PROGMEM = "Tak";
const char OFF[4] PROGMEM = "Nie";
const char BRAK[5] PROGMEM = "Brak";

const char *const Sub_table[3] PROGMEM = { ON, OFF, BRAK };

const char pF[3] PROGMEM = "pF";
const char k[2] PROGMEM = "k";
const char dB[3] PROGMEM = "dB";
const char OMEGA[] PROGMEM = { (char)233, '\0' };

const char *const unit_table[4] PROGMEM = { pF, k, dB, OMEGA };

const byte LED1 = 11;
const byte LED2 = 12;
const byte RLY = 10;
const byte DC_ERR = 6;
const byte SW_SEL = 7;
const byte SW_JUMP = 8;
const byte P_DOWN = 5;
const byte VU_L = A3;
const byte VU_R = A2;
const byte CLK = 2;
const byte DT = 3;
const byte PWR_ERR = 9;

unsigned long timer0 = 0ul;
unsigned long timer1 = 0ul;
unsigned long timer3 = 0ul;

const int max_syg = 430;      // Maks poziom odczytu analogu
const float Range = -40.0;

float left;
float right;
int volL = 0;
int volR = 0;

int gain;
int Index_gain = -1;
int Res;
int Index_Res = -1;
int Index_Res_MC = -1;
int Res_MC;
byte Wsk;
int Cap;
int Index_Cap = -1;
int Sub;
int Index_Sub = -1;
int Tryb;
int New_Cap;
int New_Gain;
int New_Res;
int New_Res_MC;
int New_Sub;
int index_Tryb;
int BRNESS;
byte Jump = 0;
byte diody;
byte led_sw;
byte black = 0;
byte PWM;
byte Index_PWM = 100;
byte Index_diody = 100;
byte kontrast;
byte Index_kontrast = 100;
byte czas_wkl_sec;
byte czas_wkl_min = 40;
byte czas_wkl_h = 100;
byte P_DOWN_DET = 0;
byte blue = 0;

int screen = 0;
int wskoff;
int oledoff;

int menu = 0;

const char znak = 16;
const char gwiazda = 4;

char War_R[7];
char War_C[7];
char War_G[4];
char War_GdB[7];
char War_Sub[4];
String War_Brness;

void f_Res() {

  char temp_val[7];
  int val;

  switch (gain) {

    case 0 ... 1:

      // Wczytujemy wartość Rezystancji
      val = pgm_read_byte(&(Resistors[Res]));
      itoa(val, temp_val, 10);  // char *itoa(int value, char *buffer, int radix);
      //radix = 10 (Dziesiętny): Oznacza, że liczba zostanie skonwertowana na znaki w systemie dziesiętnym.
      //Przykład: Liczba 47 zostanie skonwertowana na ciąg znaków "47".
      //radix = 2 (Binarny): Konwersja na ciąg bitów.
      //Przykład: Liczba 47 zostanie skonwertowana na ciąg znaków "101111".
      //radix = 16 (Szesnastkowy): Często używany do adresów pamięci lub kolorów.
      //Przykład: Liczba 47 zostanie skonwertowana na ciąg znaków "2F".

      // Rozpocznij budowanie War_R: np "47"
      strcpy(War_R, temp_val);
      // Dodaj " k" (index 2)
      strcat_P(War_R, (char *)pgm_read_word(&(unit_table[1])));
      // Dodaj "omege" (index 4)
      strcat_P(War_R, (char *)pgm_read_word(&(unit_table[3])));

      break;

    case 2 ... 3:

      val = pgm_read_word(&(Resistors_MC[Res_MC]));
      itoa(val, temp_val, 10);
      strcpy(War_R, temp_val);

      if (Res_MC == 7) {

        // Dodaj " k" (index 2)
        strcat_P(War_R, (char *)pgm_read_word(&(unit_table[1])));
      }

      // Dodaj "omege" (index 4)
      strcat_P(War_R, (char *)pgm_read_word(&(unit_table[3])));
      break;
  }
}

float f_dB(byte odczyt) {  // funkcja odczytująca dane z wybranego wejścia ADC i zwracająca wynik w postaci dB
  float dB;
  float analog;
  analog = analogRead(odczyt);
  dB = (20 * log10(analog / max_syg));
  if (dB < Range) {
    dB = Range;
  } else if (dB > 0) {
    dB = 0;
  }
  return dB;
}

void f_wskaznik() {
  switch (Wsk) {
    case 0:
      OLED.drawRoundRect(4, 4, 120, 20, 4, 1);
      OLED.setCursor(5, 10);
      break;
    case 1:
      OLED.drawRoundRect(4, 24, 120, 20, 4, 1);
      OLED.setCursor(5, 30);
      break;
    case 2:
      OLED.drawRoundRect(4, 44, 120, 20, 4, 1);
      OLED.setCursor(5, 50);
      break;
    case 3:
      OLED.drawRoundRect(4, 4, 120, 20, 4, 1);
      OLED.setCursor(5, 10);
      break;
    case 5:
      OLED.drawRoundRect(4, 24, 120, 20, 4, 1);
      OLED.setCursor(5, 30);
      break;
    case 6:
      OLED.drawRoundRect(4, 44, 120, 20, 4, 1);
      OLED.setCursor(5, 50);
      break;
  }
  OLED.setTextSize(1);
  OLED.print(znak);
}

void f_diody() {  // tryb diod switchy
  if ((Tryb == 0 && diody == 1) || diody == 0) {
    digitalWrite(LED2, LOW);
  } else {
    digitalWrite(LED2, HIGH);
  }
}

/*void f_kontrast() {  // ustawienie jasnosci wyswietlacza OLED
  switch (kontrast) {
    case 1:
      OLED.setContrast(20);
      break;
    case 2:
      OLED.setContrast(40);
      break;
    case 3:
      OLED.setContrast(70);
      break;
    case 4:
      OLED.setContrast(90);
      break;
    case 5:
      OLED.setContrast(120);
      break;
    case 6:
      OLED.setContrast(140);
      break;
    case 7:
      OLED.setContrast(160);
      break;
    case 8:
      OLED.setContrast(175);
      break;
    case 9:
      OLED.setContrast(190);
      break;
    case 10:
      OLED.setContrast(210);
      break;
  }
  }*/

void f_Cap() {

  char temp_val[7];
  int val;

  if (gain < 2 && Cap != 0) {

    val = pgm_read_word(&(Capacitors[Cap]));
    itoa(val, temp_val, 10);
    strcpy(War_C, temp_val);
    strcat_P(War_C, (char *)pgm_read_word(&(unit_table[0])));

  } else {
    strcpy_P(War_C, (char *)pgm_read_word(&(Sub_table[2])));
  }

}

void f_Gain() {

  char temp_val[7];
  byte val;

  strcpy_P(War_G, (char *)pgm_read_word(&(gain_table[gain])));
  val = pgm_read_byte(&(Gain[gain]));
  itoa(val, temp_val, 10);
  strcpy(War_GdB, temp_val);
  strcat_P(War_GdB, (char *)pgm_read_word(&(unit_table[2])));

}

void f_Sub() {

  strcpy_P(War_Sub, (char *)pgm_read_word(&(Sub_table[Sub])));

}

void f_PWM() {  // pwm dla diody włacznika
  PWM = map(BRNESS, 0, 100, 0, 255);
  analogWrite(LED1, PWM);
}

void f_MENU() {

  Tryb = 0;

  OLED.setTextSize(2, 1);

  if (gain != Index_gain) {
    Index_gain = gain;
    f_Res();
    f_Cap();
    f_Sub();
    f_Gain();
  }
  //zmiana = 0;
  //}*/
  switch (Wsk) {
    case 0 ... 2:

      OLED.setCursor(14, 10);
      OLED.print(F("R:"));
      OLED.setCursor(60, 10);
      OLED.print(War_R);
      OLED.setCursor(14, 30);
      OLED.print(F("C:"));
      OLED.setCursor(60, 30);
      OLED.print(War_C);
      OLED.setCursor(14, 50);
      OLED.print(F("G:"));
      OLED.setCursor(60, 50);
      //OLED.print(War_G);
      OLED.print(War_GdB);

      if (gain == 0 || gain == 1) {
        if (Res != New_Res) {
          OLED.setCursor(40, 10);
          OLED.print(gwiazda);
        }
        if (Cap != New_Cap) {
          OLED.setCursor(40, 30);
          OLED.print(gwiazda);
        }
      } else if (gain == 2 || gain == 3) {
        if (Res_MC != New_Res_MC) {
          OLED.setCursor(40, 10);
          OLED.print(gwiazda);
        }
      } if (gain != New_Gain) {
        OLED.setCursor(40, 50);
        OLED.print(gwiazda);
      }
      break;

    case 3 ... 6:
      OLED.setCursor(14, 10);
      OLED.print(F("Sub:"));
      OLED.setCursor(75, 10);
      OLED.print(War_Sub);
      OLED.setCursor(14, 30);
      OLED.print(F("VU Meters"));
      OLED.setCursor(14, 50);
      OLED.print(F("Opcje"));

      if (Sub != New_Sub) {
        OLED.setCursor(60, 10);
        OLED.print(gwiazda);
      }
      break;
  }

  OLED.display();
  f_PWM();
  f_diody();

}

void f_LCD() {

  // if (Tryb != index_Tryb) {  // zmiana trybu czyszczenie wyswietlacza
  OLED.clearDisplay();
  // OLED.display();
  //index_Tryb = Tryb;
  //}

  //  if (Wsk == 5 && Tryb != 0) {

  int volL;
  int volR;
  int volR_prev;
  int volL_prev;
  float dBR;
  float dBL;
  const char L[2] = "L";
  const char P[2] = "P";

  switch (Tryb) {

    case 0: break;

    case 1:  // bargrafy

      f_diody();
      f_PWM();

      volL = 12;
      volR = 12;
      volR_prev = 12;
      volL_prev = 12;

      OLED.setTextSize(1.6);  // rysowanie ramki wskazników
      OLED.setCursor(0, 12);
      OLED.print(L);
      OLED.setCursor(0, 45);
      OLED.print(P);
      OLED.setTextSize(1);
      OLED.drawRoundRect(10, 0, 117, 30, 4, 1);
      OLED.drawRoundRect(10, 32, 117, 30, 4, 1);

      OLED.display();

      while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH) {

        delay(25);

        // Rysowanie lewego wskaznika w zamknietej pętli

        dBL = f_dB(VU_L);

        volL_prev = volL;

        volL = map(dBL, Range, 0, 11, 125);

        if (volL > 11) {
          volL = volL + 4;
          if (volL > 125) {
            volL = 125;
          }
        }

        if (volL < volL_prev) {
          OLED.fillRect(volL, 4, volL_prev - volL, 22, 0);
        } else if (volL > volL_prev) {
          for (int colL = volL_prev; colL < volL; colL++) {
            if (colL % 4 == 1) {
              OLED.drawFastVLine(colL, 4, 22, 1);
            }
          }
        }

        // Rysowanie prawego wskaznika w zamknietej pętli

        dBR = f_dB(VU_R);

        volR_prev = volR;

        volR = map(dBR, Range, 0, 11, 125);

        if (volR < volR_prev) {
          OLED.fillRect(volR, 36, volR_prev - volR, 22, 0);
        } else if (volR > volR_prev) {
          for (int colR = volR_prev; colR < volR; colR++) {
            if (colR % 4 == 1) {
              OLED.drawFastVLine(colR, 36, 22, 1);
            }
          }
        }
        OLED.display();
        //Serial.println(volL);
        //Serial.println(dBL);
        //Serial.println(volR);
        //Serial.println(dBR);
        //Serial.println();
      }
      break;
  }
  //} else {  // wyswietlanie menu


}

void f_zapis() {

  if (Res_MC != New_Res_MC || Cap != New_Cap || Res != New_Res || gain != New_Gain || Sub != New_Sub) {

    char buffer[4];
    strcpy_P(buffer, (char *)pgm_read_word(&(Sub_table[0])));
    String TAK = buffer;

    OLED.clearDisplay();
    OLED.setTextSize(1);
    OLED.drawPixel(101, 12, 1);
    OLED.drawPixel(100, 13, 1);
    OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
    OLED.setTextSize(1, 2);
    OLED.setCursor(18, 17);
    OLED.print("CHCESZ ZAPISAC ?");
    OLED.setTextSize(2);
    OLED.setCursor(72, 43);
    OLED.print(buffer);
    OLED.print(znak);
    OLED.display();
    delay(40ul);

    while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH) {}

    if (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == LOW) {
      digitalWrite(RLY, HIGH);
      New_Res = Res;
      New_Gain = gain;
      New_Cap = Cap;
      New_Res_MC = Res_MC;
      New_Sub = Sub;
      delay(20ul);
      OLED.clearDisplay();
      OLED.setTextSize(1);
      OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
      OLED.setTextSize(2, 1);
      OLED.setCursor(22, 16);
      OLED.print("NASTAWY");
      OLED.setCursor(18, 40);
      OLED.print("ZAPISANE");
      OLED.display();
      delay(500ul);
      Wsk = 0;
      delay(500ul);
      OLED.clearDisplay();
      f_wskaznik();
    }


    //while (digitalRead(SW_JUMP) == HIGH) {}
  }
}

void f_start_czas() {

  int volR_czas;

  volR_czas = analogRead(VU_R);

  if (volR_czas > 4) {
    if (millis() - timer3 >= 1ul) {
      timer3 = millis();
      czas_wkl_sec++;
      if (czas_wkl_sec > 59) {
        czas_wkl_sec = 0;
        czas_wkl_min++;
        if (czas_wkl_min > 59) {
          czas_wkl_min = 0;
          czas_wkl_h++;
        }
      }
    }
  } else if (volR_czas < 4) {
    timer3 = 0ul;
  }
}

void setup() {
  OLED.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  //OLED.setFont(&FreeMono9pt7b);
  OLED.setTextColor(1);
  OLED.clearDisplay();
  //Serial.begin(9600);
  //attachInterrupt(digitalPinToInterrupt(SW), toggleMenu, FALLING);
  pinMode(SW_JUMP, INPUT_PULLUP);  // put your setup code here, to run once:
  pinMode(SW_SEL, INPUT_PULLUP);
  pinMode(LED2, OUTPUT);
  pinMode(LED1, OUTPUT);
  pinMode(RLY, OUTPUT);
  pinMode(P_DOWN, INPUT_PULLUP);
  pinMode(PWR_ERR, INPUT_PULLUP);
}

void loop() {

  //bool stan = digitalRead(SW_JUMP);
  // Serial.println(Wsk);
  //Serial.println(menu);
  //Serial.println(Tryb);
  //Serial.println(index_Tryb);
  //Serial.println(diody);
  //Serial.println(volR);
  //Serial.println(volL);
  //Serial.println(Index_PWM);
  //Serial.println(Index_diody);
  //Serial.println();
  //Serial.println(War_R);
  //Serial.print(P_DOWN_DET);

  if (PWM != Index_PWM) {  // ustaw pwm na diodzie jesli jest inny niz zapisany
    Index_PWM = PWM;
    f_PWM();
  }
  if (diody != Index_diody) {  // ustaw tryb diod switchy jesli jest inny niz zapisany
    Index_diody = diody;
    f_diody();
  }
  if (kontrast != Index_kontrast) {  // ustaw jasnosc OLED jesli jest inny niz zapisany
    Index_kontrast = kontrast;
    //f_kontrast();
  }

  if (Tryb > 0 && digitalRead(DC_ERR) == HIGH) {  // tryb wyswietlenia inny niz menu

    digitalWrite(RLY, LOW);
    f_LCD();

  } else if (Tryb == 0 && digitalRead(DC_ERR) == HIGH) {

    OLED.clearDisplay();
    digitalWrite(RLY, LOW);
    f_MENU();
    f_wskaznik();
    OLED.display();

    //for(int i;)

    do {
      delay(20);
      screen++;
      if (screen > 3000) {
        screen = 3000;
      }


      if (wskoff > 0) {
        if (screen == (wskoff * 250)) {

          OLED.setTextSize(1);
          OLED.drawRoundRect(4, 4, 120, 20, 4, 0);
          OLED.drawRoundRect(4, 24, 120, 20, 4, 0);
          OLED.drawRoundRect(4, 44, 120, 20, 4, 0);
          OLED.setTextColor(0);
          OLED.setCursor(5, 10);
          OLED.print(znak);
          OLED.setCursor(5, 30);
          OLED.print(znak);
          OLED.setCursor(5, 50);
          OLED.print(znak);
          OLED.display();
          Wsk --;
          if (Wsk > 6) {
            Wsk = 6;
          }
          black = 1;
        }
      }

      if (oledoff > 0) {
        if (screen == (oledoff * 250)) {
          OLED.fillRect(0, 0, 128, 64, 0);
          OLED.display();
          digitalWrite(LED2, HIGH);
          Wsk = 7;
          black = 1;
        }
      }

    } while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH);

    OLED.setTextColor(1);

    if (black == 1 && (digitalRead(SW_SEL) == LOW || digitalRead(SW_JUMP) == LOW) ) {
      Wsk++;
      if (Wsk > 6) {
        Wsk = 0;
      }
      black = 0;
    }
    screen = 0;
  }

  if (digitalRead(SW_JUMP) == LOW && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {  // zostal nacisniety przycisk zmiany pozycji manu
    Wsk++;
    Tryb = 0;

    if (Wsk == 4) {  // moment zapisu nastawów, jesli zapisane to pominie
      f_zapis();
      Wsk = 5;
    }

    if (Wsk > 6) {

      Wsk = 0;
    }

    while (digitalRead(SW_JUMP) == LOW && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}

  }


  if (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

    Jump = 1;
    int pop = 0;
    byte co2 = 0;

    switch (Wsk) {

      case 0:
        /* if (gain == 0 || gain == 1) {
           Res++;
           if (Res > 10) {
             Res = 0;
           }
          } else if (gain == 2 || gain == 3) {
           Res_MC++;
           if (Res_MC > 12) {
             Res_MC = 0;
           }
          }*/

        f_Res();
        OLED.clearDisplay();
        OLED.setTextSize(1);
        OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
        OLED.setTextSize(1, 2);
        OLED.setCursor(15, 15);
        OLED.print("Rezystancja Wej.");
        OLED.setTextSize(2);
        OLED.setCursor(40, 40);
        OLED.print(War_R);

        OLED.display();

        while (Jump == 1 && pop <= 15 && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

          pop++;
          delay(30);
          if (digitalRead(SW_SEL) == LOW) {

            pop = 0;
            co2++;

            if (co2 >= 3) {

              if (gain == 0 || gain == 1) {
                Res++;
                if (Res > 10) {
                  Res = 0;
                }
              } else if (gain == 2 || gain == 3) {
                Res_MC++;
                if (Res_MC > 12) {
                  Res_MC = 0;
                }
              }
              f_Res();
              OLED.fillRect(40,  40, 60, 20, 0);
              OLED.setTextSize(2);
              OLED.setCursor(40, 40);
              OLED.print(War_R);

              OLED.display();
              co2 = 0;
            }
          }
        }
        Jump = 0;
        break;

      case 1:
        if (gain == 0 || gain == 1) {
          f_Cap();
          OLED.clearDisplay();
          OLED.setTextSize(1);
          OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
          OLED.drawPixel(66, 15, 1);
          OLED.drawPixel(65, 16, 1);
          OLED.drawPixel(71, 15, 1);
          OLED.drawPixel(70, 16, 1);
          OLED.setTextSize(1, 2);
          OLED.setCursor(20, 15);
          OLED.print("Pojemnosc Wej.");
          OLED.setTextSize(2);
          if (Cap > 0) {
            OLED.setCursor(40, 40);
          } else if (Cap == 0) {
            OLED.setCursor(50, 40);
          }
          OLED.print(War_C);
          OLED.display();

          while (Jump == 1 && pop <= 15 && digitalRead(SW_JUMP) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {
            pop++;
            delay(50);
            if (digitalRead(SW_SEL) == LOW) {
              pop = 0;
              Cap++;
              if (Cap > 7) {
                Cap = 0;
              }
              f_Cap();
              OLED.fillRect(40,  40, 60, 20, 0);
              OLED.setTextSize(2);
              if (Cap > 0) {
                OLED.setCursor(40, 40);
              } else if (Cap == 0) {
                OLED.setCursor(50, 40);
              }
              OLED.print(War_C);
              OLED.display();
            }
          }
          Jump = 0;
        } else if (gain == 2 || gain == 0) {
        }
        break;

      case 2:

        f_Gain();
        OLED.clearDisplay();
        OLED.setTextSize(1);
        OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
        OLED.setTextSize(1, 2);
        OLED.setCursor(30, 15);
        OLED.print("Preamp GAIN");
        OLED.setTextSize(2);
        OLED.setCursor(23, 40);
        OLED.print(War_G);
        OLED.print(F(" "));
        OLED.print(War_GdB);

        OLED.display();

        while (Jump == 1 && pop <= 15 && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

          pop++;
          delay(50);

          if (digitalRead(SW_SEL) == LOW) {
            pop = 0;
            gain++;
            if (gain > 3) {
              gain = 0;
            }
            f_Gain();
            OLED.fillRect(20,  40, 100, 20, 0);
            OLED.setTextSize(2);
            OLED.setCursor(23, 40);
            OLED.print(War_G);
            OLED.print(F(" "));
            OLED.print(War_GdB);
            OLED.display();
          }
        }
        Jump = 0;
        break;

      case 3:

        f_Sub();
        OLED.clearDisplay();
        OLED.setTextSize(1);
        OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
        OLED.setTextSize(2);
        OLED.setCursor(12, 12);
        OLED.print("Subsonic");
        OLED.setCursor(50, 40);
        OLED.print(War_Sub);
        OLED.display();


        while (Jump == 1 && pop <= 15 && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {
          pop++;
          delay(50);

          if (digitalRead(SW_SEL) == LOW) {
            pop = 0;
            Sub++;
            if (Sub > 1) {
              Sub = 0;
            }
            f_Sub();
            OLED.fillRect(40,  40, 60, 20, 0);
            OLED.setTextSize(2);
            OLED.setCursor(50, 40);
            OLED.print(War_Sub);
            OLED.display();
          }
        }
        Jump = 0;
        break;



      case 5:

        Tryb++;
        if (Tryb > 1) {
          Tryb = 0;
        }
        while (digitalRead(SW_SEL) == LOW) {
        }
        break;


      case 6:

        int ledmenu = 1;
        int wskled = 0;
        BRNESS --;


        if (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

          while (ledmenu == 1 && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

            if (digitalRead(SW_JUMP) == LOW) {
              delay(100);
              wskled++;
              while (digitalRead(SW_JUMP) == LOW) {}
            }
            byte licznikled = 0;
            byte licznikled_prev = 0;
            int czas = 200;
            byte skok = 2;
            byte pasek;


            byte t_pomiar = 0;

            float dBLmess;
            float dBRmess;
            float leftmess;
            float rightmess;
            float VL;
            float VR;

            const char V[2] = "V";
            const char NIGDY[6] = "Nigdy";
            const char dB[3] = "dB";


            switch (wskled) {

              case 0:

                while (digitalRead(SW_SEL) == LOW ) {

                  BRNESS++;
                  if (BRNESS > 100) {
                    BRNESS = 0;
                  }

                  //Jasnosc++;
                  //if (Jasnosc > 100) {
                  //Jasnosc = 0;
                  //}

                  licznikled++;
                  if (licznikled > 40) {
                    licznikled = 40;
                  }

                  if (licznikled - licznikled_prev >= skok) {  //skracanie skoku cyfry o -50ms
                    licznikled_prev = licznikled;
                    czas = (czas - 30);
                    if (czas <= 30) {
                      czas = 30;
                    }
                    skok++;
                  }

                  f_PWM();
                  OLED.clearDisplay();
                  OLED.setTextSize(1);
                  OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                  OLED.drawPixel(77, 25, 1);
                  OLED.drawPixel(78, 24, 1);
                  OLED.drawPixel(83, 25, 1);
                  OLED.drawPixel(84, 24, 1);
                  OLED.setCursor(10, 12);
                  OLED.print(F("Diody Front Panelu"));
                  OLED.setCursor(45, 25);

                  OLED.print(F("Jasnosc"));
                  pasek = map(BRNESS, 0, 100, 12, 69);
                  OLED.setTextSize(2);

                  OLED.drawRoundRect(10, 40, 61, 14, 4, 1);

                  OLED.fillRect(12, 42, (pasek - 12), 10, 1);

                  OLED.setCursor(75, 40);
                  OLED.print(BRNESS);
                  OLED.print(F("%"));
                  OLED.display();
                  delay(czas);
                }
                break;

              case 1:

                if (digitalRead(SW_SEL) == LOW) {
                  kontrast++;
                  if (kontrast > 10) {
                    kontrast = 1;
                  }
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }
                //f_kontrast();
                OLED.clearDisplay();
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.drawPixel(77, 25, 1);
                OLED.drawPixel(78, 24, 1);
                OLED.drawPixel(83, 25, 1);
                OLED.drawPixel(84, 24, 1);
                OLED.setCursor(34, 12);
                OLED.print(F("Ekran OLED"));
                OLED.setCursor(45, 25);
                OLED.print(F("Jasnosc"));
                pasek = map(kontrast, 1, 10, 12, 69);
                OLED.setTextSize(2);
                OLED.drawRoundRect(10, 40, 61, 14, 4, 1);
                OLED.fillRect(12, 42, (pasek - 12), 10, 1);
                OLED.setCursor(90, 40);
                OLED.print(kontrast);
                OLED.display();
                delay(50);

                while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}

                break;

              case 2:

                if (digitalRead(SW_SEL) == LOW) {
                  diody ++;
                  if (diody > 2) {
                    diody = 0;
                  }
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }
                f_diody();
                OLED.clearDisplay();
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setCursor(25, 15);
                OLED.print(F("Diody Switchy"));
                OLED.setTextSize(2);
                OLED.setCursor(30, 35);
                if (diody == 0) {
                  OLED.print(F("Zawsze"));
                } else if (diody == 1) {
                  OLED.print(F("Menu"));
                } else if (diody == 2) {
                  OLED.print(NIGDY);
                }
                OLED.display();
                delay(100);


                break;

              case 3:
                if (digitalRead(SW_SEL) == LOW) {
                  wskoff ++;
                  if (wskoff > 12) {
                    wskoff = 0;
                  }
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }

                OLED.clearDisplay();
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);

                OLED.setCursor(50, 12);
                OLED.print(F("Zanik"));
                OLED.setCursor(45, 25);

                OLED.print(F("Kursora"));
                if (wskoff > 0) {
                  pasek = map(wskoff, 1, 12, 12, 69);
                  OLED.setTextSize(2);

                  OLED.drawRoundRect(10, 40, 61, 14, 4, 1);

                  OLED.fillRect(12, 42, (pasek - 12), 10, 1);

                  OLED.setCursor(75, 40);
                  OLED.print(wskoff * 5);
                  OLED.print(F("s"));
                  OLED.display();
                } else {
                  OLED.setTextSize(2);
                  OLED.setCursor(30, 40);
                  OLED.print(NIGDY);

                  OLED.display();
                  delay(100);
                }
                break;

              case 4:
                if (digitalRead(SW_SEL) == LOW) {
                  oledoff ++;
                  if (oledoff > 12) {
                    oledoff = 0;
                  }
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }

                OLED.clearDisplay();
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);

                OLED.setCursor(35, 12);
                OLED.print(F("Wylaczenie"));
                OLED.setCursor(45, 25);

                OLED.print(F("Ekranu"));
                if (oledoff > 0) {
                  pasek = map(oledoff, 1, 12, 12, 69);
                  OLED.setTextSize(2);

                  OLED.drawRoundRect(10, 40, 61, 14, 4, 1);

                  OLED.fillRect(12, 42, (pasek - 12), 10, 1);

                  OLED.setCursor(75, 40);
                  OLED.print(oledoff * 5);
                  OLED.print(F("s"));
                  OLED.display();
                } else {
                  OLED.setTextSize(2);
                  OLED.setCursor(30, 35);
                  OLED.print(NIGDY);

                  OLED.display();
                  delay(100);
                }
                break;

              case 5:  // pomiar wyjscia

                OLED.clearDisplay();
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(1);
                OLED.setCursor(15, 12);
                OLED.print(F("Poziom Wyjsciowy"));

                while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {

                  t_pomiar++;

                  if (t_pomiar == 4) {

                    t_pomiar = 0;

                    OLED.fillRect(8, 20, 110, 40, 0);

                    leftmess = analogRead(VU_L);
                    rightmess = analogRead(VU_R);

                    dBLmess = 20 * log10(leftmess / max_syg);

                    if (dBLmess < -99.99) {
                      dBLmess = -99.99;
                    }

                    dBRmess = 20 * log10(rightmess / max_syg);

                    if (dBRmess < -99.99) {
                      dBRmess = -99.99;
                    }

                    VL = (5.0 * leftmess) / 1023;

                    VR = (5.0 * rightmess) / 1023;

                    OLED.setTextSize(1, 2);
                    OLED.setCursor(10, 26);
                    OLED.print(dBLmess);
                    OLED.print(dB);

                    OLED.setCursor(69, 26);
                    OLED.print(dBRmess);
                    OLED.print(dB);

                    OLED.setCursor(16, 43);
                    OLED.print(VL);
                    OLED.print(V);

                    OLED.setCursor(75, 43);
                    OLED.print(VR);
                    OLED.print(V);
                    OLED.display();
                  }

                  delay(50);
                }

                break;

              case 6:

                OLED.clearDisplay();
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(1);
                OLED.setCursor(7, 12);
                OLED.print(F("Licznik odtwarzania"));
                OLED.setTextSize(2);
                OLED.setCursor(100, 40);
                OLED.print(znak);
                OLED.setTextSize(1);
                OLED.display();

                while (digitalRead(SW_JUMP) == HIGH && digitalRead(SW_SEL) == HIGH && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {
                  byte X = 22;
                  f_start_czas();

                  OLED.fillRect(7, 20, 110, 20, 0);

                  if (czas_wkl_sec < 10) {
                    X = X + 5;
                  }
                  if (czas_wkl_min < 10) {
                    X = X + 5;
                  }
                  if (czas_wkl_h < 10) {
                    X = X + 5;
                  }

                  OLED.setCursor(X, 28);
                  OLED.print(czas_wkl_h);
                  OLED.print(F("h"));
                  OLED.print(F(" "));
                  OLED.print(czas_wkl_min);
                  OLED.print(F("min"));
                  OLED.print(F(" "));
                  OLED.print(czas_wkl_sec);
                  OLED.print(F("s"));
                  OLED.display();
                  delay(50);
                }

                if (digitalRead(SW_SEL) == LOW) {
                  czas_wkl_sec = 0;
                  czas_wkl_min = 0;
                  czas_wkl_h = 0;
                }
                break;

              case 7:

                OLED.clearDisplay();
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(2, 1);
                OLED.setCursor(15, 26);
                OLED.print(F("FW: "));
                OLED.print(Wersja);
                OLED.display();
                delay(50);
                break;

              case 8:

                OLED.clearDisplay();  //Zapisanie Nastawów preampa z wyswietleniem potwierdzenia
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(2, 2);
                OLED.setCursor(29, 15);
                OLED.print(F("RESET ?"));
                OLED.setTextSize(2);
                OLED.setCursor(100, 40);
                OLED.print(znak);
                OLED.display();
                delay(100);

                if (digitalRead(SW_SEL) == LOW) {
                  digitalWrite(RLY, HIGH);
                  Res = 0;
                  Res_MC = 0;
                  Cap = 3;
                  gain = 0;
                  Sub = 0;
                  New_Res = Res;
                  New_Gain = gain;
                  New_Cap = Cap;
                  New_Res_MC = Res_MC;
                  New_Sub = Sub;
                  BRNESS = 100;
                  oledoff = 12;
                  wskoff = 6;
                  diody = 1;
                  delay(20ul);
                  OLED.clearDisplay();
                  OLED.setTextSize(1);
                  OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                  OLED.setTextSize(1, 2);
                  OLED.setCursor(33, 14);
                  OLED.print("USTAWIENIA");
                  OLED.setCursor(30, 38);
                  OLED.print("ZRESETOWANE");
                  OLED.display();
                  delay(500ul);
                  Wsk = 0;
                  ledmenu = 0;
                  delay(500ul);
                  OLED.clearDisplay();
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }

                break;

              case 9:

                if (digitalRead(SW_SEL) == LOW) {
                  blue++;
                 
                  if (blue > 1) {
                    blue = 0;
                  }
                  if (blue == 1) {

                    Serial.begin(9600);
                  }
                  while (digitalRead(SW_SEL) == LOW && digitalRead(DC_ERR) == HIGH && digitalRead(P_DOWN) == HIGH) {}
                }

                OLED.clearDisplay();  //Zapisanie Nastawów preampa z wyswietleniem potwierdzenia
                OLED.setTextSize(1);
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(2, 2);
                OLED.setCursor(10, 15);
                OLED.print(F("BLUETOOTH"));
                OLED.setTextSize(2);
                OLED.setCursor(100, 40);
                OLED.print(znak);
                //OLED.display();
                delay(100);

                if (blue == 1) {
                  //digitalWrite(BT_CTRL_PIN, HIGH);   // Włącz masę przez ULN
                  //delay(500);
;

                  OLED.setTextSize(2);
                  OLED.setCursor(10, 40);
                  OLED.print(F("ON"));
                  OLED.display();


                  if (Serial.available() > 0) {
                    if (Serial.read() == '#') { // Start ramki

                      // Parsowanie (zakładając format: #v1,v2,v3*)
                      byte BlueRes = Serial.parseInt();
                      byte BlueRes_MC = Serial.parseInt();
                      byte BlueCap = Serial.parseInt();
                      byte BlueGain = Serial.parseInt();


                      // Porównywanie i podmiana


                      if (BlueRes != Res && BlueRes != 99) {
                        Res = BlueRes;

                        //Serial.println("Zmieniono V1!");
                      }
                      if (BlueRes_MC != Res_MC && BlueRes_MC != 99) {
                        Res_MC = BlueRes_MC;

                        //Serial.println("Zmieniono V2!");
                      }
                      if (BlueCap != Cap && BlueCap != 99) {
                        Cap = BlueCap;

                        //Serial.println("Zmieniono V3!");
                      }
                      if (BlueGain != gain) {
                        gain = BlueGain;
                        //Serial.println("Zmieniono V4!");
                      }
                      f_zapis();
                    }
                  }


                }

                if(blue == 0){
                  Serial.end();
                pinMode(0, INPUT);
                pinMode(1, INPUT);
                //digitalWrite(BT_CTRL_PIN, LOW);
                OLED.display();
                }

                break;

              case 10:
                Wsk = 0;
                ledmenu = 0;
                if(blue == 1){
                Serial.end();
                pinMode(0, INPUT);
                pinMode(1, INPUT);
                //digitalWrite(BT_CTRL_PIN, LOW);
                blue = 0;
                }
                break;

            }
          }
        }

        break;
    }
  }

  if (digitalRead(P_DOWN) == LOW && P_DOWN_DET == 0) {
    digitalWrite(RLY, HIGH);
    digitalWrite(LED1, HIGH);
    digitalWrite(LED2, HIGH);
    OLED.clearDisplay();
    //OLED.setTextSize(2);
    //OLED.setCursor(40, 6);
    //OLED.print("BRAK");
    //OLED.setCursor(10, 26);
    //OLED.print("ZASILANIA");
    //OLED.setTextSize(1);
    //OLED.setCursor(23, 50);
    //OLED.print("DO ZOBACZENIA");
    OLED.display();
    Index_diody = 100;
    Index_PWM = 100;

    timer0 = millis();

    while (digitalRead(P_DOWN) == LOW && P_DOWN_DET == 0) {

      if (millis() - timer0 >= 2000ul) {

        P_DOWN_DET = 1;
        timer0 = millis();
      }
    }

  }

  if (digitalRead(DC_ERR) == LOW || P_DOWN_DET == 1 || digitalRead(PWR_ERR) == LOW) {

    digitalWrite(RLY, HIGH);

    byte Index_ERR = 0;
    byte PWR_ERR_stat = 0;
    byte P_DOWN_stat = 0;
    byte DC_ERR_stat = 0;

    if (digitalRead(DC_ERR) == LOW) {
      DC_ERR_stat = 1;
    }
    if (digitalRead(PWR_ERR) == LOW) {
      PWR_ERR_stat = 1;
    }
    if (P_DOWN_DET == 1) {
      P_DOWN_stat = 1;
    }

    while (digitalRead(DC_ERR) == LOW && Index_ERR < 20) {  // Przez 3 sek wykrycia składowej stałej jest wył ekran
      delay(50ul);
      Index_ERR++;
    }
    digitalWrite(LED1, HIGH);
    digitalWrite(LED2, HIGH);
    OLED.clearDisplay();
    OLED.display();
    Index_diody = 100;
    Index_PWM = 100;
    Index_ERR = 0;
    while (digitalRead(DC_ERR) == LOW && Index_ERR < 60) {  // Przez 3 sek wykrycia składowej stałej jest wył ekran
      delay(50ul);
      Index_ERR++;
    }

    while (digitalRead(DC_ERR) == LOW || P_DOWN_DET == 1 || digitalRead(PWR_ERR) == LOW ) {

      if (digitalRead(P_DOWN) == HIGH) {
        P_DOWN_DET = 0;
      }
      OLED.clearDisplay();
      OLED.setTextSize(2);
      OLED.setCursor(25, 6);
      OLED.print("USTERKA");
      OLED.setCursor(42, 26);
      OLED.setTextSize(1);
      OLED.print("WYJSCIE");
      OLED.setCursor(34, 40);
      OLED.print("NIEAKTYWNE");
      OLED.setCursor(15, 55);
      OLED.print("WYLACZ ZASILANIE");
      OLED.display();

      if (millis() - timer1 >= 100ul) {
        timer1 = millis();
        digitalWrite(LED2, !digitalRead(LED2));
        digitalWrite(LED1, !digitalRead(LED1));
        Index_ERR++;
        if (Index_ERR == 30) {
          // digitalWrite(PWR, HIGH);

          do {
            if (millis() - timer1 >= 100ul) {
              timer1 = millis();
              digitalWrite(LED2, !digitalRead(LED2));
              digitalWrite(LED1, !digitalRead(LED1));

              if (digitalRead(SW_SEL) == LOW) {


                OLED.clearDisplay();
                OLED.drawRoundRect(4, 4, 120, 58, 4, 1);
                OLED.setTextSize(2, 1);
                OLED.setCursor(11, 10);
                OLED.print(F("DC OUT: "));
                OLED.print(DC_ERR_stat);
                OLED.setCursor(11, 26);
                OLED.print(F("PRE DC: "));
                OLED.print(PWR_ERR_stat);
                OLED.setCursor(11, 43);
                OLED.print(F("IN DC:  "));
                OLED.print(P_DOWN_stat);
                OLED.display();

              }
            }
          } while (1);
        }
      }
    }
  }
}