// энкодер
#define ENC_DT       9
#define ENC_CLK      8
#define ENC_SW       10

// ИК датчик
#define IR           12

// кнопки управления
#define POWER_BUTTON    3
#define MUTE_BUTTON     4

// выход управления standby
#define STANDBY_OUT     13

// коды кнопок ИК пульта
#define MENU      0x2FDB24D // button encoder
#define UP        0x2FDD02F // >>>
#define DW        0x2FD32CD // <<<
#define POWER_IR  0x2FD00FF // POWER
#define MUTE_IR   0x2FDB04F // MUTE

#include <Wire.h> 
#include <U8glib.h>             // https://github.com/olikraus/u8glib/
#include <Encoder.h>            // http://rcl-radio.ru/wp-content/uploads/2019/05/Encoder.zip    
#include <EEPROM.h>
#include <MsTimer2.h>           // http://rcl-radio.ru/wp-content/uploads/2018/11/MsTimer2.zip       
#include <boarddefs.h>          // входит в состав библиотеки IRremote
#include <IRremote.h>           // http://rcl-radio.ru/wp-content/uploads/2019/06/IRremote.zip
#include <PT2257.h>             // http://rcl-radio.ru/wp-content/uploads/2019/01/PT2257.zip

 U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 
 IRrecv irrecv(IR);
 Encoder myEnc(ENC_DT, ENC_CLK);
 decode_results ir; 
 PT2257 rt;

 extern uint8_t SmallFont[],BigNumbers[];
 long times,oldPosition  = -999,newPosition;
 int vol,balans,bass,treb,in,menu;
 bool mute=0,gr1,gr2,w,w1,power=0;

 void setup(){
  Wire.begin();
  irrecv.enableIRIn();
  Serial.begin(9600);
  MsTimer2::set(3, to_Timer);MsTimer2::start();
  if(EEPROM.read(100)!=0){for(int i=0;i<101;i++){EEPROM.update(i,0);}}// очистка памяти при первом включении  
  pinMode(POWER_BUTTON,INPUT_PULLUP);
  pinMode(MUTE_BUTTON,INPUT_PULLUP);
  pinMode(STANDBY_OUT,OUTPUT); 

 u8g.firstPage(); do {
  u8g.setFont(u8g_font_profont29r);u8g.drawStr(5,25,"PT2257"); 
  }while( u8g.nextPage() );

  delay(300);
  digitalWrite(STANDBY_OUT,LOW);
  vol = EEPROM.read(0);balans = EEPROM.read(3)-8;
  audio(); 
 }

 void loop(){
  // IR ////////////////////////////////////////
  if ( irrecv.decode( &ir )) {Serial.print("0x");Serial.println( ir.value,HEX);irrecv.resume();times=millis();w=1;}// IR приемник - чтение, в мониторе порта отображаются коды кнопок
  if(ir.value==0){gr1=0;gr2=0;}// запрет нажатий не активных кнопок пульта  
  
 if(power==0){ 
 if(digitalRead(ENC_SW)==LOW || ir.value==MENU){menu++;cl();delay(200);times=millis();w1=1;w=1;if(menu>1){menu=0;}} // меню


 if((digitalRead(MUTE_BUTTON)==LOW || ir.value==MUTE_IR)&& mute==0){mute=1;cl();times=millis();w1=1;w=1;audio();
 u8g.firstPage(); do {u8g.setFont(u8g_font_profont29r);u8g.drawStr(25,25,"MUTE");}while( u8g.nextPage() );delay(300);menu=100;} // mute on 

 if((digitalRead(MUTE_BUTTON)==LOW || ir.value==MUTE_IR)&& mute==1){mute=0;cl();times=millis();w1=1;w=1;audio();
 delay(300);menu=0;} // mute off 
 }

 if((digitalRead(POWER_BUTTON)==LOW || ir.value==POWER_IR)&& power==0){power=1;cl();times=millis();w1=1;w=1;mute=1;audio();digitalWrite(STANDBY_OUT,HIGH);
 u8g.firstPage(); do {u8g.setFont(u8g_font_profont29r);u8g.drawStr(10,25,"STANDBY");}while( u8g.nextPage() );delay(2000);menu=100;
 u8g.firstPage(); do {}while( u8g.nextPage() );} // power on 

 if((digitalRead(POWER_BUTTON)==LOW || ir.value==POWER_IR)&& power==1){power=0;cl();times=millis();w1=1;w=1;mute=0;audio();digitalWrite(STANDBY_OUT,LOW);delay(300);menu=0;} // power off 
 
  
//////// VOLUME //////////////////////////////////////////////////////////////////////////////////////////////////////////////  
  if(menu==0){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   vol=vol+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;vol_func();audio();}
 
   if(ir.value==UP){vol++;gr1=1;gr2=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка > 
   if(ir.value==0xFFFFFFFF and gr1==1){vol++;gr2=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка >>>>>>
   if(ir.value==DW){vol--;gr1=0;gr2=1;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка <
   if(ir.value==0xFFFFFFFF and gr2==1){vol--;gr1=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка <<<<<<
 
  if(w==1){w=0;
 // Serial.println(63-vol+balans);
  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"VOLUME");
  u8g.setFont(u8g_font_profont29r); u8g.setPrintPos(95, 24);u8g.print(vol-8);
  for(int v_pos=0; v_pos<(71-8)*1.3;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  for(int v_pos=0; v_pos<(vol-8)*1.3;v_pos+=4){u8g.drawBox(v_pos+0,18, 2, 9);}
  for(int v_pos=0; v_pos<(71-8)*1.3;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
   } while( u8g.nextPage() );
  }}

///////// BALL /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  if(menu==1){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   balans=balans+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;ball_func();audio();}

   if(ir.value==UP){balans++;gr1=1;gr2=0;ir.value=0;times=millis();w=1;w1=1;ball_func();audio();}// кнопка > 
   if(ir.value==DW){balans--;gr1=0;gr2=1;ir.value=0;times=millis();w=1;w1=1;ball_func();audio();}// кнопка <
 
  if(w==1){w=0;
//  Serial.println(vol+balans);
//  Serial.println(vol-balans);
  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"BALANCE");
  u8g.setFont(u8g_font_profont29r); 
  if(balans>=0){u8g.setPrintPos(112, 24);u8g.print(balans);u8g.drawStr(95,24,"+");}
  else{u8g.setPrintPos(95, 24);u8g.print(balans);}

  for(int v_pos=0; v_pos<(12-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  const int SCREEN_WIDTH = 84; 
  u8g.drawBox(43,18, 1, 9);// 0 dB
  if(balans >= 0){for(int v_pos=0; v_pos<(balans*4);v_pos+=4){u8g.drawBox(v_pos+48,18, 2, 9);}} 
  else{for(int v_pos=SCREEN_WIDTH-48; v_pos>(SCREEN_WIDTH-(abs(balans)*4)-48); v_pos-=4){u8g.drawBox(v_pos,18, 2, 9);}}
  for(int v_pos=0; v_pos<(12-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
  
   } while( u8g.nextPage() );
  }}
  

////////////// EEPROM /////////////////////////////////////////////////////////////////////  
  if(millis()-times>5000 && w1==1 && power==0 && mute==0){
     EEPROM.update(0,vol);EEPROM.update(3,balans+8);
     menu=0;w1=0;w=1;myEnc.write(0);}
  }

 
void to_Timer(){newPosition = myEnc.read()/4;} 
void audio(){
  rt.setLeft(vol-8+balans); // int 0...79 
  rt.setRight(vol-8-balans);// int 0...79
  rt.setMute(mute);  // int 0...1
}

void vol_func(){if(vol>71){vol=71;}if(vol<=8){vol=8;}} // int 0 ... int 79 
void ball_func(){if(balans>8){balans=8;}if(balans<=-8){balans=-8;}}
void cl(){ir.value=0;delay(200);} 

// энкодер
#define ENC_DT       9
#define ENC_CLK      8
#define ENC_SW       10

// ИК датчик
#define IR           12

// кнопки управления
#define IN_BUTTON       2
#define POWER_BUTTON    3
#define MUTE_BUTTON     4

// выход управления standby
#define STANDBY_OUT     13

// коды кнопок ИК пульта
#define MENU      0x2FDB24D // button encoder
#define UP        0x2FDD02F // >>>
#define DW        0x2FD32CD // <<<
#define INPUT_IR  0x2FD6A95 // IN
#define POWER_IR  0x2FD00FF // POWER
#define MUTE_IR   0x2FDB04F // MUTE

#include <Wire.h> 
#include <U8glib.h>             // https://github.com/olikraus/u8glib/
#include <Encoder.h>            // http://rcl-radio.ru/wp-content/uploads/2019/05/Encoder.zip    
#include <EEPROM.h>
#include <MsTimer2.h>           // http://rcl-radio.ru/wp-content/uploads/2018/11/MsTimer2.zip       
#include <boarddefs.h>          // входит в состав библиотеки IRremote
#include <IRremote.h>           // http://rcl-radio.ru/wp-content/uploads/2019/06/IRremote.zip
#include <TDA8425.h>            // http://rcl-radio.ru/wp-content/uploads/2018/11/TDA8425.zip

 U8GLIB_SSD1306_128X32 u8g(U8G_I2C_OPT_NONE);  // I2C / TWI 
 IRrecv irrecv(IR);
 Encoder myEnc(ENC_DT, ENC_CLK);
 decode_results ir; 
 TDA8425 tda;

 extern uint8_t SmallFont[],BigNumbers[];
 long times,oldPosition  = -999,newPosition;
 int vol,balans,bass,treb,in,menu;
 bool mute=0,gr1,gr2,w,w1,power=0;

 void setup(){
  Wire.begin();
  irrecv.enableIRIn();
  Serial.begin(9600);
  MsTimer2::set(3, to_Timer);MsTimer2::start();
  if(EEPROM.read(100)!=0){for(int i=0;i<101;i++){EEPROM.update(i,0);}}// очистка памяти при первом включении  
  pinMode(IN_BUTTON,INPUT_PULLUP);
  pinMode(POWER_BUTTON,INPUT_PULLUP);
  pinMode(MUTE_BUTTON,INPUT_PULLUP);
  pinMode(STANDBY_OUT,OUTPUT); 

 u8g.firstPage(); do {
  u8g.setFont(u8g_font_profont29r);u8g.drawStr(5,25,"TDA8425"); 
  }while( u8g.nextPage() );

  delay(300);
  digitalWrite(STANDBY_OUT,LOW);
  vol = EEPROM.read(0);bass = EEPROM.read(1);treb = EEPROM.read(2);balans = EEPROM.read(3)-4;in = EEPROM.read(4);
  audio(); 
 }

 void loop(){
  // IR ////////////////////////////////////////
  if ( irrecv.decode( &ir )) {Serial.print("0x");Serial.println( ir.value,HEX);irrecv.resume();times=millis();w=1;}// IR приемник - чтение, в мониторе порта отображаются коды кнопок
  if(ir.value==0){gr1=0;gr2=0;}// запрет нажатий не активных кнопок пульта  
  
 if(power==0){ 
 if(digitalRead(ENC_SW)==LOW || ir.value==MENU){menu++;cl();delay(200);times=millis();w1=1;w=1;if(menu>3){menu=0;}} // меню

 if((digitalRead(IN_BUTTON)==LOW || ir.value==INPUT_IR) && mute==0){in++;cl();times=millis();w1=1;w=1;if(in>1){in=0;}audio();
 u8g.firstPage(); do {u8g.setFont(u8g_font_profont29r);u8g.drawStr(0,25,"INPUT");u8g.setPrintPos(95, 25);u8g.print(in+1);}while( u8g.nextPage() );delay(1000);} // input 

 if((digitalRead(MUTE_BUTTON)==LOW || ir.value==MUTE_IR)&& mute==0){mute=1;cl();times=millis();w1=1;w=1;audio();
 u8g.firstPage(); do {u8g.setFont(u8g_font_profont29r);u8g.drawStr(25,25,"MUTE");}while( u8g.nextPage() );delay(300);menu=100;} // mute on 

 if((digitalRead(MUTE_BUTTON)==LOW || ir.value==MUTE_IR)&& mute==1){mute=0;cl();times=millis();w1=1;w=1;audio();
 delay(300);menu=0;} // mute off 
 }

 if((digitalRead(POWER_BUTTON)==LOW || ir.value==POWER_IR)&& power==0){power=1;cl();times=millis();w1=1;w=1;mute=1;audio();digitalWrite(STANDBY_OUT,HIGH);
 u8g.firstPage(); do {u8g.setFont(u8g_font_profont29r);u8g.drawStr(10,25,"STANDBY");}while( u8g.nextPage() );delay(2000);menu=100;
 u8g.firstPage(); do {}while( u8g.nextPage() );} // power on 

 if((digitalRead(POWER_BUTTON)==LOW || ir.value==POWER_IR)&& power==1){power=0;cl();times=millis();w1=1;w=1;mute=0;audio();digitalWrite(STANDBY_OUT,LOW);delay(300);menu=0;} // power off 
 
  
//////// VOLUME //////////////////////////////////////////////////////////////////////////////////////////////////////////////  
  if(menu==0){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   vol=vol+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;vol_func();audio();}
 
   if(ir.value==UP){vol++;gr1=1;gr2=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка > 
   if(ir.value==0xFFFFFFFF and gr1==1){vol++;gr2=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка >>>>>>
   if(ir.value==DW){vol--;gr1=0;gr2=1;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка <
   if(ir.value==0xFFFFFFFF and gr2==1){vol--;gr1=0;cl();times=millis();w=1;w1=1;vol_func();audio();}// кнопка <<<<<<
 
  if(w==1){w=0;
 // Serial.println(63-vol+balans);
  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"VOLUME");
  u8g.setFont(u8g_font_profont29r); u8g.setPrintPos(95, 24);u8g.print(vol-4);
  for(int v_pos=0; v_pos<(59-3)*1.5;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  for(int v_pos=0; v_pos<(vol-3)*1.5;v_pos+=4){u8g.drawBox(v_pos+0,18, 2, 9);}
  for(int v_pos=0; v_pos<(59-3)*1.5;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
   } while( u8g.nextPage() );
  }}

///////// BASS /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  if(menu==1){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   bass=bass+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;bass_func();audio();}

   if(ir.value==UP){bass++;gr1=1;gr2=0;ir.value=0;times=millis();w=1;w1=1;bass_func();audio();}// кнопка > 
   if(ir.value==DW){bass--;gr1=0;gr2=1;ir.value=0;times=millis();w=1;w1=1;bass_func();audio();}// кнопка <
 
  if(w==1){w=0;

  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"BASS");
  u8g.setFont(u8g_font_profont29r); u8g.setPrintPos(95, 24);u8g.print(bass-6);
  for(int v_pos=0; v_pos<(11-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  for(int v_pos=0; v_pos<(bass-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,18, 2, 9);}
  for(int v_pos=0; v_pos<(11-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
   } while( u8g.nextPage() );
  }}

///////// TREB /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  if(menu==2){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   treb=treb+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;treb_func();audio();}

   if(ir.value==UP){treb++;gr1=1;gr2=0;ir.value=0;times=millis();w=1;w1=1;treb_func();audio();}// кнопка > 
   if(ir.value==DW){treb--;gr1=0;gr2=1;ir.value=0;times=millis();w=1;w1=1;treb_func();audio();}// кнопка <
 
  if(w==1){w=0;

  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"TREBLE");
  u8g.setFont(u8g_font_profont29r); u8g.setPrintPos(95, 24);u8g.print(treb-6);
  for(int v_pos=0; v_pos<(10-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  for(int v_pos=0; v_pos<(treb-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,18, 2, 9);}
  for(int v_pos=0; v_pos<(10-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
   } while( u8g.nextPage() );
  }}

///////// BALL /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  if(menu==3){
   if(newPosition != oldPosition){oldPosition = newPosition;if(newPosition>1){newPosition=1;}if(newPosition<-1){newPosition=-1;}
   balans=balans+newPosition;myEnc.write(0);newPosition=0;times=millis();w=1;w1=1;ball_func();audio();}

   if(ir.value==UP){balans++;gr1=1;gr2=0;ir.value=0;times=millis();w=1;w1=1;ball_func();audio();}// кнопка > 
   if(ir.value==DW){balans--;gr1=0;gr2=1;ir.value=0;times=millis();w=1;w1=1;ball_func();audio();}// кнопка <
 
  if(w==1){w=0;
 // Serial.println(63-vol+balans);
 // Serial.println(63-vol-balans);
  u8g.firstPage();  
   do {
  u8g.setFont(u8g_font_profont12r);u8g.drawStr(0,8,"BALANCE");
  u8g.setFont(u8g_font_profont29r); 
  if(balans>=0){u8g.setPrintPos(112, 24);u8g.print(balans);u8g.drawStr(95,24,"+");}
  else{u8g.setPrintPos(95, 24);u8g.print(balans);}

  for(int v_pos=0; v_pos<(12-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,16, 2, 1);}
  const int SCREEN_WIDTH = 84; 
  u8g.drawBox(43,18, 1, 9);// 0 dB
  if(balans >= 0){for(int v_pos=0; v_pos<(balans*8);v_pos+=4){u8g.drawBox(v_pos+48,18, 2, 9);}} 
  else{for(int v_pos=SCREEN_WIDTH-48; v_pos>(SCREEN_WIDTH-(abs(balans)*8)-48); v_pos-=4){u8g.drawBox(v_pos,18, 2, 9);}}
  for(int v_pos=0; v_pos<(12-1)*8;v_pos+=4){u8g.drawBox(v_pos+0,28, 2, 1);}
  
   } while( u8g.nextPage() );
  }}
  

////////////// EEPROM /////////////////////////////////////////////////////////////////////  
  if(millis()-times>5000 && w1==1 && power==0 && mute==0){
     EEPROM.update(0,vol);EEPROM.update(1,bass);EEPROM.update(2,treb);EEPROM.update(3,balans+4);EEPROM.update(4,in);
     menu=0;w1=0;w=1;myEnc.write(0);}
  }


  
void to_Timer(){newPosition = myEnc.read()/4;} 
void audio(){
  tda.setVolumeL(vol+balans);
  tda.setVolumeR(vol-balans);
  tda.setBass(bass);
  tda.setTreble(treb);
  tda.setMute(mute);
  tda.setSource(in);
 } 

void vol_func(){if(vol>59){vol=59;}if(vol<=4){vol=4;}} // int 0 = min ... int 63 = max + ballans 4 dB 
void bass_func(){if(bass>11){bass=11;}if(bass<2){bass=2;}} // int 6 = 0 dB | int 2 = -12 dB | int 11 = 15 dB
void treb_func(){if(treb>10){treb=10;}if(treb<2){treb=2;}} // int 6 = 0 dB | int 2 = -12 dB | int 10 = 12 dB
void ball_func(){if(balans>4){balans=4;}if(balans<=-4){balans=-4;}}
void cl(){ir.value=0;delay(200);} 

#include <Wire.h>              // Библиотека для работы с I2C
#include <Adafruit_GFX.h>      // Библиотека для работы с графикой
#include <Adafruit_SSD1306.h>  // Библиотека для работы с OLED-дисплеем (0.96 дюйма)
#include <SoftwareSerial.h>    // Библиотека для использования программного последовательного порта
#include <MsTimer2.h>          // Библиотека для работы с таймерами
#include <EEPROM.h>            // Библиотека для работы с EEPROM

// Определение пинов
#define MODE_PIN    2
#define ENTER_PIN   3
#define SELECT_PIN  4
#define onPin      6             // Кнопка ручного включения вентилятора++++++++++
#define RX_PIN     10
#define TX_PIN     11
#define LED_PIN    7             // Выход индикатора измерения
#define funPin     5             // Выход управления вентилятором+++++
#define BAUDRATE           9600  // Скорость передачи данных для MH-Z19 (фиксированная)
#define T1                 1000  // Интервал измерений в миллисекундах (минимум 1000 = 1 секунда))
#define DISP_ON_TIME       30000  // Время включения дисплея (время до отключения)
#define DISP_WAKEUP_VALUE  1000  // Уровень CO2, при котором дисплей включается
#define FUN_VALUE_ON        900  // Уровень CO2, при котором вентилятор ВКЛ+++++++++
#define FUN_VALUE_OFF       799  // Уровень CO2, при котором вентилятор ВКЛ++++++++
#define SCREEN_WIDTH 128         // Ширина OLED-дисплея
#define SCREEN_HEIGHT 64         // Высота OLED-дисплея
#define OLED_RESET    -1         // Пин сброса (или -1, если используется общий сброс Arduino)

// Инициализация OLED-дисплея
Adafruit_SSD1306 OLED(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET);


// Объявление переменных
unsigned int co2Val;             // Измеренное значение CO2
unsigned int calib;              // Режим калибровки
int dispTimer = DISP_ON_TIME;    // Оставшееся время до выключения дисплея

// Для управления кнопкой
bool funState = false;       // Состояние вентилятора+++++++
unsigned long funOnTime = 0; // Время включения вентилятора+++++++++

byte ReadCO2[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79}; // Команда чтения CO2
byte SCalOn[9]  = {0xFF, 0x01, 0x79, 0xA0, 0x00, 0x00, 0x00, 0x00, 0xE6}; // Команда включения калибровки
byte SCalOff[9] = {0xFF, 0x01, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86}; // Команда выключения калибровки
byte RetVal[9];                                                           // Массив для ответа от датчика


// Структура для описания диапазона графиков
struct recipe {     
  int gInterval;   // Интервал графика
  byte scaleV;     // Время на один делитель (30 пикселей)
  char scaleC[2];  // Единицы времени
};

struct recipe hRange[12] = {
  {   1, 30, "s"},  // Диапазон 0: период графика, время на делитель, единицы времени
  {   2,  1, "m"},  //       1
  {   4,  2, "m"},  //       2
  {  10,  5, "m"},  //       3
  {  20, 10, "m"},  //       4
  {  40, 20, "m"},  //       5
  { 120,  1, "h"},  //       6
  { 240,  2, "h"},  //       7
  { 480,  4, "h"},  //       8
  { 960,  8, "h"},  //       9
  {1440, 12, "h"},  //      10
  {2880,  1, "d"},  //      11
};

int dataBuff[91]; // Буфер данных (91 элемент от 0 до 90)
int latestData; // Последние данные CO2
int dataMin = 400; // Минимальное значение для отображения графика
int dataMax = 400; // Максимальное значение для отображения графика
int tCount = 0; // Счетчик времени интервала логирования
unsigned int rNum = 0; // Номер диапазона (rangeNumber) от 0 до 11
char chrBuff[6]; // Буфер символов для строковых данных

volatile boolean timerFlag = false; // Флаг прерывания таймера
boolean entPushed = false; // Флаг нажатия кнопки ENTER

// Инициализация программного последовательного порта для взаимодействия с MH-Z19C
SoftwareSerial mySerial(RX_PIN, TX_PIN);  // MH-Z19C

void setup() {
    pinMode(MODE_PIN, INPUT_PULLUP); // Установка режима авто-калибровки
    pinMode(ENTER_PIN, INPUT_PULLUP); // Установка кнопки ENTER как входа с подтяжкой
    pinMode(SELECT_PIN, INPUT_PULLUP); // Установка кнопки SELECT как входа с подтяжкой
    pinMode(LED_PIN, OUTPUT); // Установка пина LED как выхода
    pinMode(RX_PIN, INPUT); // Установка пина RX как входа для программного порта
    pinMode(TX_PIN, OUTPUT); // Установка пина TX как выхода для программного порта
    pinMode(onPin, INPUT_PULLUP); // Настройка кнопки включения вентиляторв с подтяжкой+++++++
    pinMode(funPin, OUTPUT);           // Настройка пина вентилятора как выход++++++++++
    mySerial.begin(9600); // Инициализация программного последовательного порта с заданной скоростью


  for (int i = 0; i <= 90; i++) {
    dataBuff[i] = -1;                 // Заполнение буфера данных значением -1 (неопределено)
  }

  if (!OLED.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3C for 128x32
    for (;;);                                    // Остановка программы в случае неудачи инициализации OLED-дисплея
  }
  OLED.clearDisplay();                 // Очистка дисплея перед выводом информации
  OLED.setTextColor(WHITE);            // Установка цвета текста на белый
  if (digitalRead(ENTER_PIN) == LOW) {  
    rangeSet();                        // Если кнопка ENTER нажата при запуске - выполнить настройку диапазона
  }
  rNum = EEPROM.read(0);               // Чтение номера диапазона из EEPROM

  OLED.setCursor(10, 12);
  OLED.print(F("CO2 monitor V0.8"));   // // Вывод стартового сообщения на дисплей
  OLED.display();

  if (digitalRead(MODE_PIN) == LOW) {  
    calib = 0;                         // Если режим LOW - установить ручную калибровку (без авто-калибровки)
  } else {                             
    calib = 1;                         // В противном случае установить авто-калибровку (по умолчанию)
  }
  setCalMode(calib);                   // Установка режима калибровки: 0 - ручной, 1 - автоматический
  measure();                           // Первичное измерение CO2
  MsTimer2::set(T1, timer2_IRQ);       // Запуск таймера
  MsTimer2::start();
}

void loop() {

// Проверяем состояние кнопки (активная низкая)+++++++++++
  if (digitalRead(onPin) == LOW && !funState) {
    funState = true;               // Включаем светодиод
    digitalWrite(funPin, HIGH);    // Включаем светодиод
    funOnTime = millis();          // Запоминаем время включения
  }
  
  // Проверяем, прошло ли 30 минут (1800000 миллисекунд)
  if (funState && (millis() - funOnTime >= 30000)) {
    funState = false;              // Выключаем светодиод
    digitalWrite(funPin, LOW);     // Выключаем светодиод
  }
  
  while (timerFlag != true) {              
    if (digitalRead(ENTER_PIN) == LOW) {   
      entPushed = true;                   // Установка флага нажатия кнопки ENTER в true при нажатии кнопки во время ожидания
    }
  }
  timerFlag = false;                      // Сброс флага таймера для следующего прерывания

  if (entPushed == true) {                 
    if (dispTimer > 1) {                   
      dispTimer = 1;                      // Если дисплей еще включен - выключить его
    } else {                              
      dispTimer = DISP_ON_TIME;           // Если дисплей выключен - вернуть его в исходное состояние (включить)
    }
  }
  entPushed = false;                      // Сброс флага нажатия кнопки ENTER

  digitalWrite(LED_PIN, HIGH);
  measure();                              // Включение светодиода во время измерения CO2
  digitalWrite(LED_PIN, LOW);
  latestData = co2Val;                    // Сохранение последнего измеренного значения CO2
  if (co2Val > DISP_WAKEUP_VALUE) {        
    dispTimer = DISP_ON_TIME;             // Если уровень CO2 превышает заданное значение - сбросить таймер дисплея
  }
  if (co2Val > FUN_VALUE_ON){
    digitalWrite(funPin, HIGH);          // Включить вентилятор если CO2 больше +++++++++++++
    }          
  if (co2Val < FUN_VALUE_OFF){            // Если значение CO2 меньше вентилятор ВЫКЛ++++++++++++++!!!!!!!!!!!!!!!!!!!!!!!
    digitalWrite(funPin, LOW);
  }

  tCount++;                               // Увеличение счетчика интервалов логирования
  if (tCount == hRange[rNum].gInterval) { // Если достигнут заданный интервал логирования - сохранить данные в буфер
    saveBuff();                           // Сброс счетчика интервалов логирования
    tCount = 0;
  }

  dispTimer--; // Декрементирование таймера отображения
    if (dispTimer > 0) { 
        disp(); // Если таймер больше нуля - отобразить данные на OLED-дисплее
    } else {
        OLED.clearDisplay(); // Если таймер равен нулю - очистить OLED-дисплей (выключить его)
        OLED.display(); 
        dispTimer = 1; // Установить значение для следующего отключения дисплея
    }
}

// Чтение значения концентрации CO2 с MH-Z19C

int measure() {                                 // MH-Z19С
  int err;
  mySerial.write(ReadCO2, sizeof ReadCO2);      // Отправка команды измерения
  memset(RetVal, 0x00, sizeof RetVal);          // Очистка буфера приема
  mySerial.readBytes((char *)RetVal, sizeof RetVal); // Получение результатов измерения

  if (RetVal[0] == 0xff && RetVal[1] == 0x86) { // Если чтение прошло успешно
    co2Val = RetVal[2] * 256 + RetVal[3];       // Вычисление концентрации CO2
    err = 0;
  } else {
    co2Val = 399;                               // Если чтение неудачно, вернуть это значение
    err = 1;
  }
  return err;
}

void setCalMode(int m) {                     // Установка режима калибровки
  if (m == 0) {
    mySerial.write(SCalOff, sizeof SCalOff); // Выключение калибровки 
  }
  if (m == 1) {
    mySerial.write(SCalOn, sizeof SCalOn);   // Включение калибровки 
  }
  mySerial.readBytes((char *)RetVal, sizeof RetVal); // Дамми-прием. Без этого не получится прочитать результаты измерений после включения питания
  delay(100);
}

void saveBuff() {                       // Обновление буфера данных и определение максимального и минимального значений
  int d;
  dataMin = 9999;                       // Минимальное значение
  dataMax = 0;                          // Максимальное значение
  for (int i = 90; i >= 1; i--) {       // Сохранение значений в массиве и определение максимального и минимального значений
    d = dataBuff[i - 1];                // Предыдущее значение
    dataBuff[i] = d;                    // Сдвиг массива
    if (d != -1) {                      // Если сдвинутые данные являются допустимыми значениями
      if (d < dataMin) {                // обновить минимальное значение
        dataMin = d;
      }
      if (d > dataMax) {                // обновить максимальное значение
        dataMax = d;
      }
    }
  }
  dataBuff[0] = latestData; // Запись последних данных в начало массива
    if (latestData < dataMin) { // Если последние данные меньше минимального значения
        dataMin = latestData; 
    } 
    if (latestData > dataMax) { // Если последние данные больше максимального значения
        dataMax = latestData; 
    } 
    if (dataMin < 0) { 
        dataMin = 0; // Но нижний предел - 0 
    } 
    if (dataMax > 5000) { 
        dataMax = 5000; // Но если больше 5000, ограничить до 5000 
    } 
}


void disp() { // Отображение на OLED-экране
    OLED.clearDisplay(); // Очистка экрана
    headWrite(); // Запись заголовка
    graphWrite(); // Отображение фона графика
    graphPlot(); // Отображение графика в виде линий
    OLED.display(); // Передача данных и отображение на экране
}

void headWrite() { // Отображение заголовка
    OLED.setCursor(0, 0); 
    OLED.setTextSize(1); // Маленький шрифт для первой строки
    OLED.print(F("CO2")); 
    OLED.setCursor(16 * 6, 0); // Отображение режима калибровки в правом верхнем углу
    if (calib == 0) { 
        OLED.print(F("AZoff")); 
    } else { 
        OLED.print(F("AZon")); 
    } 
    OLED.setCursor(24, 0); 
    OLED.setTextSize(2); // Увеличенный шрифт для значения CO2
    sprintf(chrBuff, "%4d", co2Val); // Форматирование значения CO2 в 4 цифры
    OLED.print(chrBuff); // Отображение значения CO2
    OLED.setCursor(26 + 4 * 6 * 2, 7); // Перемещение курсора для отображения единицы измерения
    OLED.setTextSize(1); 
    OLED.print(F("ppm")); // Отображение единицы измерения
    OLED.print(" "); 
    sprintf(chrBuff, "%4d", (hRange[rNum].gInterval - tCount) - 1); // Остаток времени до обновления графика
    OLED.setCursor(102, 8); 
    OLED.print(chrBuff); 
}


void graphWrite() {                       // Рисование фона графика
  OLED.drawFastVLine(30, 16, 40, WHITE);  // Левый ориентир (вертикальная линия)
  for (int x = 30; x <= 120; x += 4) {
    OLED.drawFastHLine(x, 36, 2, WHITE);  // Рисование пунктирной линии по центру (горизонтальная пунктирная линия)
  }

  for (int x = (120 - 30); x > 40; x -= 30) {
    for (int y = 16; y < 55; y += 4) {
      OLED.drawFastVLine(x, y, 2, WHITE); // Рисование двух пунктирных вертикальных линий
    }
  }
  // Левая шкала (отображение концентрации)
    OLED.drawFastHLine(26, 16, 4, WHITE); // Метка максимального значения
    OLED.drawFastHLine(26, 36, 4, WHITE); // Центр
    OLED.drawFastHLine(26, 55, 4, WHITE); // Минимум
    OLED.setCursor(0, 16); // Отображение максимального значения
    sprintf(chrBuff, "%4d", dataMax); 
    OLED.print(chrBuff); 
    OLED.setCursor(0, 32); // Отображение центрального значения
    sprintf(chrBuff, "%4d", (dataMax + dataMin) / 2); 
    OLED.print(chrBuff); 
    OLED.setCursor(0, 48); // Отображение минимального значения
    sprintf(chrBuff, "%4d", dataMin); 
    OLED.print(chrBuff); 

  // Нижняя шкала (отображение времени)
    OLED.setCursor(19, 57); // Левая шкала времени
    sprintf(chrBuff, "%+3d", (hRange[rNum].scaleV) * -3); // Получение значения из структуры и умножение на -3
    OLED.print(chrBuff); // Передача на OLED
    OLED.print(hRange[rNum].scaleC); // Отображение единицы измерения    
    OLED.setCursor(49, 57); // Центральная шкала времени
    sprintf(chrBuff, "%+3d", (hRange[rNum].scaleV) * -2); // Умножение на -2
    OLED.print(chrBuff); 
    OLED.print(hRange[rNum].scaleC);    
    OLED.setCursor(79, 57); // Правая шкала времени
    sprintf(chrBuff, "%+3d", (hRange[rNum].scaleV) * -1); // Умножение на -1
    OLED.print(chrBuff); 
    OLED.print(hRange[rNum].scaleC);    
    OLED.setCursor(118, 57); // Ноль времени
    OLED.print(F("0")); 
}

void graphPlot() { // Отображение данных в виде линейного графика на основе значений массива
    long y1, y2; 
    for (int i = 0; i <= 89; i++) { 
        if (dataBuff[i + 1] == -1) { // Если данные y2 неопределены (-1), прервать цикл
            break; // Прекращение построения графика
        } 
        y1 = map(dataBuff[i], dataMin, dataMax, 55, 16); // Преобразование для координат графика
        y2 = map(dataBuff[i + 1], dataMin, dataMax, 55, 16); // Преобразование для координат графика
        OLED.drawLine(120 - i, y1, 119 - i, y2, WHITE); // Рисование графика концентрации CO2 линией
    } 
}


void rangeSet() {                              // Установка диапазона записи данных
  unsigned int d;
  d = EEPROM.read(0);
  if (d > 11) {                                // Если номер диапазона вне диапазона,
    d = 0;                                     // установить в 0
  }
  OLED.setCursor(0, 40);                       // Сначала записать маленькие буквы
  OLED.print(F("SEL:change value"));
  OLED.setCursor(0, 50);
  OLED.print(F("ENT:save and exit"));
  OLED.setCursor(0, 0);
  OLED.setTextSize(2);                         // Следующие строки будут отображены шрифтом в 2 раза больше
  OLED.print(F("Range set"));
  OLED.display();
  while (digitalRead(ENTER_PIN) == LOW) {      // Ждать, пока кнопка ENTER не будет отпущена
  }
  delay(30);
  OLED.setCursor(0, 20);
  OLED.print(F("Fs = "));                      // Полный масштаб =
  sprintf(chrBuff, "%2d", 3 * (hRange[d].scaleV)); // Получить значение из определения диапазона и умножить на 3
  OLED.print(chrBuff);                         // Передать на OLED
  OLED.print(hRange[d].scaleC);                // Отображение единицы измерения
  OLED.display();                              // Фактическое отображение
  while (digitalRead(ENTER_PIN) == HIGH) {     // Ждать, пока кнопка ENTER не будет нажата
    if (digitalRead(SELECT_PIN) == LOW) {
      d++;                                     // Увеличить номер диапазона
      if (d > 11) {                            // Если номер диапазона превышает верхний предел
        d = 0;                                 // Вернуться к началу
      }
      OLED.fillRect(0, 20, 128, 16, BLACK);    // Закрасить предыдущие значения черным прямоугольником
      OLED.setCursor(0, 20);
      OLED.print(F("Fs = "));
      sprintf(chrBuff, "%2d", 3 * (hRange[d].scaleV)); // Получить значение из определения диапазона и умножить на 3
      OLED.print(chrBuff);                     // Передать на OLED
      OLED.print(hRange[d].scaleC);            // Отображение единицы измерения
      OLED.display();
      while (digitalRead(SELECT_PIN) == LOW) { // Ждать, пока кнопка SELECT не будет отпущена
      }
      delay(30);
    }
  }
  EEPROM.write(0, d);                          // Сохранить номер диапазона в EEPROM
  OLED.clearDisplay();
  OLED.setCursor(0, 0);
  OLED.setTextSize(1);                 
  OLED.display();
}

void timer2_IRQ() {                        // Прерывание MsTime
  timerFlag = true;                        // Установить флаг, так как произошло прерывание
}

//       !!!ВНИМАНИЕ!!!
//пины ввода/вывода можно заменить на любые удобные
//только в строках #define !!!
//кроме А0 и А1 - их можно менять на любые аналоговые

#define PUSK_PIN 8      // номер вывода кнопки "пуск"
#define DATCHIK_PIN 9   // номер вывода сигнала датчика 
#define LedPUSK_PIN 10  // номер вывода светодиода "пуск"
#define LedPAUSA_PIN 11 // номер вывода светодиода "пауза"
#define RELE_PIN 12     // номер вывода светодиодa c реле

unsigned long tmr ;     // переменная таймера
unsigned long tmr1 ;    // переменная таймера1

void setup() {
  pinMode(PUSK_PIN, INPUT_PULLUP);    // кнопка пуск
  pinMode(DATCHIK_PIN, INPUT_PULLUP); // !!!сигнал с датчика-"0"!!!
  pinMode(LedPUSK_PIN, OUTPUT);       // индикация пуска
  pinMode(LedPAUSA_PIN, OUTPUT);      // индикация паузы
  pinMode(RELE_PIN, OUTPUT);          // реле и светодиод
}
void loop() {
  if ( digitalRead(PUSK_PIN) == LOW ) //если кнопка пуск нажата
  { delay(20);                  //задержка на дребезг контактов
    digitalWrite(LedPUSK_PIN, HIGH);  // вкл. светодиода "пуск"

    tmr = millis();
tmr:
    if (millis() - tmr < 500) //время включенного светодиода "пуск"
    {
      if ( digitalRead(PUSK_PIN) == HIGH) //пауза если отжата "пуск"
      {
        goto pauza;
      }
      if ( digitalRead(DATCHIK_PIN) == LOW) //если есть сигнал датчика
      {
        digitalWrite(RELE_PIN, HIGH);      // вкл.реле и светодиода

 //время на отключение реле регулировка(мс) переменным резистором
        int t1 =  analogRead(A1) / 2 ;
        tmr1 = millis();
tmr1:
        if (millis() - tmr1 > t1 or
            digitalRead(PUSK_PIN) == HIGH)
        {
          goto pauza;
        }
        goto tmr1;
      }
      goto tmr;
    }
pauza:
    digitalWrite(LedPUSK_PIN, LOW);  // выкл. светодиода "пуск"
    digitalWrite(RELE_PIN, LOW);      //выключение реле
    digitalWrite(LedPAUSA_PIN, HIGH); //индикация паузы
    //регулировка паузы(мс) переменным резистором
    int t0 = 4 * analogRead(A0);
    delay(t0);                         //время паузы
    digitalWrite(LedPAUSA_PIN, LOW);  //конец паузы
  }
}

// 1 зуб = 2 полупериодам, т.к. полупериод - это время между сигналами 0 и 1. 2 таких сигнала и составляют импульс, т.е. 1 зуб:
// при 36-зубной шестерни вала, 200 об/мин возможны на полупериоде = 4.2 мс, 5000 об/мин - при 0.168 мс
// при 60-зубной шестерни вала, 200 об/мин возможны на полупериоде = 2.5 мс, 5000 об/мин - при 0.1 мс
// при 60 зубах на шестерне коленвала 1 оборот происходит за 72 мс
// при 36 зубах на шестерне коленвала 1 оборот происходит за 43.2 мс

int gear = 60;                  // кол-во зубов шестрени вала
int poluperiod;               // полупериод (мкс)

void setup()  
{
   pinMode(2, OUTPUT);          // 2 пин назначен на выдачу импульсов
   pinMode(A1, INPUT);          // к входу A1 подключаем потенциометр
}

void loop() {
  int val = analogRead(A1);                       // считываем данные с порта A1 (значения потенциометра от 0 до 1023)
  if (gear == 60){                                // для шестерни с 60 зубами
    poluperiod = map(val, 0, 1023, 2500, 100);     // переводим val в новый диапазон от 2500 мкс до 100 мкс и присваиваем знаение потенциометра полупериоду
  }else if(gear == 36){                           // для шестерни с 36 зубами
    poluperiod = map(val, 0, 1023, 4200, 168);   // переводим val в новый диапазон от 4200 мкс до 168 мкс
  }
   
  for(int a=1; a <= gear - 2; a++){               // gear - 2 - отнимаем 2 пропущенных зуба от кол-ва зубов шестерни
    digitalWrite(2, HIGH); 
    delayMicroseconds(poluperiod);
    digitalWrite(2, LOW);
    delayMicroseconds(poluperiod);
  }
  delayMicroseconds(poluperiod * 4);                          // кол-во импульсов до задержки в 2 импульса = 2 зуба
}