Blog

#include <EEPROM.h>
//Lets start by importing the necessary libraries to aid our code.
#include <SoftwareSerial.h> //Import library for using additional UART pins
//include a library to help communicate with the LCD via I2C
#include <LiquidCrystal_I2C.h>
//include a library for the PZEM module. note that it depends on UART in this case we sed a software serial to //define other pins as UART
#include <PZEM004Tv30.h>

//#define CAYENNE_DEBUG
#define CAYENNE_PRINT Serial
#include <CayenneMQTTESP8266.h>

//create and instance of the LiquidCrystal, this name will be use as a class to call all the functions of the lcd library
LiquidCrystal_I2C lcd(0x27, 20, 4);
//create an instance of the PZEM004Tv30 library, this name will be used to call the functions available in the pzem library.
//the pins of the UART is also declared
PZEM004Tv30 pzem(D2, D1); // (RX, TX) OF THE SOFTWARE-SERIAL

//create global variables to hold the values of parameters to be read from the module later in the program
// we declare these variables as float because they will hold floating poin numbers, that is numbers with decimal points
  float voltage;
  float current;
  float power;
  float energy;
  float frequency;
  float pf;

// WiFi network info.
char ssid[] = "XXXXXXXXXX";
char wifiPassword[] = "1234567890";

// Cayenne authentication info. This should be obtained from the Cayenne Dashboard.
char username[] = "00d420d0-cfbe-11eb-8779-7d56e82df461";
char password[] = "b72281be1c7d94c9d604963032cabbd20cedbcbd";
char clientID[] = "XXXXXXXXXXXXXXXXXXXXXXXXX";

unsigned long lastMillis = 0;
const int relay = D5;
float energy_unit = 0.00f;
int reset_state;
bool unit_flag = false;

void setup() {
  EEPROM.begin(512);
  EEPROM.get(1, energy_unit);
  pinMode(relay, OUTPUT);
  digitalWrite(relay, LOW);
  lcd.begin(D3,D4);  // set the 2 required pin for I2C(sda, scl) and initialize the lcd to start operation.
  // Turn on the blacklight and print a message.
  lcd.backlight();//turn on the lcd backlight
  lcd.setCursor(0,0);//set the coordinate for the lcd cursor. this is the point where the lcd start writing.
  lcd.print("Welcome, Miss Ada!");// ouput the text om the lcd screen
  Serial.begin(115200);// initialize UART protocol at a speed of 115200 baud rate.
	Cayenne.begin(username, password, clientID, ssid, wifiPassword);
  lcd.setCursor(0,1);
  lcd.print("Connected to:");
  lcd.setCursor(0,2);
  lcd.print(ssid);
  lcd.setCursor(0,3);
  //lcd.print("Connected to:");
  delay(3000);
  lcd.clear();
}

void loop() {
	Cayenne.loop();
 voltage = pzem.voltage();//request for the voltage reading and store it in out earlier declared volatge
    if( !isnan(voltage) ){//if the reading is  available, display it on cosole
        Serial.print("Voltage: "); Serial.print(voltage); Serial.println("V");
    } else {//if not availabe print an error message as below
        Serial.println("Error reading voltage");
    }
   current = pzem.current();
    if( !isnan(current) ){
        Serial.print("Current: "); Serial.print(current); Serial.println("A");
    } else {
        Serial.println("Error reading current");
    }

    power = pzem.power();
    if( !isnan(power) ){
        Serial.print("Power: "); Serial.print(power); Serial.println("W");
    } else {
        Serial.println("Error reading power");
    }

   energy = pzem.energy();
    if( !isnan(energy) ){
        Serial.print("Energy: "); Serial.print(energy,3); Serial.println("kWh");
    } else {
        Serial.println("Error reading energy");
    }

    frequency = pzem.frequency();
    if( !isnan(frequency) ){
        Serial.print("Frequency: "); Serial.print(frequency, 1); Serial.println("Hz");
    } else {
        Serial.println("Error reading frequency");
    }

    pf = pzem.pf();
    if( !isnan(pf) ){
        Serial.print("PF: "); Serial.println(pf);
    } else {
        Serial.println("Error reading power factor");
    }
   
    // the following lines tell the MCU to write the measured values on the lcd at designated coordinates
      // the following lines tell the MCU to write the measured values on the lcd at designated coordinates   
    
    lcd.setCursor(0,2);
    lcd.print("Energy:   Volt: Unit:");
    lcd.setCursor(0,3);   
    lcd.print(energy,4);
    lcd.print("kWH    ");
    lcd.setCursor(10,3);
    lcd.print(voltage,0);
    lcd.print("v   ");
    lcd.setCursor(16,3);
    lcd.print((energy_unit - energy), 2);
    lcd.print("");
    
    

    Serial.println();
    Serial.print("Remaining Energy unit is: ");
    Serial.println(energy_unit - energy);
    Serial.println(reset_state);

    if((energy_unit - energy) <= 0){
    digitalWrite(relay, LOW);
    lcd.setCursor(0,0);
    lcd.print("Out of Energy Quota!");
    lcd.setCursor(0,1);
    lcd.print("Contact Ada for More");
    }
    else{ 
    digitalWrite(relay, HIGH);
    lcd.setCursor(0,0);
    lcd.print("Power:  P.F:   Curr:");
    lcd.setCursor(0,1);
    lcd.print(power,1);
    lcd.print("W    ");
    lcd.setCursor(8,1);
    lcd.print(pf*100, 1);
    lcd.print("%    ");
    lcd.setCursor(14,1);
    lcd.print(current,3);
    lcd.print("A");
    lcd.print("");
    }
    if (unit_flag == true){
      EEPROM.put(1, energy_unit);
   if (EEPROM.commit()) {
      Serial.print("EEPROM successfully committed: ");
      Serial.println(EEPROM.get(1, energy_unit), 3);
      unit_flag = false;
    } else {
      Serial.println("ERROR! EEPROM commit failed");
    }
    }
    delay(1000);// wait 1 seconds before taking another reading.
    
}

CAYENNE_IN(8)
{
  int value = getValue.asInt();
  reset_state = value;
  CAYENNE_LOG("Channel %d, value %d", 8, value);
  // Write the value received to the digital pin.
  if(value == 1){
    pzem.resetEnergy();
    //value = 0;
  }
}
// Default function for sending sensor data at intervals to Cayenne.
// You can also use functions for specific channels, e.g CAYENNE_OUT(1) for sending channel 1 data.
CAYENNE_OUT_DEFAULT()
{
	// Write data to Cayenne here. This example just sends the current uptime in milliseconds on virtual channel 0.
	//Cayenne.virtualWrite(0, millis());
  Cayenne.virtualWrite(1, power);
  Cayenne.virtualWrite(2, energy);
  Cayenne.virtualWrite(3, frequency);
  Cayenne.virtualWrite(4, voltage);
  Cayenne.virtualWrite(5, current);
  Cayenne.virtualWrite(6, pf);
  Cayenne.virtualWrite(0, reset_state, TYPE_DIGITAL_SENSOR, UNIT_DIGITAL);
}

// This function is called when data is sent from Cayenne.
CAYENNE_IN(7)
{
  int value = getValue.asInt(); // 0 to 255
  CAYENNE_LOG("Channel %d, pin %d, value %d", 7, relay, value);
  // Write the value received to the PWM pin. analogWrite accepts a value from 0 to 255.
  energy_unit = value/1000.00;
  unit_flag = true;
}
// Default function for processing actuator commands from the Cayenne Dashboard.
// You can also use functions for specific channels, e.g CAYENNE_IN(1) for channel 1 commands.
CAYENNE_IN_DEFAULT()
{
	CAYENNE_LOG("Channel %u, value %s", request.channel, getValue.asString());
	//Process message here. If there is an error set an error message using getValue.setError(), e.g getValue.setError("Error message");
}