Reactive Problems

Have you tried the ade9000 calibration xls? www.analog.com/.../ADE9000-Calibration-Tool.zip

If you can't provide the pf required for calibration, Try reading the angle register  average a bunch of reading and compare to the equipment you have. 

Pf -.94 = -19.948 deg 

Find the delta between your averaged angle measurement and the -19.948 deg this is the angle you need to compensate for. 

Dave

You should not need pgain if Igain and Vgain are calibrated correctly.

Hi dave,

We try excell too. 

When we use excel format pf change too much. AFter we do calibration with 0.88 pf, we measure pf 0.18 but normaly it will 0.8. 

#include <SPI.h>
#include <ADE9000RegMap.h>
#include <ADE9000API.h>
#include <math.h>
#include "arduinoFFT.h"
#include "EasyNextionLibrary.h"

/*Basic initializations*/
ADE9000Class ade9000;
#define SPI_SPEED 20000000 //SPI Speed
#define CS_PIN 5 //8-->Arduino Zero. 16-->ESP8266
#define ADE9000_RESET_PIN 27 //Reset Pin on HW
#define PM_1 26 //PM1 Pin: 4-->Arduino Zero. 15-->ESP8266

#define N 128 // Örneklem sayısı
#define SAMPLING_FREQ 6400 // Örnekleme frekansı (Hz)

arduinoFFT FFT = arduinoFFT();
//EasyNex myNex(Serial);

double real[N]; // Reel bileşen
double imag[N]; // Sanal bileşen
static double Veri[N];
double Frekans[N];
double Genlik[N];
double HGenlik[N];
double vReal[N]; //Real part of FFT array
double vImag[N]; //Imaginary part of FFT aray
static double VeriVC[512];
static double VeriVA[512];

//ESP32 Default SPI
//MOSI: 23
//MISO: 19
//SCK: 18
//SS: 5

/*Structure decleration */
struct CurrentRMSRegs curntRMSRegs; //Current RMS
struct VoltageRMSRegs vltgRMSRegs; //Voltage RMS
//struct VoltageTHDRegs voltageTHDRegsnValues; //Voltage THD
struct ResampledWfbData resampledData; // Resampled Data
struct ActivePowerRegs activePowerRegs;
struct ReactivePowerRegs reactivePowerRegs;
struct ApparentPowerRegs apparentPowerRegs;

struct PowerFactorRegs powerFactorRegs;
struct VoltageTHDRegs vltgthdRegs; //Value olarak ta alınabiliyor. Regs olarakta
struct CurrentTHDRegs curntThdRegs;//Value olarak ta alınabiliyor. Regs olarakta
struct PowerFactorRegs pfactorRegs;//Value olarak ta alınabiliyor. Regs olarakta
struct ResampledWfbData_harmonic resampledData_harmonic;
struct PeriodRegs prdRegs;
struct FundActivePowerRegs fndap;
struct FundReactivePowerRegs fndqp;
struct FundApparentPowerRegs fndsp;

/*Function Decleration*/
void readRegisterData(void);
void readResampledData(void);
void resetADE9000(void);
double harmonic_samples(double);

void setup() {
//myNex.begin(9600);
delay(2000);
Serial.begin(115200);
pinMode(PM_1, OUTPUT); //Set PM1 pin as output
digitalWrite(PM_1, LOW); //Set PM1 select pin low for PSM0 mode
pinMode(ADE9000_RESET_PIN, OUTPUT);
digitalWrite(ADE9000_RESET_PIN, HIGH);
void resetADE9000();
delay(1000);
ade9000.SPI_Init(SPI_SPEED,CS_PIN); //Initialize SPI
ade9000.SetupADE9000(); //Initialize ADE9000 registers according to values in ADE9000API.h
//ade9000.SPI_Write_16(ADDR_RUN,0x1); //Set RUN=1 to turn on DSP. Uncomment if SetupADE9000 function is not used
//Serial.print("RUN Register: ");
//Serial.println(ade9000.SPI_Read_16(ADDR_RUN),HEX);
delay(2000);
ade9000.SPI_Write_32(ADDR_AVGAIN,0x16C5C3);
ade9000.SPI_Write_32(ADDR_APHCAL0,0xF76DEE7A);
/*ade9000.SPI_Write_32(ADDR_AIGAIN,0xFFE77E9D);
ade9000.SPI_Write_32(ADDR_AVRMSOS,0x9E5E4D28);
ade9000.SPI_Write_32(ADDR_AIRMSOS,0x3DAEBDD4);
ade9000.SPI_Write_32(ADDR_AVFRMSOS,0x9FA58821);
ade9000.SPI_Write_32(ADDR_AIFRMSOS,0x3DBD997D); */
}

void loop() {

readRegisterData();

Serial.print("ADDR_AWATTHR_HI: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AWATTHR_HI),DEC);
Serial.print("ADDR_AVARHR_HI: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AVARHR_HI),DEC);
Serial.print("ADDR_AVRMS: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AVRMS),DEC);
Serial.print("ADDR_AIRMS: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AIRMS),DEC);
Serial.print("ADDR_AVFRMS: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AVFRMS),DEC);
Serial.print("ADDR_AFIRMS: ");
Serial.println(ade9000.SPI_Read_32(ADDR_AIFRMS),DEC);
float APFF = (pfactorRegs.PowerFactorReg_A*0.0000000074505805969);
Serial.print("A PF: ");
Serial.println(APFF);
delay(1000);
/*ade9000.SPI_Read_32(ADDR_AWATTHR_HI);
Serial.print("AWATTHR_HI ");
Serial.println(ADDR_AWATTHR_HI);*/
float AVTHDF = 0;
float BVTHDF = 0;
float CVTHDF = 0;

float AITHDF = 0;
float BITHDF = 0;
float CITHDF = 0;

float AVRMSF = 0;
float BVRMSF = 0;
float CVRMSF = 0;

float AIRMSF = 0;
float BIRMSF = 0;
float CIRMSF = 0;
float NIRMSF = 0;

float AAPF = 0;
float BAPF = 0;
float CAPF = 0;
float TAP = 0;

float ASPF=0;
float BSPF=0;
float CSPF=0;
float TSP=0;

float AQPF = 0;
float BQPF = 0;
float CQPF = 0;
float TQP = 0;

//float APFF = 0;
float BPFF = 0;
float CPFF = 0;

float LI = 0;
float LIA = 0;
float LIB = 0;
float LIC = 0;
float AFKayip = 0;
float BFKayip = 0;
float CFKayip = 0;
float TopFKayip =0;

float AHKayip = 0;
float BHKayip = 0;
float CHKayip = 0;
float TopHKayip =0;

AVRMSF = (vltgRMSRegs.VoltageRMSReg_A*(0.0000132940876766141)) ;
BVRMSF = (vltgRMSRegs.VoltageRMSReg_B*(0.0000132940876766141));
CVRMSF = (vltgRMSRegs.VoltageRMSReg_C*(0.0000132940876766141));

AIRMSF = (curntRMSRegs.CurrentRMSReg_A*(0.0000002032579885467));
BIRMSF = (curntRMSRegs.CurrentRMSReg_B*(0.0000002032579885467));
CIRMSF = (curntRMSRegs.CurrentRMSReg_C*(0.0000002032579885467));
NIRMSF = (curntRMSRegs.CurrentRMSReg_N*(0.0000002032579885467));

APFF = (pfactorRegs.PowerFactorReg_A*0.0000000074505805969);
BPFF = (pfactorRegs.PowerFactorReg_B*0.0000000074505805969);
CPFF = (pfactorRegs.PowerFactorReg_C*0.0000000074505805969);

AAPF = ((activePowerRegs.ActivePowerReg_A*0.0003626792564446720));
BAPF = (activePowerRegs.ActivePowerReg_B*0.0003626792564446720);
CAPF = (activePowerRegs.ActivePowerReg_C*0.0003626792564446720);
TAP = ((AAPF + BAPF + CAPF)/1000);
Serial.print("A Fazı Akım: ");
Serial.println(AIRMSF);
Serial.print("A Fazı Gerilim: ");
Serial.println(AVRMSF);
Serial.print("B Fazı Akım: ");
Serial.println(BIRMSF);
Serial.print("A Fazı Gerilim: ");
Serial.println(AVRMSF);
Serial.print("A Fazı PF: ");
Serial.println(APFF);
Serial.print("B Fazı PF: ");
Serial.println(BPFF);

float APFFF = (fndap.FundActivePowerReg_A*0.0003626792564446720);
Serial.print("A Fazı Aktif Güçfun: ");
Serial.println(APFFF);
float AQFFF = (fndqp.FundReactivePowerReg_A*0.0003626792564446720);
Serial.print("A Fazı Reaktif Fun Güçfun: ");
Serial.println(AQFFF);
float ASFFF = (fndsp.FundApparentPowerReg_A*0.0003626792564446720);
Serial.print("A Fazı Görünür Güçfun: ");
Serial.println(ASFFF);

Serial.print("A Fazı Aktif Güç: ");
Serial.println(AAPF);
Serial.print("B Fazı Aktif Güç: ");
Serial.println(BAPF);
Serial.print("C Fazı Aktif Güç: ");
Serial.println(CAPF);
AQPF = ((reactivePowerRegs.ReactivePowerReg_A*0.0003626792564446720));
BQPF = (reactivePowerRegs.ReactivePowerReg_B*0.0003626792564446720);
CQPF = (reactivePowerRegs.ReactivePowerReg_C*0.0003626792564446720);
TQP = ((AQPF + BQPF + CQPF)/1000);

Serial.print("A Fazı Reaktif Güç: ");
Serial.println(AQPF);
Serial.print("B Fazı Reaktif Güç: ");
Serial.println(BQPF);
Serial.print("C Fazı Reaktif Güç: ");
Serial.println(CQPF);

ASPF=(apparentPowerRegs.ApparentPowerReg_A*0.0003626792564446720);
BSPF=(apparentPowerRegs.ApparentPowerReg_B*0.0003626792564446720);
CSPF=(apparentPowerRegs.ApparentPowerReg_C*0.0003626792564446720);
TSP = ((ASPF + BSPF + CSPF)/1000);
Serial.print("A Fazı Görünür Güç: ");
Serial.println(ASPF);
Serial.print("B Fazı Görünür Güç: ");
Serial.println(BSPF);
Serial.print("C Fazı Görünür Güç: ");
Serial.println(CSPF);

AVTHDF = (vltgthdRegs.VoltageTHDReg_A*0.0000007450580596924);
BVTHDF = (vltgthdRegs.VoltageTHDReg_B*0.0000007450580596924);
CVTHDF = (vltgthdRegs.VoltageTHDReg_C*0.0000007450580596924);

AITHDF = (curntThdRegs.CurrentTHDReg_A*0.0000007450580596924);
BITHDF = (curntThdRegs.CurrentTHDReg_B*0.0000007450580596924);
CITHDF = (curntThdRegs.CurrentTHDReg_C*0.0000007450580596924);
float Freq = 0;
Freq = (prdRegs.FrequencyValue_C);
String Freqs= String (Freq,2);
delay(1000);
}

void readRegisterData()
{
/*Read and Print RMS & WATT Register using ADE9000 Read Library*/
ade9000.ReadVoltageRMSRegs(&vltgRMSRegs); //Template to read Power registers from ADE9000 and store data in Arduino MCU
ade9000.ReadCurrentRMSRegs(&curntRMSRegs);
ade9000.ReadActivePowerRegs(&activePowerRegs);
ade9000.ReadReactivePowerRegs(&reactivePowerRegs);
ade9000.ReadApparentPowerRegs(&apparentPowerRegs);
ade9000.ReadVoltageTHDRegsnValues(&vltgthdRegs);
ade9000.ReadCurrentTHDRegsnValues(&curntThdRegs);
ade9000.ReadPowerFactorRegsnValues(&pfactorRegs);
ade9000.ReadFundActivePowerRegs(&fndap);
ade9000.ReadFundReactivePowerRegs(&fndqp);
ade9000.ReadFundApparentPowerRegs(&fndsp);

}

void resetADE9000(void)
{
digitalWrite(ADE9000_RESET_PIN, LOW);
delay(50);
digitalWrite(ADE9000_RESET_PIN, HIGH);
delay(200);
Serial.println("Reset Done");
}