SOURCE CODE PROGRAM SMART AGRICULTURE

 Hari ini saya mencari contoh source code program smart agriculture

 config

#include "config.h"

//callback notifying us of the need to save config

void saveConfigCallback () {

  Serial.println("Should save config");

  shouldSaveConfig = true;

}

void ReadConfigFile()

{

    //read configuration from FS json

  Serial.println("mounting FS...");

  if (SPIFFS.begin()) {

    Serial.println("mounted file system");

    if (SPIFFS.exists("/config.json")) {

      //SPIFFS.remove("/config.json");

      //file exists, reading and loading

      Serial.println("reading config file");

      File configFile = SPIFFS.open("/config.json", "r");

      if (configFile) {

        Serial.println("opened config file");

        size_t size = configFile.size();

        // Allocate a buffer to store contents of the file.

        std::unique_ptr<char[]> buf(new char[size]);

        configFile.readBytes(buf.get(), size);

        DynamicJsonBuffer jsonBuffer;

        JsonObject& json = jsonBuffer.parseObject(buf.get());

        json.printTo(Serial);

        if (json.success()) {

          Serial.println("\nparsed json");

          strcpy(mqtt_server, json["mqtt_server"]);

          String port = json["mqtt_port"];

          mqtt_port = port.toInt();

          strcpy(mqtt_user, json["mqtt_user"]);

          strcpy(mqtt_password, json["mqtt_password"]);

//          strcpy(mqtt_keywords1, json["mqtt_keywords1"]);

          //strcpy(mqtt_keywords2, json["mqtt_keywords2"]);

        } else {

          Serial.println("failed to load json config");

        }

      }

    }

  } else {

    Serial.println("failed to mount FS");

  }

  //end read

}

String IpAddress2String(const IPAddress& ipAddress)

{

  return String(ipAddress[0]) + String(".") +\

  String(ipAddress[1]) + String(".") +\

  String(ipAddress[2]) + String(".") +\

  String(ipAddress[3])  ; 

}

void SaveConfigFile()

{

  

  //save the custom parameters to FS

  if (shouldSaveConfig) {

    Serial.println("saving config");

    DynamicJsonBuffer jsonBuffer;

    JsonObject& json = jsonBuffer.createObject();

    json["mqtt_server"] = mqtt_server;

    json["mqtt_port"] = String(mqtt_port);

    json["mqtt_user"] = mqtt_user;

    json["mqtt_password"] = mqtt_password;

    json["mqtt_keywords1"] = "";

   // json["mqtt_keywords2"] = mqtt_keywords2;

    

    File configFile = SPIFFS.open("/config.json", "w");

    if (!configFile) {

      Serial.println("failed to open config file for writing");

    }

    json.printTo(Serial);

    json.printTo(configFile);

    configFile.close();

    //end save

  }

}

void ResetSettings()

{

        WiFiManager wifiManager;

        wifiManager.resetSettings();

        delay(2000);

        ESP.restart();

}

RMQ with control relay

/*

    Develop by      : 

    Email           :

    Project         : 

    Version         :

*/

//library

/*

   Library

   Version:

   <ESP8266WiFi.h> 1.0.0

   <DNSServer.h> 1.1.0

   <ESP8266WebServer.h> 1.0.0

   <WiFiManager.h> 0.12.0

   <ArduinoJson.h> 5.13.2

   <PubSubClient.h> 2.6.0

*/

#include <FS.h> //this needs to be first, or it all crashes and burns...

#include <Ticker.h>

#include <ESP8266WiFi.h>

#include <DNSServer.h>

#include <ESP8266WebServer.h>

#include <WiFiManager.h>

#include <ArduinoJson.h>

//#include <SPI.h>

//#include "MFRC522.h"

#include <PubSubClient.h>

#include "config.h"

#include <EEPROM.h>

StaticJsonBuffer<200> jsonBuffer;

void writeString(char add,String data);

String read_String(char add);

//const char* id_user,aktif;

//var temp untuk menampung data json dari payload

char payloadTemp[200];

//var untuk PIN sensor

int soilSensor = A0;

int powerPin = 15;

//char devicename[40]="";

char registerstatus[40]="";

char aktivasistatus[40]="";

//var untuk userID

String commandMessage1 = "1"; //message pesan subscribe

String commandMessage2 = "2"; //message pesan publish

String typeDevice = "Soil Sensor";

char routingkey2[40] ="publish";

int relay1 = D1 ;

int relay2 = D2 ;

int relay3 = D3 ;

int relay4 = D4 ;

void setup_wifi() {

  WiFi.macAddress(MAC_array);

  for (int i = 0; i < sizeof(MAC_array) - 1; ++i) {

    sprintf(MAC_char, "%s%02x:", MAC_char, MAC_array[i]);

  }

  sprintf(MAC_char, "%s%02x", MAC_char, MAC_array[sizeof(MAC_array) - 1]);

  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);

  String(mqtt_port).toCharArray(smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_port("port", "mqtt port", smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 40);

  WiFiManagerParameter custom_mqtt_password("password", "mqtt password", mqtt_password, 40);

  WiFiManagerParameter custom_mqtt_keywords1("keyword1", "mqtt keyword1", MAC_char, 40);

  //WiFiManagerParameter custom_mqtt_keywords2("keyword2", "mqtt keyword2", mqtt_keywords2, 40);

  WiFiManager wifiManager;

  wifiManager.setSaveConfigCallback(saveConfigCallback);

  wifiManager.addParameter( & custom_mqtt_server);

  wifiManager.addParameter( & custom_mqtt_port);

  wifiManager.addParameter( & custom_mqtt_user);

  wifiManager.addParameter( & custom_mqtt_password);

  wifiManager.addParameter(&custom_mqtt_keywords1);

  if (!wifiManager.autoConnect(MAC_char, "password")) {

    Serial.println("failed to connect and hit timeout");

    delay(2000);

    //reset and try again, or maybe put it to deep sleep

    ESP.reset();

    delay(2000);

  }

  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}

void callback(char * topic, byte * payload, unsigned int length) {

  char message [7] ;

  Serial.print("Message arrived [");

  Serial.print(topic);

  Serial.println("] ");

  for (int i = 0; i < length; i++) {

    message[i] = (char)payload[i];

  }

  String convertMsg = String(message) ;

  String data = convertMsg.substring(5);

  int timer = data.toInt();

  Serial.println(message);

     

  //relay 1

  if (message[0] == '1') {

    digitalWrite(relay1, HIGH);

    Serial.println("relay 1 mati");

  } else {

    digitalWrite(relay1, LOW);

    Serial.println("relay 1 idup");

  }

  //relay 2

  if (message[1] == '1') {

    digitalWrite(relay2, HIGH);

    Serial.println("relay 2 mati");

//    publish_ulang();

  } else {

    digitalWrite(relay2, LOW);

    Serial.println("relay 2 idup");

//    publish_ulang();

  }

  //relay 3

  if (message[2] == '1') {

    digitalWrite(relay3, HIGH);

    Serial.println("relay 3 mati");

//    publish_ulang();

  } else {

    digitalWrite(relay3, LOW);

    Serial.println("relay 3 idup");

//    publish_ulang();

  }

  //relay 4

  if (message[3] == '1') {

    digitalWrite(relay4, HIGH);

    Serial.println("relay 4 mati");

//    publish_ulang();

  } else {

    digitalWrite(relay4, LOW);

    Serial.println("relay 4 idup");

//    publish_ulang();

  }

  delay (timer);

  digitalWrite(relay1, HIGH);

  digitalWrite(relay2, HIGH);

  digitalWrite(relay3, HIGH);

  digitalWrite(relay4, HIGH);

  Serial.println("relay mati");

   //  publish_ulang();

if (message >=0){

      publish_ulang();

     }else{

      Serial.println("0");

      } 

  

 }

void reconnect() {

  // Loop until we're reconnected

  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...%s");

    Serial.println(mqtt_server);

    // Attempt to connect

    if (client.connect(MAC_char, mqtt_user, mqtt_password)) {

      Serial.println("connected");

      Serial.println(MAC_char);

      client.subscribe(MAC_char);

     

    } else {

      Serial.print("failed, rc=");

      Serial.print(client.state());

      if (client.state() == 4) ESP.restart();

      else {

        Serial.println(" try again in 5 seconds");

        // Wait 5 seconds before retrying

        //delay(10000);

      }

    }

  }

}

void setup() {

  //setup pin mode

  //  pinMode(soilSensor, INPUT_PULLUP);

  pinMode(D1, OUTPUT);

  pinMode(D2, OUTPUT);

  pinMode(D3, OUTPUT);

  pinMode(D4, OUTPUT);

  pinMode(powerPin, OUTPUT);

  digitalWrite(D1, HIGH);

  digitalWrite(D2, HIGH);

  digitalWrite(D3, HIGH);

  digitalWrite(D4, HIGH);

  Serial.begin(115200);

  EEPROM.begin(512);

  Serial.println(F("Booting...."));

  //read config wifi,mqtt dan yang lain

  ReadConfigFile();

  setup_wifi();

  SaveConfigFile();

  client.setServer(mqtt_server, mqtt_port);

  client.setCallback(aktivasi);

  

}

void loop() {

  String  recivedData = read_String(10);

   Serial.println("Ini datanya:");

  Serial.println(recivedData);

  delay(1000);

//  int pesan=1;

  if(recivedData=="1"){

    client.setCallback(callback);

     client.loop(); 

  }else{

     client.setCallback(aktivasi);

     client.loop(); 

    Serial.println("Device Belum Teraktivasi");  

    }

     if (!client.connected()) {

    reconnect();

  }

}

void publish_ulang (){

//const char tambahan=MAC_char,"Ast";

  String berhasil = "berhasil";

  String pubmsg = "";

  StaticJsonBuffer<200> jsonBuffer;

  JsonObject& root = jsonBuffer.createObject();

  root["mac"] = MAC_char;

//  root["waktu siram"] =timer;

  root["pesan"] =berhasil;

  root.printTo(pubmsg);

  Serial.println(pubmsg);

  Serial.println(MAC_char);

  client.publish(routingkey2 ,pubmsg.c_str());

//client.publish(tambahan());

  delay(3000);

  }

  

//void publish_rmq(){

  //String pubmsg = "";

  //StaticJsonBuffer<200> jsonBuffer;

  //JsonObject& root = jsonBuffer.createObject();

  //root["mac_address"] = MAC_char;

  //root["namadevice"] =devicename;

  //root.printTo(pubmsg);

  //Serial.println(pubmsg);

  //Serial.println(MAC_char);

  //client.publish(routingkey2,pubmsg.c_str());

  //delay(3000);

  //}

void writeString(char add,String data){

  int _size = data.length();

  int i;

  for(i=0;i<_size;i++)

  {

    EEPROM.write(add+i,data[i]);

  }

  EEPROM.write(add+_size,'\0');   

  EEPROM.commit();

}

 

 

String read_String(char add){

  int i;

  char data[100]; 

  int len=0;

  unsigned char k;

  k=EEPROM.read(add);

  while(k != '\0' && len<500){    

    k=EEPROM.read(add+len);

    data[len]=k;

    len++;

  }

  data[len]='\0';

  return String(data);

}

void aktivasi(char * topic, byte * payload, unsigned int length) {

  String pesan;

  Serial.print("Message arrived [");

  Serial.print(topic);

  Serial.println("] ");

  for (int i = 0; i < length; i++) {

      pesan = (char)payload[i];

      Serial.print(pesan);

      writeString(10,pesan);   

  }

}

soil moisture shadoof

#include <PubSubClient.h>

#include <ESP8266WiFi.h>

#include <ArduinoJson.h>

#include <SoftwareSerial.h>

#include <EasyNTPClient.h>

#include <WiFiUdp.h>

//#include <NTPClient.h>

#include <FS.h> //this needs to be first, or it all crashes and burns...

#include <Ticker.h>

#include <ESP8266WiFi.h>

#include <DNSServer.h>

#include <ESP8266WebServer.h>

#include <WiFiManager.h>

#include <ArduinoJson.h>

#include <PubSubClient.h>

#include "config.h"

//WiFiClient espClient;

//PubSubClient client(espClient);

WiFiUDP udp;

EasyNTPClient ntpClient(udp, "pool.ntp.org", 25200); 

StaticJsonBuffer<200> jsonBuffer;

void writeString(char add,String data);

String read_String(char add);

char payloadTemp[200];

int soilSensor = A0;

int powerPin = 15;

String commandMessage1 = "1"; //message pesan subscribe

String commandMessage2 = "2"; //message pesan publish

String typeDevice = "Soil Sensor";

char routingkey2[40] ="soilsensor";

String waktu;

const int soil_sensor = A0;

const int LED = 13;

String Kondisi;

void setup_wifi() {

  WiFi.macAddress(MAC_array);

  for (int i = 0; i < sizeof(MAC_array) - 1; ++i) {

    sprintf(MAC_char, "%s%02x:", MAC_char, MAC_array[i]);

  }

  sprintf(MAC_char, "%s%02x", MAC_char, MAC_array[sizeof(MAC_array) - 1]);

  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);

  String(mqtt_port).toCharArray(smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_port("port", "mqtt port", smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 40);

  WiFiManagerParameter custom_mqtt_password("password", "mqtt password", mqtt_password, 40);

  WiFiManagerParameter custom_mqtt_keywords1("keyword1", "mqtt keyword1", MAC_char, 40);

  //WiFiManagerParameter custom_mqtt_keywords2("keyword2", "mqtt keyword2", mqtt_keywords2, 40);

  WiFiManager wifiManager;

  wifiManager.setSaveConfigCallback(saveConfigCallback);

  wifiManager.addParameter( & custom_mqtt_server);

  wifiManager.addParameter( & custom_mqtt_port);

  wifiManager.addParameter( & custom_mqtt_user);

  wifiManager.addParameter( & custom_mqtt_password);

  wifiManager.addParameter(&custom_mqtt_keywords1);

  if (!wifiManager.autoConnect(MAC_char, "password")) {

    Serial.println("failed to connect and hit timeout");

    delay(2000);

    //reset and try again, or maybe put it to deep sleep

    ESP.reset();

    delay(2000);

  }

  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}

void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Message arrived [");

  Serial.print(topic);

  Serial.print("] ");

  for (int i = 0; i < length; i++) {

    Serial.print((char)payload[i]);

  }

  Serial.println();

  // Switch on the LED if an 1 was received as first character

  if ((char)payload[0] == '1') {

    digitalWrite(LED, HIGH);   // Turn the LED on (Note that HIGH is the voltage level

  } else {

    digitalWrite(LED, LOW);  // Turn the LED off by making the voltage LOW

  }

}

void reconnect() {

  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...%s");

    Serial.println(mqtt_server);

    if (client.connect(MAC_char, mqtt_user, mqtt_password)) {

      Serial.println("connected");

      Serial.println(MAC_char);

      client.subscribe(MAC_char);

     

    } else {

      Serial.print("failed, rc=");

      Serial.print(client.state());

      if (client.state() == 4) ESP.restart();

      else {

        Serial.println(" try again in 5 seconds");

      }

    }

  }

}

void setup() {

   pinMode(soil_sensor, INPUT);

  pinMode(LED, OUTPUT);

  Serial.begin(9600);

  setup_wifi();

  client.setServer(mqtt_server, 1883);

  client.setCallback(callback);

 

}

void loop() {

  String pubmsg = "";

  float speed;

  char time[32];

  char date[32];

  if (!client.connected()) {

    reconnect();

  }

  client.loop();

  

  int adc = analogRead(soil_sensor);     // read the value from the sensor

  float tegangan = adc * (5.0 / 1023.0);       // convertion formula to volt

  Serial.print("ADC:");

  Serial.print(adc);

  Serial.print(" | ");

  Serial.print("tegangan:");

  Serial.println(tegangan, 2);

  delay(1000);

  

  if (tegangan >= 3.7) {

    Serial.println("Kering");

    Kondisi="Kering";

  } else {

    Serial.println("Basah");

    Kondisi="Basah";

  }

   float unixtime = ntpClient.getUnixTime();

   Serial.println(unixtime);

  

  delay(20000); // wait for 20 seconds before refreshing.

  StaticJsonBuffer<200> jsonBuffer;

  JsonObject& root = jsonBuffer.createObject();

  root["MAC"] = MAC_char;

  root["Tegangan_Tanah"] =tegangan ;

  root["Kondisi_Tanah"] =Kondisi;

  JsonArray& data = root.createNestedArray("data");

  JsonArray& deviceId = root.createNestedArray("deviceId");

  data.add(adc);

  deviceId.add("Sensor_SOIL_003"); //device id Sensor Soil

  Serial.print("Publish message: ");

  root.printTo(pubmsg);

  String jenis_iot = "Sensor_Soil_001";

  String longitude = "0";

  String latitude = "0";

  String data_1 = MAC_char;

  float  data_2 = tegangan;

  String data_3 = "001";

  String data_4 = "0";

  float  timestamp_device = unixtime;

  String kode_device = "0";

    

  String publisheddata = "#" + jenis_iot + "#" + longitude + "#" + latitude + "#" + data_1 + "#" + data_2 + "#" + data_3 + "#" + data_4 + "#" + timestamp_device + "#" + kode_device;

  Serial.println(publisheddata);

  Serial.println(pubmsg);

  client.publish(routingkey2, pubmsg.c_str());

}

Water flow shadoof

#include <PubSubClient.h>

#include <ESP8266WiFi.h>

#include <ArduinoJson.h>

#include <SoftwareSerial.h>

#include <EasyNTPClient.h>

#include <WiFiUdp.h>

//#include <NTPClient.h>

#include <FS.h> //this needs to be first, or it all crashes and burns...

#include <Ticker.h>

#include <ESP8266WiFi.h>

#include <DNSServer.h>

#include <ESP8266WebServer.h>

#include <WiFiManager.h>

#include <ArduinoJson.h>

#include <PubSubClient.h>

#include "config.h"

#include <NTPClient.h>

//WiFiClient espClient;

//PubSubClient client(espClient);

WiFiUDP udp;

EasyNTPClient ntpClient(udp, "pool.ntp.org", 25200); 

StaticJsonBuffer<200> jsonBuffer;

void writeString(char add,String data);

String read_String(char add);

char payloadTemp[200];

int soilSensor = A0;

int powerPin = 15;

String commandMessage1 = "1"; //message pesan subscribe

String commandMessage2 = "2"; //message pesan publish

String typeDevice = "Soil Sensor";

const char* routingkey2 = "pubwaterflow";

WiFiUDP ntpUDP;

NTPClient timeClient(ntpUDP, "pool.ntp.org", 25200);

int TURBINE;      //pengukuran SINYAL data yang bersifat incremental

int waterflow = D3; //nama alias pada pin 2

int Calc;

const int LED = 13;

void setup_wifi() {

  WiFi.macAddress(MAC_array);

  for (int i = 0; i < sizeof(MAC_array) - 1; ++i) {

    sprintf(MAC_char, "%s%02x:", MAC_char, MAC_array[i]);

  }

  sprintf(MAC_char, "%s%02x", MAC_char, MAC_array[sizeof(MAC_array) - 1]);

  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);

  String(mqtt_port).toCharArray(smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_port("port", "mqtt port", smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 40);

  WiFiManagerParameter custom_mqtt_password("password", "mqtt password", mqtt_password, 40);

  WiFiManagerParameter custom_mqtt_keywords1("keyword1", "mqtt keyword1", MAC_char, 40);

  //WiFiManagerParameter custom_mqtt_keywords2("keyword2", "mqtt keyword2", mqtt_keywords2, 40);

  WiFiManager wifiManager;

  wifiManager.setSaveConfigCallback(saveConfigCallback);

  wifiManager.addParameter( & custom_mqtt_server);

  wifiManager.addParameter( & custom_mqtt_port);

  wifiManager.addParameter( & custom_mqtt_user);

  wifiManager.addParameter( & custom_mqtt_password);

  wifiManager.addParameter(&custom_mqtt_keywords1);

  if (!wifiManager.autoConnect(MAC_char, "password")) {

    Serial.println("failed to connect and hit timeout");

    delay(2000);

    //reset and try again, or maybe put it to deep sleep

    ESP.reset();

    delay(2000);

  }

  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}

void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Message arrived [");

  Serial.print(topic);

  Serial.print("] ");

  for (int i = 0; i < length; i++) {

    Serial.print((char)payload[i]);

  }

  Serial.println();

  // Switch on the LED if an 1 was received as first character

  if ((char)payload[0] == '1') {

    digitalWrite(LED, HIGH);   // Turn the LED on (Note that HIGH is the voltage level

  } else {

    digitalWrite(LED, LOW);  // Turn the LED off by making the voltage LOW

  }

}

void reconnect() {

  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...%s");

    Serial.println(mqtt_server);

    if (client.connect(MAC_char, mqtt_user, mqtt_password)) {

      Serial.println("connected");

      Serial.println(MAC_char);

      client.subscribe(MAC_char);

     

    } else {

      Serial.print("failed, rc=");

      Serial.print(client.state());

      if (client.state() == 4) ESP.restart();

      else {

        Serial.println(" try again in 5 seconds");

      }

    }

  }

}

void speedrpm ()    //fungsi penghitungan dan interrupt

{

  TURBINE++; //bersifat incrementing (dengan mode falling edge)

}

  byte indikator = 13;

  byte sensorInt = 0;

  byte flowsensor = D3;

  float konstanta = 4.5; // konstanta flow meter

  volatile byte pulseCount;

  float debit;

  unsigned int flowmlt;

  unsigned long totalmlt;

  unsigned long oldTime;

void setup() {

  //Inisialisasi port serial

  Serial.begin(115200);

  pinMode(indikator, OUTPUT);

  digitalWrite(indikator, HIGH);

  pinMode(flowsensor,INPUT);

  digitalWrite(flowsensor, HIGH);

  setup_wifi();

//  printMACAddress();

  client.setServer(mqtt_server, 1883);

//  client.setCallback(callback);

  timeClient.begin();

  pulseCount = 0;

  debit = 0.0;

  flowmlt = 0;

  totalmlt = 0;

  oldTime = 0;

  attachInterrupt(sensorInt, pulseCounter, FALLING);

 

}

void loop() {

 

  if (!client.connected()){

    reconnect();}

//  client.loop();

  if((millis() - oldTime) > 1000){

    detachInterrupt(sensorInt);

    debit = ((1000.0 / (millis() - oldTime)) *pulseCount)/

    konstanta;

    oldTime = millis();

    flowmlt = (debit / 120) *1000;

    totalmlt += flowmlt;

    unsigned int frac;

    Serial.print("Debit air: ");

    Serial.print(int(debit));

    Serial.print("L/min");

    Serial.print("\t");

    Serial.print("Volume: ");

    Serial.print(totalmlt);

    Serial.println("mL");

    pulseCount = 0;

    attachInterrupt(sensorInt,pulseCounter,FALLING);

  }

    String pubmsg="";

  StaticJsonBuffer<200> jsonBuffer;

  JsonObject& root = jsonBuffer.createObject();

  root["MAC"] = MAC_char;

  root["Debit_air"] =debit ;

  root["Volume_air"]=totalmlt;

  Serial.print("Publish message: ");

  root.printTo(pubmsg);

  Serial.println(pubmsg);

  client.publish(routingkey2,(char*)pubmsg.c_str());

  delay (1000);

  

}

  void pulseCounter(){

   pulseCount++;

  

  }

Water level shadoof

/*

 * Edit By Asep Trisna Setiawan

 * Bandung 15 03 2020

 */

#include <PubSubClient.h>

#include <ESP8266WiFi.h>

#include <ArduinoJson.h>

#include <SoftwareSerial.h>

#include <EasyNTPClient.h>

#include <WiFiUdp.h>

#include <FS.h> //this needs to be first, or it all crashes and burns...

#include <Ticker.h>

#include <ESP8266WiFi.h>

#include <DNSServer.h>

#include <ESP8266WebServer.h>

#include <WiFiManager.h>

#include <ArduinoJson.h>

#include <PubSubClient.h>

#include "config.h"

//WiFiClient espClient;

//PubSubClient client(espClient);

#include <ArduinoJson.h>

#include <PubSubClient.h>

#include <ESP8266WiFi.h>

#include <ESP8266WebServer.h>

#include <WiFiManager.h>

int FloatSensor  = D1;

int FloatSensor2 = D2;

int FloatSensor3 = D3;

int Buzzer       = D4;

int buttonState  = 1;

int buttonState2 = 1;

int buttonState3 = 1;

const int LED = 13;

char routingkey2[40] ="waterlev";

byte   mac[6];

char   msg[50];

String Level;

void setup_wifi() {

  WiFi.macAddress(MAC_array);

  for (int i = 0; i < sizeof(MAC_array) - 1; ++i) {

    sprintf(MAC_char, "%s%02x:", MAC_char, MAC_array[i]);

  }

  sprintf(MAC_char, "%s%02x", MAC_char, MAC_array[sizeof(MAC_array) - 1]);

  WiFiManagerParameter custom_mqtt_server("server", "mqtt server", mqtt_server, 40);

  String(mqtt_port).toCharArray(smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_port("port", "mqtt port", smqtt_port, 5);

  WiFiManagerParameter custom_mqtt_user("user", "mqtt user", mqtt_user, 40);

  WiFiManagerParameter custom_mqtt_password("password", "mqtt password", mqtt_password, 40);

  WiFiManagerParameter custom_mqtt_keywords1("keyword1", "mqtt keyword1", MAC_char, 40);

  //WiFiManagerParameter custom_mqtt_keywords2("keyword2", "mqtt keyword2", mqtt_keywords2, 40);

  WiFiManager wifiManager;

  wifiManager.setSaveConfigCallback(saveConfigCallback);

  wifiManager.addParameter( & custom_mqtt_server);

  wifiManager.addParameter( & custom_mqtt_port);

  wifiManager.addParameter( & custom_mqtt_user);

  wifiManager.addParameter( & custom_mqtt_password);

  wifiManager.addParameter(&custom_mqtt_keywords1);

  if (!wifiManager.autoConnect(MAC_char, "password")) {

    Serial.println("failed to connect and hit timeout");

    delay(2000);

    //reset and try again, or maybe put it to deep sleep

    ESP.reset();

    delay(2000);

  }

  Serial.println("");

  Serial.println("WiFi connected");

  Serial.println("IP address: ");

  Serial.println(WiFi.localIP());

}

void callback(char* topic, byte* payload, unsigned int length) {

  Serial.print("Message arrived [");

  Serial.print(topic);

  Serial.print("] ");

  for (int i = 0; i < length; i++) {

    Serial.print((char)payload[i]);

  }

  Serial.println();

  // Switch on the LED if an 1 was received as first character

  if ((char)payload[0] == '1') {

    digitalWrite(LED, HIGH);   // Turn the LED on (Note that HIGH is the voltage level

  } else {

    digitalWrite(LED, LOW);  // Turn the LED off by making the voltage LOW

  }

}

void reconnect() {

  while (!client.connected()) {

    Serial.print("Attempting MQTT connection...%s");

    Serial.println(mqtt_server);

    if (client.connect(MAC_char, mqtt_user, mqtt_password)) {

      Serial.println("connected");

      Serial.println(MAC_char);

      client.subscribe(MAC_char);

     

    } else {

      Serial.print("failed, rc=");

      Serial.print(client.state());

      if (client.state() == 4) ESP.restart();

      else {

        Serial.println(" try again in 5 seconds");

      }

    }

  }

}

void setup() {

  Serial.begin(115200);

  setup_wifi();

  client.setServer(mqtt_server, 1883);

  client.setCallback(callback);

  pinMode(FloatSensor,  INPUT_PULLUP);

  pinMode(FloatSensor2, INPUT_PULLUP);

  pinMode(FloatSensor3, INPUT_PULLUP);

  pinMode(Buzzer,   OUTPUT);

  digitalWrite(Buzzer,HIGH);

  delay(100);

  }

void loop(){

  if (!client.connected()) {

    reconnect();

  }

  String pubmsg = "";

  float speed;

  char time[32];

  char date[32];

  

  client.loop();

    // read the value from the sensor

  int value = digitalRead (buttonState);     

  int value2 = digitalRead (buttonState2); 

  int value3 = digitalRead (buttonState3); 

  Serial.println(value);

  delay(5000);

   buttonState  = digitalRead(FloatSensor);  // read the value of float sensor

   buttonState2 = digitalRead(FloatSensor2);  // read the value of float sensor

   buttonState3 = digitalRead(FloatSensor3);  // read the value of float sensor

  if ((buttonState == HIGH)&&(buttonState2 == HIGH)&&(buttonState3 == HIGH)){

    Level = "Empty";                                         

    Serial.println( "WATER LEVEL - LOW");

    digitalWrite(Buzzer, HIGH);

                

   

  }else if ((buttonState == HIGH)&&(buttonState2 == LOW)&&(buttonState3 == LOW)){

     Level = "Medium"; 

    Serial.println( "WATER LEVEL - MEDIUM" );                     

    digitalWrite(Buzzer, LOW);           

  

  }

  else if ((buttonState == LOW)&&(buttonState2 == LOW)&&(buttonState3 == LOW)){

    Level = "Full";

    Serial.println( "WATER LEVEL - HIGH" ); // if the value is LOW                       // the level is low

    digitalWrite(Buzzer, HIGH);     

    

  }

  StaticJsonBuffer<200> jsonBuffer;

  JsonObject& root = jsonBuffer.createObject();

  root["MAC"] = MAC_char;

  root["Level_Air"] = Level;

  JsonArray& data = root.createNestedArray("data");

  JsonArray& deviceId = root.createNestedArray("deviceId");

  data.add(value);

  data.add(value2);

  data.add(value3 );

  deviceId.add("Sensor_WATER_001"); //device id Sensor WATER LEVEL

  Serial.print("Publish message: ");

  root.printTo(pubmsg);

  String jenis_iot = "Sensor_Water_Level";

  String longitude = "0";

  String latitude = "0";

  String data_1 = MAC_char;

  int data_2 = value;

  int data_3 = value2;

  int data_4 = value3;

  String timestamp_device = "0";

  String kode_device = "0";

  String publisheddata = "#" + jenis_iot + "#" + longitude + "#" + latitude + "#" + data_1 + "#" + data_2 + "#" + data_3 + "#" + data_4 + "#" + timestamp_device + "#" + kode_device;

  Serial.println(publisheddata);

  Serial.println(pubmsg);

  client.publish(routingkey2,(char*) pubmsg.c_str());

  delay(10000);

}