How I Monitor Power

I'm using current transformers (200A) that clip around the main power lines coming into the house.  These feed one of the analog inputs to an Arduino Duemilanove.  I also sample the wall power level to give me a voltage reference and use a basic wall wart for power.  I added a Wishield for wifi since there is no network connection near the power panel.

Like a whole lot of people, my wireless gateway to the DSL line is way across the house in the opposite corner and wifi won't go that far.  So I recycled an old wireless router by turning it into an access point and mounted it as close to the power panel as I could; I already had a wired network connection in the garage just not close to where the power panel was.

Every couple of seconds the Arduino samples the power levels, calculates power and holds the values in variables.  I have a minimal web server running on the Arduino interfaced to the Wishield so I can get the power levels with an HTTP request.  However, the network connection turned out to be unreliable so I had to sample it locally and use an HTTP put to send the data to Pachube.com.  I have a laptop that runs the grab and forward software as a simple batch script running in a command window.

So, it's power panel to Arduino to wireless to laptop to gateway to Pachube.  Confused yet?  

I'm only serving comma separated values so they're easy to parse.  In order they are, real power, apparent power, power factor, rms current, rms voltage and frequency.  This makes it really easy to grab the data and forward it using a batch file.

Details on the Implementation

Somehow, I needed to measure the current flowing through the wires into the house.  There are a number of devices out there that can do this, but they're expensive, won't work on my house, inadequate or the company wouldn't respond to questions.  And yes, I did try to call them and even left messages.  But prowling the web looking at these devices I discovered a little component called the current transformer.

These things are a coil of wire that wraps around the wire and inductively measures the power flowing through a wire.  There are a ton of web descriptions of these devices so learning about them was relatively easy; finding one at a reasonable price was a different matter.  Finally, I found a nice device that would work at my house.  I have a 400 Amp service that splits into two 200 Amp distributions.  I'm currently only using half of it for 200 Amps but the wires leading to it are a little over a half inch in diameter.  I actually broke the first device I tried by forcing it over the wire.

Here are the two devices, one on each leg of the 240 split phase mains we have here in the US.  They were not hard to install; just clip them around the mains and run the wire out of the box.  There's very little risk of shock since the wires are insulated and you don't have to touch them to clip the CT (current transformer) around the wire.  They tended to slip down the wire so a couple of plastic ties hold them in place.

You can actually tie these in series, attach a multimeter and get a reasonable indication of the power usage by watching the voltage rise and fall as you turn on appliances.  The voltage output has to be compared against some standard before you actually know how much power you're using, but you can certainly tell they are working.

The CTs are available from ITeadStudio and usually have about a two week lead time.  Besides the 200 Amp version I used, there are other styles and ratings available.  Just be sure to get one big enough to go around the wire.

Most of my implementation was blatantly stolen from Trystan Lea.  Please visit his site at http://openenergymonitor.org/emon/ for an in-depth discussion of his ongoing implementation.  I took his Arduino code for power monitoring, modified it to work with two current transformers, and added network code to serve data based on a simple html request.  Trystan has single phase 240 power and didn’t need to consider using double CTs, but don’t worry, you simply tie the two of them in series if you have split phase 220.  My device hasn’t made it past the breadboard stage.  Why bother right now?  It works fine and I can get back to it anytime.

The transformer on the left is a 10V center taped step down to provide a reference for the AC mains.  The wires coming in the center are the outputs from the CTs and are tied in series.  I use the center connection of the CTs to calibrate a single CT; one has to do this only once in the beginning.  Yes, I know that the transformer could be used to power the Arduino, that will come in time, but for now…it works, don’t fix it.  The wire leaving the Arduino and looping up to the right is the Wifi antenna; I got the Wishield with the separate antenna to extend the range and prevent worrying about where I put the device.

My future plans for this device are to add screw terminals for the incoming wires, get power from the step down transformer removing the wall wart and solder the various parts down on a proto board to pretty it up.  Heck, someday I might actually mount it on a pretty plastic base instead of the piece of plywood I found.  I’ll never cover it up though since it’s too much fun to show off the circuitry.

Trystan’s site (http://openenergymonitor.org/emon/) has tons of details on how the measurements are made and links to the source he used.  Each implementation will have some nuance that will need adaptation though so use his work as a starting example; consider my work as a recreation and proof of concept.  But basically rapid measurements of the instantaneous voltage and current are squared, summed and averaged to get the Vrms and Irms.  These are used along with the power factor to get a fairly accurate measure of real power usage.  I simply combined this with a very simple web server to pass the data along.


Update March19, 2011:  I had a failure of a WiShield in the power display that I will detail on that page later, but this pointed out that I need to have a wireless communication path that has massive availability.  I chose XBee as the tool to use.  Since this entire set of projects is for saving power, I started with the power monitor.  After doing a bunch of work to enable the device to send over XBee radio I realized I had forgotten how I had built the darn thing.  So I reverse engineered my own device to get the schematic and am posting it here to help other folks and provide a reference for myself next time.

Simple isn't it?  Nothing but a couple of voltage sources and dividers to scale the values for the Arduino to read.

The Arduino Sketch #1

//Basic energy monitoring sketch plus kwh and frequency calc - by Trystan Lea
//Licenced under GNU General Public Licence more details here
// openenergymonitor.org
/*
 * Credits:
 * Most of the power measurement and calculations were invented by Trystan Lea and documented at
 * http://openenergymonitor.org/.  I modified it for the split phase 240 in residential use in the U.S.
 * I'm using a ladyada boot rom (purchased directly from her site) to overcome weak network problems
 * and multiple vulnerable arduinos.  A lot of the remaining code was taken from example sketches
 * supplied by the Arduino site www.arduino.cc
 *
 * Open source rules!
 * Dave Thompson
 */


//Sketch measures voltage and current.
//and then calculates useful values like real power,
//apparent power, powerfactor, Vrms, Irms, frequency and kwh.

#include <WiServer.h>
#include <avr/wdt.h>

#define WIRELESS_MODE_INFRA 1
#define WIRELESS_MODE_ADHOC 2

// Wireless configuration parameters ----------------------------------------
unsigned char local_ip[] = {192,168,0,200}; // IP address of WiShield
unsigned char gateway_ip[] = {192,168,0,1}; // router or gateway IP address
unsigned char subnet_mask[] = {255,255,255,0}; // subnet mask for the local network
PROGMEM const prog_char ssid[] = {"whatever"}; // max 32 bytes

unsigned char security_type = 1; // 0 - open; 1 - WEP; 2 - WPA; 3 - WPA2

// WPA/WPA2 passphrase
const prog_char security_passphrase[] PROGMEM = {"whatever"}; // max 64 characters

// WEP 128-bit keys
// sample HEX keys
prog_uchar wep_keys[] PROGMEM = { 0x11, 0x11, 0x11, 0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Key 0
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Key 1
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // Key 2
 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // Key 3
};

// setup the wireless mode
// infrastructure - connect to AP
// adhoc - connect to another WiFi device
unsigned char wireless_mode = WIRELESS_MODE_INFRA;

unsigned char ssid_len;
unsigned char security_passphrase_len;
// End of wireless configuration parameters ----------------------------------------


//Setup variables
int numberOfSamples = 3000;

//Set Voltage and current input pins
int inPinV = 4;
int inPinI = 5;

//Calibration coeficients
double VCAL = 0.592;
double ICAL = 03.2;
double PHASECAL = 0.1;

//Sample variables
int lastSampleV,lastSampleI,sampleV,sampleI;

//Filter variables
double lastFilteredV, lastFilteredI, filteredV, filteredI = 0;
double filterTemp;

//Stores the phase calibrated instantaneous voltage.
double calibratedV;

//Power calculation variables
double sqI,sqV,instP,sumI,sumV,sumP;

//Useful value variables
double realPower,
       apparentPower,
       powerFactor,
       Vrms,
       Irms;

#define NETTIMECHECK 120
long netTimeout = 0;  // counter to check for net activity    
    
  //--ENERGY MEASURMENT VARIABLES------------------------------
    //Calculation of kwh

    //time taken since last measurment timems = tmillis - ltmillis;
    unsigned long ltmillis, tmillis, timems;
    //time when arduino is switched on... is it 0?
    unsigned long startmillis;
  
    //kwhTotal is cumulative kwh today, the other 3 are historical over the last 3 days for comparison.
    double kwhTotal =0.0;
  //-----------------------------------------------------------

  //--FREQUENCY MEASURMENT VARIABLES---------------------------
    //time in microseconds when the voltage waveform
    //last crossed zero.
    unsigned long vLastZeroMsec;
    //Micro seconds since last zero-crossing
    unsigned long vPeriod;
    //Sum of vPeriod's to obtain an average.
    unsigned long vPeriodSum;
    //Number of periods summed
    unsigned long vPeriodCount;
  
    //Frequency
    float freq;
  
    //Used to filter out fringe vPeriod readings.
    //Configured for 50Hz
    //- If your 60Hz set expPeriod = 16666
    unsigned long expPeriod = 16666;
    unsigned long filterWidth = 2000;
  //-----------------------------------------------------------

// This is my page serving function that generates web pages
boolean sendMyPage(char* URL) {
    /* The assumption is that if the code got here, the network is alive.  However
        if too much time passes without someone requesting data, the network may
        have died.  Therefore, measure the time and after it passes set a watchdog
        to expire.  In this routine the timer will be reset and the main loop will
        set the watchdog.
    */
    netTimeout = millis();        // made it, reset the timer
    wdt_reset();                  // turn off the watchdog
    wdt_disable();                // and disable it just in case
    Serial.println("net request");

    // Check if the requested URL matches "/"
    if (strcmp(URL, "/") == 0) {
        WiServer.print(realPower);
        WiServer.print(", ");
        WiServer.print(apparentPower);
        WiServer.print(", ");
        WiServer.print(powerFactor);
        WiServer.print(", ");
        WiServer.print(Irms);
        WiServer.print(", ");
        WiServer.print(Vrms);
        WiServer.print(", ");
        WiServer.print(freq);
        // URL was recognized
        return true;
    }
    // URL not found
    return false;
}

/* Measurement calculations */

int PwrCalcs()
{
  for (int n=0; n<numberOfSamples; n++) // gather samples
  {

     //Used for offset removal
     lastSampleV=sampleV;
     lastSampleI=sampleI;
     // wireless server has to have some time to work
     WiServer.server_task();
     //Read in voltage and current samples.
     sampleV = analogRead(inPinV);
     sampleI = analogRead(inPinI);

     //Used for offset removal
     lastFilteredV = filteredV;
     lastFilteredI = filteredI;

     //Digital high pass filters to remove 2.5V DC offset.
     filteredV = 0.996 * (lastFilteredV+sampleV-lastSampleV);
     filteredI = 0.996 * (lastFilteredI+sampleI-lastSampleI);

     //Phase calibration goes here.
     calibratedV = lastFilteredV + PHASECAL * (filteredV - lastFilteredV);

     //Root-mean-square method voltage
     //1) square voltage values
     sqV= calibratedV * calibratedV;
     //2) sum
     sumV += sqV;

     //Root-mean-square method current
     //1) square current values
     sqI = filteredI * filteredI;
     //2) sum
     sumI += sqI;

     //Instantaneous Power
     instP = abs(calibratedV * filteredI);
     //Sum
     sumP += instP;

     //--FREQUENCY MEASURMENT---------------------------        
     if (n==0) vLastZeroMsec = micros();

     //Check for zero crossing from less than zero to more than zero
     if (lastFilteredV < 0 && filteredV >= 0 && n>1)
     {
       //period of voltage waveform
       vPeriod = micros() - vLastZeroMsec;

       //Filteres out any erronous period measurments
       //Increases accuracy considerably
       if (vPeriod > (expPeriod-filterWidth) && vPeriod<(expPeriod+filterWidth))
       {
          vPeriodSum += vPeriod;
          vPeriodCount++;
       }
       vLastZeroMsec = micros();
     }
  } //end of sample gathering

  //Calculation of the root of the mean of the voltage and current squared (rms)
  //Calibration coeficients applied.
  Vrms = VCAL*sqrt(sumV / numberOfSamples);
  Irms = ICAL*sqrt(sumI / numberOfSamples);

  //Calculation power values
  realPower = VCAL*ICAL*sumP / numberOfSamples;
  apparentPower = Vrms * Irms;
  powerFactor = realPower / apparentPower;

  //FREQUENCY CALCULATION--------------------------
  freq = (1000000.0 * vPeriodCount) / vPeriodSum;
    
  vPeriodSum=0;
  vPeriodCount=0;
  //------------------------------------------------

  //--ENERGY MEASURMENT CALCULATION----------------  
      
  //Calculate amount of time since last realpower measurment.
  ltmillis = tmillis;
  tmillis = millis();
  timems = tmillis - ltmillis;
    
  //Calculate number of kwh consumed.
  //kwhTotal = kwhTotal + ((realPower/1000.0) * 1.0/3600.0 * (timems/1000.0));

  //Output to serial
  Serial.print("RP=");
  Serial.print(realPower);
  Serial.print(" AP=");
  Serial.print(apparentPower);
  Serial.print(" PF=");
  Serial.print(powerFactor);
  Serial.print(" V=");
  Serial.print(Vrms);
  Serial.print(" I=");
  Serial.print(Irms);
  Serial.print(" KW=");
  Serial.print(kwhTotal);
  Serial.print(" F=");
  Serial.println(freq);

    //Reset accumulators
  sumV = 0;
  sumI = 0;
  sumP = 0;
}

void setup()
{
  
  Serial.begin(57600);
  Serial.println("Initialize web server");

  wdt_enable(WDTO_8S);          // I'm giving the network 8 seconds to set itself up
  // Initialize WiServer and have it use the sendMyPage function to serve pages
  WiServer.init(sendMyPage);
  // Enable Serial output and ask WiServer to generate log messages (optional)
  wdt_reset();                  // made it, turn off the watchdog until things start working
  wdt_disable();
  Serial.println("Enable webserver");
  WiServer.setIndicatorPins(5, 6);              //This could make it fun to monitor.
                                                //However, the Wishield uses 2,8,9,10,11,12,13
                                              
                                              

  //debug mode for webserver
  //WiServer.enableVerboseMode(true);

  netTimeout = millis();               // timer to make sure the net is active

  //--ENERGY MEASURMENT SETUP--------------------------------
  //Calculation of kwh
  tmillis = millis();
  startmillis=tmillis;
  //---------------------------------------------------------
}

void loop()
{
    // get power calcs into variables
  PwrCalcs();
  // Run WiServer
  WiServer.server_task();
  delay(100);
  if ((millis() - netTimeout) >= (NETTIMECHECK * 1000))  //has too much time passed?
  {
    wdt_enable(WDTO_8S);    // eight seconds from now the device will reboot
    Serial.println("net timeout, rebooting");
    while(1) {}
  }
}