Четыре датчика CO2 в одном устройстве: сверяем показания.

/*
© Tykhon, 2019.

MH-Z19
TX: 3<->5 A0
RX: 3<->5 A1
Gnd:      Gnd
Vin:      +5v

MH-Z19b
TX: 3<->5 4
RX: 3<->5 A1
Gnd:      Gnd
Vin:      +5v


MH-Z14A
1_+5v:    +5v
2_Gnd:    Gnd
11_RX: 3<->5 7
10_TX: 3<->5 6


S8:
G+:       +5v
G0:       Gnd
Rx: 3<->5 A3
Tx: 3<->5 A2

DS3231
SCL:      A5
SDA:      A4
Gnd:      Gnd
VDD:      5v


TFT
Led: -> 150 Ohm -> 5v
SCK: -> 1 KOhm -> 13
SDA: -> 1 KOhm -> 11
A0:  -> 1 KOhm -> 8
Reset: -> 1 KOhm ->  9
CS:  -> 1 KOhm -> 10
Gnd:      Gnd
Vcc:      5v

*/

#include "Adafruit_GFX.h"                 // for LCD Core graphics library
#include <Adafruit_ST7735.h>              // for LCD  Hardware-specific library
#include <SoftwareSerial.h>
#include "Wire.h"

/////////////////////// for LCD //////////////////////////////

#define TFT_CS     10
#define TFT_RST    9  // you can also connect this to the Arduino reset in which case, set this #define pin to -1!
#define TFT_DC     8

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS,  TFT_DC, TFT_RST);  //for LCD 

#define DS1307_ADDR 0x68                     // RTC address

int s8_co2;
int z14_co2;
int z19_co2;
int z19b_co2;
int z19_t;
int z19_ss;
int z19b_t;
int z19b_ss;
int s8_co2_last;
int z14_co2_last;
int z19_co2_last;
int z19b_co2_last;
int s8_co2_mean_last;
int z14_co2_mean_last;
int z19_co2_mean_last;
int z19b_co2_mean_last;
int s8_co2_mean;
int z14_co2_mean;
int z19_co2_mean;
int z19b_co2_mean;
int s8_co2_mean2;
int z14_co2_mean2;
int z19_co2_mean2;
int z19b_co2_mean2;


SoftwareSerial mySerial_z19(A0, A1);
SoftwareSerial mySerial_z19b(4, 5);
SoftwareSerial mySerial_s8(A2, A3);
SoftwareSerial mySerial_z14(7, 6);



byte cmd_z14[9] = {0xFF,0x01,0x86,0x00,0x00,0x00,0x00,0x00,0x79}; 
unsigned char response_z14[9]; 
String ppmString = " ";


byte cmd_z19[9] = {0xFF,0x01,0x86,0x00,0x00,0x00,0x00,0x00,0x79}; 
byte cmd_s8[7] = {0xFE,0x44,0x00,0x08,0x02,0x9F,0x25}; 
unsigned char response_z19[9];
unsigned char response_z19b[9];
byte response_s8[] = {0,0,0,0,0,0,0};

unsigned int current_minute, lastminute;
int second_delay = 30000;                     // delay between measurements, ms
int work_period = 2;                          // period for recording data, min
float smoothing_factor = 0.5;                 // coefficient for Kalman filter
float smoothing_factor2 = 0.15;               // coefficient for Kalman filter

////////////////////////////////////////   functions    //////////////////////////////////////////////


byte bcdToDec(byte val)  {
  return ( (val/16*10) + (val%16) );
}


String getdate(){
  Wire.beginTransmission(DS1307_ADDR);      // Reset the register pointer
  byte zero = 0x00;
  Wire.write(zero);
  Wire.endTransmission();
  Wire.requestFrom(DS1307_ADDR, 7);
  int secondint = bcdToDec(Wire.read());
  int minuteint = bcdToDec(Wire.read());
  current_minute = minuteint;
  int hour = bcdToDec(Wire.read() & 0b111111); //24 hour time
  int weekDay = bcdToDec(Wire.read()); //0-6 -> sunday - Saturday
  int monthDay = bcdToDec(Wire.read());
  int month = bcdToDec(Wire.read());
  int year = bcdToDec(Wire.read());
  String second = String(secondint); if (secondint < 10) {second ="0"+second;};
  String minute = String(minuteint); if (minuteint < 10) {minute ="0"+minute;};
  return String(hour)+":"+minute+":"+second+" "+String(monthDay)+"/"+String(month)+"/"+String(year);
}



void sendRequest_s8(byte packet[]){ 
 mySerial_s8.begin(9600);
 while(!mySerial_s8.available()){                       //keep sending request until we start to get a response 
    mySerial_s8.write(cmd_s8,7); 
    delay(50); 
 }
 int timeout=0;                                         //set a timeout counter 
  while(mySerial_s8.available() < 7 ) {                 //Wait to get a 7 byte response 
    timeout++; 
    if(timeout > 10) {                                  //if it takes to long there was probably an error 
        while(mySerial_s8.available())                  //flush whatever we have 
        mySerial_s8.read(); 
        break;                                          //exit and try again 
    } 
    delay(50); 
  } 
 for (int i=0; i < 7; i++) { 
      response_s8[i] = mySerial_s8.read(); 
 }
  mySerial_s8.end();
}                      



unsigned long getValue_s8(byte packet[]) 
{ 
 int high = packet[3];                                   //high byte for value is 4th byte in packet in the packet 
 int low = packet[4];                                    //low byte for value is 5th byte in the packet 
 unsigned long val = high*256 + low;                     //Combine high byte and low byte with this formula to get value 
 return val; 
}


void sendRequest_z14(){
  mySerial_z14.begin(9600);
  mySerial_z14.write(cmd_z14, 9);
  memset(response_z14, 0, 9);
  mySerial_z14.readBytes(response_z14, 9);

  int i;
  byte crc = 0;
  for (i = 1; i < 8; i++) crc+=response_z14[i];
  crc = 255 - crc;
  crc++;
  if ( !(response_z14[0] == 0xFF && response_z14[1] == 0x86 && response_z14[8] == crc) ) {
    Serial.println("CRC error z14: " + String(crc) + " / "+ String(response_z14[8]));
  } else { 
    unsigned int responseHigh = (unsigned int) response_z14[2];
    unsigned int responseLow = (unsigned int) response_z14[3];
  z14_co2 = (256*responseHigh) + responseLow;
  };
  mySerial_z14.end();
}



void sendRequest_z19(){
  mySerial_z19.begin(9600);
  mySerial_z19.write(cmd_z19, 9);
  memset(response_z19, 0, 9);
  mySerial_z19.readBytes(response_z19, 9);
  int i;
  byte crc = 0;
  for (i = 1; i < 8; i++) crc+=response_z19[i];
  crc = 255 - crc;
  crc++;
  if (response_z19[0] != 0xFF) {Serial.println("CRC error z19: response_z19[0] != 0xFF: " + String(response_z19[0]));};
  if (response_z19[1] != 0x86) {Serial.println("CRC error z19: response_z19[1] != 0x86: " + String(response_z19[1]));};
  if (response_z19[8] != crc) {Serial.println("CRC error z19: response_z19[8] != crc: " + String(response_z19[8]) + " / "+ String(crc));};
  
  if ( !(response_z19[0] == 0xFF && response_z19[1] == 0x86 && response_z19[8] == crc) ) {
    Serial.println("CRC error z19: " + String(crc) + " / "+ String(response_z19[8]));
  } else { 
    unsigned int responseHigh = (unsigned int) response_z19[2];
    unsigned int responseLow = (unsigned int) response_z19[3];
    unsigned int responseTT = (unsigned int) response_z19[4];
    unsigned int responseSS = (unsigned int) response_z19[5];
    z19_t = responseTT-40;
    z19_ss =  responseSS;
    z19_co2 = (256*responseHigh) + responseLow;
   };
  mySerial_z19.end();
}

void sendRequest_z19b(){
  mySerial_z19b.begin(9600);
  mySerial_z19b.write(cmd_z19, 9);
  memset(response_z19b, 0, 9);
  mySerial_z19b.readBytes(response_z19b, 9);
  int i;
  byte crc = 0;
  for (i = 1; i < 8; i++) crc+=response_z19b[i];
  crc = 255 - crc;
  crc++;
  if (response_z19b[0] != 0xFF) {Serial.println("CRC error z19b: response_z19b[0] != 0xFF: " + String(response_z19b[0]));};
  if (response_z19b[1] != 0x86) {Serial.println("CRC error z19b: response_z19b[1] != 0x86: " + String(response_z19b[1]));};
  if (response_z19b[8] != crc) {Serial.println("CRC error z19b: response_z19b[8] != crc: " + String(response_z19b[8]) + " / "+ String(crc));};
  
  if ( !(response_z19b[0] == 0xFF && response_z19b[1] == 0x86 && response_z19b[8] == crc) ) {
    Serial.println("CRC error z19b: " + String(crc) + " / "+ String(response_z19b[8]));
  } else { 
    unsigned int responseHigh = (unsigned int) response_z19b[2];
    unsigned int responseLow = (unsigned int) response_z19b[3];
    unsigned int responseTT = (unsigned int) response_z19b[4];
    unsigned int responseSS = (unsigned int) response_z19b[5];
    z19b_t = responseTT-40;
    z19b_ss =  responseSS;
    z19b_co2 = (256*responseHigh) + responseLow;
   };
  mySerial_z19b.end();
}


void tft_form(){
  tft.setTextSize(2);
  tft.setTextColor(0x177F);

  tft.setCursor(2, 4);
  tft.print("z14");
  tft.setCursor(2, 33);
  tft.print("z19");
  tft.setCursor(2, 62);
  tft.print("z19b");
  tft.setCursor(2, 91);
  tft.print("s8");
  
}


void tft_output(){

  tft.setTextSize(2);

  tft.setCursor(56, 4);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z14_co2_mean_last));

  tft.setCursor(56, 4);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z14_co2_mean));
  z14_co2_mean_last = z14_co2_mean;

  tft.setCursor(56, 33);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z19_co2_mean_last));

  tft.setCursor(56, 33);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z19_co2_mean));
  z19_co2_mean_last = z19_co2_mean;

  tft.setCursor(56, 62);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z19b_co2_mean_last));

  tft.setCursor(56, 62);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z19b_co2_mean));
  z19b_co2_mean_last = z19b_co2_mean;

  tft.setCursor(56, 91);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(s8_co2_mean_last));

  tft.setCursor(56, 91);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(s8_co2_mean));
  s8_co2_mean_last = s8_co2_mean;


  
  tft.setTextSize(1);
  tft.setCursor(110, 4);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z14_co2_last));

  tft.setCursor(110, 4);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z14_co2));
  z14_co2_last = z14_co2;

  tft.setCursor(110, 33);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z19_co2_last));

  tft.setCursor(110, 33);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z19_co2));
  z19_co2_last = z19_co2;

  tft.setCursor(110, 62);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(z19b_co2_last));

  tft.setCursor(110, 62);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(z19b_co2));
  z19b_co2_last = z19b_co2;

  tft.setCursor(110, 91);
  tft.setTextColor(ST7735_BLACK);
  tft.print(String(s8_co2_last));

  tft.setCursor(110, 91);
  tft.setTextColor(ST7735_WHITE);
  tft.print(String(s8_co2));
  s8_co2_last = s8_co2;


  
  tft.setTextSize(1);
  tft.fillRect(0, 117, 160, 120, ST7735_BLACK);
  tft.setCursor(0, 117);
  tft.print(String(getdate()));

}



void z19setup() {

/*  2     3    6    7
  {0x86,0x00,0x00,0x00},   // mhz_cmnd_read_ppm
  {0x79,0xA0,0x00,0x00},   // mhz_cmnd_abc_enable
  {0x79,0x00,0x00,0x00},   // mhz_cmnd_abc_disable
  {0x87,0x00,0x00,0x00},   // mhz_cmnd_zeropoint
  {0x8D,0x00,0x00,0x00},   // mhz_cmnd_reset
  {0x99,0x00,0x03,0xE8},   // mhz_cmnd_set_range_1000
  {0x99,0x00,0x07,0xD0},   // mhz_cmnd_set_range_2000
  {0x99,0x00,0x0B,0xB8},   // mhz_cmnd_set_range_3000
  {0x99,0x00,0x13,0x88}};  // mhz_cmnd_set_range_5000
*/

//  byte setrangeA_cmd[9] = {0xFF, 0x01, 0x99, 0x00, 0x00, 0x00, 0x07, 0xD0, 0x8F};     // set range 0 - 2000ppm
  byte setrangeA_cmd[9] = {0xFF, 0x01, 0x99, 0x00, 0x00, 0x00, 0x13, 0x88, 0xCB};     // set range 0 - 5000ppm
//  byte setrangeA_cmd[9] = {0xFF, 0x01, 0x79, 0x00, 0x00, 0x00, 0x00, 0x00, 0x86},     // mhz_cmnd_abc_disable
//  byte setrangeA_cmd[9] = {0xFF, 0x01, 0x79, 0xA0, 0x00, 0x00, 0x00, 0x00, 0xE6};     // mhz_cmnd_abc_enable
//  byte setrangeA_cmd[9] = {0xFF, 0x01, 0x86, 0x00, 0x00, 0x00, 0x00, 0x00, 0x79};     // data request
  unsigned char setrangeA_response[9]; 

  mySerial_z19.begin(9600);

  mySerial_z19.write(setrangeA_cmd,9);
  mySerial_z19.readBytes(setrangeA_response, 9);
  int setrangeA_i;
  byte setrangeA_crc = 0;
  for (setrangeA_i = 1; setrangeA_i < 8; setrangeA_i++) setrangeA_crc+=setrangeA_response[setrangeA_i];
  setrangeA_crc = 255 - setrangeA_crc;
  setrangeA_crc += 1;
  if ( !(setrangeA_response[0] == 0xFF && setrangeA_response[1] == 0x99 && setrangeA_response[8] == setrangeA_crc) ) {
    Serial.println("Range CRC error: " + String(setrangeA_crc) + " / "+ String(setrangeA_response[8]) + " (bytes 6 and 7)");
  } else {
    Serial.println("Range was set! (bytes 6 and 7)");
  }
  delay(1000);
  mySerial_z19.end();
}

///////////////////////////////////////  setup   /////////////////////////////////////////

void setup(void) {
  Serial.begin(38400);
  Wire.begin();
//  z19setup();
  tft.initR(INITR_BLACKTAB);   // initialize a ST7735S chip, black tab
  Serial.println("init");
    
  tft.setTextWrap(false); // Allow text to run off right edge
  tft.setRotation(3);
  tft.fillScreen(ST7735_BLACK);
  tft_form();
 
}

////////////////////////////////////////////////   loop    /////////////////////////////////////////////////////

void loop() {

  sendRequest_z14();
  sendRequest_z19();
  sendRequest_z19b();
  sendRequest_s8(cmd_s8); 
  s8_co2 = getValue_s8(response_s8); 

  if (!s8_co2_mean) s8_co2_mean = s8_co2;
  if (!z14_co2_mean) z14_co2_mean = z14_co2;
  if (!z19_co2_mean) z19_co2_mean = z19_co2;
  if (!z19b_co2_mean) z19b_co2_mean = z19b_co2;

  s8_co2_mean = s8_co2_mean - smoothing_factor*(s8_co2_mean - s8_co2);
  z14_co2_mean = z14_co2_mean - smoothing_factor*(z14_co2_mean - z14_co2);
  z19_co2_mean = z19_co2_mean - smoothing_factor*(z19_co2_mean - z19_co2);
  z19b_co2_mean = z19b_co2_mean - smoothing_factor*(z19b_co2_mean - z19b_co2);

  if (!s8_co2_mean2) s8_co2_mean2 = s8_co2;
  if (!z14_co2_mean2) z14_co2_mean2 = z14_co2;
  if (!z19_co2_mean2) z19_co2_mean2 = z19_co2;
  if (!z19b_co2_mean2) z19b_co2_mean2 = z19b_co2;

  s8_co2_mean2 = s8_co2_mean2 - smoothing_factor2*(s8_co2_mean2 - s8_co2);
  z14_co2_mean2 = z14_co2_mean2 - smoothing_factor2*(z14_co2_mean2 - z14_co2);
  z19_co2_mean2 = z19_co2_mean2 - smoothing_factor2*(z19_co2_mean2 - z19_co2);
  z19b_co2_mean2 = z19b_co2_mean2 - smoothing_factor2*(z19b_co2_mean2 - z19b_co2);

  
  getdate();
  tft_output();
//  if (((current_minute)%work_period == 0)&&(lastminute != current_minute)) {

String dataString = getdate()+"  s8~~:  "+String(s8_co2_mean2)+"  s8~:  "+String(s8_co2_mean)+"  s8:  "+String(s8_co2)+"  z14~~:  "+String(z14_co2_mean2)+"  z14~:  "+String(z14_co2_mean)+"  z14:  "+String(z14_co2)+"  z19~~:  "+String(z19_co2_mean2)+"  z19~:  "+String(z19_co2_mean)+"  z19:  "+String(z19_co2)+"  z19b~~:  "+String(z19b_co2_mean2)+"  z19b~:  "+String(z19b_co2_mean)+"  z19b:  "+String(z19b_co2);
// +"  z19_t:  "+String(z19_t)+"  z19b_t:  "+String(z19b_t);
    dataString.replace(".",",");
    dataString.replace("  ","\t");
    Serial.println(dataString);
  lastminute = current_minute;
//  };

  delay(second_delay);
}