e.cruz/Industrial_Emulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

3

Browse Source
This commit is contained in:
Emmanuel HC
2025-10-27 08:07:59 -05:00
parent 39e70ca9ad
commit 83a2028238
8 changed files with 327 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files

51
src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Running.cpp
View File

@@ -39,20 +39,19 @@
template<> template<>
RunningState<ModbusIP>::RunningState() { RunningState<ModbusIP>::RunningState() {
addStrategy("Source 1 Volts AB", new SingleValueStrategy(0.0F, 0.0f, 1000));
addStrategy("Source 1 Volts BC", new SingleValueStrategy(0.0F, 0.0f, 1000));
addStrategy("Source 2 Volts CA", new SingleValueStrategy(0.0F, 0.0f, 1000));
addStrategy("Source 2 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 2 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 2 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 2 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 2 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 2 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 1 Frequency", new SingleValueStrategy(0.0f, 0.0f, 1000));
addStrategy("Source 2 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000)); addStrategy("Source 2 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000));
addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000)); addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000));
addStrategy("Volts AB", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Amps A", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("Votls BC", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Amps B", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("Volts CA", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Amps C", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("Amps A", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Amps B", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Amps C", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Total Active Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
addStrategy("Total Apparent Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
} }
@@ -78,20 +77,31 @@ State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment)
return new StandbyState<ModbusIP>(); return new StandbyState<ModbusIP>();
} }
int I_load = getPointValue(equipment, "ATS_Load"); float load = getPointValue(equipment, "ATS_Load");
int I_rating = getPointValue(equipment, "ATS_Rating"); float rating = getPointValue(equipment, "ATS_Rating");
float load = static_cast<float>(I_load); float sim_load = rating * (load/100.0f);
float rating = static_cast<float>(I_rating);
float real_load = rating * (load/100.0f);
Strategy_Behavior* ampsA_svs = getStrategy("Amps A"); Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
Strategy_Behavior* ampsB_svs = getStrategy("Amps B"); Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
Strategy_Behavior* ampsC_svs = getStrategy("Amps C"); Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load);
static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load);
static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load);
// Apply any strategies defined for the standby state // Apply any strategies defined for the standby state
float v_ab = getPointValue(equipment, "Source 2 Volts AB");
float v_bc = getPointValue(equipment, "Source 2 Volts BC");
float v_ca = getPointValue(equipment, "Source 2 Volts CA");
float i_a = getPointValue(equipment, "Amps A");
float i_b = getPointValue(equipment, "Amps B");
float i_c = getPointValue(equipment, "Ampc C");
float pwr = ((v_ab * i_a) + (v_bc * i_b) + (v_ca * i_c));
setPointValue(equipment, "Total Active Power", pwr*1000.0f);
float pf = getPointValue(equipment, "Power Factor");
float a_pwr = pwr * (pf/100.0f);
setPointValue(equipment, "Total Apparent Power", a_pwr*1000.0f);
_applyStrategies(equipment); _applyStrategies(equipment);
return nullptr; return nullptr;
} }
@@ -113,6 +123,11 @@ void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
setPointValue(equipment, "Source 1 Preferred", 1); setPointValue(equipment, "Source 1 Preferred", 1);
setPointValue(equipment, "Source 2 Preferred", 0); setPointValue(equipment, "Source 2 Preferred", 0);
setPointValue(equipment, "Source 1 Volts AB", 0.0f);
setPointValue(equipment, "Source 1 Volts BC", 0.0f);
setPointValue(equipment, "Source 1 Volts CA", 0.0f);
setPointValue(equipment, "Source 1 Frequency", 0.0f);
int transferQty = getPointValue(equipment, "Number of Transfers"); int transferQty = getPointValue(equipment, "Number of Transfers");
setPointValue(equipment, "Number of Transfers", transferQty + 1); setPointValue(equipment, "Number of Transfers", transferQty + 1);
} }

61
src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/State_Standby.cpp
View File

@@ -37,21 +37,21 @@
*/ */
template<> template<>
StandbyState<ModbusIP>::StandbyState() { StandbyState<ModbusIP>::StandbyState() {
// You can add initialization code here if needed // You can add initialization code here if needed
addStrategy("Source 1 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 1 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 1 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 1 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 1 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("Source 1 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000));
addStrategy("Source 2 Volts AB", new SingleValueStrategy(0.0F, 0.0f, 1000)); addStrategy("Source 1 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000));
addStrategy("Source 2 Volts BC", new SingleValueStrategy(0.0F, 0.0f, 1000)); addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000));
addStrategy("Source 2 Volts CA", new SingleValueStrategy(0.0F, 0.0f, 1000)); addStrategy("Volts AB", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Source 1 Frequency", new SingleValueStrategy(60.0f, 1.0f, 1000)); addStrategy("Votls BC", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Source 2 Frequency", new SingleValueStrategy(0.0f, 0.0f, 1000)); addStrategy("Volts CA", new SingleValueStrategy(480.0f, 2.0f, 1000));
addStrategy("Amps A", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Amps B", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Amps C", new SingleValueStrategy(1.0f, 3.0f, 1000));
addStrategy("Total Active Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
addStrategy("Total Apparent Power", new SingleValueStrategy(6.0f, 5.0f, 1000));
addStrategy("Power Factor", new SingleValueStrategy(90.0f, 2.0f, 1000));
addStrategy("Amps A", new SingleValueStrategy(1.0f, 5.0f, 1000));
addStrategy("Amps B", new SingleValueStrategy(1.0f, 5.0f, 1000));
addStrategy("Amps C", new SingleValueStrategy(1.0f, 5.0f, 1000));
} }
/** /**
@@ -73,19 +73,31 @@ State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment)
return new RunningState<ModbusIP>(); return new RunningState<ModbusIP>();
} }
int I_load = getPointValue(equipment, "ATS_Load"); float load = getPointValue(equipment, "ATS_Load");
int I_rating = getPointValue(equipment, "ATS_Rating"); float rating = getPointValue(equipment, "ATS_Rating");
float load = static_cast<float>(I_load); float sim_load = rating * (load/100.0f);
float rating = static_cast<float>(I_rating);
float real_load = rating * (load/100.0f);
Strategy_Behavior* ampsA_svs = getStrategy("Amps A"); Strategy_Behavior* ampsA_svs = getStrategy("Amps A");
Strategy_Behavior* ampsB_svs = getStrategy("Amps B"); Strategy_Behavior* ampsB_svs = getStrategy("Amps B");
Strategy_Behavior* ampsC_svs = getStrategy("Amps C"); Strategy_Behavior* ampsC_svs = getStrategy("Amps C");
static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load);
static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load);
static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load);
// Apply any strategies defined for the standby state // Apply any strategies defined for the standby state
float v_ab = getPointValue(equipment, "Source 1 Volts AB");
float v_bc = getPointValue(equipment, "Source 1 Volts BC");
float v_ca = getPointValue(equipment, "Source 1 Volts CA");
float i_a = getPointValue(equipment, "Amps A");
float i_b = getPointValue(equipment, "Amps B");
float i_c = getPointValue(equipment, "Ampc C");
float pwr = ((v_ab * i_a) + (v_bc * i_b) + (v_ca * i_c));
setPointValue(equipment, "Total Active Power", pwr*1000.0f);
float pf = getPointValue(equipment, "Power Factor");
float a_pwr = pwr * (pf/100.0f);
setPointValue(equipment, "Total Apparent Power", a_pwr*1000.0f);
_applyStrategies(equipment); _applyStrategies(equipment);
return nullptr; return nullptr;
} }
@@ -107,6 +119,11 @@ void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
setPointValue(equipment, "Source 1 Preferred", 0); setPointValue(equipment, "Source 1 Preferred", 0);
setPointValue(equipment, "Source 2 Preferred", 1); setPointValue(equipment, "Source 2 Preferred", 1);
setPointValue(equipment, "Source 2 Volts AB", 0.0f);
setPointValue(equipment, "Source 2 Volts BC", 0.0f);
setPointValue(equipment, "Source 2 Volts CA", 0.0f);
setPointValue(equipment, "Source 2 Frequency", 0.0f);
int transferQty = getPointValue(equipment, "Number of Transfers"); int transferQty = getPointValue(equipment, "Number of Transfers");
setPointValue(equipment, "Number of Transfers", transferQty + 1); setPointValue(equipment, "Number of Transfers", transferQty + 1);
} }

6
src/EPMS/ATS/ATS_Eaton_ATC900_RPD_TCP/config.h
View File

@@ -86,9 +86,9 @@ modbusMap mb_map[] =
{IR, 6158, 0, "Amps A"}, {IR, 6158, 0, "Amps A"},
{IR, 6159, 0, "Amps B"}, {IR, 6159, 0, "Amps B"},
{IR, 6160, 0, "Amps C"}, {IR, 6160, 0, "Amps C"},
{IR_LONG, 6165, 0, "Total Active Power"}, {IR_LONG, 6165, 0, "Total Active Power"}, //0.001
{IR_LONG, 6169, 0, "Total Apparent Power"}, {IR_LONG, 6169, 0, "Total Apparent Power"}, //0.001
{IR, 6171, 0, "Power Factor"}, {IR, 6171, 0, "Power Factor"}, //0.001
{IR, 6263, 0, "Number of Transfers"}, {IR, 6263, 0, "Number of Transfers"},
{IR, 6297, 0, "Alarm Status Bits"}, {IR, 6297, 0, "Alarm Status Bits"},

54
src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Running.cpp
View File

@@ -39,15 +39,15 @@
template<> template<>
RunningState<ModbusIP>::RunningState() { RunningState<ModbusIP>::RunningState() {
addStrategy("S2 Volts AB", new SingleValueStrategy(4800.0F, 2.0f, 1000)); addStrategy("S2 Volts AB", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("S2 Volts BC", new SingleValueStrategy(4800.0F, 2.0f, 1000)); addStrategy("S2 Volts BC", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("S2 Volts CA", new SingleValueStrategy(4800.0F, 2.0f, 1000)); addStrategy("S2 Volts CA", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("PF", new SingleValueStrategy(90.0f, 2.0f, 1000)); addStrategy("PF", new SingleValueStrategy(910.0f, 20.0f, 1000));
addStrategy("S2 Amps A", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S2 Amps A", new SingleValueStrategy(200.0f, 100.0f, 1000));
addStrategy("S2 Amps B", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S2 Amps B", new SingleValueStrategy(200.0f, 100.0f, 1000));
addStrategy("S2 Amps C", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S2 Amps C", new SingleValueStrategy(200.0f, 100.0f, 1000));
} }
@@ -74,33 +74,36 @@ State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment)
} }
float volts_AB = getPointValue(equipment, "S2 Volts AB"); float volts_AB = getPointValue(equipment, "S2 Volts AB");
float volts_BC = getPointValue(equipment, "S2 Volts BC"); float volts_BC = getPointValue(equipment, "S2 Volts BC");
float volts_AC = getPointValue(equipment, "S2 Volts CA"); float volts_CA = getPointValue(equipment, "S2 Volts CA");
setPointValue(equipment, "S2 Volts AN", volts_AB/17.32); setPointValue(equipment, "S2 Volts AN", volts_AB/1.732);
setPointValue(equipment, "S2 Volts BN", volts_BC/17.32); setPointValue(equipment, "S2 Volts BN", volts_BC/1.732);
setPointValue(equipment, "S2 Volts CN", volts_AC/17.32); setPointValue(equipment, "S2 Volts CN", volts_CA/1.732);
int I_load = getPointValue(equipment, "ATS_Load"); int I_load = getPointValue(equipment, "ATS_Load");
int I_rating = getPointValue(equipment, "ATS_Rating"); int I_rating = getPointValue(equipment, "ATS_Rating");
float load = static_cast<float>(I_load); float load = static_cast<float>(I_load);
float rating = static_cast<float>(I_rating); float rating = static_cast<float>(I_rating);
float real_load = rating * (load/100.0f); float sim_load = rating * (load/100.0f);
Strategy_Behavior* ampsA_svs = getStrategy("S2 Amps A"); Strategy_Behavior* ampsA_svs = getStrategy("S2 Amps A");
Strategy_Behavior* ampsB_svs = getStrategy("S2 Amps B"); Strategy_Behavior* ampsB_svs = getStrategy("S2 Amps B");
Strategy_Behavior* ampsC_svs = getStrategy("S2 Amps C"); Strategy_Behavior* ampsC_svs = getStrategy("S2 Amps C");
static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load*1000.0f);
static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load*1000.0f);
static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load*1000.0f);
float pf = getPointValue(equipment, "PF"); float get_pf = getPointValue(equipment, "PF");
float pf = get_pf/1000.0f;
float real_v_AB = volts_AB/1000.0f;
float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000; float real_v_BC = volts_BC/1000.0f;
float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000; float real_v_CA = volts_CA/1000.0f;
float kw = (1.732f * ((real_v_AB + real_v_BC + real_v_CA)/3.0f) * sim_load * pf)*10;
float mwh = kw *600.0f;
setPointValue(equipment, "S2 kW", kw); setPointValue(equipment, "S2 kW", kw);
setPointValue(equipment, "S2 kVA", kva); setPointValue(equipment, "S2 MWh", mwh);
// Apply any strategies defined for the standby state // Apply any strategies defined for the standby state
_applyStrategies(equipment); _applyStrategies(equipment);
@@ -117,9 +120,6 @@ void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
// Logic to run when the equipment enters this state // Logic to run when the equipment enters this state
Serial.println("Enter Running State..."); Serial.println("Enter Running State...");
// You could also update a Modbus register to show the "standby" state // You could also update a Modbus register to show the "standby" state
setPointValue(equipment, "Source Active", 32);
setPointValue(equipment, "Source Preferred", 512);
setPointValue(equipment, "S1 Volts AB", 0.0f); setPointValue(equipment, "S1 Volts AB", 0.0f);
setPointValue(equipment, "S1 Volts BC", 0.0f); setPointValue(equipment, "S1 Volts BC", 0.0f);
setPointValue(equipment, "S1 Volts CA", 0.0f); setPointValue(equipment, "S1 Volts CA", 0.0f);
@@ -129,8 +129,14 @@ void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
setPointValue(equipment, "S1 Amps A", 0.0f); setPointValue(equipment, "S1 Amps A", 0.0f);
setPointValue(equipment, "S1 Amps B", 0.0f); setPointValue(equipment, "S1 Amps B", 0.0f);
setPointValue(equipment, "S1 Amps C", 0.0f); setPointValue(equipment, "S1 Amps C", 0.0f);
setBitValue(equipment, "Source Active", 3, true); setPointValue(equipment, "S1 kW", 0.0f);
setPointValue(equipment, "S1 MWh", 0.0f);
setBitValue(equipment, "Source Active", 4, false); setBitValue(equipment, "Source Active", 4, false);
setBitValue(equipment, "Source Active", 3, true);
setBitValue(equipment, "Source Preferred", 8, false);
setBitValue(equipment, "Source Preferred", 9, true);
} }
/** /**

46
src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/State_Standby.cpp
View File

@@ -38,15 +38,15 @@
template<> template<>
StandbyState<ModbusIP>::StandbyState() { StandbyState<ModbusIP>::StandbyState() {
// You can add initialization code here if needed // You can add initialization code here if needed
addStrategy("S1 Volts AB", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("S1 Volts AB", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("S1 Volts BC", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("S1 Volts BC", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("S1 Volts CA", new SingleValueStrategy(480.0F, 2.0f, 1000)); addStrategy("S1 Volts CA", new SingleValueStrategy(4800.0F, 10.0f, 1000));
addStrategy("PF", new SingleValueStrategy(90.0f, 2.0f, 1000)); addStrategy("PF", new SingleValueStrategy(910.0f, 20.0f, 1000));
addStrategy("S1 Amps A", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S1 Amps A", new SingleValueStrategy(200.0f, 100.0f, 1000));
addStrategy("S1 Amps B", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S1 Amps B", new SingleValueStrategy(200.0f, 100.0f, 1000));
addStrategy("S1 Amps C", new SingleValueStrategy(1.0f, 5.0f, 1000)); addStrategy("S1 Amps C", new SingleValueStrategy(200.0f, 100.0f, 1000));
} }
/** /**
@@ -68,33 +68,36 @@ State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment)
} }
float volts_AB = getPointValue(equipment, "S1 Volts AB"); float volts_AB = getPointValue(equipment, "S1 Volts AB");
float volts_BC = getPointValue(equipment, "S1 Volts BC"); float volts_BC = getPointValue(equipment, "S1 Volts BC");
float volts_AC = getPointValue(equipment, "S1 Volts CA"); float volts_CA = getPointValue(equipment, "S1 Volts CA");
setPointValue(equipment, "S1 Volts AN", volts_AB/1.732); setPointValue(equipment, "S1 Volts AN", volts_AB/1.732);
setPointValue(equipment, "S1 Volts BN", volts_BC/1.732); setPointValue(equipment, "S1 Volts BN", volts_BC/1.732);
setPointValue(equipment, "S1 Volts CN", volts_AC/1.732); setPointValue(equipment, "S1 Volts CN", volts_CA/1.732);
int I_load = getPointValue(equipment, "ATS_Load"); int I_load = getPointValue(equipment, "ATS_Load");
int I_rating = getPointValue(equipment, "ATS_Rating"); int I_rating = getPointValue(equipment, "ATS_Rating");
float load = static_cast<float>(I_load); float load = static_cast<float>(I_load);
float rating = static_cast<float>(I_rating); float rating = static_cast<float>(I_rating);
float real_load = rating * (load/100.0f); float sim_load = rating * (load/100.0f);
Strategy_Behavior* ampsA_svs = getStrategy("S1 Amps A"); Strategy_Behavior* ampsA_svs = getStrategy("S1 Amps A");
Strategy_Behavior* ampsB_svs = getStrategy("S1 Amps B"); Strategy_Behavior* ampsB_svs = getStrategy("S1 Amps B");
Strategy_Behavior* ampsC_svs = getStrategy("S1 Amps C"); Strategy_Behavior* ampsC_svs = getStrategy("S1 Amps C");
static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsA_svs)->setSetpoint(sim_load*1000.0f);
static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsB_svs)->setSetpoint(sim_load*1000.0f);
static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(real_load); static_cast<SingleValueStrategy*>(ampsC_svs)->setSetpoint(sim_load*1000.0f);
float pf = getPointValue(equipment, "PF"); float get_pf = getPointValue(equipment, "PF");
float pf = get_pf/1000.0f;
float real_v_AB = volts_AB/1000.0f;
float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000; float real_v_BC = volts_BC/1000.0f;
float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000; float real_v_CA = volts_CA/1000.0f;
float kw = (1.732f * ((real_v_AB + real_v_BC + real_v_CA)/3.0f) * sim_load * pf)*10;
float mwh = kw *600.0f;
setPointValue(equipment, "S1 kW", kw); setPointValue(equipment, "S1 kW", kw);
setPointValue(equipment, "S1 kVA", kva); setPointValue(equipment, "S1 MWh", mwh);
_applyStrategies(equipment); _applyStrategies(equipment);
return nullptr; return nullptr;
} }
@@ -109,8 +112,6 @@ template<>
void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) { void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
// Logic to run when the equipment enters this state // Logic to run when the equipment enters this state
Serial.println("Enter Standby State..."); Serial.println("Enter Standby State...");
setPointValue(equipment, "Source Active", 64);
setPointValue(equipment, "Source Preferred", 1024);
setPointValue(equipment, "S2 Volts AB", 0.0f); setPointValue(equipment, "S2 Volts AB", 0.0f);
setPointValue(equipment, "S2 Volts BC", 0.0f); setPointValue(equipment, "S2 Volts BC", 0.0f);
@@ -121,9 +122,14 @@ void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
setPointValue(equipment, "S2 Amps A", 0.0f); setPointValue(equipment, "S2 Amps A", 0.0f);
setPointValue(equipment, "S2 Amps B", 0.0f); setPointValue(equipment, "S2 Amps B", 0.0f);
setPointValue(equipment, "S2 Amps C", 0.0f); setPointValue(equipment, "S2 Amps C", 0.0f);
setPointValue(equipment, "S2 kW", 0.0f);
setPointValue(equipment, "S2 MWh", 0.0f);
setBitValue(equipment, "Source Active", 3, false); setBitValue(equipment, "Source Active", 3, false);
setBitValue(equipment, "Source Active", 4, true); setBitValue(equipment, "Source Active", 4, true);
setBitValue(equipment, "Source Preferred", 8, false);
setBitValue(equipment, "Source Preferred", 9, true);
} }
/** /**

51
src/EPMS/ATS/ATS_Woodward_DTSC200A_TCP/config.h
View File

@@ -64,31 +64,32 @@ modbusMap mb_map[] =
{HR, 10, 0, "ATS_Load"}, {HR, 10, 0, "ATS_Load"},
{HR, 11, 0, "ATS_Rating"}, //Internal Fault code from Modscan {HR, 11, 0, "ATS_Rating"}, //Internal Fault code from Modscan
{HR, 50009, 0, "PF"}, {HR, 50009, 0, "PF"}, //0.001x
{HR_LONG, 50001, 0, "S2 Volts AB"}, {HR_LONG, 50001, 0, "S2 Volts AB"}, //0.1x
{HR_LONG, 50004, 0, "S2 Volts AN"}, {HR_LONG, 50004, 0, "S2 Volts AN"}, //0.1x
{HR_LONG, 50007, 0, "S2 Volts BC"}, {HR_LONG, 50007, 0, "S2 Volts BC"}, //0.1x
{HR_LONG, 50010, 0, "S2 Volts BN"}, {HR_LONG, 50010, 0, "S2 Volts BN"}, //0.1x
{HR_LONG, 50013, 0, "S2 Volts CA"}, {HR_LONG, 50013, 0, "S2 Volts CA"}, //0.1x
{HR_LONG, 50016, 0, "S2 Volts CN"}, {HR_LONG, 50016, 0, "S2 Volts CN"}, //0.1x
{HR_LONG, 50019, 0, "S1 Volts AB"}, {HR_LONG, 50019, 0, "S1 Volts AB"}, //0.1x
{HR_LONG, 50022, 0, "S1 Volts AN"}, {HR_LONG, 50022, 0, "S1 Volts AN"}, //0.1x
{HR_LONG, 50025, 0, "S1 Volts BC"}, {HR_LONG, 50025, 0, "S1 Volts BC"}, //0.1x
{HR_LONG, 50028, 0, "S1 Volts BN"}, {HR_LONG, 50028, 0, "S1 Volts BN"}, //0.1x
{HR_LONG, 50031, 0, "S1 Volts CA"}, {HR_LONG, 50031, 0, "S1 Volts CA"}, //0.1x
{HR_LONG, 50034, 0, "S1 Volts CN"}, {HR_LONG, 50034, 0, "S1 Volts CN"}, //0.1x
{HR_LONG, 50037, 0, "S2 Amps A"}, {HR_LONG, 50037, 0, "S2 Amps A"}, //0.001x
{HR_LONG, 50040, 0, "S2 Amps B"}, {HR_LONG, 50040, 0, "S2 Amps B"}, //0.001x
{HR_LONG, 50043, 0, "S2 Amps C"}, {HR_LONG, 50043, 0, "S2 Amps C"}, //0.001x
{HR_LONG, 50060, 0, "S2 kW"}, {HR_LONG, 50060, 0, "S2 kW"},
{HR_LONG, 50064, 0, "S2 MWh"}, {HR_LONG, 50064, 0, "S2 MWh"}, //0.01x
{HR, 50078, 0, "Source Preferred"}, // bit 8 and bit 9 {HR, 50078, 0, "Source Preferred"}, //bit9 source1 bit8 source 2
{HR, 50082, 0, "Source Active"}, //bit2 and bit 3 {HR, 50082, 0, "Source Active"}, //bit4 source1 bit3 source 2
{HR_LONG, 50091, 0, "S1 Amps A"}, {HR_LONG, 50091, 0, "S1 Amps A"}, //.001x
{HR, 50093, 0, "S1 kW"}, {HR, 50093, 0, "S1 kW"}, //.1x
{HR_LONG, 50094, 0, "S1 Amps B"}, {HR_LONG, 50094, 0, "S1 Amps B"}, //.001x
{HR_LONG, 50097, 0, "S1 Amps C"}, {HR_LONG, 50097, 0, "S1 Amps C"}, //.001x
{HR_LONG, 50100, 0, "S1 MWh"}, {HR_LONG, 50100, 0, "S1 MWh"}, //.01x
}; };
//Size of modbus map used in FOR cycles, automatically calculated. //Size of modbus map used in FOR cycles, automatically calculated.

18
src/EPMS/PDU/PDU_Maverick_Power_TCP/State_Running.cpp
View File

@@ -36,29 +36,21 @@
* state, such as a PID controller for the 'CW Valve Position' and totalizers * state, such as a PID controller for the 'CW Valve Position' and totalizers
* for the run-hours of each EC fan. * for the run-hours of each EC fan.
*/ */
std::string cbs[] = {"CB0", "CB1", "CB2", "CB3", "CB4", "CB5", "CB6", "CB7", "CB8", "CB9"}; std::string cbs[] = {"CB1", "CB2", "CB3", "CB4", "CB5", "CB6", "CB7", "CB8"};
template<> template<>
RunningState<ModbusIP>::RunningState() { RunningState<ModbusIP>::RunningState() {
for (const std::string& cb : cbs) { for (const std::string& cb : cbs) {
std::string tag = ""; std::string tag = "";
tag = cb + "_V1N"; tag = cb + "_V1N";
addStrategy(tag, new SingleValueStrategy(0.0f, 30.0f, 1000)); addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
tag = ""; tag = "";
tag = cb + "_V2N"; tag = cb + "_V2N";
addStrategy(tag, new SingleValueStrategy(0.0f, 30.0f, 1000)); addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
tag = ""; tag = "";
tag = cb + "_V3N"; tag = cb + "_V3N";
addStrategy(tag, new SingleValueStrategy(0.0f, 30.0f, 1000)); addStrategy(tag, new SingleValueStrategy(40.0f, 30.0f, 1000));
tag = "";
tag = cb + "_L1PF";
addStrategy(tag, new SingleValueStrategy(93.0f, 9.0f, 1000));
tag = "";
tag = cb + "_L2PF";
addStrategy(tag, new SingleValueStrategy(93.0f, 9.0f, 1000));
tag = "";
tag = cb + "_L3PF";
addStrategy(tag, new SingleValueStrategy(93.0f, 9.0f, 1000));
tag = ""; tag = "";
tag = cb + "_V1THD"; tag = cb + "_V1THD";
addStrategy(tag, new SingleValueStrategy(20.0f, 7.0f, 1000)); addStrategy(tag, new SingleValueStrategy(20.0f, 7.0f, 1000));

649
src/EPMS/PDU/PDU_Maverick_Power_TCP/config.h
View File

@@ -64,9 +64,9 @@ modbusMap mb_map[] = {
// Write Registers (as Input Registers - 3X) // Write Registers (as Input Registers - 3X)
//*************************************** //***************************************
{HR, 9, 0, "Px Ctrl"}, {HR, 9, 0, "Px Ctrl"},
{HR, 10, 0, "Px Rating"}, //Watts {HR, 10, 0, "Px Rating"}, //Amps
{HR, 11, 0, "Px Load"}, //%load {HR, 11, 0, "Px Load"}, //%load
{HR, 19, 0, "Px_CB0"}, {HR, 19, 0, "Px_Input"},
{HR, 20, 0, "Px_CB1"}, {HR, 20, 0, "Px_CB1"},
{HR, 21, 0, "Px_CB2"}, {HR, 21, 0, "Px_CB2"},
{HR, 22, 0, "Px_CB3"}, {HR, 22, 0, "Px_CB3"},
@@ -75,497 +75,178 @@ modbusMap mb_map[] = {
{HR, 25, 0, "Px_CB6"}, {HR, 25, 0, "Px_CB6"},
{HR, 26, 0, "Px_CB7"}, {HR, 26, 0, "Px_CB7"},
{HR, 27, 0, "Px_CB8"}, {HR, 27, 0, "Px_CB8"},
{HR, 28, 0, "Px_CB9"}, {HR, 28, 0, "Px_Output"},
// System Status // PDU Input
{IR_LONG, 0, 0, "CB0_V1N" }, {IR_LONG, 6, 0, "Input_I1" }, //0.01
{IR_LONG, 2, 0, "CB0_V2N" }, {IR_LONG, 8, 0, "Input_I2" }, //0.01
{IR_LONG, 4, 0, "CB0_V3N" }, {IR_LONG, 10, 0, "Input_I3" }, //0.01
{IR_LONG, 6, 0, "CB0_I1" }, {IR_LONG, 70, 0, "Input_kVA" }, //0.001
{IR_LONG, 8, 0, "CB0_I2" }, {IR_LONG, 68, 0, "Input_KVAR" }, //0.001
{IR_LONG, 10, 0, "CB0_I3" }, {IR_LONG, 66, 0, "Input_kW" }, //0.001
{IR_LONG, 12, 0, "CB0_L1KW" }, {IR_LONG, 66, 0, "Input_kWh" }, //0.1
{IR_LONG, 14, 0, "CB0_L2KW" }, {IR_LONG, 72, 0, "Input_PF" }, //0.001
{IR_LONG, 16, 0, "CB0_L3KW" }, {IR_LONG, 60, 0, "Input_V_AB" }, //0.1
{IR_LONG, 18, 0, "CB0_L1KVar" }, {IR_LONG, 0, 0, "Input_V_AN" }, //0.1
{IR_LONG, 20, 0, "CB0_L2KVar" }, {IR_LONG, 62, 0, "Input_V_BC" }, //0.1
{IR_LONG, 22, 0, "CB0_L3KVar" }, {IR_LONG, 2, 0, "Input_V_BN" }, //0.1
{IR_LONG, 24, 0, "CB0_L1KVA" }, {IR_LONG, 64, 0, "Input_V_CA" }, //0.1
{IR_LONG, 26, 0, "CB0_L2KVA" }, {IR_LONG, 4, 0, "Input_V_CN" }, //0.1
{IR_LONG, 28, 0, "CB0_L3KVA" }, {IR_LONG, 88, 0, "Input_LL_Avg" },//0.1
{IR_LONG, 30, 0, "CB0_L1PF" }, {IR_LONG, 86, 0, "Input_LN_Avg" },//0.1
{IR_LONG, 32, 0, "CB0_L2PF" },
{IR_LONG, 34, 0, "CB0_L3PF" }, // Circuit Breaker 1 (CB1)
{IR_LONG, 36, 0, "CB0_V1THD" }, {IR_LONG, 106, 0, "CB1_I1" }, //0.01x
{IR_LONG, 38, 0, "CB0_V2THD" }, {IR_LONG, 108, 0, "CB1_I2" }, //0.01x
{IR_LONG, 40, 0, "CB0_V3THD" }, {IR_LONG, 110, 0, "CB1_I3" }, //0.01x
{IR_LONG, 42, 0, "CB0_I1THD" }, {IR_LONG, 170, 0, "CB1_kVA" }, //0.001x
{IR_LONG, 44, 0, "CB0_I2THD" }, {IR_LONG, 124, 0, "CB1_kVA1" }, //0.001x
{IR_LONG, 46, 0, "CB0_I3THD" }, {IR_LONG, 126, 0, "CB1_kVA2" }, //0.001x
{IR_LONG, 48, 0, "CB0_I1Kfactor" }, {IR_LONG, 128, 0, "CB1_kVA3" }, //0.001x
{IR_LONG, 50, 0, "CB0_I2Kfactor" }, {IR_LONG, 168, 0, "CB1_kVAR" }, //0.001x
{IR_LONG, 52, 0, "CB0_I3Kfactor" }, {IR_LONG, 166, 0, "CB1_kW" }, //0.001x
{IR_LONG, 54, 0, "CB0_I1TDD" }, {IR_LONG, 112, 0, "CB1_kW1" }, //0.001x
{IR_LONG, 56, 0, "CB0_I2TDD" }, {IR_LONG, 114, 0, "CB1_kW2" }, //0.001x
{IR_LONG, 58, 0, "CB0_I3TDD" }, {IR_LONG, 116, 0, "CB1_kW3" }, //0.001x
{IR_LONG, 60, 0, "CB0_V12" }, {IR_LONG, 1113, 0, "CB1_kWh" },
{IR_LONG, 62, 0, "CB0_V23" }, {IR_LONG, 172, 0, "CB1_PF" }, //0.001x
{IR_LONG, 64, 0, "CB0_V31" },
{IR_LONG, 66, 0, "CB0_TotalKW" },
{IR_LONG, 68, 0, "CB0_TotalKVar" },
{IR_LONG, 70, 0, "CB0_TotalKVA" }, //
{IR_LONG, 72, 0, "CB0_TotalPF" },
{IR_LONG, 74, 0, "CB0_TotalPFLag" },
{IR_LONG, 76, 0, "CB0_TotalPFLead" },
{IR_LONG, 78, 0, "CB0_TotalKWImport" },
{IR_LONG, 80, 0, "CB0_TotalKWExport" },
{IR_LONG, 82, 0, "CB0_TotalKVarImport" },
{IR_LONG, 84, 0, "CB0_TotalKVarExport" },
{IR_LONG, 86, 0, "CB0_LN_Avg" },
{IR_LONG, 88, 0, "CB0_LL_Avg" },
{IR_LONG, 92, 0, "CB0_TotalKWh" },
{IR_LONG, 99, 0, "CB0_Status" },
// Circuit Breaker 1 (OB01) // Circuit Breaker 2 (CB1)
{IR_LONG, 100, 0, "CB1_V1N" }, {IR_LONG, 206, 0, "CB2_I1" }, //0.01x
{IR_LONG, 102, 0, "CB1_V2N" }, {IR_LONG, 208, 0, "CB2_I2" }, //0.01x
{IR_LONG, 104, 0, "CB1_V3N" }, {IR_LONG, 210, 0, "CB2_I3" }, //0.01x
{IR_LONG, 106, 0, "CB1_I1" }, {IR_LONG, 270, 0, "CB2_kVA" }, //0.001x
{IR_LONG, 108, 0, "CB1_I2" }, {IR_LONG, 224, 0, "CB2_kVA1" }, //0.001x
{IR_LONG, 110, 0, "CB1_I3" }, {IR_LONG, 226, 0, "CB2_kVA2" }, //0.001x
{IR_LONG, 112, 0, "CB1_L1KW" }, {IR_LONG, 228, 0, "CB2_kVA3" }, //0.001x
{IR_LONG, 114, 0, "CB1_L2KW" }, {IR_LONG, 268, 0, "CB2_kVAR" }, //0.001x
{IR_LONG, 116, 0, "CB1_L3KW" }, {IR_LONG, 266, 0, "CB2_kW" }, //0.001x
{IR_LONG, 118, 0, "CB1_L1KVar" }, {IR_LONG, 212, 0, "CB2_kW1" }, //0.001x
{IR_LONG, 120, 0, "CB1_L2KVar" }, {IR_LONG, 214, 0, "CB2_kW2" }, //0.001x
{IR_LONG, 122, 0, "CB1_L3KVar" }, {IR_LONG, 216, 0, "CB2_kW3" }, //0.001x
{IR_LONG, 124, 0, "CB1_L1KVA" }, {IR_LONG, 1168, 0, "CB2_kWh" },
{IR_LONG, 126, 0, "CB1_L2KVA" }, {IR_LONG, 272, 0, "CB2_PF" }, //0.001x
{IR_LONG, 128, 0, "CB1_L3KVA" },
{IR_LONG, 130, 0, "CB1_L1PF" },
{IR_LONG, 132, 0, "CB1_L2PF" },
{IR_LONG, 134, 0, "CB1_L3PF" },
{IR_LONG, 136, 0, "CB1_V1THD" },
{IR_LONG, 138, 0, "CB1_V2THD" },
{IR_LONG, 140, 0, "CB1_V3THD" },
{IR_LONG, 142, 0, "CB1_I1THD" },
{IR_LONG, 144, 0, "CB1_I2THD" },
{IR_LONG, 146, 0, "CB1_I3THD" },
{IR_LONG, 148, 0, "CB1_I1Kfactor" },
{IR_LONG, 150, 0, "CB1_I2Kfactor" },
{IR_LONG, 152, 0, "CB1_I3Kfactor" },
{IR_LONG, 154, 0, "CB1_I1TDD" },
{IR_LONG, 156, 0, "CB1_I2TDD" },
{IR_LONG, 158, 0, "CB1_I3TDD" },
{IR_LONG, 160, 0, "CB1_V12" },
{IR_LONG, 162, 0, "CB1_V23" },
{IR_LONG, 164, 0, "CB1_V31" },
{IR_LONG, 166, 0, "CB1_TotalKW" },
{IR_LONG, 168, 0, "CB1_TotalKVar" },
{IR_LONG, 170, 0, "CB1_TotalKVA" },
{IR_LONG, 172, 0, "CB1_TotalPF" },
{IR_LONG, 174, 0, "CB1_TotalPFLag" },
{IR_LONG, 176, 0, "CB1_TotalPFLead" },
{IR_LONG, 178, 0, "CB1_TotalKWImport" },
{IR_LONG, 180, 0, "CB1_TotalKWExport" },
{IR_LONG, 182, 0, "CB1_TotalKVarImport" },
{IR_LONG, 184, 0, "CB1_TotalKVarExport" },
{IR_LONG, 186, 0, "CB1_LN_Avg" },
{IR_LONG, 188, 0, "CB1_LL_Avg" },
{IR_LONG, 199, 0, "CB1_Status" },
// Circuit Breaker 2 (OB02) // Circuit Breaker 3 (CB1)
{IR_LONG, 200, 0, "CB2_V1N" }, {IR_LONG, 306, 0, "CB3_I1" }, //0.01x
{IR_LONG, 202, 0, "CB2_V2N" }, {IR_LONG, 308, 0, "CB3_I2" }, //0.01x
{IR_LONG, 204, 0, "CB2_V3N" }, {IR_LONG, 310, 0, "CB3_I3" }, //0.01x
{IR_LONG, 206, 0, "CB2_I1" }, {IR_LONG, 370, 0, "CB3_kVA" }, //0.001x
{IR_LONG, 208, 0, "CB2_I2" }, {IR_LONG, 324, 0, "CB3_kVA1" }, //0.001x
{IR_LONG, 210, 0, "CB2_I3" }, {IR_LONG, 326, 0, "CB3_kVA2" }, //0.001x
{IR_LONG, 212, 0, "CB2_L1KW" }, {IR_LONG, 328, 0, "CB3_kVA3" }, //0.001x
{IR_LONG, 214, 0, "CB2_L2KW" }, {IR_LONG, 368, 0, "CB3_kVAR" }, //0.001x
{IR_LONG, 216, 0, "CB2_L3KW" }, {IR_LONG, 366, 0, "CB3_kW" }, //0.001x
{IR_LONG, 218, 0, "CB2_L1KVar" }, {IR_LONG, 312, 0, "CB3_kW1" }, //0.001x
{IR_LONG, 220, 0, "CB2_L2KVar" }, {IR_LONG, 314, 0, "CB3_kW2" }, //0.001x
{IR_LONG, 222, 0, "CB2_L3KVar" }, {IR_LONG, 316, 0, "CB3_kW3" }, //0.001x
{IR_LONG, 224, 0, "CB2_L1KVA" }, {IR_LONG, 1223, 0, "CB3_kWh" },
{IR_LONG, 226, 0, "CB2_L2KVA" }, {IR_LONG, 372, 0, "CB3_PF" }, //0.001x
{IR_LONG, 228, 0, "CB2_L3KVA" },
{IR_LONG, 230, 0, "CB2_L1PF" },
{IR_LONG, 232, 0, "CB2_L2PF" },
{IR_LONG, 234, 0, "CB2_L3PF" },
{IR_LONG, 236, 0, "CB2_V1THD" },
{IR_LONG, 238, 0, "CB2_V2THD" },
{IR_LONG, 240, 0, "CB2_V3THD" },
{IR_LONG, 242, 0, "CB2_I1THD" },
{IR_LONG, 244, 0, "CB2_I2THD" },
{IR_LONG, 246, 0, "CB2_I3THD" },
{IR_LONG, 248, 0, "CB2_I1Kfactor" },
{IR_LONG, 250, 0, "CB2_I2Kfactor" },
{IR_LONG, 252, 0, "CB2_I3Kfactor" },
{IR_LONG, 254, 0, "CB2_I1TDD" },
{IR_LONG, 256, 0, "CB2_I2TDD" },
{IR_LONG, 258, 0, "CB2_I3TDD" },
{IR_LONG, 260, 0, "CB2_V12" },
{IR_LONG, 262, 0, "CB2_V23" },
{IR_LONG, 264, 0, "CB2_V31" },
{IR_LONG, 266, 0, "CB2_TotalKW" },
{IR_LONG, 268, 0, "CB2_TotalKVar" },
{IR_LONG, 270, 0, "CB2_TotalKVA" },
{IR_LONG, 272, 0, "CB2_TotalPF" },
{IR_LONG, 274, 0, "CB2_TotalPFLag" },
{IR_LONG, 276, 0, "CB2_TotalPFLead" },
{IR_LONG, 278, 0, "CB2_TotalKWImport" },
{IR_LONG, 280, 0, "CB2_TotalKWExport" },
{IR_LONG, 282, 0, "CB2_TotalKVarImport" },
{IR_LONG, 284, 0, "CB2_TotalKVarExport" },
{IR_LONG, 286, 0, "CB2_LN_Avg" },
{IR_LONG, 288, 0, "CB2_LL_Avg" },
{IR_LONG, 299, 0, "CB2_Status" },
// Circuit Breaker 3 (OB03) // Circuit Breaker 4 (CB1)
{IR_LONG, 300, 0, "CB3_V1N" }, {IR_LONG, 406, 0, "CB4_I1" }, //0.01x
{IR_LONG, 302, 0, "CB3_V2N" }, {IR_LONG, 408, 0, "CB4_I2" }, //0.01x
{IR_LONG, 304, 0, "CB3_V3N" }, {IR_LONG, 410, 0, "CB4_I3" }, //0.01x
{IR_LONG, 306, 0, "CB3_I1" }, {IR_LONG, 470, 0, "CB4_kVA" }, //0.001x
{IR_LONG, 308, 0, "CB3_I2" }, {IR_LONG, 424, 0, "CB4_kVA1" }, //0.001x
{IR_LONG, 310, 0, "CB3_I3" }, {IR_LONG, 426, 0, "CB4_kVA2" }, //0.001x
{IR_LONG, 312, 0, "CB3_L1KW" }, {IR_LONG, 428, 0, "CB4_kVA3" }, //0.001x
{IR_LONG, 314, 0, "CB3_L2KW" }, {IR_LONG, 468, 0, "CB4_kVAR" }, //0.001x
{IR_LONG, 316, 0, "CB3_L3KW" }, {IR_LONG, 466, 0, "CB4_kW" }, //0.001x
{IR_LONG, 318, 0, "CB3_L1KVar" }, {IR_LONG, 412, 0, "CB4_kW1" }, //0.001x
{IR_LONG, 320, 0, "CB3_L2KVar" }, {IR_LONG, 414, 0, "CB4_kW2" }, //0.001x
{IR_LONG, 322, 0, "CB3_L3KVar" }, {IR_LONG, 416, 0, "CB4_kW3" }, //0.001x
{IR_LONG, 324, 0, "CB3_L1KVA" }, {IR_LONG, 1278, 0, "CB4_kWh" },
{IR_LONG, 326, 0, "CB3_L2KVA" }, {IR_LONG, 472, 0, "CB4_PF" }, //0.001x
{IR_LONG, 328, 0, "CB3_L3KVA" },
{IR_LONG, 330, 0, "CB3_L1PF" },
{IR_LONG, 332, 0, "CB3_L2PF" },
{IR_LONG, 334, 0, "CB3_L3PF" },
{IR_LONG, 336, 0, "CB3_V1THD" },
{IR_LONG, 338, 0, "CB3_V2THD" },
{IR_LONG, 340, 0, "CB3_V3THD" },
{IR_LONG, 342, 0, "CB3_I1THD" },
{IR_LONG, 344, 0, "CB3_I2THD" },
{IR_LONG, 346, 0, "CB3_I3THD" },
{IR_LONG, 348, 0, "CB3_I1Kfactor" },
{IR_LONG, 350, 0, "CB3_I2Kfactor" },
{IR_LONG, 352, 0, "CB3_I3Kfactor" },
{IR_LONG, 354, 0, "CB3_I1TDD" },
{IR_LONG, 356, 0, "CB3_I2TDD" },
{IR_LONG, 358, 0, "CB3_I3TDD" },
{IR_LONG, 360, 0, "CB3_V12" },
{IR_LONG, 362, 0, "CB3_V23" },
{IR_LONG, 364, 0, "CB3_V31" },
{IR_LONG, 366, 0, "CB3_TotalKW" },
{IR_LONG, 368, 0, "CB3_TotalKVar" },
{IR_LONG, 370, 0, "CB3_TotalKVA" },
{IR_LONG, 372, 0, "CB3_TotalPF" },
{IR_LONG, 374, 0, "CB3_TotalPFLag" },
{IR_LONG, 376, 0, "CB3_TotalPFLead" },
{IR_LONG, 378, 0, "CB3_TotalKWImport" },
{IR_LONG, 380, 0, "CB3_TotalKWExport" },
{IR_LONG, 382, 0, "CB3_TotalKVarImport" },
{IR_LONG, 384, 0, "CB3_TotalKVarExport" },
{IR_LONG, 386, 0, "CB3_LN_Avg" },
{IR_LONG, 388, 0, "CB3_LL_Avg" },
{IR_LONG, 399, 0, "CB3_Status" },
// Circuit Breaker 4 (OB04) // Circuit Breaker 5 (CB1)
{IR_LONG, 400, 0, "CB4_V1N" }, {IR_LONG, 506, 0, "CB5_I1" }, //0.01x
{IR_LONG, 402, 0, "CB4_V2N" }, {IR_LONG, 508, 0, "CB5_I2" }, //0.01x
{IR_LONG, 404, 0, "CB4_V3N" }, {IR_LONG, 510, 0, "CB5_I3" }, //0.01x
{IR_LONG, 406, 0, "CB4_I1" }, {IR_LONG, 570, 0, "CB5_kVA" }, //0.001x
{IR_LONG, 408, 0, "CB4_I2" }, {IR_LONG, 524, 0, "CB5_kVA1" }, //0.001x
{IR_LONG, 410, 0, "CB4_I3" }, {IR_LONG, 526, 0, "CB5_kVA2" }, //0.001x
{IR_LONG, 412, 0, "CB4_L1KW" }, {IR_LONG, 528, 0, "CB5_kVA3" }, //0.001x
{IR_LONG, 414, 0, "CB4_L2KW" }, {IR_LONG, 568, 0, "CB5_kVAR" }, //0.001x
{IR_LONG, 416, 0, "CB4_L3KW" }, {IR_LONG, 566, 0, "CB5_kW" }, //0.001x
{IR_LONG, 418, 0, "CB4_L1KVar" }, {IR_LONG, 512, 0, "CB5_kW1" }, //0.001x
{IR_LONG, 420, 0, "CB4_L2KVar" }, {IR_LONG, 514, 0, "CB5_kW2" }, //0.001x
{IR_LONG, 422, 0, "CB4_L3KVar" }, {IR_LONG, 516, 0, "CB5_kW3" }, //0.001x
{IR_LONG, 424, 0, "CB4_L1KVA" }, {IR_LONG, 1333, 0, "CB5_kWh" },
{IR_LONG, 426, 0, "CB4_L2KVA" }, {IR_LONG, 572, 0, "CB5_PF" }, //0.001x
{IR_LONG, 428, 0, "CB4_L3KVA" },
{IR_LONG, 430, 0, "CB4_L1PF" },
{IR_LONG, 432, 0, "CB4_L2PF" },
{IR_LONG, 434, 0, "CB4_L3PF" },
{IR_LONG, 436, 0, "CB4_V1THD" },
{IR_LONG, 438, 0, "CB4_V2THD" },
{IR_LONG, 440, 0, "CB4_V3THD" },
{IR_LONG, 442, 0, "CB4_I1THD" },
{IR_LONG, 444, 0, "CB4_I2THD" },
{IR_LONG, 446, 0, "CB4_I3THD" },
{IR_LONG, 448, 0, "CB4_I1Kfactor" },
{IR_LONG, 450, 0, "CB4_I2Kfactor" },
{IR_LONG, 452, 0, "CB4_I3Kfactor" },
{IR_LONG, 454, 0, "CB4_I1TDD" },
{IR_LONG, 456, 0, "CB4_I2TDD" },
{IR_LONG, 458, 0, "CB4_I3TDD" },
{IR_LONG, 460, 0, "CB4_V12" },
{IR_LONG, 462, 0, "CB4_V23" },
{IR_LONG, 464, 0, "CB4_V31" },
{IR_LONG, 466, 0, "CB4_TotalKW" },
{IR_LONG, 468, 0, "CB4_TotalKVar" },
{IR_LONG, 470, 0, "CB4_TotalKVA" },
{IR_LONG, 472, 0, "CB4_TotalPF" },
{IR_LONG, 474, 0, "CB4_TotalPFLag" },
{IR_LONG, 476, 0, "CB4_TotalPFLead" },
{IR_LONG, 478, 0, "CB4_TotalKWImport" },
{IR_LONG, 480, 0, "CB4_TotalKWExport" },
{IR_LONG, 482, 0, "CB4_TotalKVarImport" },
{IR_LONG, 484, 0, "CB4_TotalKVarExport" },
{IR_LONG, 486, 0, "CB4_LN_Avg" },
{IR_LONG, 488, 0, "CB4_LL_Avg" },
{IR_LONG, 499, 0, "CB4_Status" },
// Circuit Breaker 5 (OB05) // Circuit Breaker 6 (CB1)
{IR_LONG, 500, 0, "CB5_V1N" }, {IR_LONG, 606, 0, "CB6_I1" }, //0.01x
{IR_LONG, 502, 0, "CB5_V2N" }, {IR_LONG, 608, 0, "CB6_I2" }, //0.01x
{IR_LONG, 504, 0, "CB5_V3N" }, {IR_LONG, 610, 0, "CB6_I3" }, //0.01x
{IR_LONG, 506, 0, "CB5_I1" }, {IR_LONG, 670, 0, "CB6_kVA" }, //0.001x
{IR_LONG, 508, 0, "CB5_I2" }, {IR_LONG, 624, 0, "CB6_kVA1" }, //0.001x
{IR_LONG, 510, 0, "CB5_I3" }, {IR_LONG, 626, 0, "CB6_kVA2" }, //0.001x
{IR_LONG, 512, 0, "CB5_L1KW" }, {IR_LONG, 628, 0, "CB6_kVA3" }, //0.001x
{IR_LONG, 514, 0, "CB5_L2KW" }, {IR_LONG, 668, 0, "CB6_kVAR" }, //0.001x
{IR_LONG, 516, 0, "CB5_L3KW" }, {IR_LONG, 666, 0, "CB6_kW" }, //0.001x
{IR_LONG, 518, 0, "CB5_L1KVar" }, {IR_LONG, 612, 0, "CB6_kW1" }, //0.001x
{IR_LONG, 520, 0, "CB5_L2KVar" }, {IR_LONG, 614, 0, "CB6_kW2" }, //0.001x
{IR_LONG, 522, 0, "CB5_L3KVar" }, {IR_LONG, 616, 0, "CB6_kW3" }, //0.001x
{IR_LONG, 524, 0, "CB5_L1KVA" }, {IR_LONG, 1388, 0, "CB6_kWh" },
{IR_LONG, 526, 0, "CB5_L2KVA" }, {IR_LONG, 672, 0, "CB6_PF" }, //0.001x
{IR_LONG, 528, 0, "CB5_L3KVA" },
{IR_LONG, 530, 0, "CB5_L1PF" },
{IR_LONG, 532, 0, "CB5_L2PF" },
{IR_LONG, 534, 0, "CB5_L3PF" },
{IR_LONG, 536, 0, "CB5_V1THD" },
{IR_LONG, 538, 0, "CB5_V2THD" },
{IR_LONG, 540, 0, "CB5_V3THD" },
{IR_LONG, 542, 0, "CB5_I1THD" },
{IR_LONG, 544, 0, "CB5_I2THD" },
{IR_LONG, 546, 0, "CB5_I3THD" },
{IR_LONG, 548, 0, "CB5_I1Kfactor" },
{IR_LONG, 550, 0, "CB5_I2Kfactor" },
{IR_LONG, 552, 0, "CB5_I3Kfactor" },
{IR_LONG, 554, 0, "CB5_I1TDD" },
{IR_LONG, 556, 0, "CB5_I2TDD" },
{IR_LONG, 558, 0, "CB5_I3TDD" },
{IR_LONG, 560, 0, "CB5_V12" },
{IR_LONG, 562, 0, "CB5_V23" },
{IR_LONG, 564, 0, "CB5_V31" },
{IR_LONG, 566, 0, "CB5_TotalKW" },
{IR_LONG, 568, 0, "CB5_TotalKVar" },
{IR_LONG, 570, 0, "CB5_TotalKVA" },
{IR_LONG, 572, 0, "CB5_TotalPF" },
{IR_LONG, 574, 0, "CB5_TotalPFLag" },
{IR_LONG, 576, 0, "CB5_TotalPFLead" },
{IR_LONG, 578, 0, "CB5_TotalKWImport" },
{IR_LONG, 580, 0, "CB5_TotalKWExport" },
{IR_LONG, 582, 0, "CB5_TotalKVarImport" },
{IR_LONG, 584, 0, "CB5_TotalKVarExport" },
{IR_LONG, 586, 0, "CB5_LN_Avg" },
{IR_LONG, 588, 0, "CB5_LL_Avg" },
{IR_LONG, 599, 0, "CB5_Status" },
// Circuit Breaker 6 (OB06)
{IR_LONG, 600, 0, "CB6_V1N" },
{IR_LONG, 602, 0, "CB6_V2N" },
{IR_LONG, 604, 0, "CB6_V3N" },
{IR_LONG, 606, 0, "CB6_I1" },
{IR_LONG, 608, 0, "CB6_I2" },
{IR_LONG, 610, 0, "CB6_I3" },
{IR_LONG, 612, 0, "CB6_L1KW" },
{IR_LONG, 614, 0, "CB6_L2KW" },
{IR_LONG, 616, 0, "CB6_L3KW" },
{IR_LONG, 618, 0, "CB6_L1KVar" },
{IR_LONG, 620, 0, "CB6_L2KVar" },
{IR_LONG, 622, 0, "CB6_L3KVar" },
{IR_LONG, 624, 0, "CB6_L1KVA" },
{IR_LONG, 626, 0, "CB6_L2KVA" },
{IR_LONG, 628, 0, "CB6_L3KVA" },
{IR_LONG, 630, 0, "CB6_L1PF" },
{IR_LONG, 632, 0, "CB6_L2PF" },
{IR_LONG, 634, 0, "CB6_L3PF" },
{IR_LONG, 636, 0, "CB6_V1THD" },
{IR_LONG, 638, 0, "CB6_V2THD" },
{IR_LONG, 640, 0, "CB6_V3THD" },
{IR_LONG, 642, 0, "CB6_I1THD" },
{IR_LONG, 644, 0, "CB6_I2THD" },
{IR_LONG, 646, 0, "CB6_I3THD" },
{IR_LONG, 648, 0, "CB6_I1Kfactor" },
{IR_LONG, 650, 0, "CB6_I2Kfactor" },
{IR_LONG, 652, 0, "CB6_I3Kfactor" },
{IR_LONG, 654, 0, "CB6_I1TDD" },
{IR_LONG, 656, 0, "CB6_I2TDD" },
{IR_LONG, 658, 0, "CB6_I3TDD" },
{IR_LONG, 660, 0, "CB6_V12" },
{IR_LONG, 662, 0, "CB6_V23" },
{IR_LONG, 664, 0, "CB6_V31" },
{IR_LONG, 666, 0, "CB6_TotalKW" },
{IR_LONG, 668, 0, "CB6_TotalKVar" },
{IR_LONG, 670, 0, "CB6_TotalKVA" },
{IR_LONG, 672, 0, "CB6_TotalPF" },
{IR_LONG, 674, 0, "CB6_TotalPFLag" },
{IR_LONG, 676, 0, "CB6_TotalPFLead" },
{IR_LONG, 678, 0, "CB6_TotalKWImport" },
{IR_LONG, 680, 0, "CB6_TotalKWExport" },
{IR_LONG, 682, 0, "CB6_TotalKVarImport" },
{IR_LONG, 684, 0, "CB6_TotalKVarExport" },
{IR_LONG, 686, 0, "CB6_LN_Avg" },
{IR_LONG, 688, 0, "CB6_LL_Avg" },
{IR_LONG, 699, 0, "CB6_Status" },
// Circuit Breaker 7 (OB07)
{IR_LONG, 700, 0, "CB7_V1N" },
{IR_LONG, 702, 0, "CB7_V2N" },
{IR_LONG, 704, 0, "CB7_V3N" },
{IR_LONG, 706, 0, "CB7_I1" },
{IR_LONG, 708, 0, "CB7_I2" },
{IR_LONG, 710, 0, "CB7_I3" },
{IR_LONG, 712, 0, "CB7_L1KW" },
{IR_LONG, 714, 0, "CB7_L2KW" },
{IR_LONG, 716, 0, "CB7_L3KW" },
{IR_LONG, 718, 0, "CB7_L1KVar" },
{IR_LONG, 720, 0, "CB7_L2KVar" },
{IR_LONG, 722, 0, "CB7_L3KVar" },
{IR_LONG, 724, 0, "CB7_L1KVA" },
{IR_LONG, 726, 0, "CB7_L2KVA" },
{IR_LONG, 728, 0, "CB7_L3KVA" },
{IR_LONG, 730, 0, "CB7_L1PF" },
{IR_LONG, 732, 0, "CB7_L2PF" },
{IR_LONG, 734, 0, "CB7_L3PF" },
{IR_LONG, 736, 0, "CB7_V1THD" },
{IR_LONG, 738, 0, "CB7_V2THD" },
{IR_LONG, 740, 0, "CB7_V3THD" },
{IR_LONG, 742, 0, "CB7_I1THD" },
{IR_LONG, 744, 0, "CB7_I2THD" },
{IR_LONG, 746, 0, "CB7_I3THD" },
{IR_LONG, 748, 0, "CB7_I1Kfactor" },
{IR_LONG, 750, 0, "CB7_I2Kfactor" },
{IR_LONG, 752, 0, "CB7_I3Kfactor" },
{IR_LONG, 754, 0, "CB7_I1TDD" },
{IR_LONG, 756, 0, "CB7_I2TDD" },
{IR_LONG, 758, 0, "CB7_I3TDD" },
{IR_LONG, 760, 0, "CB7_V12" },
{IR_LONG, 762, 0, "CB7_V23" },
{IR_LONG, 764, 0, "CB7_V31" },
{IR_LONG, 766, 0, "CB7_TotalKW" },
{IR_LONG, 768, 0, "CB7_TotalKVar" },
{IR_LONG, 770, 0, "CB7_TotalKVA" },
{IR_LONG, 772, 0, "CB7_TotalPF" },
{IR_LONG, 774, 0, "CB7_TotalPFLag" },
{IR_LONG, 776, 0, "CB7_TotalPFLead" },
{IR_LONG, 778, 0, "CB7_TotalKWImport" },
{IR_LONG, 780, 0, "CB7_TotalKWExport" },
{IR_LONG, 782, 0, "CB7_TotalKVarImport" },
{IR_LONG, 784, 0, "CB7_TotalKVarExport" },
{IR_LONG, 786, 0, "CB7_LN_Avg" },
{IR_LONG, 788, 0, "CB7_LL_Avg" },
{IR_LONG, 799, 0, "CB7_Status" },
// Circuit Breaker 8 (OB08)
{IR_LONG, 800, 0, "CB8_V1N" },
{IR_LONG, 802, 0, "CB8_V2N" },
{IR_LONG, 804, 0, "CB8_V3N" },
{IR_LONG, 806, 0, "CB8_I1" },
{IR_LONG, 808, 0, "CB8_I2" },
{IR_LONG, 810, 0, "CB8_I3" },
{IR_LONG, 812, 0, "CB8_L1KW" },
{IR_LONG, 814, 0, "CB8_L2KW" },
{IR_LONG, 816, 0, "CB8_L3KW" },
{IR_LONG, 818, 0, "CB8_L1KVar" },
{IR_LONG, 820, 0, "CB8_L2KVar" },
{IR_LONG, 822, 0, "CB8_L3KVar" },
{IR_LONG, 824, 0, "CB8_L1KVA" },
{IR_LONG, 826, 0, "CB8_L2KVA" },
{IR_LONG, 828, 0, "CB8_L3KVA" },
{IR_LONG, 830, 0, "CB8_L1PF" },
{IR_LONG, 832, 0, "CB8_L2PF" },
{IR_LONG, 834, 0, "CB8_L3PF" },
{IR_LONG, 836, 0, "CB8_V1THD" },
{IR_LONG, 838, 0, "CB8_V2THD" },
{IR_LONG, 840, 0, "CB8_V3THD" },
{IR_LONG, 842, 0, "CB8_I1THD" },
{IR_LONG, 844, 0, "CB8_I2THD" },
{IR_LONG, 846, 0, "CB8_I3THD" },
{IR_LONG, 848, 0, "CB8_I1Kfactor" },
{IR_LONG, 850, 0, "CB8_I2Kfactor" },
{IR_LONG, 852, 0, "CB8_I3Kfactor" },
{IR_LONG, 854, 0, "CB8_I1TDD" },
{IR_LONG, 856, 0, "CB8_I2TDD" },
{IR_LONG, 858, 0, "CB8_I3TDD" },
{IR_LONG, 860, 0, "CB8_V12" },
{IR_LONG, 862, 0, "CB8_V23" },
{IR_LONG, 864, 0, "CB8_V31" },
{IR_LONG, 866, 0, "CB8_TotalKW" },
{IR_LONG, 868, 0, "CB8_TotalKVar" },
{IR_LONG, 870, 0, "CB8_TotalKVA" },
{IR_LONG, 872, 0, "CB8_TotalPF" },
{IR_LONG, 874, 0, "CB8_TotalPFLag" },
{IR_LONG, 876, 0, "CB8_TotalPFLead" },
{IR_LONG, 878, 0, "CB8_TotalKWImport" },
{IR_LONG, 880, 0, "CB8_TotalKWExport" },
{IR_LONG, 882, 0, "CB8_TotalKVarImport" },
{IR_LONG, 884, 0, "CB8_TotalKVarExport" },
{IR_LONG, 886, 0, "CB8_LN_Avg" },
{IR_LONG, 888, 0, "CB8_LL_Avg" },
{IR_LONG, 899, 0, "CB8_Status" },
// Circuit Breaker 8 (OB08)
{IR_LONG, 900, 0, "CB9_V1N" },
{IR_LONG, 902, 0, "CB9_V2N" },
{IR_LONG, 904, 0, "CB9_V3N" },
{IR_LONG, 906, 0, "CB9_I1" },
{IR_LONG, 908, 0, "CB9_I2" },
{IR_LONG, 910, 0, "CB9_I3" },
{IR_LONG, 912, 0, "CB9_L1KW" },
{IR_LONG, 914, 0, "CB9_L2KW" },
{IR_LONG, 916, 0, "CB9_L3KW" },
{IR_LONG, 918, 0, "CB9_L1KVar" },
{IR_LONG, 920, 0, "CB9_L2KVar" },
{IR_LONG, 922, 0, "CB9_L3KVar" },
{IR_LONG, 924, 0, "CB9_L1KVA" },
{IR_LONG, 926, 0, "CB9_L2KVA" },
{IR_LONG, 928, 0, "CB9_L3KVA" },
{IR_LONG, 930, 0, "CB9_L1PF" },
{IR_LONG, 932, 0, "CB9_L2PF" },
{IR_LONG, 934, 0, "CB9_L3PF" },
{IR_LONG, 936, 0, "CB9_V1THD" },
{IR_LONG, 938, 0, "CB9_V2THD" },
{IR_LONG, 940, 0, "CB9_V3THD" },
{IR_LONG, 942, 0, "CB9_I1THD" },
{IR_LONG, 944, 0, "CB9_I2THD" },
{IR_LONG, 946, 0, "CB9_I3THD" },
{IR_LONG, 948, 0, "CB9_I1Kfactor" },
{IR_LONG, 950, 0, "CB9_I2Kfactor" },
{IR_LONG, 952, 0, "CB9_I3Kfactor" },
{IR_LONG, 954, 0, "CB9_I1TDD" },
{IR_LONG, 956, 0, "CB9_I2TDD" },
{IR_LONG, 958, 0, "CB9_I3TDD" },
{IR_LONG, 960, 0, "CB9_V12" },
{IR_LONG, 962, 0, "CB9_V23" },
{IR_LONG, 964, 0, "CB9_V31" },
{IR_LONG, 966, 0, "CB9_TotalKW" },
{IR_LONG, 968, 0, "CB9_TotalKVar" },
{IR_LONG, 970, 0, "CB9_TotalKVA" },
{IR_LONG, 972, 0, "CB9_TotalPF" },
{IR_LONG, 974, 0, "CB9_TotalPFLag" },
{IR_LONG, 976, 0, "CB9_TotalPFLead" },
{IR_LONG, 978, 0, "CB9_TotalKWImport" },
{IR_LONG, 980, 0, "CB9_TotalKWExport" },
{IR_LONG, 982, 0, "CB9_TotalKVarImport" },
{IR_LONG, 984, 0, "CB9_TotalKVarExport" },
{IR_LONG, 986, 0, "CB9_LN_Avg" },
{IR_LONG, 988, 0, "CB9_LL_Avg" },
{IR_LONG, 999, 0, "CB9_Status" },
{IR_FLOAT, 1068, 0, "Amps G" },
{IR_FLOAT, 1066, 0, "Amps N" },
{IR_FLOAT, 1087, 0, "kWh" },
{IR_FLOAT, 1091, 0, "PF" },
// Circuit Breaker 7 (CB1)
{IR_LONG, 706, 0, "CB7_I1" }, //0.01x
{IR_LONG, 708, 0, "CB7_I2" }, //0.01x
{IR_LONG, 710, 0, "CB7_I3" }, //0.01x
{IR_LONG, 770, 0, "CB7_kVA" }, //0.001x
{IR_LONG, 724, 0, "CB7_kVA1" }, //0.001x
{IR_LONG, 726, 0, "CB7_kVA2" }, //0.001x
{IR_LONG, 728, 0, "CB7_kVA3" }, //0.001x
{IR_LONG, 768, 0, "CB7_kVAR" }, //0.001x
{IR_LONG, 766, 0, "CB7_kW" }, //0.001x
{IR_LONG, 712, 0, "CB7_kW1" }, //0.001x
{IR_LONG, 714, 0, "CB7_kW2" }, //0.001x
{IR_LONG, 716, 0, "CB7_kW3" }, //0.001x
{IR_LONG, 1443, 0, "CB7_kWh" },
{IR_LONG, 772, 0, "CB7_PF" }, //0.001x
// Circuit Breaker 8 (CB1)
{IR_LONG, 806, 0, "CB8_I1" }, //0.01x
{IR_LONG, 808, 0, "CB8_I2" }, //0.01x
{IR_LONG, 810, 0, "CB8_I3" }, //0.01x
{IR_LONG, 870, 0, "CB8_kVA" }, //0.001x
{IR_LONG, 824, 0, "CB8_kVA1" }, //0.001x
{IR_LONG, 826, 0, "CB8_kVA2" }, //0.001x
{IR_LONG, 828, 0, "CB8_kVA3" }, //0.001x
{IR_LONG, 868, 0, "CB8_kVAR" }, //0.001x
{IR_LONG, 866, 0, "CB8_kW" }, //0.001x
{IR_LONG, 812, 0, "CB8_kW1" }, //0.001x
{IR_LONG, 814, 0, "CB8_kW2" }, //0.001x
{IR_LONG, 816, 0, "CB8_kW3" }, //0.001x
{IR_LONG, 1498, 0, "CB8_kWh" },
{IR_LONG, 872, 0, "CB8_PF" }, //0.001x
// PDU Output
{IR_LONG, 906, 0, "Output_I1" }, //0.01x
{IR_LONG, 908, 0, "Output_I2" },
{IR_LONG, 910, 0, "Output_I3" },
{IR_LONG, 1068, 0, "Output_IG" },
{IR_LONG, 1066, 0, "Output_IN" },
{IR_LONG, 924, 0, "Output_kVA1" }, //0.001
{IR_LONG, 926, 0, "Output_kVA2" },
{IR_LONG, 928, 0, "Output_kVA3" },
{IR_LONG, 968, 0, "Output_kVAR" }, //0.001
{IR_LONG, 912, 0, "Output_kW1" }, //0.001x
{IR_LONG, 914, 0, "Output_kW2" },
{IR_LONG, 916, 0, "Output_kW3" },
{IR_LONG, 1086, 0, "Output_kWh" },
{IR_LONG, 1091, 0, "Output_PF" }, //0.001
{IR_LONG, 960, 0, "Output_V_AB" },
{IR_LONG, 900, 0, "Output_V_AN" }, //0.01x
{IR_LONG, 962, 0, "Output_V_BC" },
{IR_LONG, 902, 0, "Output_V_BN" },
{IR_LONG, 964, 0, "Output_V_CA" },
{IR_LONG, 904, 0, "Output_V_CN" },
{IR, 1550, 0, "CB_Status" }, {IR, 1550, 0, "CB_Status" },
{IR, 1551, 0, "CB_Tripped" }, {IR, 1551, 0, "CB_Tripped" },
}; };
//Size of modbus map used in FOR cycles, automatically calculated. //Size of modbus map used in FOR cycles, automatically calculated.