wifi_jadi_punya_orang

#define BLYNK_PRINT Serial
#include <ESP8266_Lib.h>
#include <BlynkSimpleShieldEsp8266.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h>

int relay1 = 5;
int relay2 = 4;
int relay3 = 3;

float v;
double p1 = 0;
double p2 = 0;
double p3 = 0;
float pt1 = 0;
float pt2 = 0;
float pt3 = 0;
float Arus = 0;
float x1, x2;

bool status = 0;
char auth[] = "c6b8c4dd89364245a9f849c8b440f096";
BlynkTimer timer;

//steARUs
const int sensorIn = A1;
const int sensorIn1 = A2;
const int sensorIn2 = A3;
int mVperAmp = 66;

double Volt = 0, VRMSvolt = 0;
double Voltage = 0; double Voltage2 = 0; double Voltage3 = 0;
double VRMS = 0, VRMS2 = 0, VRMS3 = 0;
double AmpsRMS = 0, AmpsRMS2 = 0, AmpsRMS3 = 0;
double I = 0, I2 = 0, I3 = 0;
double DAYA1 = 0;
float mcuVoltage = 5.0;
float dayatotal = 0;

char ssid[] = "ryzen1234";
char pass[] = "ryen1234";

#define EspSerial Serial1
#define ESP8266_BAUD 115200

ESP8266 wifi(&EspSerial);
LiquidCrystal_I2C lcd(0x27, 20, 4);

void setup()
{

  Serial.begin(9600);
  //lcd.init();
  lcd.backlight();
  lcd.clear();
  delay(500);
  EspSerial.begin(ESP8266_BAUD);
  delay(10);
  pinMode(relay1, OUTPUT);
  pinMode(relay2, OUTPUT);
  pinMode(relay3, OUTPUT);

  if (VRMSvolt > 200)
  {
    digitalWrite(relay1, LOW);
    digitalWrite(relay2, LOW);
    digitalWrite(relay3, LOW);
    status = 1;
  }
  else
  {
    digitalWrite(relay1, HIGH);
    digitalWrite(relay2, HIGH);
    digitalWrite(relay3, HIGH);
    status = 0;
  }

  Blynk.begin(auth, wifi, ssid, pass, "iwancilibur.my.id", 8080);
  timer.setInterval(500L, getACS712);
  timer.setInterval(500L, getACS712B);
  timer.setInterval(500L, getACS712C);
}

void loop()
{

  timer.run();
  lcd.setCursor(00, 00);
  lcd.print("Tegangan :");
  lcd.setCursor(00, 1);
  lcd.print("DAYA 1   :");
  lcd.setCursor(00, 2);
  lcd.print("DAYA 2   :");
  lcd.setCursor(00, 3);
  lcd.print("DAYA 3   :");
  lcd.setCursor(11, 00);
  lcd.print(String(VRMSvolt) + "  ");
  lcd.setCursor(11, 01);
  lcd.print(String(p1) + "  ");
  lcd.setCursor(11, 02);
  lcd.print(String(p2) + "  ");
  lcd.setCursor(11, 03);
  lcd.print(String(p3) + "  ");


  //             getACS712();
  //             getACS712B();
  //             getACS712C();
  getVOLT();
  dayatotal = p1 + p2 + p3;
  Blynk.virtualWrite(V10, float(dayatotal));


  Serial.print(String("v1 = ") + VRMSvolt + " V");
  Serial.print(String("i1 = ") + I + " A");
  Serial.print(String("p1 = ") + p1 + " Watts");
  Serial.print(String("i2 = ") + I2 + " A");
  Serial.print(String("p2 = ") + p2 + " Watts");
  Serial.print(String("i3 = ") + I3 + " A");
  Serial.println(String("p3 = ") + p3 + " Watts");
  delay(50);


  delay(2000);
}

//SENSOR ARUS 1
float getVPP() {
  float result;
  int readValue;
  int maxValue = 0;
  int minValue = 1024;
  uint32_t start_time = millis();
  while ((millis() - start_time) < 1000) {
    readValue = analogRead(sensorIn);
    if (readValue > maxValue) {
      maxValue = readValue;
    }
    if (readValue < minValue) {
      minValue = readValue;
    }
  }
  result = ((maxValue - minValue) * 5.0) / 1024.0;
  return result;
}
//SENSOR ARUS 2
float getVPP1()
{
  float result;
  int readValue; //value read from the sensor
  int maxValue = 0; // store max value here
  int minValue = 1024; // store min value here
  uint32_t start_time = millis();
  while ((millis() - start_time) < 1000) //sample for 1 Sec
  {
    readValue = analogRead(sensorIn1);
    // see if you have a new maxValue
    if (readValue > maxValue)
    {
      /*record the maximum sensor value*/
      maxValue = readValue;
    }
    if (readValue < minValue)
    {
      /*record the maximum sensor value*/
      minValue = readValue;
    }
  }
  // Subtract min from max
  result = ((maxValue - minValue) * 5.0) / 1024.0;
  return result;
}
//SENSOR ARUS 3
float getVPP2()
{
  float result;
  int readValue; //value read from the sensor
  int maxValue = 0; // store max value here
  int minValue = 1024; // store min value here
  uint32_t start_time = millis();
  while ((millis() - start_time) < 1000) //sample for 1 Sec
  {
    readValue = analogRead(sensorIn2);
    // see if you have a new maxValue
    if (readValue > maxValue)
    {
      /*record the maximum sensor value*/
      maxValue = readValue;
    }
    if (readValue < minValue)
    {
      /*record the maximum sensor value*/
      minValue = readValue;
    }
  }
  // Subtract min from max
  result = ((maxValue - minValue) * 5.0) / 1024.0;
  return result;
}
float getVPPvolt()
{
  float result;
  int readValue; //value read from the sensor
  int maxValue = 0; // store max value here
  int minValue = 1024; // store min value here
  uint32_t start_time = millis();
  while ((millis() - start_time) < 50) //sample for 1 Sec
  {
    readValue = analogRead(A0);
    // see if you have a new maxValue
    if (readValue > maxValue)
    {
      /*record the maximum sensor value*/
      maxValue = readValue;
    }
    if (readValue < minValue)
    {
      /*record the maximum sensor value*/
      minValue = readValue;
    }
  }
  // Subtract min from max
  result = ((maxValue - minValue) * 5.0) / 1024.0;
  return result;
}

void getVOLT()
{
  Volt = getVPPvolt();
  VRMSvolt = (Volt / 2.0) * 0.707 * 489;
  if (VRMSvolt < 50) {
    VRMSvolt = 0;
  }
  Blynk.virtualWrite(V4, float(VRMSvolt));
}

// TARIK ARUS 1
void getACS712()
{
  Voltage = getVPP();
  VRMS = (Voltage / 2.0) * 0.707;
  AmpsRMS = (VRMS * 1000) / mVperAmp;
  I = AmpsRMS - 0.50;
  p1 = I * VRMSvolt * 0.85;
  if (p1 < 0) {
    p1 = 0;
  }

  Blynk.virtualWrite(V3, float(I));
  Blynk.virtualWrite(V9, float(p1));

}
// TARIK ARUS 2
void getACS712B()
{
  Voltage2 = getVPP1();
  VRMS2 = (Voltage2 / 2.0) * 0.707;
  AmpsRMS2 = (VRMS2 * 1000) / mVperAmp;
  I2 = AmpsRMS2 - 0.53;
  p2 = I2 * VRMSvolt * 0.85;
  if (p2 < 0)  {
    p2 = 0;
  }
  Blynk.virtualWrite(V5, float(I2));
  Blynk.virtualWrite(V8, float(p2));


}
// TARIK ARUS 3
void getACS712C()
{
  Voltage3 = getVPP2();
  VRMS3 = (Voltage3 / 2.0) * 0.707;
  AmpsRMS3 = (VRMS3 * 1000) / mVperAmp;
  I3 = AmpsRMS3 - 0.57;
  p3 = I3 * VRMSvolt * 0.85;
  if (p3 < 0)  {
    p3 = 0;
  }
  Blynk.virtualWrite(V6, float(I3));
  Blynk.virtualWrite(V7, float(p3));
}

bool isLargerThan(double first, double second) {
  return first > second;
}

void sortArray(double array[][2], size_t arraySize) {
  for (size_t i = 1; i < arraySize; i++) {
    for (size_t j = i; j > 0 && (isLargerThan(array[j - 1][0], array[j][0])); j--) {
      double tmp0 = array[j - 1][0];
      double tmp1 = array[j - 1][1];
      array[j - 1][0] = array[j][0];
      array[j - 1][1] = array[j][1];
      array[j][0] = tmp0;
      array[j][1] = tmp1;
    }
  }
}

uint8_t* getRelayOrder() {
  static uint8_t relay[3];
  double arrayList[3][2] = {{p1, relay1}, {p2, relay2}, {p3, relay3}};
  sortArray(arrayList, 3);
  for (int i = 0; i < 3; i++) relay[i] = arrayList[i][1];
  return relay;
}

void checkRelay() {
  uint8_t *relayPointer = getRelayOrder();
  if (VRMSvolt <= 200) {
    if (status == 1) {
      Blynk.run();
      digitalWrite(relay1, HIGH);
      digitalWrite(relay2, HIGH);
      digitalWrite(relay3, HIGH);
      status = 0;
    }
  } else {
    if (status == 0) {
      Blynk.run();
      digitalWrite(*relayPointer, LOW);
      delay(3000);
      digitalWrite(*relayPointer + sizeof(uint8_t), LOW);
      delay(3000);
      digitalWrite(*relayPointer + 2 * sizeof(uint8_t), LOW);
      delay(3000);
      status = 1;
    }
  }
}