CyberShell
/
esp32-tm-code
mirror of https://github.com/UAH-SD-Transformer-Monitor/esp32-tm-code
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

add config for integrator

Browse Source
master
Andrew Woodlee 4 weeks ago
parent a40825f6d7
commit 60e6c9e9a1
16 changed files with 85 additions and 1077 deletions
Show Stats Download Patch File Download Diff File

2
include/transformerMonitor.h
Unescape View File

@ -127,7 +127,7 @@ struct energyData {
};
struct xformerMonitorData {
unsigned short sysStatus, meterStatus;
unsigned short sys0Status, sys1Status;
double lineCurrent, neutralCurrent, lineVoltage, phase;
tm *timeInfo;
tempData temps;

504
lib/ATM90E36/ATM90E36-master/ATM90E36.cpp
Unescape View File

@ -1,504 +0,0 @@
#include "ATM90E36.h"
ATM90E36::ATM90E36(void){
}
ATM90E36::~ATM90E36() {
// end
}
/* CommEnergyIC - Communication Establishment */
/*
- Defines Register Mask
- Treats the Register and SPI Comms
- Outputs the required value in the register
*/
unsigned short ATM90E36::CommEnergyIC(unsigned char RW, unsigned short address, unsigned short val)
{
unsigned char* data = (unsigned char*)&val;
unsigned char* adata = (unsigned char*)&address;
unsigned short output;
unsigned short address1;
// Slows the SPI interface to communicate
#if !defined(ENERGIA) && !defined(ESP8266) && !defined(ESP32) && !defined(ARDUINO_ARCH_SAMD)
SPISettings settings(200000, MSBFIRST, SPI_MODE0);
#endif
#if defined(ESP8266)
SPISettings settings(200000, MSBFIRST, SPI_MODE2);
#endif
#if defined(ESP32)
SPISettings settings(200000, MSBFIRST, SPI_MODE3);
#endif
#if defined(ARDUINO_ARCH_SAMD)
SPISettings settings(400000, MSBFIRST, SPI_MODE3);
#endif
// Switch MSB and LSB of value
output = (val >> 8) | (val << 8);
val = output;
// Set R/W flag
address |= RW << 15;
// Swap byte address
address1 = (address >> 8) | (address << 8);
address = address1;
// Transmit & Receive Data
#if !defined(ENERGIA)
SPI.beginTransaction(settings);
#endif
// Chip enable and wait for SPI activation
digitalWrite (_energy_CS, LOW);
delayMicroseconds(10);
// Write address byte by byte
for (byte i=0; i<2; i++)
{
SPI.transfer (*adata);
adata++;
}
/* Must wait 4 us for data to become valid */
delayMicroseconds(4);
// READ Data
// Do for each byte in transfer
if (RW)
{
for (byte i=0; i<2; i++)
{
*data = SPI.transfer (0x00);
data++;
}
}
else
{
for (byte i=0; i<2; i++)
{
SPI.transfer(*data);
data++;
}
}
// Chip enable and wait for transaction to end
digitalWrite(_energy_CS, HIGH);
delayMicroseconds(10);
#if !defined(ENERGIA)
SPI.endTransaction();
#endif
output = (val >> 8) | (val << 8); // reverse MSB and LSB
return output;
}
int ATM90E36::Read32Register(signed short regh_addr, signed short regl_addr) {
int val, val_h, val_l;
val_h = CommEnergyIC(READ, regh_addr, 0xFFFF);
val_l = CommEnergyIC(READ, regl_addr, 0xFFFF);
val = CommEnergyIC(READ, regh_addr, 0xFFFF);
val = val_h << 16;
val |= val_l; //concatenate the 2 registers to make 1 32 bit number
return (val);
}
/* Parameters Functions*/
/*
- Gets main electrical parameters,
such as: Voltage, Current, Power, Energy,
and Frequency
- Also gets the temperature
*/
// VOLTAGE
double ATM90E36::GetLineVoltageA() {
unsigned short voltage = CommEnergyIC(READ, UrmsA, 0xFFFF);
return (double)voltage / 100;
}
double ATM90E36::GetLineVoltageB() {
unsigned short voltage = CommEnergyIC(READ, UrmsB, 0xFFFF);
return (double)voltage / 100;
}
double ATM90E36::GetLineVoltageC() {
unsigned short voltage = CommEnergyIC(READ, UrmsC, 0xFFFF);
return (double)voltage / 100;
}
// CURRENT
double ATM90E36::GetLineCurrentA() {
unsigned short current = CommEnergyIC(READ, IrmsA, 0xFFFF);
return (double)current / 1000;
}
double ATM90E36::GetLineCurrentB() {
unsigned short current = CommEnergyIC(READ, IrmsB, 0xFFFF);
return (double)current / 1000;
}
double ATM90E36::GetLineCurrentC() {
unsigned short current = CommEnergyIC(READ, IrmsC, 0xFFFF);
return (double)current / 1000;
}
double ATM90E36::GetLineCurrentN() {
unsigned short current = CommEnergyIC(READ, IrmsN1, 0xFFFF);
return (double)current / 1000;
}
double ATM90E36::GetCalcLineCurrentN() {
unsigned short current = CommEnergyIC(READ, IrmsN0, 0xFFFF);
return (double)current / 1000;
}
// ACTIVE POWER
double ATM90E36::GetActivePowerA() {
signed short apower = (signed short) CommEnergyIC(READ, PmeanA, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetActivePowerB() {
signed short apower = (signed short) CommEnergyIC(READ, PmeanB, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetActivePowerC() {
signed short apower = (signed short) CommEnergyIC(READ, PmeanC, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetTotalActivePower() {
signed short apower = (signed short) CommEnergyIC(READ, PmeanT, 0xFFFF);
return (double)apower / 250;
}
// REACTIVE POWER
double ATM90E36::GetReactivePowerA() {
signed short apower = (signed short) CommEnergyIC(READ, QmeanA, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetReactivePowerB() {
signed short apower = (signed short) CommEnergyIC(READ, QmeanB, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetReactivePowerC() {
signed short apower = (signed short) CommEnergyIC(READ, QmeanC, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetTotalReactivePower() {
signed short apower = (signed short) CommEnergyIC(READ, QmeanT, 0xFFFF);
return (double)apower / 250;
}
// APPARENT POWER
double ATM90E36::GetApparentPowerA() {
signed short apower = (signed short) CommEnergyIC(READ, SmeanA, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetApparentPowerB() {
signed short apower = (signed short) CommEnergyIC(READ, SmeanB, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetApparentPowerC() {
signed short apower = (signed short) CommEnergyIC(READ, SmeanC, 0xFFFF);
return (double)apower / 1000;
}
double ATM90E36::GetTotalApparentPower() {
signed short apower = (signed short) CommEnergyIC(READ, SmeanT, 0xFFFF);
return (double)apower / 250;
}
// FREQUENCY
double ATM90E36::GetFrequency() {
unsigned short freq = CommEnergyIC(READ, Freq, 0xFFFF);
return (double)freq / 100;
}
// POWER FACTOR
double ATM90E36::GetPowerFactorA() {
signed short pf = (signed short) CommEnergyIC(READ, PFmeanA, 0xFFFF);
return (double)pf / 1000;
}
double ATM90E36::GetPowerFactorB() {
signed short pf = (signed short) CommEnergyIC(READ, PFmeanB, 0xFFFF);
return (double)pf / 1000;
}
double ATM90E36::GetPowerFactorC() {
signed short pf = (signed short) CommEnergyIC(READ, PFmeanC, 0xFFFF);
return (double)pf / 1000;
}
double ATM90E36::GetTotalPowerFactor() {
signed short pf = (signed short) CommEnergyIC(READ, PFmeanT, 0xFFFF);
return (double)pf / 1000;
}
// VOLTAGE Harmonics
double ATM90E36::GetVHarmA() {
unsigned short value = CommEnergyIC(READ, THDNUA, 0xFFFF);
return (double)value;
}
double ATM90E36::GetVHarmB() {
unsigned short value = CommEnergyIC(READ, THDNUB, 0xFFFF);
return (double)value;
}
double ATM90E36::GetVHarmC() {
unsigned short value = CommEnergyIC(READ, THDNUC, 0xFFFF);
return (double)value;
}
// CURRENT Harmonics
double ATM90E36::GetCHarmA() {
unsigned short value = CommEnergyIC(READ, THDNIA, 0xFFFF);
return (double)value;
}
double ATM90E36::GetCHarmB() {
unsigned short value = CommEnergyIC(READ, THDNIB, 0xFFFF);
return (double)value;
}
double ATM90E36::GetCHarmC() {
unsigned short value = CommEnergyIC(READ, THDNIC, 0xFFFF);
return (double)value;
}
// PHASE ANGLE
double ATM90E36::GetPhaseA() {
signed short apower = (signed short) CommEnergyIC(READ, PAngleA, 0xFFFF);
return (double)apower / 10;
}
double ATM90E36::GetPhaseB() {
signed short apower = (signed short) CommEnergyIC(READ, PAngleB, 0xFFFF);
return (double)apower / 10;
}
double ATM90E36::GetPhaseC() {
signed short apower = (signed short) CommEnergyIC(READ, PAngleC, 0xFFFF);
return (double)apower / 10;
}
// TEMPERATURE
double ATM90E36::GetTemperature() {
short int apower = (short int) CommEnergyIC(READ, Temp, 0xFFFF);
return (double)apower;
}
/* Gets the Register Value if Desired */
// REGISTER
unsigned short ATM90E36::GetValueRegister(unsigned short registerRead) {
return (CommEnergyIC(READ, registerRead, 0xFFFF)); //returns value register
}
// ENERGY MEASUREMENT
double ATM90E36::GetImportEnergy() {
unsigned short ienergyT = CommEnergyIC(READ, APenergyT, 0xFFFF);
// unsigned short ienergyA = CommEnergyIC(READ, APenergyA, 0xFFFF);
// unsigned short ienergyB = CommEnergyIC(READ, APenergyB, 0xFFFF);
// unsigned short ienergyC = CommEnergyIC(READ, APenergyC, 0xFFFF);
// unsigned short renergyT = CommEnergyIC(READ, RPenergyT, 0xFFFF);
// unsigned short renergyA = CommEnergyIC(READ, RPenergyA, 0xFFFF);
// unsigned short renergyB = CommEnergyIC(READ, RPenergyB, 0xFFFF);
// unsigned short renergyC = CommEnergyIC(READ, RPenergyC, 0xFFFF);
// unsigned short senergyT = CommEnergyIC(READ, SAenergyT, 0xFFFF);
// unsigned short senergyA = CommEnergyIC(READ, SenergyA, 0xFFFF);
// unsigned short senergyB = CommEnergyIC(READ, SenergyB, 0xFFFF);
// unsigned short senergyC = CommEnergyIC(READ, SenergyC, 0xFFFF);
return (double)(((double)ienergyT / 32) * 3600); // returns kWh
}
double ATM90E36::GetExportEnergy() {
unsigned short eenergyT = CommEnergyIC(READ, ANenergyT, 0xFFFF);
// unsigned short eenergyA = CommEnergyIC(READ, ANenergyA, 0xFFFF);
// unsigned short eenergyB = CommEnergyIC(READ, ANenergyB, 0xFFFF);
// unsigned short eenergyC = CommEnergyIC(READ, ANenergyC, 0xFFFF);
// unsigned short reenergyT = CommEnergyIC(READ, RNenergyT, 0xFFFF);
// unsigned short reenergyA = CommEnergyIC(READ, RNenergyA, 0xFFFF);
// unsigned short reenergyB = CommEnergyIC(READ, RNenergyB, 0xFFFF);
// unsigned short reenergyC = CommEnergyIC(READ, RNenergyC, 0xFFFF);
return (double)(((double)eenergyT / 32) * 3600); // returns kWh
}
/* System Status Registers */
unsigned short ATM90E36::GetSysStatus0() {
return CommEnergyIC(READ, SysStatus0, 0xFFFF);
}
unsigned short ATM90E36::GetSysStatus1() {
return CommEnergyIC(READ, SysStatus1, 0xFFFF);
}
unsigned short ATM90E36::GetMeterStatus0() {
return CommEnergyIC(READ, EnStatus0, 0xFFFF);
}
unsigned short ATM90E36::GetMeterStatus1() {
return CommEnergyIC(READ, EnStatus1, 0xFFFF);
}
/* Checksum Error Function */
bool ATM90E36::calibrationError() {
bool CS0, CS1, CS2, CS3;
unsigned short systemstatus0 = GetSysStatus0();
if (systemstatus0 & 0x4000) {
CS0 = true;
} else {
CS0 = false;
}
if (systemstatus0 & 0x1000) {
CS1 = true;
} else {
CS1 = false;
}
if (systemstatus0 & 0x0400) {
CS2 = true;
} else {
CS2 = false;
}
if (systemstatus0 & 0x0100) {
CS3 = true;
} else {
CS3 = false;
}
#if DEBUG_SERIAL
if (CS0) {
Serial.println("Error in CS0");
}
if (CS1) {
Serial.println("Error in CS1");
}
if (CS2) {
Serial.println("Error in CS2");
}
if (CS3) {
Serial.println("Error in CS3");
}
#endif
if (CS0 || CS1 || CS2 || CS3) return (true);
else return (false);
}
uint16_t ATM90E36::checkSum(int start, int end) {
int tmpl = 0;
int tmph = 0;
for (int i = start; i <= end; i++) {
uint16_t registerValue = GetValueRegister(i);
tmpl += (byte)(registerValue) + (byte)(registerValue >> 8);
tmph ^= (byte)(registerValue) ^ (byte)(registerValue >> 8);
}
uint16_t CS = (uint16_t)((byte)(((tmpl % 256) + 256) % 256) +
(uint16_t)((tmph << 8) & 0xFF00));
#if DEBUG_SERIAL
Serial.print(" Value of checksum : ");
Serial.println(CS, HEX);
#endif
return CS;
}
/* BEGIN FUNCTION */
/*
- Define the pin to be used as Chip Select
- Set serialFlag to true for serial debugging
- Use SPI MODE 0 for the ATM90E36
*/
void ATM90E36::begin(int pin, unsigned short lineFreq, unsigned short pgagain, unsigned short ugain, unsigned short igainA, unsigned short igainB, unsigned short igainC, unsigned short igainN)
{
_energy_CS = pin; // SS PIN
_lineFreq = lineFreq; //frequency of power
_pgagain = pgagain; //PGA Gain for current channels
_ugain = ugain; //voltage rms gain
_igainA = igainA; //CT1
_igainB = igainB; //CT2
_igainC = igainC; //CT3
_igainN = igainN; //N
//pinMode(_energy_CS, OUTPUT);
/* Enable SPI */
//SPI.begin(); //moved to main program to assign different SPI pins
Serial.println("Connecting to ATM90E36");
#if defined(ENERGIA)
SPI.setBitOrder(MSBFIRST);
SPI.setDataMode(SPI_MODE0);
SPI.setClockDivider(SPI_CLOCK_DIV16);
#endif
CommEnergyIC(WRITE, SoftReset, 0x789A); // Perform soft reset
delay(100);
CommEnergyIC(WRITE, FuncEn0, 0x0000); // Voltage sag
CommEnergyIC(WRITE, FuncEn1, 0x0000); // Voltage sag
CommEnergyIC(WRITE, SagTh, 0x0001); // Voltage sag threshold
//CommEnergyIC(WRITE, ZXConfig, 0xD654); // 07 ZX2, ZX1, ZX0 pin config - set to current channels, all polarity
/* SagTh = Vth * 100 * sqrt(2) / (2 * Ugain / 32768) */
//Set metering config values (CONFIG)
CommEnergyIC(WRITE, ConfigStart, 0x5678); // Metering calibration startup
CommEnergyIC(WRITE, PLconstH, 0x0861); // PL Constant MSB (default)
CommEnergyIC(WRITE, PLconstL, 0xC468); // PL Constant LSB (default)
CommEnergyIC(WRITE, MMode0, _lineFreq); // Mode Config (60 Hz, 3P4W)
CommEnergyIC(WRITE, MMode1, _pgagain); // 0x5555 (x2) // 0x0000 (1x)
CommEnergyIC(WRITE, PStartTh, 0x1D4C); // Active Startup Power Threshold
CommEnergyIC(WRITE, QStartTh, 0x1D4C); // Reactive Startup Power Threshold
CommEnergyIC(WRITE, SStartTh, 0x1D4C); // Apparent Startup Power Threshold
CommEnergyIC(WRITE, PPhaseTh, 0x02EE); // Active Phase Threshold
CommEnergyIC(WRITE, QPhaseTh, 0x02EE); // Reactive Phase Threshold
CommEnergyIC(WRITE, SPhaseTh, 0x02EE); // Apparent Phase Threshold
CommEnergyIC(WRITE, CSZero, checkSum(PLconstH, SPhaseTh)); // Checksum 0
//Set metering calibration values (CALIBRATION)
CommEnergyIC(WRITE, CalStart, 0x5678); // Metering calibration startup
CommEnergyIC(WRITE, GainA, 0x0000); // Line calibration gain
CommEnergyIC(WRITE, PhiA, 0x0000); // Line calibration angle
CommEnergyIC(WRITE, GainB, 0x0000); // Line calibration gain
CommEnergyIC(WRITE, PhiB, 0x0000); // Line calibration angle
CommEnergyIC(WRITE, GainC, 0x0000); // Line calibration gain
CommEnergyIC(WRITE, PhiC, 0x0000); // Line calibration angle
CommEnergyIC(WRITE, PoffsetA, 0x0000); // A line active power offset
CommEnergyIC(WRITE, QoffsetA, 0x0000); // A line reactive power offset
CommEnergyIC(WRITE, PoffsetB, 0x0000); // B line active power offset
CommEnergyIC(WRITE, QoffsetB, 0x0000); // B line reactive power offset
CommEnergyIC(WRITE, PoffsetC, 0x0000); // C line active power offset
CommEnergyIC(WRITE, QoffsetC, 0x0000); // C line reactive power offset
CommEnergyIC(WRITE, CSOne, checkSum(PoffsetA, PhiC)); // Checksum 1
//Set metering calibration values (HARMONIC)
CommEnergyIC(WRITE, HarmStart, 0x5678); // Metering calibration startup
CommEnergyIC(WRITE, POffsetAF, 0x0000); // A Fund. active power offset
CommEnergyIC(WRITE, POffsetBF, 0x0000); // B Fund. active power offset
CommEnergyIC(WRITE, POffsetCF, 0x0000); // C Fund. active power offset
CommEnergyIC(WRITE, PGainAF, 0x0000); // A Fund. active power gain
CommEnergyIC(WRITE, PGainBF, 0x0000); // B Fund. active power gain
CommEnergyIC(WRITE, PGainCF, 0x0000); // C Fund. active power gain
CommEnergyIC(WRITE, CSTwo, checkSum(POffsetAF, PGainCF)); // Checksum 2
//Set measurement calibration values (ADJUST)
CommEnergyIC(WRITE, AdjStart, 0x5678); // Measurement calibration
CommEnergyIC(WRITE, UgainA, _ugain); // A Voltage rms gain
CommEnergyIC(WRITE, IgainA, _igainA); // A line current gain
CommEnergyIC(WRITE, UoffsetA, 0x0000); // A Voltage offset
CommEnergyIC(WRITE, IoffsetA, 0x0000); // A line current offset
CommEnergyIC(WRITE, UgainB, _ugain); // B Voltage rms gain
CommEnergyIC(WRITE, IgainB, _igainB); // B line current gain
CommEnergyIC(WRITE, UoffsetB, 0x0000); // B Voltage offset
CommEnergyIC(WRITE, IoffsetB, 0x0000); // B line current offset
CommEnergyIC(WRITE, UgainC, _ugain); // C Voltage rms gain
CommEnergyIC(WRITE, IgainC, _igainC); // C line current gain
CommEnergyIC(WRITE, UoffsetC, 0x0000); // C Voltage offset
CommEnergyIC(WRITE, IoffsetC, 0x0000); // C line current offset
CommEnergyIC(WRITE, IgainN, _igainN); // C line current gain
CommEnergyIC(WRITE, CSThree, checkSum(UgainA, IoffsetN)); // Checksum 3
// Done with the configuration
CommEnergyIC(WRITE, ConfigStart, 0x8765);
CommEnergyIC(WRITE, CalStart, 0x8765); // 0x6886 //0x5678 //8765);
CommEnergyIC(WRITE, HarmStart, 0x8765); // 0x6886 //0x5678 //8765);
CommEnergyIC(WRITE, AdjStart, 0x8765); // 0x6886 //0x5678 //8765);
//CommEnergyIC(WRITE, SoftReset, 0x789A); // Perform soft reset
}

317
lib/ATM90E36/ATM90E36-master/ATM90E36.h
Unescape View File

@ -1,317 +0,0 @@
#ifndef ATM90E36_h
#define ATM90E36_h
#include <Arduino.h>
#include <SPI.h>
#define WRITE 0 // WRITE SPI
#define READ 1 // READ SPI
#define DEBUG_SERIAL 1
/* STATUS REGISTERS */
#define SoftReset 0x00 // Software Reset
#define SysStatus0 0x01 // System Status0
#define SysStatus1 0x02 // System Status1
#define FuncEn0 0x03 // Function Enable0
#define FuncEn1 0x04 // Function Enable1
#define ZXConfig 0x07 // Zero-Crossing Config
#define SagTh 0x08 // Voltage Sag Th
#define PhaseLossTh 0x09 // Voltage Phase Losing Th
#define INWarnTh0 0x0A // N Current Line Th
#define INWarnTh1 0x0B // Voltage ADC Th
#define THDNUTh 0x0C // Voltage THD Th
#define THDNITh 0x0D // Current THD Th
#define DMACtrl 0x0E // DMA Int. Control
#define LastSPIData 0x0F // Last Read/Write SPI Value
/* LOW POWER MODE REGISTERS - NOT USED */
#define DetectCtrl 0x10
#define DetectTh1 0x11
#define DetectTh2 0x12
#define DetectTh3 0x13
#define PMOffsetA 0x14
#define PMOffsetB 0x15
#define PMOffsetC 0x16
#define PMPGA 0x17
#define PMIrmsA 0x18
#define PMIrmsB 0x19
#define PMIrmsC 0x1A
#define PMConfig 0x10B
#define PMAvgSamples 0x1C
#define PMIrmsLSB 0x1D
/* CONFIGURATION REGISTERS */
#define ConfigStart 0x30 // Configuration Start
#define PLconstH 0x31 // High Word of PL_Constant
#define PLconstL 0x32 // Low Word of PL_Constant
#define MMode0 0x33 // Metering Mode Config
#define MMode1 0x34 // Metering Mode Config
#define PStartTh 0x35 // Startup Power Th (P)
#define QStartTh 0x36 // Startup Power Th (Q)
#define SStartTh 0x37 // Startup Power Th (S)
#define PPhaseTh 0x38 // Startup Power Accum Th (P)
#define QPhaseTh 0x39 // Startup Power Accum Th (Q)
#define SPhaseTh 0x3A // Startup Power Accum Th (S)
#define CSZero 0x3B // Checksum 0
/* CALIBRATION REGISTERS */
#define CalStart 0x40 // Cal Start
#define PoffsetA 0x41 // A Line Power Offset (P)
#define QoffsetA 0x42 // A Line Power Offset (Q)
#define PoffsetB 0x43 // B Line Power Offset (P)
#define QoffsetB 0x44 // B Line Power Offset (Q)
#define PoffsetC 0x45 // C Line Power Offset (P)
#define QoffsetC 0x46 // C Line Power Offset (Q)
#define GainA 0x47 // A Line Calibration Gain
#define PhiA 0x48 // A Line Calibration Angle
#define GainB 0x49 // B Line Calibration Gain
#define PhiB 0x4A // B Line Calibration Angle
#define GainC 0x4B // C Line Calibration Gain
#define PhiC 0x4C // C Line Calibration Angle
#define CSOne 0x4D // Checksum 1
/* HARMONIC & ENERGY REGISTERS */
#define HarmStart 0x50 // Harmonic Cal Start
#define POffsetAF 0x51 // A Fund Power Offset (P)
#define POffsetBF 0x52 // B Fund Power Offset (P)
#define POffsetCF 0x53 // C Fund Power Offset (P)
#define PGainAF 0x54 // A Fund Power Gain (P)
#define PGainBF 0x55 // B Fund Power Gain (P)
#define PGainCF 0x56 // C Fund Power Gain (P)
#define CSTwo 0x57 // Checksum 2
/* MEASUREMENT CALIBRATION REGISTERS */
#define AdjStart 0x60 // Measurement Cal Start
#define UgainA 0x61 // A Voltage RMS Gain
#define IgainA 0x62 // A Current RMS Gain
#define UoffsetA 0x63 // A Voltage Offset
#define IoffsetA 0x64 // A Current Offset
#define UgainB 0x65 // B Voltage RMS Gain
#define IgainB 0x66 // B Current RMS Gain
#define UoffsetB 0x67 // B Voltage Offset
#define IoffsetB 0x68 // B Current Offset
#define UgainC 0x69 // C Voltage RMS Gain
#define IgainC 0x6A // C Current RMS Gain
#define UoffsetC 0x6B // C Voltage Offset
#define IoffsetC 0x6C // C Current Offset
#define IgainN 0x6D // N Current Gain
#define IoffsetN 0x6E // N Current Offset
#define CSThree 0x6F // Checksum 3
/* ENERGY REGISTERS */
#define APenergyT 0x80 // Total Forward Active
#define APenergyA 0x81 // A Forward Active
#define APenergyB 0x82 // B Forward Active
#define APenergyC 0x83 // C Forward Active
#define ANenergyT 0x84 // Total Reverse Active
#define ANenergyA 0x85 // A Reverse Active
#define ANenergyB 0x86 // B Reverse Active
#define ANenergyC 0x87 // C Reverse Active
#define RPenergyT 0x88 // Total Forward Reactive
#define RPenergyA 0x89 // A Forward Reactive
#define RPenergyB 0x8A // B Forward Reactive
#define RPenergyC 0x8B // C Forward Reactive
#define RNenergyT 0x8C // Total Reverse Reactive
#define RNenergyA 0x8D // A Reverse Reactive
#define RNenergyB 0x8E // B Reverse Reactive
#define RNenergyC 0x8F // C Reverse Reactive
#define SAenergyT 0x90 // Total Apparent Energy
#define SenergyA 0x91 // A Apparent Energy
#define SenergyB 0x92 // B Apparent Energy
#define SenergyC 0x93 // C Apparent Energy
#define SVenergyT 0x94 // Total Apparent Energy (Arit)
#define EnStatus0 0x95 // Metering Status 0
#define EnStatus1 0x96 // Metering Status 1
///////////////// 0x97 // Reserved Register
#define SVmeanT 0x98 // Total Apparent Energy (Vect)
#define SVmeanTLSB 0x99 // LSB of Vector Sum
/* FUNDAMENTAL / HARMONIC ENERGY REGISTERS */
#define APenergyTF 0xA0 // Total Forward Fund. Energy
#define APenergyAF 0xA1 // A Forward Fund. Energy
#define APenergyBF 0xA2 // B Forward Fund. Energy
#define APenergyCF 0xA3 // C Forward Fund. Energy
#define ANenergyTF 0xA4 // Total Reverse Fund Energy
#define ANenergyAF 0xA5 // A Reverse Fund. Energy
#define ANenergyBF 0xA6 // B Reverse Fund. Energy
#define ANenergyCF 0xA7 // C Reverse Fund. Energy
#define APenergyTH 0xA8 // Total Forward Harm. Energy
#define APenergyAH 0xA9 // A Forward Harm. Energy
#define APenergyBH 0xAA // B Forward Harm. Energy
#define APenergyCH 0xAB // C Forward Harm. Energy
#define ANenergyTH 0xAC // Total Reverse Harm. Energy
#define ANenergyAH 0xAD // A Reverse Harm. Energy
#define ANenergyBH 0xAE // B Reverse Harm. Energy
#define ANenergyCH 0xAF // C Reverse Harm. Energy
/* POWER & P.F. REGISTERS */
#define PmeanT 0xB0 // Total Mean Power (P)
#define PmeanA 0xB1 // A Mean Power (P)
#define PmeanB 0xB2 // B Mean Power (P)
#define PmeanC 0xB3 // C Mean Power (P)
#define QmeanT 0xB4 // Total Mean Power (Q)
#define QmeanA 0xB5 // A Mean Power (Q)
#define QmeanB 0xB6 // B Mean Power (Q)
#define QmeanC 0xB7 // C Mean Power (Q)
#define SmeanT 0xB8 // Total Mean Power (S)
#define SmeanA 0xB9 // A Mean Power (S)
#define SmeanB 0xBA // B Mean Power (S)
#define SmeanC 0xBB // C Mean Power (S)
#define PFmeanT 0xBC // Mean Power Factor
#define PFmeanA 0xBD // A Power Factor
#define PFmeanB 0xBE // B Power Factor
#define PFmeanC 0xBF // C Power Factor
#define PmeanTLSB 0xC0 // Lower Word (Tot. Act. Power)
#define PmeanALSB 0xC1 // Lower Word (A Act. Power)
#define PmeanBLSB 0xC2 // Lower Word (B Act. Power)
#define PmeanCLSB 0xC3 // Lower Word (C Act. Power)
#define QmeanTLSB 0xC4 // Lower Word (Tot. React. Power)
#define QmeanALSB 0xC5 // Lower Word (A React. Power)
#define QmeanBLSB 0xC6 // Lower Word (B React. Power)
#define QmeanCLSB 0xC7 // Lower Word (C React. Power)
#define SAmeanTLSB 0xC8 // Lower Word (Tot. App. Power)
#define SmeanALSB 0xC9 // Lower Word (A App. Power)
#define SmeanBLSB 0xCA // Lower Word (B App. Power)
#define SmeanCLSB 0xCB // Lower Word (C App. Power)
/* FUND/HARM POWER & V/I RMS REGISTERS */
#define PmeanTF 0xD0 // Total Active Fund. Power
#define PmeanAF 0xD1 // A Active Fund. Power
#define PmeanBF 0xD2 // B Active Fund. Power
#define PmeanCF 0xD3 // C Active Fund. Power
#define PmeanTH 0xD4 // Total Active Harm. Power
#define PmeanAH 0xD5 // A Active Harm. Power
#define PmeanBH 0xD6 // B Active Harm. Power
#define PmeanCH 0xD7 // C Active Harm. Power
#define IrmsN1 0xD8 // N Sampled Current
#define UrmsA 0xD9 // A RMS Voltage
#define UrmsB 0xDA // B RMS Voltage
#define UrmsC 0xDB // C RMS Voltage
#define IrmsN0 0xDC // N Calculated Current
#define IrmsA 0xDD // A RMS Current
#define IrmsB 0xDE // B RMS Current
#define IrmsC 0xDF // C RMS Current
#define PmeanTFLSB 0xE0 // Lower Word (Tot. Act. Fund. Power)
#define PmeanAFLSB 0xE1 // Lower Word (A Act. Fund. Power)
#define PmeanBFLSB 0xE2 // Lower Word (B Act. Fund. Power)
#define PmeanCFLSB 0xE3 // Lower Word (C Act. Fund. Power)
#define PmeanTHLSB 0xE4 // Lower Word (Tot. Act. Harm. Power)
#define PmeanAHLSB 0xE5 // Lower Word (A Act. Harm. Power)
#define PmeanBHLSB 0xE6 // Lower Word (B Act. Harm. Power)
#define PmeanCHLSB 0xE7 // Lower Word (C Act. Harm. Power)
///////////////// 0xE8 // Reserved Register
#define UrmsALSB 0xE9 // Lower Word (A RMS Voltage)
#define UrmsBLSB 0xEA // Lower Word (B RMS Voltage)
#define UrmsCLSB 0xEB // Lower Word (C RMS Voltage)
///////////////// 0xEC // Reserved Register
#define IrmsALSB 0xED // Lower Word (A RMS Current)
#define IrmsBLSB 0xEE // Lower Word (B RMS Current)
#define IrmsCLSB 0xEF // Lower Word (C RMS Current)
/* THD, FREQUENCY, ANGLE & TEMP REGISTERS*/
#define THDNUA 0xF1 // A Voltage THD+N
#define THDNUB 0xF2 // B Voltage THD+N
#define THDNUC 0xF3 // C Voltage THD+N
///////////////// 0xF4 // Reserved Register
#define THDNIA 0xF5 // A Current THD+N
#define THDNIB 0xF6 // B Current THD+N
#define THDNIC 0xF7 // V Current THD+N
#define Freq 0xF8 // Frequency
#define PAngleA 0xF9 // A Mean Phase Angle
#define PAngleB 0xFA // B Mean Phase Angle
#define PAngleC 0xFB // C Mean Phase Angle
#define Temp 0xFC // Measured Temperature
#define UangleA 0xFD // A Voltage Phase Angle
#define UangleB 0xFE // B Voltage Phase Angle
#define UangleC 0xFF // C Voltage Phase Angle
class ATM90E36
{
private:
unsigned short CommEnergyIC(unsigned char RW, unsigned short address, unsigned short val);
int _energy_CS;
unsigned short _lineFreq;
unsigned short _pgagain;
unsigned short _ugain;
unsigned short _igainA;
unsigned short _igainB;
unsigned short _igainC;
unsigned short _igainN;
int Read32Register(signed short regh_addr, signed short regl_addr);
public:
/* Construct */
ATM90E36(void);
/* Destruct */
~ATM90E36(void);
/* Initialization Functions */
void begin(int pin, unsigned short lineFreq, unsigned short pgagain, unsigned short ugain, unsigned short igainA, unsigned short igainB, unsigned short igainC, unsigned short igainN);
uint16_t checkSum(int start, int end);
/* Main Electrical Parameters (GET)*/
double GetLineVoltageA();
double GetLineVoltageB();
double GetLineVoltageC();
double GetLineCurrentA();
double GetLineCurrentB();
double GetLineCurrentC();
double GetLineCurrentN();
double GetCalcLineCurrentN();
double GetActivePowerA();
double GetActivePowerB();
double GetActivePowerC();
double GetTotalActivePower();
double GetReactivePowerA();
double GetReactivePowerB();
double GetReactivePowerC();
double GetTotalReactivePower();
double GetApparentPowerA();
double GetApparentPowerB();
double GetApparentPowerC();
double GetTotalApparentPower();
double GetFrequency();
double GetPowerFactorA();
double GetPowerFactorB();
double GetPowerFactorC();
double GetTotalPowerFactor();
double GetVHarmA();
double GetVHarmB();
double GetVHarmC();
double GetCHarmA();
double GetCHarmB();
double GetCHarmC();
double GetPhaseA();
double GetPhaseB();
double GetPhaseC();
double GetTemperature();
/* Gain Parameters (GET)*/
unsigned short GetValueRegister(unsigned short registerRead);
/* Energy Consumption */
double GetImportEnergy();
double GetExportEnergy();
/* System Status */
unsigned short GetSysStatus0();
unsigned short GetSysStatus1();
unsigned short GetMeterStatus0();
unsigned short GetMeterStatus1();
/* Checksum Function */
bool calibrationError();
};
#endif

BIN
lib/ATM90E36/ATM90E36-master/CalibrationRegs.xlsx
View File

Binary file not shown.

BIN
lib/ATM90E36/ATM90E36-master/docs/Atmel-46004-SE-M90E36A-Datasheet.pdf
View File

Binary file not shown.

BIN
lib/ATM90E36/ATM90E36-master/docs/Atmel-46104-SE-M90E36A- ApplicationNote .pdf
View File

Binary file not shown.

BIN
lib/ATM90E36/ATM90E36-master/docs/CalibrationRegs.xlsx
View File

Binary file not shown.

BIN
lib/ATM90E36/ATM90E36-master/docs/Test_ATM90E36.psimsch
View File

Binary file not shown.

65
lib/ATM90E36/ATM90E36-master/examples/ATM90E36_Basic/ATM90E36_Basic.ino
Unescape View File

@ -1,65 +0,0 @@
/* ATM90E36 Energy Monitor Demo Application
The MIT License (MIT)
Copyright (c) 2016 whatnick and Ryzee
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <SPI.h>
#include <ATM90E36.h>
ATM90E36 eic(10);
void setup() {
/* Initialize the serial port to host */
Serial.begin(115200);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB
}
Serial.println("Start ATM90E36");
/*Initialise the ATM90E36 + SPI port */
eic.begin();
delay(1000);
}
void loop() {
/*Repeatedly fetch some values from the ATM90E36 */
double voltageA,freq,voltageB,voltageC,currentA,currentB,currentC,power,pf,new_current,new_power;
int sys0=eic.GetSysStatus0();
int sys1=eic.GetSysStatus1();
int en0=eic.GetMeterStatus0();
int en1=eic.GetMeterStatus1();
Serial.println("S0:0x"+String(sys0,HEX));
delay(10);
Serial.println("S1:0x"+String(sys1,HEX));
delay(10);
Serial.println("E0:0x"+String(en0,HEX));
delay(10);
Serial.println("E1:0x"+String(en1,HEX));
voltageA=eic.GetLineVoltageA();
Serial.println("VA:"+String(voltageA)+"V");
voltageB=eic.GetLineVoltageB();
Serial.println("VB:"+String(voltageB)+"V");
voltageC=eic.GetLineVoltageC();
Serial.println("VC:"+String(voltageC)+"V");
delay(10);
currentA = eic.GetLineCurrentA();
Serial.println("IA:"+String(currentA)+"A");
currentB = eic.GetLineCurrentB();
Serial.println("IB:"+String(currentB)+"A");
currentC = eic.GetLineCurrentC();
Serial.println("IC:"+String(currentC)+"A");
delay(10);
freq=eic.GetFrequency();
delay(10);
Serial.println("f"+String(freq)+"Hz");
delay(1000);
}

95
lib/ATM90E36/ATM90E36-master/examples/ATM90E36_OLED/ATM90E36_OLED.ino
Unescape View File

@ -1,95 +0,0 @@
/* ATM90E36 Energy Monitor Demo Application
The MIT License (MIT)
Copyright (c) 2016 whatnick and Ryzee
Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
#include <SPI.h>
#include <ATM90E36.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#define OLED_RESET 4
Adafruit_SSD1306 display(OLED_RESET);
ATM90E36 eics[2] = {ATM90E36(10),ATM90E36(9)};
void setup() {
/* Initialize the serial port to host */
Serial.begin(115200);
while (!Serial) {
; // wait for serial port to connect. Needed for native USB
}
Serial.println("Start ATM90E36");
// by default, we'll generate the high voltage from the 3.3v line internally! (neat!)
display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // initialize with the I2C addr 0x3C (for the 128x32)
// init done
// Show image buffer on the display hardware.
// Since the buffer is intialized with an Adafruit splashscreen
// internally, this will display the splashscreen.
display.display();
display.setTextSize(1);
display.setTextColor(WHITE);
display.setCursor(0,0);
/*Initialise the ATM90E36 + SPI port */
eics[0].begin();
delay(1000);
eics[1].begin();
delay(1000);
}
void scanEic(ATM90E36 eic)
{
double voltageA,freq,voltageB,voltageC,currentA,currentB,currentC,power,pf,new_current,new_power;
int sys0=eic.GetSysStatus0();
int sys1=eic.GetSysStatus1();
int en0=eic.GetMeterStatus0();
int en1=eic.GetMeterStatus1();
Serial.println("S0:0x"+String(sys0,HEX));
delay(10);
Serial.println("S1:0x"+String(sys1,HEX));
delay(10);
Serial.println("E0:0x"+String(en0,HEX));
delay(10);
Serial.println("E1:0x"+String(en1,HEX));
display.clearDisplay();
display.setCursor(0,0);
voltageA=eic.GetLineVoltageA();
Serial.println("VA:"+String(voltageA)+"V");
display.println("VA:"+String(voltageA)+"V");
voltageB=eic.GetLineVoltageB();
Serial.println("VB:"+String(voltageB)+"V");
display.println("VB:"+String(voltageB)+"V");
voltageC=eic.GetLineVoltageC();
Serial.println("VC:"+String(voltageC)+"V");
display.println("VC:"+String(voltageC)+"V");
delay(10);
currentA = eic.GetLineCurrentA();
Serial.println("IA:"+String(currentA)+"A");
currentB = eic.GetLineCurrentB();
Serial.println("IB:"+String(currentB)+"A");
currentC = eic.GetLineCurrentC();
Serial.println("IC:"+String(currentC)+"A");
delay(10);
freq=eic.GetFrequency();
delay(10);
Serial.println("f"+String(freq)+"Hz");
display.println("f"+String(freq)+"Hz");
display.display();
delay(1000);
}
void loop() {
/*Repeatedly fetch some values from the ATM90E36 */
scanEic(eics[0]);
scanEic(eics[1]);
}

75
lib/ATM90E36/ATM90E36-master/keywords.txt
Unescape View File

@ -1,75 +0,0 @@
#######################################
# Syntax Coloring Map For ATM90E36
#######################################
#######################################
# Datatypes (KEYWORD1)
#######################################
ATM90E36 KEYWORD1
#######################################
# Methods and Functions (KEYWORD2)
#######################################
begin KEYWORD2
GetLineVoltageA KEYWORD2
GetLineVoltageB KEYWORD2
GetLineVoltageC KEYWORD2
GetLineCurrentA KEYWORD2
GetLineCurrentB KEYWORD2
GetLineCurrentC KEYWORD2
GetLineCurrentN KEYWORD2
GetActivePowerA KEYWORD2
GetActivePowerB KEYWORD2
GetActivePowerC KEYWORD2
GetTotalActivePower KEYWORD2
GetReactivePowerA KEYWORD2
GetReactivePowerB KEYWORD2
GetReactivePowerC KEYWORD2
GetTotalReactivePower KEYWORD2
GetApparentPowerA KEYWORD2
GetApparentPowerB KEYWORD2
GetApparentPowerC KEYWORD2
GetTotalApparentPower KEYWORD2
GetFrequency KEYWORD2
GetTemperature KEYWORD2
GetPowerFactorA KEYWORD2
GetPowerFactorB KEYWORD2
GetPowerFactorC KEYWORD2
GetTotalPowerFactor KEYWORD2
GetPhaseA KEYWORD2
GetPhaseB KEYWORD2
GetPhaseC KEYWORD2
GetValueRegister KEYWORD2
SetVoltageGainA KEYWORD2
SetVoltageGainB KEYWORD2
SetVoltageGainC KEYWORD2
SetCurrentGainA KEYWORD2
SetCurrentGainB KEYWORD2
SetCurrentGainC KEYWORD2
SetCurrentGainN KEYWORD2
GetImportEnergy KEYWORD2
GetExportEnergy KEYWORD2
GetSysStatus0 KEYWORD2
GetSysStatus1 KEYWORD2
GetMeterStatus0 KEYWORD2
GetMeterStatus1 KEYWORD2
#######################################
# Constants (LITERAL1)
#######################################
WRITE LITERAL1
READ LITERAL1

50
lib/ATM90E36/ATM90E36.cpp
Unescape View File

@ -335,6 +335,56 @@ unsigned short ATM90E36::GetMeterStatus1() {
return CommEnergyIC(READ, EnStatus1, 0xFFFF);
}
double ATM90E36::CalibrateVI(unsigned short reg, unsigned short actualVal)
{
// input the Voltage or Current register, and the actual value that it should be
// actualVal can be from a calibration meter or known value from a power supply
uint16_t gain, val, m, gainReg;
// sample the reading
val = CommEnergyIC(READ, reg, 0xFFFF);
val += CommEnergyIC(READ, reg, 0xFFFF);
val += CommEnergyIC(READ, reg, 0xFFFF);
val += CommEnergyIC(READ, reg, 0xFFFF);
// get value currently in gain register
switch (reg)
{
case UrmsA:
{
gainReg = UgainA;
}
case UrmsB:
{
gainReg = UgainB;
}
case UrmsC:
{
gainReg = UgainC;
}
case IrmsA:
{
gainReg = IgainA;
}
case IrmsB:
{
gainReg = IgainB;
}
case IrmsC:
{
gainReg = IgainC;
}
}
gain = CommEnergyIC(READ, gainReg, 0xFFFF);
m = actualVal;
m = ((m * gain) / val);
gain = m;
// write new value to gain register
CommEnergyIC(WRITE, gainReg, gain);
return (gain);
} // ATM90E3x::CalibrateVI
/* Checksum Error Function */
bool ATM90E36::calibrationError() {

1
lib/ATM90E36/ATM90E36.h
Unescape View File

@ -313,5 +313,6 @@ class ATM90E36
/* Checksum Function */
bool calibrationError();
double CalibrateVI(unsigned short reg, unsigned short actualVal);
};
#endif

11
lib/transformerEnergyMonitor/ATM90E36_IC.cpp
Unescape View File

@ -18,15 +18,16 @@
void ATM90E36_IC::begin(){
/*
CS pin - 5 for ESP32
Line Frequency - 60 Hz for NA - 4485
CS pin - 33 for ESP32
Line Frequency - 60 Hz for NA - 5509 - see MMode0 section (4.2.3) in data sheet for ATM90E36
PGA Gain -
Current gain -
Note: values are adjusted from https://github.com/DitroniX/IPEM-IoT-Power-Energy-Monitor/blob/main/Code/IPEM_1_Test_Code_ATM90E32_ATM90E36/include/IPEM_Hardware.h
*/
unsigned short PgaGain = 0b0101010101111111;
unsigned short VoltageGain = 19700;
this->eic->begin(5, 4485, PgaGain, VoltageGain, 0x1000,0x1000, 0x1000, 0x1000);
unsigned short PgaGain = 0b0101010101111100;
unsigned short frequency = 0b0001010110000101;
unsigned short VoltageGain = 20200;
this->eic->begin(SS, frequency, PgaGain, VoltageGain, 0x1000,0x0111, 0x1000, 0x1000);
}
double ATM90E36_IC::GetLineVoltage()
{

22
src/tests/AT90E36.cpp
Unescape View File

@ -21,7 +21,7 @@ void setup() {
/*
The ATM90E36 has to be setup via SPI.
SPI for the ESP32:
- CLK: 18
- CLK: 33
- MISO: 19
- MOSI: 23
- CS: 5
@ -38,17 +38,19 @@ void setup() {
SPI.begin(SCK, MISO, MOSI, SS);
delay(1000);
/*
pin
line frequency
PgaGain
CS pin - 33 for ESP32
Line Frequency - 60 Hz for NA - 5509 - see MMode0 section (4.2.3) in data sheet for ATM90E36
PGA Gain -
Current gain -
Note: values are adjusted from https://github.com/DitroniX/IPEM-IoT-Power-Energy-Monitor/blob/main/Code/IPEM_1_Test_Code_ATM90E32_ATM90E36/include/IPEM_Hardware.h
*/
eic.begin(5, 0x0001, 0x00, 0xC172, 0x1200,0, 0, 0);
unsigned short PgaGain = 0x5555;
unsigned short frequency = 0b0001010110000101;
unsigned short VoltageGain = 19800;
eic.begin(SS, frequency, PgaGain, VoltageGain, 0x1000,0x1000, 0x1000, 0x1000);
delay(1000);
}
void loop() {
/*Repeatedly fetch some values from the ATM90E36 */
@ -81,6 +83,6 @@ void loop() {
freq=eic.GetFrequency();
delay(10);
Serial.println("f"+String(freq)+"Hz");
Serial.println("Waiting 5s");
delay(2000);
Serial.println("Waiting 1s");
delay(1000);
}

20
src/transformerMonitor.cpp
Unescape View File

@ -146,17 +146,24 @@ void loop()
int emptySpaces = uxQueueSpacesAvailable(eicDataQueue);
for (;;)
{
// Serial.println("hello from Sensor data");
if (messagesWaiting > 2)
{
xQueueReceive(eicDataQueue, &mqttSensorData, portMAX_DELAY);
char timeBuffer[32];
strftime(timeBuffer, sizeof(timeBuffer), "%FT%TZ", mqttSensorData.timeInfo);
// Sensor is not working
if (mqttSensorData.sys0Status == 6555 || mqttSensorData.sys0Status == 0)
{
setLEDColor(255,0,0);
} else {
setLEDColor(0,255,0);
}
mqttJsonData["deviceId"] = client_id;
mqttJsonData["time"] = timeBuffer;
mqttJsonData["meterStatus"] = mqttSensorData.meterStatus;
mqttJsonData["sysStatus"] = mqttSensorData.sysStatus;
mqttJsonData["sys0Status"] = mqttSensorData.sys0Status;
mqttJsonData["sys1Status"] = mqttSensorData.sys1Status;
mqttJsonData["current"] = mqttSensorData.lineCurrent;
mqttJsonData["neutralCurrent"] = mqttSensorData.neutralCurrent;
mqttJsonData["voltage"] = mqttSensorData.lineCurrent;
@ -221,6 +228,8 @@ void setupEnergyMonitor()
delay(1000);
eic.begin();
#endif
}
@ -266,7 +275,8 @@ void IRAM_ATTR ReadData(){
time(&now);
// set {"time":"2021-05-04T13:13:04Z"}
sensorData.timeInfo = gmtime(&now);
sensorData.sys0Status = eic.GetMeterStatus0();
sensorData.sys1Status = eic.GetMeterStatus1();
sensorData.lineVoltage = eic.GetLineVoltage();
sensorData.lineCurrent = eic.GetLineCurrent();
sensorData.neutralCurrent = eic.GetLineCurrentN();

Write Preview
Loading…
Cancel
Save