This post shows how to build a simple DIY single phase power meter station mainly based on Microchip PIC18F46K22 8-bit microcontroller.
Power quantities which are: Voltage, Current, Apparent Power, Active Power, Reactive Power, Frequency and Power Factor are printed on Nokia 5110 LCD screen as shown in the below images.

Theoretically, this DIY power station can measure electric currents up to 50 Amps and voltages up to 500V, this means it should work with home electric network (2-phase and 1-phase AC loads).
This circuit can measure positive and negative values of Active Power, Reactive Power and power Factor. A negative Active Power means that the power is transferred from the load to the source (reverse power), this occurs only when we have a real power source such as generator. A negative Reactive Power means that the power is transferred from the load to the source, this occurs when we have reactive power source such as capacitor.
CCS C Compiler is used in this project.

Hints:
No warranty is provided with this project, so do it at your own risk!
A part of project circuit may be subjected to a high voltage level which is very harmful to human body, so be-careful!

Abbreviations:
AC: Alternating Current
DC: Direct Current
TRMS: True Root Mean Square.
ADC: Analog-to-Digital Converter
CT: Current Transformer
VT: Voltage Transformer
PCB: Printed Circuit Board
DIY: Do It Yourself

Single phase power meter station with PIC18F46K22 MCU circuit:
Project circuit diagram is shown below (click on the image for full resolution view).

The main power source voltage of the circuit is 5V, it’s connected to J1 connector (5V Input connector) where pin 1 is negative (GND) and pin 2 is positive terminal.

Hardware required:
This is a summary of circuit required parts (circuit schematic diagram may contain some component parameters not mentioned below).

PIC18F46K22 microcontroller (U3) —> datasheet
Nokia 5110 LCD screen
Current-type voltage transformer 2mA/2mA (T1)
Current transformer with turns ratio 1000:1 (T2)
ADG609 analog multiplexer (U8) —> details
2 x OPA2191 op amp (U6, U7) —> details
MCP6V02 op amp (U5) —> details
MCP1501-20 2.048V voltage reference (U4) —> details
TPS60403 charge pump voltage inverter (U2) —> details
AMS1117-3.3 voltage regulator
3 x BAT54S dual serial small signal Schottky diode
2 x SMBJ3.3CA TVS diode
16MHz quartz crystal (Y1)
3 x 10uF capacitor (C2, C3, C4)
4 x 1uF capacitor (C1, C5, C6, C12)
15 x 100nF capacitor (C9, C10, C11, C13, C14, C15, C19, C20, C21, C22, C24, C29, C30, C31, C32)
22nF capacitor (C26)
6 x 10nF capacitor (C17, C18, C23, C25, C27, C28)
1nF capacitor (C16)
2 x 22pF capacitor (C7, C8)
1M Ohm resistor (R1)
2 x 200k Ohm resistor (R27, R43)
2 x 100k Ohm resistor (R36, R41)
2 x 80k Ohm resistor (R35, R40)
4 x 75k Ohm resistor (R19, R20, R22, R23)
6 x 20k Ohm resistor (R15, R17, R24, R28, R31, R39)
2 x 18k Ohm resistor (R33, R38)
7 x 10k Ohm resistor (R13, R14, R16, R25, R26, R29, R42)
7 x 2k Ohm resistor (R7, R8, R9, R10, R11, R30, R37)
5 x 1k Ohm resistor (R2, R3, R4, R5, R6)
300 Ohm resistor (R21)
2 x 100 Ohm resistor (R18, R32)
2 x 10 Ohm resistor (R12, R34)
1k Ohm ferrite bead (FB2)
120 Ohm ferrite bead (FB1)
5V source
Breadboard & jumper wires…
PIC MCU programmer (PICkit 3, PICkit 4 …)

Note for better accuracy that the following resistors should have a tolerance no more than 1%:

R19, R20, R22, R23 (75k) –> 0.25W Through hole resistors are recommended in order to handle voltage rating of 500V.
R21 (300R)
R16, R25, R29, R42 (10k)
R15, R24, R28, R39 (20k)
R27, R43 (200k)
R30, R37(2k)
R33, R38 (18k)
R35, R40 (80k)
R36, R41 (100k)
R34 (10R)

Circuit description:
The PIC18F46K22 microcontroller used in this project is a 40-pin 8-bit MCU supplied with 5V at VDD pins (#11 and #32). A Quartz crystal with frequency of 16MHz is used as an external clock source to the MCU, with the PLL enabled in the software the MCU becomes running at frequency of 16 x 4 = 64MHz.

As mentioned earlier, all power quantities are displayed on Nokia 5110 LCD screen. This display contains the PCD8544 controller, it is similar to the one used in Nokia 5110 mobile phone, it uses SPI interface protocol with maximum clock frequency of 4 MHz and requires 5 control pins.

The resolution of this LCD is 84 x 48 which means it has 4032 pixels. This module works with 3.3V only and it doesn’t support 5V (not 5V tolerant), this means interfacing it with 5V microcontroller such as the PIC18F46K22 MCU requires voltage level shifter.

To get a 3.3V supply I used the AMS1117 3.3 LDO regulator, it just gives a regulated 3.3V from the 5V input.
To connect the PIC18F46K22 data lines to the LCD module, I used voltage divider for each line. This means there are 5 voltage dividers, each one consists of 1k and 2k resistors, this drops control voltage from 5V into 3.3V.

Actually, choosing the values of voltage divider resistors depends on many factors such as: maximum frequency and input pin capacitance but 1k & 2k will do the job as it should be in our case, however, using a 3.3V microcontroller is recommended when dealing with 3.3V devices.

So, the Nokia 5110 LCD pins are connected to PIC18F46K22 MCU as follows (each one through voltage divider):
RST (reset) pin is connected to pin RC0 (#15),
CE (chip enable) pin is connected to pin RC1 (#16),
DC (data/command) pin is connected to pin RC2 (#17),
CLK (clock) pin is connected to pin RC3 (#18),
DIN (data in) pin is connected to pin RC5 (#24).

VCC and BL are connected to AMS1117-3V3 regulator output pin and GND is connected to circuit ground (0V).

ADC Voltage reference:
I used the MCP1501-20 high-precision buffered voltage reference from Microchip to get a precise voltage of 2.048V which is then used as a positive voltage reference for the PIC18F46K22 microcontroller ADC module and a bias voltage for voltage and current AC signals.
I also used 1 op amp of U5 (MCP6V02) as voltage follower to buffer the output voltage of the MCP1501-20.

Voltage signal conditioning circuit:
As we can not connect mains wires directly to the microcontroller due to the high voltage level, I used a small current-type voltage transformer labeled in the circuit schematic as T1. The full name of the one I’m using in this project is DL-PT202D with turns ratio of 1. The input of this transformer is current and the output is also current proportional to the input. I used 4 current limiting resistors (R19, R20, R22, R23) each of 75k to keep transformer input current under its rated one (2mA RMS) when it is subjected to 500V AC.
In order to handle 500V with no problem and for nice accuracy, the last 4 resistors should be a through hole type, 1/4W with tolerance of 0.1%.
With this transformer the high voltage circuit is galvanically isolated from low voltage circuit.

There are many alternatives to the voltage transformer that I’m using such as ZMPT112, any other replacement should have the same voltage rating (or higher) and ratio (2mA/2mA).
This type of transformers gives a significant safety factor to the circuit as it provide a galvanic isolation between the high voltage mains circuit and the low voltage control circuit which is in a direct contact with human body and other electronic equipments. They also have a small size, low cost and require few components.

A resistor of 300 Ohm (R21) is connected across the secondary of the voltage transformer, a voltage drop will be created across this resistor when an electric current passes through it.
With the created voltage, the MCU will be able to get voltage samples and also measure line frequency.

Current signal conditioning circuit:
As shown in project circuit schematic diagram above, the current transformer which noted as T2 has turns ratio of 1000/1, the secondary of the current transformer is connected to a shunt resistor with resistance of 10 Ohm (R34), this means at a load current of 50A AC the voltage generated across R34 will be: 50 x 10 / 1000 = 500 mV AC.

I used the ADG609 analog multiplexer from Analog Devices and OPA2191 op amp (U7) from Texas Instruments with some resistors to build a programmable gain amplifier with gains: 1, 2, 10 & 100 where we can change the gain through the ADG609 inputs A0 (pin #1) and A1 (pin #16). For example if A0 = A1 = LOW then the gain = 100, and so on.

The ADG609 analog multiplexer and the two OPA2191 op amp ICs (U6, U7) are powered with bipolar supply of voltage ±5V, I used the TPS60403 60mA charge pump voltage inverter from Texas Instruments to get -5V where it automatically generates a -5 V from the +5 V supply.

Another alternatives with pin compatible to the ADG609 are: ADG409 –datasheet– and ADG5409 –datasheet-, the best one is the ADG5409 since its typical ON resistance is low (13.5 Ohm), but according to device’s datasheet the ADG409 as well as the ADG5409 require dual supply with minimum voltage of ±9.

Resistor R35 & R40 have a resistance of a not well used value -80k Ohm-, we may connect two resistors in parallel to get 80k, for example in my DIY circuit I used 120k in parallel with 240k.
Note that for better accuracy all the PGA circuit resistors should have a tolerance of 0.1%. A tolerance of 1% can also be used but it will directly affects the accuracy of the measurements.

Single phase power meter with PIC18F46K22 MCU C code:
The C code below is for CCS C compiler, it was tested with version 5.112.
To be able to compile the C code with no error, a driver C file for Nokia 5110 LCD is required, download link is the one below. After the download just put the file in project folder:
NOKIA_LCD.c

Project microcontroller C code calculates average and RMS values of AC signals, the average value is just used in the RMS calculations. The MCU only shows the RMS values of mains voltage and load current on the LCD.

Simply the average (mean or DC offset) value in discrete-time is the sum of all sample values divided by number of samples:

and the RMS value in discrete-time domain can be calculated using the following equation:

The PIC18F46K22 microcontroller contains a 10-bit ADC module, with a positive voltage reference of 2.048 V, a 0 V is digitally represented by 0 and a 2.048 V is represented by 1023.

Programming hints:
As we have a 10-bit ADC module working in the range [0, 2.048V], the MCU makes 64 samples every 1 cycle for both Voltage and Current.

For a 50 Hz signal the period is 20 ms, the MCU takes one sample every 20000/64 = 312.5 us. I used CCP5 (Capture, Compare, PWM) module to start an ADC conversion every 312.5 us where the module is configured to use Timer5 for the compare operation, once the conversion is complete ADC interrupt saves the digital values on its corresponding array. The array element is incremented every new reading until the filling of all elements and completion of the cycle.

To measure voltage frequency I used PIC18F46K22 MCU internal analog comparator for zero crossing event detection and CCP4 with Timer3 for measuring the pulse widths and therefor line frequency. After every cycle CCP5 registers updated in order to adapt the new cycle period, number of samples which is 64 and ADC sampling frequency.

At all times the microcontroller automatically changes the gain of the PGA circuit according to the load current, if the load current is less than 0.5A the MCU sets the gain to 100, if the load current is between 0.5A & 5A then the MCU sets the gain to 10, if the current is between 5A & 25A then the MCU sets the gain to 10 and if the load current is higher than 25A the MCU sets the gain to 1.

Full CCS C code:

/**********************************************************************
  Single Phase power monitor station using PIC18F46K22 microcontroller.
  Power quantities are displayed on Nokia 5110 LCD screen.
  C Code for CCS C compiler.
  This is a free software with NO WARRANTY - Use it at your own risk!.
  http://simple-circuit.com/

 /**********************************************************************/

// define Nokia LCD module pin connections
#define LCD_RST  PIN_C0  // reset pin, optional!
#define LCD_CS   PIN_C1  // chip select pin
#define LCD_DC   PIN_C2  // data/command pin

// define programmable gain amplifier circuit control pins
#define PGA1  PIN_B0
#define PGA2  PIN_B1

// define CT burden resistor in Ohm (resistor connected across CT secondary)
#define CT_Burden  10

// define Voltage & Current correction factors (used as calibration factors)
#define Voltage_Correction  1.016
#define Current_Correction  1

#include <18F46K22.h>
#device ADC = 10
#fuses  NOMCLR,NOLVP,NOBROWNOUT,PUT,NOXINST
#use fast_io(B)
#use fast_io(C)
#use delay(XTAL = 16MHZ, CLOCK = 64MHZ)
#include <stdint.h>
#include <math.h>
#use SPI(SPI1, MODE = 0, BITS = 8, STREAM = LCD, FORCE_HW, BAUD=4000000)
#include <NOKIA_LCD.c>
// CCP5 registers (CCP5 used to trigger ADC module)
#byte CCPTMRS1 = getenv("SFR:CCPTMRS1")
#byte CCP5CON  = getenv("SFR:CCP5CON")
#byte CCPR5L   = getenv("SFR:CCPR5L")
#byte CCPR5H   = getenv("SFR:CCPR5H")
// CCP4 registers (CCP4 used to measure Voltage frequency)
#byte CCP4CON  = getenv("SFR:CCP4CON")
#byte CCPR4L   = getenv("SFR:CCPR4L")
#byte CCPR4H   = getenv("SFR:CCPR4H")

const uint8_t gain_table[4] = {100, 10, 2, 1};  // programmable gain amplifier gain values
const uint8_t n = 64;   // number of samples
uint8_t m  = 0,         // sample number ( 0 <= m < n)
        m1 = 0,         // used to specify the writing array (sample collecting and saving array)
        m2 = 0,         // used to specify the reading array
        dis = 0,        // variable for data display on LCD
        gain;           // variable for PGA s gain selection

struct PWR {
int16_t Samples[2*n];
uint16_t RMS, SamplesSum, Average;
};
struct PWR Voltage, Current;
int1 s_pwr = 0;  // a varibale to distinguish between Current & Voltage while
                 // performing ADC readings (used only in ADC ISR)

uint16_t ApparentPwr;
int16_t ActivePwr, ReactivePwr;
int8_t PwrFactor;

uint16_t period = 0, freq = 0, CCP5;
int1 ZC_Event = 0;  // if = 1 --> ZC event occured

// ADC ISR
#INT_AD 
void ADC_ISR(void) {
  if (m < n) {
    if(s_pwr) {
      Voltage.Samples[m1 + m] = read_adc(ADC_READ_ONLY);
      set_adc_channel(1);            // select AN1 channel (current sensing)
      Voltage.SamplesSum += Voltage.Samples[m1 + m];
      s_pwr = 0;
      m++;  // increment m for the next sample
    }
    else {
      Current.Samples[m1 + m] = read_adc(ADC_READ_ONLY) ;
      set_adc_channel(0);            // select AN0 channel (voltage sensing)
      Current.SamplesSum += Current.Samples[m1 + m];
      read_adc(ADC_START_ONLY) ;
      s_pwr = 1;
    }
  }
}

#INT_CCP4
void CCP4_ISR(void) {
  set_timer3(0);
  period = (uint16_t)CCPR4H << 8 | CCPR4L;
  ZC_Event = TRUE;
}
#INT_TIMER3
void TIMER3_ISR(void) {
  period = 40000;  // set line frequency to 50Hz (default frequency) --> Period = 40000/2 = 20ms
  ZC_Event = TRUE;
}

// gain set function
void gain_set(uint8_t g) {
  switch(g) {
    case 0:
      output_low(PGA1);
      output_low(PGA2);
      break;
    case 1:
      output_high(PGA1);
      output_low(PGA2);
      break;
    case 2:
      output_low(PGA1);
      output_high(PGA2);
      break;
    case 3:
      output_high(PGA1);
      output_high(PGA2);
  }
}

// main function
void main(void) {

  delay_ms(100);
  setup_adc(ADC_CLOCK_DIV_64 | ADC_TAD_MUL_2);   // set ADC module clock source to FOSC/64 = 1MHz
  // configure AN0 & AN1 pins as analog inputs & set voltage references to: VSS - VREF (external voltage reference)
  setup_adc_ports(sAN0 | sAN1, VSS_VREF);
  set_adc_channel(1);            // select AN1 channel
  // analog comparator 2 configuration (used for ZC event detection)
  setup_comparator(CP2_B3_A2 | CP2_OUT_ON_A5);
  // PGA pins
  output_drive(PGA1);
  output_drive(PGA2);
  // SPI pins
  output_drive(PIN_C3);  // SCK pin
  output_drive(PIN_C5);  // MOSI pin
  
  // initialize the LCD
  LCD_Init();
  // init done
  // you can change the contrast around (0 ... 63) to
  // adapt the display for the best viewing!
  LCD_SetContrast(50);
  // clear the whole LCD
  LCD_Clear();

  LCD_GotoXY(0,  0);  LCD_PrintC("V = 000.0V");
  LCD_GotoXY(0,  1);  LCD_PrintC("I = 00.00A");
  LCD_GotoXY(0,  2);  LCD_PrintC("S = 00.000kVA");
  LCD_GotoXY(0,  3);  LCD_PrintC("P = 00.000kW");
  LCD_GotoXY(0,  4);  LCD_PrintC("Q = 00.000kVAr");
  LCD_GotoXY(0,  5);  LCD_PrintC("00.00Hz | 0.00");

  enable_interrupts(GLOBAL);        // enable global interrupts
  
  // CCP5 configuration: -compare mode, Special Event Trigger
  //                     -Timer is reset & ADON is set
  CCP5CON  = 0x0B;
  CCPTMRS1 = 0x09;    // CCP5 – Capture/Compare modes use Timer5, PWM modes use Timer6
                      // CCP4 – Capture/Compare modes use Timer3, PWM modes use Timer4
  // initial configuration of signal period (assume 50Hz frequency)
  period = 40000;
  CCP5 = period / 8;
  CCPR5H   = CCP5 >> 8;    // set compare value, 5000 (0x1388) ==> 312.5 us @ FOSC/4 clk input
  CCPR5L   = CCP5;
  // CCP4 configuration
  CCP4CON  = 0x05;    // Capture mode: every rising edge
  
  // empty sample arrays
  for (uint8_t i = 0; i < 2*n; i++) {
    Voltage.Samples[i] = 0;
    Current.Samples[i] = 0;
  }
  Voltage.SamplesSum = 0;
  Current.SamplesSum = 0;
  
  // set up Timer5 (used by CCP5)
  set_timer5(0);
  setup_timer_5(T5_INTERNAL);  // Timer 5 clock source, FOSC/4 ==> 16MHz
  clear_interrupt(INT_AD);     // clear ADC interrupt flag bit
  enable_interrupts(INT_AD);   // enable ADC interrupt

  clear_interrupt(INT_CCP4);     // clear CCP4 interrupt flag bit
  enable_interrupts(INT_CCP4);   // enable CCP4 interrupt
  // set up Timer3 (used by CCP4)
  set_timer3(0);
  setup_timer_3(T3_INTERNAL | T3_DIV_BY_8);
  clear_interrupt(INT_TIMER3);     // clear Timer3 interrupt flag bit
  enable_interrupts(INT_TIMER3);   // enable Timer3 interrupt

  // gain initial configuration
  gain = 0;
  gain_set(gain);

  while (TRUE) {
    uint32_t ch_voltage = 0;  // variable for MCU analog input channel applied
                              // RMS voltage

    while (m < n) ;    // wait for 1 cycle to complete
    // toggle between reading & writing arrays
    if (m1 > 0) {
      m1 = 0;
      m2 = 64;
    }
    else {
      m1 = 64;
      m2 = 0;
    }

    Voltage.Average = Voltage.SamplesSum / n;
    Current.Average = Current.SamplesSum / n;
    Voltage.SamplesSum = 0;
    Current.SamplesSum = 0;

    while (!ZC_Event) ;   // wait for zero crossing event
    ZC_Event = FALSE;
    CCP5 = period / 8;
    CCPR5H   = CCP5 >> 8;    // update capture value according to the new cycle period
    CCPR5L   = CCP5;
    set_timer5(0);
    m = 0;

    // calculate current RMS value (Current.RMS)
    for ( uint8_t i = 0; i < n; i++ ) {
      Current.Samples[m2 + i] -= Current.Average ;
      Current.Samples[m2 + i] = Current.Samples[m2 + i] * Current_Correction ;
      uint16_t j = abs( Current.Samples[m2 + i] ) ;
      ch_voltage += (uint32_t)j * j ;
    }

    ch_voltage = ch_voltage / n;
    ch_voltage = sqrt(ch_voltage) * 100;  // 100.0 to get a more precise value
                                          // (2 significant digits after the decimal point)

    // calculate real RMS voltage applied to MCU analog channel (multiplied by 100)
    // 2 = 2048/1024 where 2048 is ADC +ive VREF = 2048 mV and 1024 is 10-bit ADC max digital value (aprroximately)
    // Note that this voltage is measured in milliVolts multiplied by 100 always
    ch_voltage = ch_voltage * 2 ;
    // calculate electric current passing through the CT, this result is also multiplied by 100
    Current.RMS = (ch_voltage / gain_table[gain]) / CT_Burden;
    // change gain if required
    if ( (Current.RMS > 50 && gain == 0) || (Current.RMS > 500 && gain == 1) || (Current.RMS > 2500 && gain == 2) ) {
      gain++;
      gain_set(gain);
    }
    if ( (Current.RMS < 2500 && gain == 3) || (Current.RMS < 500 && gain == 2) || (Current.RMS < 50 && gain == 1) ) {
      gain--;
      gain_set(gain);
    }

    // calculate voltage RMS value (Voltage.RMS)
    ch_voltage = 0;
    for ( uint8_t i = 0; i < n; i++ ) {
      Voltage.Samples[m2 + i] -= Voltage.Average ;
      Voltage.Samples[m2 + i] = Voltage.Samples[m2 + i] * Voltage_Correction ;
      uint16_t j = abs( Voltage.Samples[m2 + i] ) ;
      ch_voltage += (uint32_t)j * j ;
    }

    ch_voltage = ch_voltage / n;
    ch_voltage = sqrt(ch_voltage) * 100;  // 100 to get a more precise value
                                          // (2 significant digit after the decimal point)

    // calculate real RMS voltage applied to MCU analog channel (multiplied by 100)
    // 2 = 2048/1024 where 2048 is ADC +ive VREF = 2048 mV and 1024 is 10-bit ADC max digital value (aprroximately)
    // Note that this voltage is measured in milliVolts multiplied by 100 always, this is also the voltage
    // under measure (x100)
    Voltage.RMS = ch_voltage * 2 ;
    if (Voltage.RMS < 5000) {  // if the RMS Voltage < 50.00V --> set it to 0
      Voltage.RMS = 0;
    }
    
    // calculate cycle average Active Power
    int32_t I_V_Product = 0;
    for (uint8_t i = 0; i < n; i++) {
      I_V_Product += (int32_t)Voltage.Samples[m2 + i] * Current.Samples[m2 + i] ;
    }
    I_V_Product /= n;
    // 4 is just 2x2 that comes from ADC +ive VREF for both voltage & current
    ActivePwr = ((I_V_Product * 4)/gain_table[gain]) / CT_Burden;
    
    // calculate cycle average Reactive Power
    I_V_Product = 0;
    for (uint8_t i = 0; i < n; i++) {
      uint8_t ii = (i + 16) % 64 ;
      I_V_Product += (int32_t)Voltage.Samples[m2 + i] * Current.Samples[m2 + ii] ;
    }
    I_V_Product /= n;
    // 4 is just 2x2 that comes from ADC +ive VREF for both voltage & current
    ReactivePwr = ((I_V_Product * 4)/gain_table[gain]) / CT_Burden;
    
    // calculate cycle Apparent Power
    // 10000 = 100x100 as both V & I quantities were each previously multiplied by 100
    ApparentPwr = (uint32_t)Voltage.RMS * Current.RMS / 10000;
    
    // calculate cycle Power Factor
    // 100 is used to get two significant digits after the decimal point
    PwrFactor = ((int32_t)ActivePwr * 100) / ApparentPwr;
    
    // calculate cycle Frequency // here 'period' is cycle period multiplied by 2 (in us) --> see Timer3 configurtion
    // 1000000 to go from us to s // 200 = 2 x 100: 100 to get two significant digits after the decimal point
    freq = (1000000 * 200) / period;

    dis++;    // increment the display variable
    if ( dis > 24) {   // display data on LCD every about 500ms for 50Hz network (25 x 20ms)
      
      dis = 0;
      
      // voltage print
      LCD_GotoXY(24, 0);
      printf( LCD_PrintC, "%03Lu.%u", Voltage.RMS / 100, (uint8_t)((Voltage.RMS/10) % 10) );
      // current print
      LCD_GotoXY(24, 1);
      printf( LCD_PrintC, "%02u.%02u", (uint8_t)(Current.RMS / 100), (uint8_t)(Current.RMS % 100) );
      
      // Apparent power
      LCD_GotoXY(24, 2);
      printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)(ApparentPwr / 1000), (uint16_t)(ApparentPwr % 1000) );
      // Active power
      LCD_GotoXY(18, 3);
      if (ActivePwr < 0) {
        LCD_PrintC("-");
        ActivePwr = abs(ActivePwr);
      }
      else
        LCD_PrintC(" ");
      printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)((ActivePwr / 1000) % 100), (uint16_t)(ActivePwr % 1000) );
      // Reactive power
      LCD_GotoXY(18, 4);
      if (ReactivePwr < 0) {
        LCD_PrintC("-");
        ReactivePwr = abs(ReactivePwr);
      }
      else
        LCD_PrintC(" ");
      printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)((ReactivePwr / 1000) % 100), (uint16_t)(ReactivePwr % 1000) );
      // Frequency
      LCD_GotoXY(0, 5);
      printf(LCD_PrintC, "%02u.%02u", (uint8_t)((freq / 100) % 100), (uint8_t)(freq % 100) );
      // Power factor
      LCD_GotoXY(54, 5);
      if (PwrFactor < 0) {
        LCD_PrintC("-");
        PwrFactor = abs( PwrFactor );
      }
      else
        LCD_PrintC(" ");
      printf(LCD_PrintC, "%u.%02u", (PwrFactor / 100) % 10, PwrFactor % 100 );

    }

  }
}

// end of code.

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

230

231

232

233

234

235

236

237

238

239

240

241

242

243

244

245

246

247

248

249

250

251

252

253

254

255

256

257

258

259

260

261

262

263

264

265

266

267

268

269

270

271

272

273

274

275

276

277

278

279

280

281

282

283

284

285

286

287

288

289

290

291

292

293

294

295

296

297

298

299

300

301

302

303

304

305

306

307

308

309

310

311

312

313

314

315

316

317

318

319

320

321

322

323

324

325

326

327

328

329

330

331

332

333

334

335

336

337

338

339

340

341

342

343

344

345

346

347

348

349

350

351

352

353

354

355

356

357

/**********************************************************************

Single Phase power monitor station using PIC18F46K22 microcontroller.

Power quantities are displayed on Nokia 5110 LCD screen.

C Code for CCS C compiler.

This is a free software with NO WARRANTY - Use it at your own risk!.

http://simple-circuit.com/

/**********************************************************************/

// define Nokia LCD module pin connections

#define LCD_RST PIN_C0 // reset pin, optional!

#define LCD_CS PIN_C1 // chip select pin

#define LCD_DC PIN_C2 // data/command pin

// define programmable gain amplifier circuit control pins

#define PGA1 PIN_B0

#define PGA2 PIN_B1

// define CT burden resistor in Ohm (resistor connected across CT secondary)

#define CT_Burden 10

// define Voltage & Current correction factors (used as calibration factors)

#define Voltage_Correction 1.016

#define Current_Correction 1

#include <18F46K22.h>

#device ADC = 10

#fuses NOMCLR,NOLVP,NOBROWNOUT,PUT,NOXINST

#use fast_io(B)

#use fast_io(C)

#use delay(XTAL = 16MHZ, CLOCK = 64MHZ)

#include <stdint.h>

#include <math.h>

#use SPI(SPI1, MODE = 0, BITS = 8, STREAM = LCD, FORCE_HW, BAUD=4000000)

#include <NOKIA_LCD.c>

// CCP5 registers (CCP5 used to trigger ADC module)

#byte CCPTMRS1 = getenv("SFR:CCPTMRS1")

#byte CCP5CON = getenv("SFR:CCP5CON")

#byte CCPR5L = getenv("SFR:CCPR5L")

#byte CCPR5H = getenv("SFR:CCPR5H")

// CCP4 registers (CCP4 used to measure Voltage frequency)

#byte CCP4CON = getenv("SFR:CCP4CON")

#byte CCPR4L = getenv("SFR:CCPR4L")

#byte CCPR4H = getenv("SFR:CCPR4H")

const uint8_t gain_table[4] = {100, 10, 2, 1}; // programmable gain amplifier gain values

const uint8_t n = 64; // number of samples

uint8_t m = 0, // sample number ( 0 <= m < n)

m1 = 0, // used to specify the writing array (sample collecting and saving array)

m2 = 0, // used to specify the reading array

dis = 0, // variable for data display on LCD

gain; // variable for PGA s gain selection

struct PWR {

int16_t Samples[2*n];

uint16_t RMS, SamplesSum, Average;

};

struct PWR Voltage, Current;

int1 s_pwr = 0; // a varibale to distinguish between Current & Voltage while

// performing ADC readings (used only in ADC ISR)

uint16_t ApparentPwr;

int16_t ActivePwr, ReactivePwr;

int8_t PwrFactor;

uint16_t period = 0, freq = 0, CCP5;

int1 ZC_Event = 0; // if = 1 --> ZC event occured

// ADC ISR

#INT_AD

void ADC_ISR(void) {

if (m < n) {

if(s_pwr) {

Voltage.Samples[m1 + m] = read_adc(ADC_READ_ONLY);

set_adc_channel(1); // select AN1 channel (current sensing)

Voltage.SamplesSum += Voltage.Samples[m1 + m];

s_pwr = 0;

m++; // increment m for the next sample

}

else {

Current.Samples[m1 + m] = read_adc(ADC_READ_ONLY) ;

set_adc_channel(0); // select AN0 channel (voltage sensing)

Current.SamplesSum += Current.Samples[m1 + m];

read_adc(ADC_START_ONLY) ;

s_pwr = 1;

}

#INT_CCP4

void CCP4_ISR(void) {

set_timer3(0);

period = (uint16_t)CCPR4H << 8 | CCPR4L;

ZC_Event = TRUE;

}

#INT_TIMER3

void TIMER3_ISR(void) {

period = 40000; // set line frequency to 50Hz (default frequency) --> Period = 40000/2 = 20ms

ZC_Event = TRUE;

}

// gain set function

void gain_set(uint8_t g) {

switch(g) {

case 0:

output_low(PGA1);

output_low(PGA2);

break;

case 1:

output_high(PGA1);

output_low(PGA2);

break;

case 2:

output_low(PGA1);

output_high(PGA2);

break;

case 3:

output_high(PGA1);

output_high(PGA2);

}

// main function

void main(void) {

delay_ms(100);

setup_adc(ADC_CLOCK_DIV_64 | ADC_TAD_MUL_2); // set ADC module clock source to FOSC/64 = 1MHz

// configure AN0 & AN1 pins as analog inputs & set voltage references to: VSS - VREF (external voltage reference)

setup_adc_ports(sAN0 | sAN1, VSS_VREF);

set_adc_channel(1); // select AN1 channel

// analog comparator 2 configuration (used for ZC event detection)

setup_comparator(CP2_B3_A2 | CP2_OUT_ON_A5);

// PGA pins

output_drive(PGA1);

output_drive(PGA2);

// SPI pins

output_drive(PIN_C3); // SCK pin

output_drive(PIN_C5); // MOSI pin

// initialize the LCD

LCD_Init();

// init done

// you can change the contrast around (0 ... 63) to

// adapt the display for the best viewing!

LCD_SetContrast(50);

// clear the whole LCD

LCD_Clear();

LCD_GotoXY(0, 0); LCD_PrintC("V = 000.0V");

LCD_GotoXY(0, 1); LCD_PrintC("I = 00.00A");

LCD_GotoXY(0, 2); LCD_PrintC("S = 00.000kVA");

LCD_GotoXY(0, 3); LCD_PrintC("P = 00.000kW");

LCD_GotoXY(0, 4); LCD_PrintC("Q = 00.000kVAr");

LCD_GotoXY(0, 5); LCD_PrintC("00.00Hz | 0.00");

enable_interrupts(GLOBAL); // enable global interrupts

// CCP5 configuration: -compare mode, Special Event Trigger

// -Timer is reset & ADON is set

CCP5CON = 0x0B;

CCPTMRS1 = 0x09; // CCP5 – Capture/Compare modes use Timer5, PWM modes use Timer6

// CCP4 – Capture/Compare modes use Timer3, PWM modes use Timer4

// initial configuration of signal period (assume 50Hz frequency)

period = 40000;

CCP5 = period / 8;

CCPR5H = CCP5 >> 8; // set compare value, 5000 (0x1388) ==> 312.5 us @ FOSC/4 clk input

CCPR5L = CCP5;

// CCP4 configuration

CCP4CON = 0x05; // Capture mode: every rising edge

// empty sample arrays

for (uint8_t i = 0; i < 2*n; i++) {

Voltage.Samples[i] = 0;

Current.Samples[i] = 0;

}

Voltage.SamplesSum = 0;

Current.SamplesSum = 0;

// set up Timer5 (used by CCP5)

set_timer5(0);

setup_timer_5(T5_INTERNAL); // Timer 5 clock source, FOSC/4 ==> 16MHz

clear_interrupt(INT_AD); // clear ADC interrupt flag bit

enable_interrupts(INT_AD); // enable ADC interrupt

clear_interrupt(INT_CCP4); // clear CCP4 interrupt flag bit

enable_interrupts(INT_CCP4); // enable CCP4 interrupt

// set up Timer3 (used by CCP4)

set_timer3(0);

setup_timer_3(T3_INTERNAL | T3_DIV_BY_8);

clear_interrupt(INT_TIMER3); // clear Timer3 interrupt flag bit

enable_interrupts(INT_TIMER3); // enable Timer3 interrupt

// gain initial configuration

gain = 0;

gain_set(gain);

while (TRUE) {

uint32_t ch_voltage = 0; // variable for MCU analog input channel applied

// RMS voltage

while (m < n) ; // wait for 1 cycle to complete

// toggle between reading & writing arrays

if (m1 > 0) {

m1 = 0;

m2 = 64;

}

else {

m1 = 64;

m2 = 0;

}

Voltage.Average = Voltage.SamplesSum / n;

Current.Average = Current.SamplesSum / n;

Voltage.SamplesSum = 0;

Current.SamplesSum = 0;

while (!ZC_Event) ; // wait for zero crossing event

ZC_Event = FALSE;

CCP5 = period / 8;

CCPR5H = CCP5 >> 8; // update capture value according to the new cycle period

CCPR5L = CCP5;

set_timer5(0);

m = 0;

// calculate current RMS value (Current.RMS)

for ( uint8_t i = 0; i < n; i++ ) {

Current.Samples[m2 + i] -= Current.Average ;

Current.Samples[m2 + i] = Current.Samples[m2 + i] * Current_Correction ;

uint16_t j = abs( Current.Samples[m2 + i] ) ;

ch_voltage += (uint32_t)j * j ;

}

ch_voltage = ch_voltage / n;

ch_voltage = sqrt(ch_voltage) * 100; // 100.0 to get a more precise value

// (2 significant digits after the decimal point)

// calculate real RMS voltage applied to MCU analog channel (multiplied by 100)

// 2 = 2048/1024 where 2048 is ADC +ive VREF = 2048 mV and 1024 is 10-bit ADC max digital value (aprroximately)

// Note that this voltage is measured in milliVolts multiplied by 100 always

ch_voltage = ch_voltage * 2 ;

// calculate electric current passing through the CT, this result is also multiplied by 100

Current.RMS = (ch_voltage / gain_table[gain]) / CT_Burden;

// change gain if required

if ( (Current.RMS > 50 && gain == 0) || (Current.RMS > 500 && gain == 1) || (Current.RMS > 2500 && gain == 2) ) {

gain++;

gain_set(gain);

}

if ( (Current.RMS < 2500 && gain == 3) || (Current.RMS < 500 && gain == 2) || (Current.RMS < 50 && gain == 1) ) {

gain--;

gain_set(gain);

}

// calculate voltage RMS value (Voltage.RMS)

ch_voltage = 0;

for ( uint8_t i = 0; i < n; i++ ) {

Voltage.Samples[m2 + i] -= Voltage.Average ;

Voltage.Samples[m2 + i] = Voltage.Samples[m2 + i] * Voltage_Correction ;

uint16_t j = abs( Voltage.Samples[m2 + i] ) ;

ch_voltage += (uint32_t)j * j ;

}

ch_voltage = ch_voltage / n;

ch_voltage = sqrt(ch_voltage) * 100; // 100 to get a more precise value

// (2 significant digit after the decimal point)

// calculate real RMS voltage applied to MCU analog channel (multiplied by 100)

// 2 = 2048/1024 where 2048 is ADC +ive VREF = 2048 mV and 1024 is 10-bit ADC max digital value (aprroximately)

// Note that this voltage is measured in milliVolts multiplied by 100 always, this is also the voltage

// under measure (x100)

Voltage.RMS = ch_voltage * 2 ;

if (Voltage.RMS < 5000) { // if the RMS Voltage < 50.00V --> set it to 0

Voltage.RMS = 0;

}

// calculate cycle average Active Power

int32_t I_V_Product = 0;

for (uint8_t i = 0; i < n; i++) {

I_V_Product += (int32_t)Voltage.Samples[m2 + i] * Current.Samples[m2 + i] ;

}

I_V_Product /= n;

// 4 is just 2x2 that comes from ADC +ive VREF for both voltage & current

ActivePwr = ((I_V_Product * 4)/gain_table[gain]) / CT_Burden;

// calculate cycle average Reactive Power

I_V_Product = 0;

for (uint8_t i = 0; i < n; i++) {

uint8_t ii = (i + 16) % 64 ;

I_V_Product += (int32_t)Voltage.Samples[m2 + i] * Current.Samples[m2 + ii] ;

}

I_V_Product /= n;

// 4 is just 2x2 that comes from ADC +ive VREF for both voltage & current

ReactivePwr = ((I_V_Product * 4)/gain_table[gain]) / CT_Burden;

// calculate cycle Apparent Power

// 10000 = 100x100 as both V & I quantities were each previously multiplied by 100

ApparentPwr = (uint32_t)Voltage.RMS * Current.RMS / 10000;

// calculate cycle Power Factor

// 100 is used to get two significant digits after the decimal point

PwrFactor = ((int32_t)ActivePwr * 100) / ApparentPwr;

// calculate cycle Frequency // here 'period' is cycle period multiplied by 2 (in us) --> see Timer3 configurtion

// 1000000 to go from us to s // 200 = 2 x 100: 100 to get two significant digits after the decimal point

freq = (1000000 * 200) / period;

dis++; // increment the display variable

if ( dis > 24) { // display data on LCD every about 500ms for 50Hz network (25 x 20ms)

dis = 0;

// voltage print

LCD_GotoXY(24, 0);

printf( LCD_PrintC, "%03Lu.%u", Voltage.RMS / 100, (uint8_t)((Voltage.RMS/10) % 10) );

// current print

LCD_GotoXY(24, 1);

printf( LCD_PrintC, "%02u.%02u", (uint8_t)(Current.RMS / 100), (uint8_t)(Current.RMS % 100) );

// Apparent power

LCD_GotoXY(24, 2);

printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)(ApparentPwr / 1000), (uint16_t)(ApparentPwr % 1000) );

// Active power

LCD_GotoXY(18, 3);

if (ActivePwr < 0) {

LCD_PrintC("-");

ActivePwr = abs(ActivePwr);

}

else

LCD_PrintC(" ");

printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)((ActivePwr / 1000) % 100), (uint16_t)(ActivePwr % 1000) );

// Reactive power

LCD_GotoXY(18, 4);

if (ReactivePwr < 0) {

LCD_PrintC("-");

ReactivePwr = abs(ReactivePwr);

}

else

LCD_PrintC(" ");

printf(LCD_PrintC, "%02u.%03Lu", (uint8_t)((ReactivePwr / 1000) % 100), (uint16_t)(ReactivePwr % 1000) );

// Frequency

LCD_GotoXY(0, 5);

printf(LCD_PrintC, "%02u.%02u", (uint8_t)((freq / 100) % 100), (uint8_t)(freq % 100) );

// Power factor

LCD_GotoXY(54, 5);

if (PwrFactor < 0) {

LCD_PrintC("-");

PwrFactor = abs( PwrFactor );

}

else

LCD_PrintC(" ");

printf(LCD_PrintC, "%u.%02u", (PwrFactor / 100) % 10, PwrFactor % 100 );

}

// end of code.

The following small video shows my DIY circuit for this project:

When a capacitive load is connected to the circuit the load then works as a reactive power source and the LCD will show the reactive power value with negative sign as shown below (-479 VAr):

The current transformer (CT) I used in this project is shown below:

Single Phase Power Monitor with PIC18F46K22 Microcontroller

Leave a Comment Cancel Reply

Related Posts

Leave a Comment Cancel Reply