esp32 - изучаем и попутно сравниваем датчики пыли

//////////////////////////////////////////////////////////////////////////////////////
//////////////              © tykhon, 2019        ////////////////////////
//////////////////////////////////////////////////////////////////////////////////////
#include <SPI.h>
#include "Ucglib.h"
#include "HardwareSerial.h"

#define PMSSerial Serial2
#define SDSSerial Serial1

unsigned int SDS_Pm25;
unsigned int SDS_Pm100;
float SDS_Pm25mean;
float SDS_Pm100mean;
float SDS_Pm25f;
float SDS_Pm100f;
float PMS_Pm10mean;
float PMS_Pm25mean;
float PMS_Pm100mean;

float smoothing_factor = 0.3;   // coeff for Kalman 0.01 - 0.99. Higher for less smoothing. 

uint32_t start = millis();
uint32_t now = millis();  
uint32_t nextrun = 0;
boolean PMSrun = false;

const int period = 180;  // period of sensor poll, sec 
const int sds_period = period/60;

int line_sds_25[200] = {};  
int line_sds_100[200] = {};  
int line_pms_10[200] = {};  
int line_pms_25[200] = {};  
int line_pms_100[200] = {};  
byte lineIndex_pms;
byte lineIndex_sds;
unsigned int line_sds_100sum = 0;
unsigned int line_sds_25sum = 0;

Ucglib_ILI9341_18x240x320_HWSPI ucg(/*cd=*/ 16, /*cs=*/ 17, /*reset=*/ 5);

//////////////////////////////////////////////////////////////////////////
/////////                      SDS 011                     ///////////////
//////////////////////////////////////////////////////////////////////////

void SDSworkmode(byte mode)
{
  byte cs = 7 + mode;
  uint8_t sleep_command[] = {0xAA, 0xB4, 0x08, 0x01, mode, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, cs, 0xAB};      
//                                                     ^^ 0 for continuous, 1-30 for 1-30 min delay between turns on.              ^^ checksum: 07 for 0x00, 08 for 0x01 and so on
  for (uint8_t i = 0; i < 19; i++) {
    SDSSerial.write(sleep_command[i]);
  }
}

void SDSwakeup()
{
  uint8_t wakeup_command[] = {0xAA, 0xB4, 0x06, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x06, 0xAB};

  for (uint8_t i = 0; i < 19; i++) {
    SDSSerial.write(wakeup_command[i]);
  }
}  

boolean ProcessSerialData()
{
  uint8_t mData = 0;
  uint8_t i = 0;
  uint8_t mPkt[10] = {0};
  uint8_t mCheck = 0;
  while (SDSSerial.available() > 0)
  {
    mData = SDSSerial.read();     delay(2);//wait until packet is received
    if (mData == 0xAA) //head1 ok
    {
      mPkt[0] =  mData;
      mData = SDSSerial.read();
      if (mData == 0xc0) //head2 ok
      {
        mPkt[1] =  mData;
        mCheck = 0;
        for (i = 0; i < 6; i++) //data recv and crc calc
        {
          mPkt[i + 2] = SDSSerial.read();
          delay(2);
          mCheck += mPkt[i + 2];
        }
        mPkt[8] = SDSSerial.read();
        delay(1);
        mPkt[9] = SDSSerial.read();
        if (mCheck == mPkt[8]) //crc ok
        {
          SDSSerial.flush();
          SDS_Pm25 = (uint16_t)mPkt[2] | (uint16_t)(mPkt[3] << 8);
          SDS_Pm100 = (uint16_t)mPkt[4] | (uint16_t)(mPkt[5] << 8);
          if (SDS_Pm25 > 9999)
            SDS_Pm25 = 9999;
          if (SDS_Pm100 > 9999)
            SDS_Pm100 = 9999;
          return true;
        } else {Serial.println('crc not ok');};
      } else {Serial.println('head not ok');};
    }
  }
}



//////////////////////////////////////////////////////////////////////////
/////////                      PMSA003                     ///////////////
//////////////////////////////////////////////////////////////////////////

void PMSworkmode(byte mode)
{
  byte cs = 70 + mode;
  uint8_t mode_command[] = {0x42, 0x4D, 0xE1, 0x00, mode, 0x01, cs};      
//                                                   ^^ 0 for passive, 1 for active. The last byte - checksum: 70 for 0x00, 71 for 0x01 and so on
  for (uint8_t i = 0; i < 7; i++) {
    PMSSerial.write(mode_command[i]);
  }
  delay(100);
}

void PMSwakeup()
{
  uint8_t wakeup_command[] = {0x42, 0x4D, 0xE4, 0x00, 0x01, 0x01, 0x74};

  for (uint8_t i = 0; i < 7; i++) {
    PMSSerial.write(wakeup_command[i]);
  }
  delay(100);
}  

void PMSsleep()
{
  uint8_t sleep_command[] = {0x42, 0x4D, 0xE4, 0x00, 0x00, 0x01, 0x73};

  for (uint8_t i = 0; i < 7; i++) {
    PMSSerial.write(sleep_command[i]);
  }
  delay(100);
}  

void PMSpassive_mode_read()
{
  uint8_t read_command[] = {0x42, 0x4D, 0xE2, 0x00, 0x00, 0x01, 0x71};

  for (uint8_t i = 0; i < 7; i++) {
    PMSSerial.write(read_command[i]);
  }
  delay(100);
}  

///////////////////////////////////////////////////////////////////

struct pms5003data {
  uint16_t framelen;
  uint16_t pm10_standard, pm25_standard, pm100_standard;
  uint16_t pm10_env, pm25_env, pm100_env;
  uint16_t particles_03um, particles_05um, particles_10um, particles_25um, particles_50um, particles_100um;
  uint16_t unused;
  uint16_t checksum;
};
 
struct pms5003data data;

boolean readPMSdata(Stream *s) {
  if (! s->available()) {
    Serial.println("data not available");
    return false;
  }
  
  // Read a byte at a time until we get to the special '0x42' start-byte
  if (s->peek() != 0x42) {
    s->read();
    Serial.println("no 42");
    return false;
  }
 
  // Now read all 32 bytes
  if (s->available() < 32) {
    Serial.println("less than 32");
    return false;
  }
    
  uint8_t buffer[32];    
  uint16_t sum = 0;
  s->readBytes(buffer, 32);
 
  // get checksum ready
  for (uint8_t i=0; i<30; i++) {
    sum += buffer[i];
  }
 
  /* debugging
  Serial.println();
  for (uint8_t i=0; i<32; i++) {
    // was i=2
    Serial.print("0x"); Serial.print(buffer[i], HEX); Serial.print(", ");
  }
  Serial.println();
  */
  
  // The data comes in endian'd, this solves it so it works on all platforms
  uint16_t buffer_u16[15];
  for (uint8_t i=0; i<15; i++) {
    buffer_u16[i] = buffer[2 + i*2 + 1];
    buffer_u16[i] += (buffer[2 + i*2] << 8);
  }
 
  // put it into a nice struct :)
  memcpy((void *)&data, (void *)buffer_u16, 30);
 
  while (s->available()) {s->read();};
  if (sum != data.checksum) {
    Serial.println("Checksum failure");
    Serial.print(" sum = ");
    Serial.print(sum, HEX);
    Serial.print(" data.checksum = ");
    Serial.println(data.checksum, HEX);
    return false;
  }
  // success!
  return true;
}

//////////////////////////////////////////////////////////////////////////////////

void math_PMS(){
  if (!PMS_Pm10mean) PMS_Pm10mean = data.pm10_standard;
  if (!PMS_Pm25mean) PMS_Pm25mean = data.pm25_standard;
  if (!PMS_Pm100mean) PMS_Pm100mean = data.pm100_standard;
  PMS_Pm10mean = PMS_Pm10mean - smoothing_factor*(PMS_Pm10mean - data.pm10_standard);
  PMS_Pm25mean = PMS_Pm25mean - smoothing_factor*(PMS_Pm25mean - data.pm25_standard);
  PMS_Pm100mean = PMS_Pm100mean - smoothing_factor*(PMS_Pm100mean - data.pm100_standard);

  line_pms_10[lineIndex_pms] = int(PMS_Pm10mean*10.0);
  line_pms_25[lineIndex_pms] = int(PMS_Pm25mean*10.0);
  line_pms_100[lineIndex_pms] = int(PMS_Pm100mean*10.0);
  lineIndex_pms++;
  if (lineIndex_pms >= sizeof(line_pms_100)/sizeof(int)) {lineIndex_pms = 0;};
}

void math_SDS(){
  if (!SDS_Pm25mean) SDS_Pm25mean = SDS_Pm25/10.0;
  SDS_Pm25mean = SDS_Pm25mean - smoothing_factor*(SDS_Pm25mean - SDS_Pm25/10.0);
  if (!SDS_Pm100mean) SDS_Pm100mean = SDS_Pm100/10.0;
  SDS_Pm100mean = SDS_Pm100mean - smoothing_factor*(SDS_Pm100mean - SDS_Pm100/10.0);

  line_sds_25[lineIndex_sds] = int(SDS_Pm25mean*10.0);
  line_sds_100[lineIndex_sds] = int(SDS_Pm100mean*10.0);
  lineIndex_sds++;
  if (lineIndex_sds >= sizeof(line_sds_100)/sizeof(int)) {lineIndex_sds = 0;};

}

//////////////////////////////////////////////////////////////////////////////////////
/////////////////////////////          graph           ///////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////

void main_graph_sds(){
  ucg.setColor(0, 0, 0);                                        // clear field
  ucg.drawBox(1, 1, 220, 119);

  ucg.setColor(255, 255, 255);                                  // half line
  ucg.drawHLine(0, (ucg.getHeight()/2), ucg.getWidth());            
  
  ucg.setColor(250, 255, 10);
  ucg.drawVLine(20, 5, 90);                                     //  y line
  ucg.drawHLine(20, 95, 200);                                   //  x line

  int maxvalue = 1;                                             // y scale
  for (int i = 0; i < (sizeof(line_sds_100)/sizeof(int)); i++){
    maxvalue = max(maxvalue, line_sds_100[i]);
    maxvalue = max(maxvalue, line_sds_25[i]);
  };
  maxvalue = int(ceil(float(maxvalue)/50.0)*50);
  ucg.setFont(ucg_font_helvB12_hr);
  ucg.setColor(255,255,255);
  ucg.setPrintPos(1,20);
  ucg.print(maxvalue/10);
  int hours_count = sizeof(line_sds_100)/sizeof(int);             // x scale
  int step_in_min = sds_period;
  hours_count = hours_count * step_in_min;
  hours_count = hours_count / (-60);
  int onestep = 1;
  if (hours_count < -5) {onestep = 2;};
  for (int i = 0; i >= hours_count; i = i - onestep) {
    int posx = 20 +(sizeof(line_sds_100)/sizeof(int)) + i*(60/step_in_min);
    ucg.setColor(250,255,10);
    ucg.drawVLine(posx, 95, 5);
    int shift = posx+1;
    if (shift > 200) {shift = shift-10;};
    ucg.setPrintPos(shift, 114);
    ucg.setColor(255,255,255);
    ucg.print(i);
  };

  int g = 20+(sizeof(line_sds_100)/sizeof(int));                  // plot draw
  for (int i = lineIndex_sds-1; i >= 0; i--){ 
    int x1 = g;
    g--;
    int y1 = map(line_sds_100[i], 0, maxvalue, 0, 92);
    int y2 = map(line_sds_25[i], 0, maxvalue, 0, 92);
    ucg.setColor(10, 80, 250);
    ucg.drawVLine(x1, 95-y1, y1);
    ucg.setColor(250, 10, 80);
    ucg.drawVLine(x1, 95-y2, y2);
  };

  for (int i = (sizeof(line_sds_100)/sizeof(int))-1; i >= lineIndex_sds; i--){ 
    int x1 = g;
    g--;
    int y1 = map(line_sds_100[i], 0, maxvalue, 0, 92);
    int y2 = map(line_sds_25[i], 0, maxvalue, 0, 92);
    ucg.setColor(10, 80, 250);
    ucg.drawVLine(x1, 95-y1, y1);
    ucg.setColor(250, 10, 80);
    ucg.drawVLine(x1, 95-y2, y2);
  };  
 
}


void main_graph_pms(){
  ucg.setColor(0, 0, 0);                                          // clear field
  ucg.drawBox(1, 124, 220, 119);

  ucg.setColor(255, 255, 255);                                    //  half line
  ucg.drawHLine(0, (ucg.getHeight()/2), ucg.getWidth());          

  ucg.setColor(250, 255, 10);
  ucg.drawVLine(20, 128, 90);                                     //  y line
  ucg.drawHLine(20, 218, 200);                                    //  x line

  int maxvalue = 1;                                               // y scale
  for (int i = 0; i < (sizeof(line_pms_100)/sizeof(int)); i++){
    maxvalue = max(maxvalue, line_pms_100[i]);
    maxvalue = max(maxvalue, line_pms_25[i]);
    maxvalue = max(maxvalue, line_pms_10[i]);
  };
  maxvalue = int(ceil(float(maxvalue)/50.0)*50);

  ucg.setFont(ucg_font_helvB12_hr);
  ucg.setColor(255,255,255);
  ucg.setPrintPos(1,143);
  ucg.print(maxvalue/10);
  int hours_count = sizeof(line_pms_100)/sizeof(int);
  int step_in_min = sds_period;
  hours_count = hours_count * step_in_min;
  hours_count = hours_count / (-60);
  int onestep = 1;
  if (hours_count < -5) {onestep = 2;};
  for (int i = 0; i >= hours_count; i = i - onestep) {
    int posx = 20 +(sizeof(line_pms_100)/sizeof(int)) + i*(60/step_in_min);
    ucg.setColor(250,255,10);
    ucg.drawVLine(posx, 218, 5);
    int shift = posx+1;
    if (shift > 200) {shift = shift-10;};
    ucg.setPrintPos(shift, 237);
    ucg.setColor(255,255,255);
    ucg.print(i);
  };

  int g = 20+(sizeof(line_pms_100)/sizeof(int));                  // plot draw
  for (int i = lineIndex_pms-1; i >= 0; i--){ 
    int x = g;
    g--;
    int y1 = map(line_pms_100[i], 0, maxvalue, 0, 92);
    int y2 = map(line_pms_25[i], 0, maxvalue, 0, 92);
    int y3 = map(line_pms_10[i], 0, maxvalue, 0, 92);
    ucg.setColor(10, 80, 250);
    ucg.drawVLine(x, 218-y1, y1);
    ucg.setColor(250, 10, 80);
    ucg.drawVLine(x, 218-y2, y2);
    ucg.setColor(80, 250, 10);
    ucg.drawVLine(x, 218-y3, y3);
  };

  for (int i = (sizeof(line_pms_100)/sizeof(int))-1; i >= lineIndex_pms; i--){ 
    int x = g;
    g--;
    int y1 = map(line_pms_100[i], 0, maxvalue, 0, 92);
    int y2 = map(line_pms_25[i], 0, maxvalue, 0, 92);
    int y3 = map(line_pms_10[i], 0, maxvalue, 0, 92);
    ucg.setColor(10, 80, 250);
    ucg.drawVLine(x, 218-y1, y1);
    ucg.setColor(250, 10, 80);
    ucg.drawVLine(x, 218-y2, y2);
    ucg.setColor(80, 250, 10);
    ucg.drawVLine(x, 218-y3, y3);
  };  
 
}

////////////////////////////////////////////////////////////////////////////

void print_SDS(){
  SDS_Pm25f = SDS_Pm25/10.0;
  SDS_Pm100f = SDS_Pm100/10.0;
  String dataString = "SDS_2.5:\t"+String(SDS_Pm25f,0)+"\tSDS_10:\t"+String(SDS_Pm100f,0)+"\tSDS_2.5~:\t"+String(SDS_Pm25mean,1)+"\tSDS_10~:\t"+String(SDS_Pm100mean,1);
  dataString.replace(".",",");
  Serial.print(dataString);
}

void print_PMS(){
  /*
  Serial.print("\tPMS_1:\t"); Serial.print(data.pm10_standard);
  Serial.print("\tPMS_2.5:\t"); Serial.print(data.pm25_standard);
  Serial.print("\tPMS_10:\t"); Serial.print(data.pm100_standard);
  Serial.print("\tPMS_1~:\t"); Serial.print(PMS_Pm10mean,1);
  Serial.print("\tPMS_2.5~:\t"); Serial.print(PMS_Pm25mean,1);
  Serial.print("\tPMS_10~:\t"); Serial.println(PMS_Pm100mean,1);
  */
  String dataString = "\tPMS_1:\t"+String(data.pm10_standard)+"\tPMS_2.5:\t"+String(data.pm25_standard)+"\tPMS_10:\t"+String(data.pm100_standard)+"\tPMS_1~:\t"+String(PMS_Pm10mean,1)+"\tPMS_2.5~:\t"+String(PMS_Pm25mean,1)+"\tPMS_10~:\t"+String(PMS_Pm100mean,1);
  dataString.replace(".",",");
  Serial.println(dataString);
}

void print_PMS_full(){
  Serial.println();
  Serial.println("---------------------------------------");
  Serial.println("Concentration Units (standard)");
  Serial.print("PM 1.0: "); Serial.print(data.pm10_standard);
  Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_standard);
  Serial.print("\t\tPM 10: "); Serial.println(data.pm100_standard);
  Serial.println("---------------------------------------");
  Serial.println("Concentration Units (environmental)");
  Serial.print("PM 1.0: "); Serial.print(data.pm10_env);
  Serial.print("\t\tPM 2.5: "); Serial.print(data.pm25_env);
  Serial.print("\t\tPM 10: "); Serial.println(data.pm100_env);
  Serial.println("---------------------------------------");
  Serial.print("Particles > 0.3um / 0.1L air:"); Serial.println(data.particles_03um);
  Serial.print("Particles > 0.5um / 0.1L air:"); Serial.println(data.particles_05um);
  Serial.print("Particles > 1.0um / 0.1L air:"); Serial.println(data.particles_10um);
  Serial.print("Particles > 2.5um / 0.1L air:"); Serial.println(data.particles_25um);
  Serial.print("Particles > 5.0um / 0.1L air:"); Serial.println(data.particles_50um);
  Serial.print("Particles > 10.0 um / 0.1L air:"); Serial.println(data.particles_100um);
  Serial.println("---------------------------------------");
}

void lcd_print(){
  ucg.setColor(0, 0, 0);
  ucg.drawBox(270, 0, 80, 119);
  ucg.drawBox(270, 121, 80, 240);
  ucg.setFont(ucg_font_fub20_hf);
  ucg.setColor(255, 255, 255);
  ucg.setPrintPos(270,35);
  ucg.print(SDS_Pm100f,0);
  ucg.setPrintPos(270,90);
  ucg.print(SDS_Pm25f,0);
  ucg.setPrintPos(270,160);
  ucg.print(data.pm100_standard);
  ucg.setPrintPos(270,195);
  ucg.print(data.pm25_standard);
  ucg.setPrintPos(270,230);
  ucg.print(data.pm10_standard);
}

void setup() {
  Serial.begin(115200);
  PMSSerial.begin(9600, SERIAL_8N1, 32, 33);
  SDSSerial.begin(9600, SERIAL_8N1, 34, 35);

  SDSwakeup();
  delay(10);
  SDSwakeup();
  SDSworkmode(sds_period);
  
  PMSwakeup();
  PMSworkmode(0);
  PMSwakeup();

  ucg.begin(UCG_FONT_MODE_SOLID);
  ucg.clearScreen();
  ucg.setRotate270();
  ucg.setFont(ucg_font_fub14_hf);
  ucg.setColor(255, 255, 155);
  ucg.setPrintPos(234,35);
  ucg.print("10");
  ucg.setPrintPos(234,90);
  ucg.print("2.5");
  ucg.setPrintPos(234,160);
  ucg.print("10");
  ucg.setPrintPos(234,195);
  ucg.print("2.5");
  ucg.setPrintPos(234,228);
  ucg.print("1.0");
}

   
void loop() {
  now = millis();
  if ((now > nextrun)&(!PMSrun)) {
    PMSwakeup();
    PMSrun = true;
  }
  if (now > (nextrun + 30000)) {
    if (ProcessSerialData()){
      math_SDS();
      print_SDS();
    };
    while (PMSSerial.available()) { PMSSerial.read(); };
    PMSpassive_mode_read();
    delay(1000);
    if (readPMSdata(&PMSSerial)) {
      math_PMS();
      print_PMS();
    };
    PMSsleep();
    PMSrun = false;
    lcd_print();
    main_graph_sds();
    main_graph_pms();
    nextrun = now + period*1000 - 30000;
  };
    
  delay(10);
}