Add readPowerFactor

Author: PaulZC

examples/Example5_ReadVoltageCurrentPowerRMS/Example5_ReadVoltageCurrentPowerRMS.ino

@@ -0,0 +1,85 @@
+/*
+  Library for the Allegro MicroSystems ACS37800 power monitor IC
+  By: Paul Clark
+  SparkFun Electronics
+  Date: December 4th, 2021
+  License: please see LICENSE.md for details
+
+  Feel like supporting our work? Buy a board from SparkFun!
+  https://www.sparkfun.com/products/17873
+*/
+
+#include "SparkFun_ACS37800_Arduino_Library.h" // Click here to get the library: http://librarymanager/All#SparkFun_ACS37800
+#include <Wire.h>
+
+ACS37800 mySensor; //Create an object of the ACS37800 class
+
+void setup()
+{
+  Serial.begin(115200);
+  Serial.println(F("ACS37800 Example"));
+
+  Wire.begin();
+
+  //mySensor.enableDebugging(); // Uncomment this line to print useful debug messages to Serial
+
+  //Initialize sensor using default I2C address
+  if (mySensor.begin() == false)
+  {
+    Serial.print(F("ACS37800 not detected. Check connections and I2C address. Freezing..."));
+    while (1)
+      ; // Do nothing more
+  }
+
+  // From the ACS37800 datasheet:
+  // CONFIGURING THE DEVICE FOR AC APPLICATIONS : DYNAMIC CALCULATION OF N
+  // Set bypass_n_en = 0 (default). This setting enables the device to
+  // dynamically calculate N based off the voltage zero crossings.
+  mySensor.setBypassNenable(false, true); // Disable bypass_n in shadow memory and eeprom
+
+  // We need to connect the LO pin to the 'low' side of the AC source.
+  // So we need to set the divider resistance to 4M Ohms (instead of 2M).
+  mySensor.setDividerRes(4000000);
+}
+
+void loop()
+{
+  float volts = 0.0;
+  float amps = 0.0;
+
+  mySensor.readRMS(&volts, &amps); // Read the RMS voltage and current
+  Serial.print(F("Volts: "));
+  Serial.print(volts, 2);
+  Serial.print(F(" Amps: "));
+  Serial.println(amps, 2);
+
+  float pactive = 0.0;
+  float preactive = 0.0;
+  
+  mySensor.readPowerActiveReactive(&pactive, &preactive); // Read the active and reactive power
+  Serial.print(F("Power: Active (W): "));
+  Serial.print(pactive, 2);
+  Serial.print(F(" Reactive (VAR): "));
+  Serial.println(preactive, 2);
+  
+  float papparent = 0.0;
+  float pfactor = 0.0;
+  bool posangle = 0;
+  bool pospf = 0;
+  
+  mySensor.readPowerFactor(&papparent, &pfactor, &posangle, &pospf); // Read the apparent power and the power factor
+  Serial.print(F("Power: Apparent (VA): "));
+  Serial.print(papparent, 2);
+  Serial.print(F(" Power Factor: "));
+  Serial.print(pfactor, 2);
+  if (posangle)
+    Serial.print(F(" Lagging"));
+  else
+    Serial.print(F(" Leading"));
+  if (pospf)
+    Serial.println(F(" Consumed"));
+  else
+    Serial.println(F(" Generated"));
+  
+  delay(250);
+}

keywords.txt

@@ -40,7 +40,8 @@ setBypassNenable	KEYWORD2
 getBypassNenable	KEYWORD2
 getCurrentCoarseGain	KEYWORD2
 readRMS	KEYWORD2
-readRMSActiveReactive	KEYWORD2
+readPowerActiveReactive	KEYWORD2
+readPowerFactor
 readInstantaneous	KEYWORD2
 readErrorFlags	KEYWORD2
 setSenseRes	KEYWORD2

src/SparkFun_ACS37800_Arduino_Library.cpp

@@ -592,7 +592,7 @@ ACS37800ERR ACS37800::readRMS(float *vRMS, float *iRMS)
 }
 
 // Read volatile register 0x21. Return the pactive and pimag.
-ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
+ACS37800ERR ACS37800::readPowerActiveReactive(float *pActive, float *pReactive)
 {
   ACS37800_REGISTER_21_t store;
   ACS37800ERR error = readRegister(&store.data.all, ACS37800_REGISTER_VOLATILE_21); // Read register 21
@@ -601,7 +601,7 @@ ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
   {
     if (_printDebug == true)
     {
-      _debugPort->print(F("readRMSActiveReactive: readRegister (21) returned: "));
+      _debugPort->print(F("readPowerActiveReactive: readRegister (21) returned: "));
       _debugPort->println(error);
     }
     return (error); // Bail
@@ -628,9 +628,9 @@ ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
   float power = (float)signedUnsigned.Signed;
   if (_printDebug == true)
   {
-    _debugPort->print(F("readRMSActiveReactive: pactive: 0x"));
+    _debugPort->print(F("readPowerActiveReactive: pactive: 0x"));
     _debugPort->println(signedUnsigned.unSigned, HEX);
-    _debugPort->print(F("readRMSActiveReactive: pactive (LSB, before correction) is "));
+    _debugPort->print(F("readPowerActiveReactive: pactive (LSB, before correction) is "));
     _debugPort->println(power);
   }
   float LSBpermW = 3.08; // LSB per mW
@@ -643,12 +643,12 @@ ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
   power /= 1000; // Convert from mW to W
   if (_printDebug == true)
   {
-    _debugPort->print(F("readRMSActiveReactive: pactive (W, after correction) is "));
+    _debugPort->print(F("readPowerActiveReactive: pactive (W, after correction) is "));
     _debugPort->println(power);
   }
   *pActive = power;
 
-  // Extract pimag. Convert to Watts
+  // Extract pimag. Convert to VAR
   // Note: datasheet says:
   // "Reactive power output. This field is an unsigned 16-bit fixed
   //  point number with 16 fractional bits, where MaxPow = 0.704. To
@@ -661,9 +661,9 @@ ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
   power = (float)store.data.bits.pimag;
   if (_printDebug == true)
   {
-    _debugPort->print(F("readRMSActiveReactive: pimag: 0x"));
+    _debugPort->print(F("readPowerActiveReactive: pimag: 0x"));
     _debugPort->println(store.data.bits.pimag, HEX);
-    _debugPort->print(F("readRMSActiveReactive: pimag (LSB, before correction) is "));
+    _debugPort->print(F("readPowerActiveReactive: pimag (LSB, before correction) is "));
     _debugPort->println(power);
   }
   float LSBpermVAR = 6.15; // LSB per mVAR
@@ -675,14 +675,94 @@ ACS37800ERR ACS37800::readRMSActiveReactive(float *pActive, float *pReactive)
   power /= 1000; // Convert from mVAR to VAR
   if (_printDebug == true)
   {
-    _debugPort->print(F("readRMSActiveReactive: pimag (VAR, after correction) is "));
+    _debugPort->print(F("readPowerActiveReactive: pimag (VAR, after correction) is "));
     _debugPort->println(power);
   }
   *pReactive = power;
 
   return (error);
 }
 
+// Read volatile register 0x22. Return the apparent power, power factor, leading / lagging, generated / consumed
+ACS37800ERR ACS37800::readPowerFactor(float *pApparent, float *pFactor, bool *posangle, bool *pospf)
+{
+  ACS37800_REGISTER_22_t store;
+  ACS37800ERR error = readRegister(&store.data.all, ACS37800_REGISTER_VOLATILE_22); // Read register 22
+
+  if (error != ACS37800_SUCCESS)
+  {
+    if (_printDebug == true)
+    {
+      _debugPort->print(F("readPowerFactor: readRegister (22) returned: "));
+      _debugPort->println(error);
+    }
+    return (error); // Bail
+  }
+
+  // Extract papparent. Convert to VA
+  // Note: datasheet says:
+  // "Apparent power output magnitude. This field is an unsigned
+  //  16-bit fixed point number with 16 fractional bits, where MaxPow
+  //  = 0.704. To convert the value (input power) to line power, divide
+  //  the input power by the RSENSE and RISO voltage divider ratio
+  //  using actual resistor values."
+  // Datasheet also says:
+  //  "6.15 LSB/mVA for the 30A version and 2.05 LSB/mVA for the 90A version"
+
+  float power = (float)store.data.bits.papparent;
+  if (_printDebug == true)
+  {
+    _debugPort->print(F("readPowerFactor: papparent: 0x"));
+    _debugPort->println(store.data.bits.papparent, HEX);
+    _debugPort->print(F("readPowerFactor: papparent (LSB, before correction) is "));
+    _debugPort->println(power);
+  }
+  float LSBpermVA = 6.15; // LSB per mVA
+  LSBpermVA *= 30.0 / _currentSensingRange; // Correct for sensor version
+  power /= LSBpermVA; //Convert from codes to mVA
+  //Correct for the voltage divider: (RISO1 + RISO2 + RSENSE) / RSENSE
+  //Or:  (RISO1 + RISO2 + RISO3 + RISO4 + RSENSE) / RSENSE
+  float resistorMultiplier = (_dividerResistance + _senseResistance) / _senseResistance;
+  power *= resistorMultiplier;
+  power /= 1000; // Convert from mVAR to VAR
+  if (_printDebug == true)
+  {
+    _debugPort->print(F("readPowerFactor: papparent (VA, after correction) is "));
+    _debugPort->println(power);
+  }
+  *pApparent = power;
+
+  // Extract power factor
+  // Datasheet says:
+  // "Power factor output. This field is a signed 11-bit fixed point number
+  //  with 10 fractional bits. It ranges from –1 to ~1 with a step
+  //  size of 2^-10."
+
+  union
+  {
+    int16_t Signed;
+    uint16_t unSigned;
+  } signedUnsigned; // Avoid any ambiguity when casting to signed int
+
+  signedUnsigned.unSigned = store.data.bits.pfactor << 5; // Move 11-bit number into 16-bits (signed)
+
+  float pfactor = (float)signedUnsigned.Signed / 32768.0; // Convert to +/- 1
+  if (_printDebug == true)
+  {
+    _debugPort->print(F("readPowerFactor: pfactor: 0x"));
+    _debugPort->println(store.data.bits.pfactor, HEX);
+    _debugPort->print(F("readPowerFactor: pfactor is "));
+    _debugPort->println(pfactor);
+  }
+  *pFactor = pfactor;
+
+  // Extract posangle and pospf
+  *posangle = store.data.bits.posangle & 0x1;
+  *pospf = store.data.bits.pospf & 0x1;
+
+  return (error);
+}
+
 // Read volatile registers 0x2A and 0x2C. Return the vInst (Volts), iInst (Amps) and pInst (VAR).
 ACS37800ERR ACS37800::readInstantaneous(float *vInst, float *iInst, float *pInst)
 {

src/SparkFun_ACS37800_Arduino_Library.h

@@ -411,7 +411,8 @@ class ACS37800
 
     //Basic methods for accessing the volatile registers
     ACS37800ERR readRMS(float *vRMS, float *iRMS); // Read volatile register 0x20. Return the vRMS and iRMS.
-    ACS37800ERR readRMSActiveReactive(float *pActive, float *pReactive); // Read volatile register 0x21. Return the pactive and pimag (reactive)
+    ACS37800ERR readPowerActiveReactive(float *pActive, float *pReactive); // Read volatile register 0x21. Return the pactive and pimag (reactive)
+    ACS37800ERR readPowerFactor(float *pApparent, float *pFactor, bool *posangle, bool *pospf); // Read volatile register 0x22. Return the apparent power, power factor, leading / lagging, generated / consumed
     ACS37800ERR readInstantaneous(float *vInst, float *iInst, float *pInst); // Read volatile registers 0x2A and 0x2C. Return the vInst, iInst and pInst.
     ACS37800ERR readErrorFlags(ACS37800_REGISTER_2D_t *errorFlags); // Read volatile register 0x2D. Return its contents in errorFlags.