program iot mtqq server

/*
 * ESP8266 NodeMCU AJAX Demo
 * Updates and Gets data from webpage without page refresh
 * https://circuits4you.com
 */
#include <ESP8266WiFi.h>
#include <PubSubClient.h>

#include <EEPROM.h>

#include <Ultrasonic.h>
//#include <NewPing.h>
#define TRIGGER_PIN D8 // Arduino pin tied to trigger pin on the ultrasonic sensor.
#define ECHO_PIN D7 // Arduino pin tied to echo pin on the ultrasonic sensor.
#define MAX_DISTANCE 250 // Maximum distance we want to ping for (in centimeters). Maximum sensor distance is rated at 400-500cm.

#define   SENDREQ         0xF8   //Send Request
#define   SAVEULTRA       0xF9   //Save Ultrasound Parameter Min, Max, Deep
#define   ONOFF           0xFA   //ONOFF Manual
#define   BUTTONMA        0xFB   //command for Button
#define   MANAUTO         0xFB   //Manual Auto
#define   FLOWSENSOR1     0xFC   //command for FLOW SENSOR 1
#define   FLOWSENSOR2     0xFD   //command for FLOW SENSOR 2
#define   RANGESENSOR     0xFE   //command for RANGE SENSOR


int addrSSID = 0x0F;  //Address SSID EEPROM
int addrPASW = 0x1F;  //Address PASSWORD EEPROM
int addrMIN = 0x2F;  //Address MINIMUM EEPROM
int addrMAX = 0x3F;  //Address MAXIMUM EEPROM
int addrDEEP = 0x4F;  //Address DEEP EEPROM

uint8_t sensorPin = D5;
uint8_t sensorInterrupt = sensorPin;

uint8_t sensorPin2 = D6;
uint8_t sensorInterrupt2 = sensorPin2;

uint8_t LED = D3;

static const uint8_t btnPin1 = D1;
static const uint8_t btnPin2 = D2;
static const uint8_t btnPin3 = D0;
static const uint8_t btnPin4 = D4;

// The hall-effect flow sensor outputs approximately 4.5 pulses per second per
// litre/minute of flow.
float calibrationFactor = 4.5;

volatile byte pulseCount;
volatile byte pulseCount2;

volatile byte nSensor;

float flowRate;
unsigned int flowMilliLitres;
unsigned long totalMilliLitres;
float flowRate2;
unsigned int flow2MilliLitres;
unsigned long totalMilliLitres2;

unsigned long oldTime;
unsigned long oldTime2;
unsigned long oldTime3;
unsigned long oldTime4;
unsigned long oldTime5;

// defines pins numbers Ultrasound
Ultrasonic ultrasonic(TRIGGER_PIN, ECHO_PIN);
//NewPing sonar(TRIGGER_PIN, ECHO_PIN, MAX_DISTANCE); // NewPing setup of pins and maximum distance.
int distance;
int BtnStat;
int btnStatONOFF;
int setMin;
int setMax;
int setDep;

int counter=0;

int SendReq;

int serialStop = 0;

int sendcoun=0;
String msg_dta="";
String msg_cmd;

bool stringComplete = false;  // whether the string is complete

int setDeep=0;
int LastPercent = 0;
int btnStatMA = 123;

//Button Pin declare
int buttonState1 = 0; // variable for reading the pushbutton status
int buttonState2 = 0; // variable for reading the pushbutton status
int buttonState3 = 0; // variable for reading the pushbutton status
int buttonState4 = 0; // variable for reading the pushbutton status

int buttonSelect1 = 0;
int buttonONOFF = 0;
int btnStatus = 1;

String inputString = "";         // a String to hold incoming data
String request = "";
String btnStr = "";
String ultrasoundStr = "";
String flowRateStr = "";
String flowRate2Str = "";
String manautoStr1 = "";
String manautoStr2 = "";
String manautoStr3 = "";
String manautoStr4 = "";
String manautoStr5 = "";
String onoffStr1 = "";
String onoffStr2 = "";

String btnOnOff1 ="";
String btnOnOff2 ="";

String rs232Command ="";
String EEssid="";
String EEpass="";
String EEmin="";
String EEmax="";
String EEdeep="";

//SSID and Password of your WiFi router
char ssid[12] = "myssid";
char password[12] = "mypassss";

//Enter your mqtt server configurations
const char* mqttServer = "postman.cloudmqtt.com";    //Enter Your mqttServer address
const int mqttPort = 10480;       //Port number
const char* mqttUser = "ehfyorks"; //User
const char* mqttPassword = "al-lm4ncEaLx"; //Password

WiFiClient espClient;
PubSubClient client(espClient);

//TANK min, max and deep
char minimum[2];// = "25";
char maximum[2];// = "75";
char deeptank[3];// = "100";

void MQTTcallback(char* topic, byte* payload, unsigned int length) {
  if(serialStop!=1){
    String message="";
    for (int i = 0; i < length; i++) {
      message = message + (char)payload[i];  //Conver *byte to String
    }
    msg_dta = message;
    if(msg_dta=="#manu" or msg_dta=="#auto"){
      msg_cmd = msg_dta;
    }
  }
}

//==============================================================
//                  SETUP
//==============================================================
void setup(void){
  delay(20);
  Serial.begin(115200);
/**
  EEPROM.begin(512);  //Initialize EEPROM

  //Read EEPROM SSID
  for(int i=0;i<12;i++)
  {
    EEssid = EEssid + char(EEPROM.read(addrSSID+i)); //Read one by one with starting address of 0x0F
  }
  //Read EEPROM PASSWORD
  for(int i=0;i<12;i++)
  {
    EEpass = EEpass + char(EEPROM.read(addrPASW+i)); //Read one by one with starting address of 0x0F
  }

  //Read EEPROM MINIMUM TANK
  for(int i=0;i<12;i++)
  {
    EEmin = EEmin + char(EEPROM.read(addrMIN+i)); //Read one by one with starting address of 0x0F
  }
  //Read EEPROM MAXIMUM TANK
  for(int i=0;i<12;i++)
  {
    EEmax = EEmax + char(EEPROM.read(addrMAX+i)); //Read one by one with starting address of 0x0F
  }
  //Read EEPROM MAXIMUM DEEP TANK
  for(int i=0;i<12;i++)
  {
    EEdeep = EEdeep + char(EEPROM.read(addrDEEP+i)); //Read one by one with starting address of 0x0F
  }

  EEssid = EEssid.substring(0);
  EEssid.replace(" ", "");
  EEpass = EEpass.substring(0);
  EEpass.replace(" ", "");

  EEmin = EEmin.substring(0);
  EEmin.replace(" ", "");
  EEmax = EEmax.substring(0);
  EEmin.replace(" ", "");
  EEdeep = EEdeep.substring(0);
  EEmin.replace(" ", "");

//  if(EEssid!=" " && EEpass!=" "){
  EEssid.toCharArray(ssid,EEssid.length()+1);
  EEpass.toCharArray(password, EEpass.length()+1);

  EEmin.toCharArray(minimum, EEmin.length()+1);
  EEmax.toCharArray(maximum, EEmax.length()+1);
  EEdeep.toCharArray(deeptank, EEdeep.length()+1);
//  }

  setMin = EEmin.toInt();
  setMax = EEmax.toInt();
  setDep = EEdeep.toInt();

 // long TankMax = setMin.toInt();
 // long TankDep = setMin.toInt();

  //setMin = atoi(minimum);
  //setMax = atoi(maximum);
  //setDep = atoi(deeptank);
  **/
  WiFi.begin(ssid, password);     //Connect to your WiFi router
  Serial.println("");

  //pinMode(LED,OUTPUT);

  pinMode(btnPin1, INPUT_PULLUP);
  pinMode(btnPin2, INPUT_PULLUP);
  pinMode(btnPin3, INPUT_PULLUP);
  pinMode(btnPin4, INPUT_PULLUP);

  pinMode(sensorPin, INPUT);
  digitalWrite(sensorPin, HIGH);
  pinMode(sensorPin2, INPUT);
  digitalWrite(sensorPin2, HIGH);

  //digitalWrite(LED, HIGH);

  nSensor           = 0;

  pulseCount        = 0;
  flowRate          = 0.0;
  totalMilliLitres  = 0;
  oldTime           = 0;

  pulseCount2       = 0;
  flowRate2         = 0.0;
  totalMilliLitres2 = 0;
  oldTime2          = 0;

  distance          = 0;

  btnStatONOFF      = 123;

  oldTime3          = 0;

  oldTime4          = 0;

  oldTime5          = 0;

  distance = distance/setDep;

  // Wait for connection
  while (WiFi.status() != WL_CONNECTED) {
    delay(20);
    Serial.print(".");

    buttonState1 = digitalRead(btnPin1);
    buttonState4 = digitalRead(btnPin4);
    if(buttonState1 == 0 && buttonState4 == 0){
      while(Serial.available()==0){
        Serial.println("Wait Command from Serial Data Communication...");
        delay(20);
      }
      rs232Command=Serial.readString();
      if(rs232Command.substring(0,4)=="ssid"){
        String abc = rs232Command.substring(4);
        int lengtchr = abc.length();
        abc.toCharArray(ssid, lengtchr);
        Serial.print("SSID : ");
        Serial.println(ssid);
        for(int i=0;i<lengtchr;i++)
        {
          EEPROM.write(addrSSID+i,ssid[i]);
        }
        EEPROM.commit();    //Store data to EEPROM

      }else if(rs232Command.substring(0,8)=="password"){
        String abc = rs232Command.substring(8);
        int lengtchr = abc.length();
        abc.toCharArray(password, lengtchr);
        Serial.print("PASSWORD : ");
        Serial.println(password);

        //Write PASSWORD to EEPROM
        for(int i=0;i<lengtchr;i++)
        {
          EEPROM.write(addrPASW+i,password[i]);
        }
        EEPROM.commit();    //Store data to EEPROM
      }else if(rs232Command.substring(0,3)=="min"){
        String abc = rs232Command.substring(3);
        int lengtchr = abc.length();
        abc.toCharArray(minimum, lengtchr);
        Serial.print("MIN TANK : ");
        Serial.println(minimum);

        //Write MINIMUM to EEPROM
        for(int i=0;i<lengtchr;i++)
        {
          EEPROM.write(addrMIN+i,minimum[i]);
        }
        EEPROM.commit();    //Store data to EEPROM
      }else if(rs232Command.substring(0,3)=="max"){
        String abc = rs232Command.substring(3);
        int lengtchr = abc.length();
        abc.toCharArray(maximum, lengtchr);
        Serial.print("MAX TANK : ");
        Serial.println(maximum);

        //Write MINIMUM to EEPROM
        for(int i=0;i<lengtchr;i++)
        {
          EEPROM.write(addrMAX+i,maximum[i]);
        }
        EEPROM.commit();    //Store data to EEPROM
      }else if(rs232Command.substring(0,4)=="deep"){
        String abc = rs232Command.substring(4);
        int lengtchr = abc.length();
        abc.toCharArray(deeptank, lengtchr);
        Serial.print("DEEP TANK : ");
        Serial.println(deeptank);

        //Write DEEP TANK to EEPROM
        for(int i=0;i<lengtchr;i++)
        {
          EEPROM.write(addrDEEP+i,deeptank[i]);
        }
        EEPROM.commit();    //Store data to EEPROM
      }
      else if(rs232Command.substring(0,4)=="read"){
        //Clear EEPROM 128 byte
        for(int i=0;i<127;i++)
        {
          EEPROM.write(i,' ');
        }

        EEPROM.commit();

        //Read SSID and PASSWORD
        Serial.println(ssid);
        Serial.println(password);
        Serial.println(minimum);
        Serial.println(maximum);
        Serial.println(deeptank);
      }
      else if(rs232Command.substring(0,5)=="erase"){
        //Clear EEPROM 128 byte
        for(int i=0;i<127;i++)
        {
          EEPROM.write(i,' ');
        }
        delay(20);
        EEPROM.commit();
        delay(20);

        //Erase EEPROM
        Serial.println("ERASE EEPROM COMPLETE");
      }

    }
  }

  //If connection successful show IP address in serial monitor
  Serial.println("");
  Serial.print("Connected to ");
  Serial.println(ssid);
  Serial.print("IP address: ");
  Serial.println(WiFi.localIP());  //IP address assigned to your ESP

  delay(20);

  client.setServer(mqttServer, mqttPort);
  client.setCallback(MQTTcallback);

  while (!client.connected()) {
    Serial.println("Connecting to MQTT...");
    if (client.connect("ESP8266", mqttUser, mqttPassword )) {
      Serial.println("connected");
    } else {
      Serial.print("failed with state ");
      Serial.println(client.state());  //If you get state 5: mismatch in configuration
      delay(20);
    }
  }

  client.publish("esp/test", "Hello from ESP8266");
  client.subscribe("esp/test");

  // The Flow Sensor is connected using Interrupt
  // Configured to trigger on a FALLING state change (transition from HIGH
  // state to LOW state)
  attachInterrupt(digitalPinToInterrupt(sensorInterrupt), pulseCounter, FALLING);
  attachInterrupt(digitalPinToInterrupt(sensorInterrupt2), pulseCounter2, FALLING);

  delay(20);
}

//==============================================================
//                     LOOP
//==============================================================
void loop(void){
  client.loop();
  if(msg_dta == "#on" && btnStatus != 1) {
      //digitalWrite(LED,HIGH);
      char inChar0 = ONOFF;
      String inChar1 = "ONNN";
      btnOnOff1 += inChar0;
      btnOnOff1 += inChar1;

      serialStop = 1;
      Serial.println(btnOnOff1);
      delay(250);
      serialStop = 0;
      String payloads = "ON";
      client.publish("esp/relay", (char*) payloads.c_str());
      client.subscribe("esp/relay");
    }   //LED on
    if(msg_dta == "#off" && btnStatus != 1) {
      //digitalWrite(LED,LOW);
      char inChar0 = ONOFF;
      String inChar1 = "OFFF";
      btnOnOff2 += inChar0;
      btnOnOff2 += inChar1;
      serialStop = 1;
      Serial.println(btnOnOff2);
      delay(250);
      serialStop = 0;
      String payloads = "OFF";
      client.publish("esp/relay", (char*) payloads.c_str());
      client.subscribe("esp/relay");
    } //LED off

    //msg_cmd = msg_dta.substring(0,5);
    if(msg_cmd == "#manu") {
      char inChar0 = MANAUTO;
      String inChar1 = "MANU";
      manautoStr1 += inChar0;
      manautoStr1 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr1);
      delay(25);
      serialStop = 0;
      //Serial.println("ZZZ");
      btnStatus = 0;
      msg_cmd="";
    } //Menu Manual
    if(msg_cmd == "#auto") {
      char inChar0 = MANAUTO;
      String inChar1 = "AUTO";
      manautoStr5 += inChar0;
      manautoStr5 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr5);
      delay(25);
      serialStop = 0;
      //Serial.println("ZZZ");
      btnStatus = 1;
      msg_cmd="";
    } //Menu Auto

  buttonState1 = digitalRead(btnPin1);
  if (buttonState1 == LOW){
    if(buttonSelect1==0){
      char inChar0 = MANAUTO;
      String inChar1 = "MANU";
      manautoStr1 += inChar0;
      manautoStr1 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr1);
      delay(25);
      serialStop = 0;
      buttonSelect1=1;
      //Serial.println("ZZZ");
    }else if(buttonSelect1==1){
      char inChar0 = MANAUTO;
      String inChar1 = "MINN";
      manautoStr2 += inChar0;
      manautoStr2 += inChar1;

      serialStop = 1;
      Serial.println(manautoStr2);
      delay(25);
      serialStop = 0;
      distance = 1;
      buttonSelect1=2;
      delay(25);
      //Serial.println("ZZZ");
    }else if(buttonSelect1==2){
      char inChar0 = MANAUTO;
      String inChar1 = "MAXX";
      manautoStr3 += inChar0;
      manautoStr3 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr3);
      delay(25);
      serialStop = 0;
      buttonSelect1=3;
      distance = 100;
      delay(25);
      //Serial.println("ZZZ");
    }else if(buttonSelect1==3){
      char inChar0 = MANAUTO;
      String inChar1 = "DEEP";
      manautoStr4 += inChar0;
      manautoStr4 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr4);
      delay(25);
      serialStop = 0;
      buttonSelect1=4;
      //Serial.println("ZZZ");
    }else if(buttonSelect1==4){
      char inChar0 = MANAUTO;
      String inChar1 = "AUTO";
      manautoStr5 += inChar0;
      manautoStr5 += inChar1;
      serialStop = 1;
      Serial.println(manautoStr5);
      delay(25);
      serialStop = 0;
      buttonSelect1=0;
      setDeep = 0;
      delay(25);
      //Serial.println("ZZZ");
    }
  }

  buttonState2 = digitalRead(btnPin2);
  if (buttonState2 == LOW){
    if(buttonONOFF==0){
      char inChar0 = ONOFF;
      String inChar1 = "ONNN";
      onoffStr1 += inChar0;
      onoffStr1 += inChar1;
      serialStop = 1;
      Serial.println(onoffStr1);
      buttonONOFF=1;
      delay(50);
      serialStop = 0;
    }else if(buttonONOFF==1){
      char inChar0 = ONOFF;
      String inChar1 = "OFFF";
      onoffStr2 += inChar0;
      onoffStr2 += inChar1;
      serialStop = 1;
      Serial.println(onoffStr2);
      buttonONOFF=0;
      delay(50);
      serialStop = 1;
    }
  }
  buttonState3 = digitalRead(btnPin3);
  if (buttonState3 == LOW){
    setDeep = 1;
    if(buttonSelect1!=0){
      setMin = distance;
    }
  }
  buttonState4 = digitalRead(btnPin4);
  if (buttonState4 == LOW){
    setDeep = 2;
    if(buttonSelect1!=0){
      setMax = distance;
    }
  }

  switch (nSensor) {
    case 0:
      if((millis() - oldTime) > 1000)    // Only process counters once per second
      {// Disable the interrupt where until complete 1 secon
        detachInterrupt(sensorInterrupt);
        flowRate = ((1000.0 / (millis() - oldTime)) * pulseCount) / calibrationFactor;

        flowMilliLitres = (flowRate / 60) * 1000;
        totalMilliLitres += flowMilliLitres;

        char inChar0 = FLOWSENSOR1;
        char inChar1 = char(flowRate);
        char inChar2[16];

        ltoa(totalMilliLitres,inChar2,10);

        flowRateStr += inChar0;
        flowRateStr += inChar1;
        flowRateStr += inChar2;

        serialStop = 1;
        Serial.println(flowRateStr);
        delay(25);
        serialStop = 0;
        //Serial.println(int(flowRateStr[1]));
        //Serial.println(int(flowRate));
        flowRateStr = "";

        oldTime = millis();
        pulseCount = 0;     // Reset the pulse counter so we can start incrementing again

        // Enable the interrupt again now that we've finished sending output
        attachInterrupt(sensorInterrupt, pulseCounter, FALLING);
        nSensor = 1;
      }
    break;

    case 1:
      if((millis() - oldTime2) > 1000)    // Only process counters once per second
      {// Disable the interrupt where until complete 1 secon
        detachInterrupt(sensorInterrupt2);
        flowRate2 = ((1000.0 / (millis() - oldTime2)) * pulseCount2) / calibrationFactor;

        flow2MilliLitres = (flowRate2 / 60) * 1000;
        totalMilliLitres2 += flow2MilliLitres;

        //String payloads = String(flowRate2);
        //client.publish("esp/flow2", (char*) payloads.c_str());
        //client.subscribe("esp/flow2");
        //delay(20);

        //String payloads2 = String(totalMilliLitres2);
        //client.publish("esp/flowtotal2", (char*) payloads2.c_str());
        //client.subscribe("esp/flowtotal2");
        //delay(20);

        char inChar0 = FLOWSENSOR2;
        char inChar1 = char(flowRate2);
        char inChar2[16];

        ltoa(totalMilliLitres2,inChar2,10);

        flowRate2Str += inChar0;
        flowRate2Str += inChar1;
        flowRate2Str += inChar2;

        serialStop = 1;
        Serial.println(flowRate2Str);
        delay(25);
        serialStop = 0;
        //Serial.println(int(flowRate2Str[1]));
        //Serial.println(int(flowRate2));
        flowRate2Str = "";
        oldTime2 = millis();
        pulseCount2 = 0;     // Reset the pulse counter so we can start incrementing again

        // Enable the interrupt again now that we've finished sending output
        attachInterrupt(sensorInterrupt2, pulseCounter2, FALLING);\
        nSensor = 2;
      }
    break;

    case 2:
      if((millis() - oldTime3) > 1000)    // Only process counters once per second
      {
        if(setDeep==0 && buttonSelect1==0){
          distance = ultrasonic.read();
          distance = (distance* 100)/setDep;//) *100;
        }else if(setDeep==1 && distance<=100 && buttonSelect1!=0){
          distance += 1;
        }else if(setDeep==2 && distance>0 && buttonSelect1!=0){
          distance -= 1;
        }
        setDeep = 0;

        distance = 100 - distance;
        char inChar0 = RANGESENSOR;
        char inChar1 = char(distance);
        char inChar2 = char(103);
        if(distance<=setMin){
          inChar2 = char(101);//ON
        }else if(distance>=setMax){
          inChar2 = char(102);//OFF
        }

        ultrasoundStr += inChar0;
        ultrasoundStr += inChar1;
        ultrasoundStr += inChar2;

        // Pass INC as a parameter to get the distance in inches
        //if(Serial.available()>0 && distance <= 100 && distance>0){
        if(distance <= 100 && distance>0){
          serialStop = 1;
          Serial.println(ultrasoundStr);
          delay(50);
          serialStop = 2;
        }
        ultrasoundStr = "";
        oldTime3 = millis();
        nSensor = 3;
      }
    break;

    case 3:
      if((millis() - oldTime4) > 1000)    // Only process counters once per second
      {
        BtnStat = btnStatONOFF; //Button ONOFF
        char inChar0 = BUTTONMA;
        char inChar1 = char(BtnStat);

        btnStr += inChar0;
        btnStr += inChar1;
        serialStop = 1;
        Serial.println(btnStr);
        delay(50);
        serialStop = 0;
        btnStr = "";
        oldTime4 = millis();
        nSensor = 4;
      }
    break;

    case 4:
      if((millis() - oldTime5) > 10000)    // Only process counters once per second
      {
        if(counter==0){
          String payloads = String(flowRate);
          client.publish("esp/flow1", (char*) payloads.c_str());
          client.subscribe("esp/flow1");
          counter=1;
          delay(50);
        }else if (counter==1){
          String payloads1 = String(totalMilliLitres);
          client.publish("esp/flowtotal1", (char*) payloads1.c_str());
          client.subscribe("esp/flowtotal1");
          counter=2;
          delay(50);
        }else if (counter==2){
          String payloads = String(flowRate2);
          client.publish("esp/flow2", (char*) payloads.c_str());
          client.subscribe("esp/flow2");
          counter=3;
          delay(50);
        }else if (counter==3){
          String payloads2 = String(totalMilliLitres2);
          client.publish("esp/flowtotal2", (char*) payloads2.c_str());
          client.subscribe("esp/flowtotal2");
          counter=4;
          delay(50);
        }else if (counter==4){
          String payloads = String(distance);
          client.publish("esp/level", (char*) payloads.c_str());
          client.subscribe("esp/level");
          counter=5;
          delay(50);
        }else if (counter==5){
          counter=0;
          delay(50);
        }

        btnStr = "";
        oldTime5 = millis();
        nSensor = 0;
      }
    break;

    default:
    // if nothing else matches, do the default
    // default is optional
    break;
  }

  delay(20);
}//END of Loop

/*
Insterrupt Service Routine
 */
void pulseCounter()
{
  // Increment the pulse counter
  pulseCount++;
}

void pulseCounter2()
{
  // Increment the pulse counter
  pulseCount2++;
}