diff --git a/lib/Core/States/State_Battery.h b/lib/Core/States/State_Battery.h new file mode 100644 index 0000000..63ee1be --- /dev/null +++ b/lib/Core/States/State_Battery.h @@ -0,0 +1,59 @@ +/** + * @file State_Battery.h + * @brief Defines the BatteryState class for the device. + * @author Emmanuel Hernandez Cruz + * @date 2025-09-05 + * + * This file contains the definition for the BatteryState, which represents + * the state where the equipment is actively performing its primary function. + */ +#ifndef Battery_State_h +#define Battery_State_h + +#include "State.h" // Include the base class header +template class Equipment; + +/** + * @class BatteryState + * @brief Represents the active Battery state of the equipment. + * + * In this state, the equipment is fully operational and performing its main + * tasks. It applies a set of predefined strategies to its Modbus points to + * simulate active behavior (e.g., fans Battery at various speeds) and waits + * for a command to transition to another state. + */ +template +class BatteryState : public State { +public: + /** + * @brief Constructs a new BatteryState object. + * Initializes the strategies for various Modbus points that are active + * during the Battery state, such as setting fan speed behaviors. + */ + BatteryState(); + + /** + * @brief Executes the Battery state's logic for one update cycle. + * This method applies all active strategies (e.g., for fan speeds, temperatures) + * and checks for conditions that would trigger a state transition, such as a + * command to stop or a fault condition. + * @param equipment Pointer to the Equipment instance. + * @return A pointer to a new State if a transition should occur, otherwise nullptr. + */ + State* update(Equipment* equipment) override; + /** + * @brief Logic to execute once when entering the Battery state. + * Typically sets status bits to indicate the equipment is active (e.g., + * setting an "On/Off" point to 1). + * @param equipment Pointer to the Equipment instance. + */ + void enterState(Equipment* equipment) override; + /** + * @brief Logic to execute once when exiting the Battery state. + * Typically resets status bits to indicate the equipment is no longer + * active before transitioning to the next state. + * @param equipment Pointer to the Equipment instance. + */ + void exitState(Equipment* equipment) override; +}; +#endif \ No newline at end of file diff --git a/lib/Core/States/State_Bypass.h b/lib/Core/States/State_Bypass.h new file mode 100644 index 0000000..1588e67 --- /dev/null +++ b/lib/Core/States/State_Bypass.h @@ -0,0 +1,59 @@ +/** + * @file State_Bypass.h + * @brief Defines the BypassState class for the device. + * @author Emmanuel Hernandez Cruz + * @date 2025-09-05 + * + * This file contains the definition for the BypassState, which represents + * the state where the equipment is actively performing its primary function. + */ +#ifndef Bypass_State_h +#define Bypass_State_h + +#include "State.h" // Include the base class header +template class Equipment; + +/** + * @class BypassState + * @brief Represents the active Bypass state of the equipment. + * + * In this state, the equipment is fully operational and performing its main + * tasks. It applies a set of predefined strategies to its Modbus points to + * simulate active behavior (e.g., fans Bypass at various speeds) and waits + * for a command to transition to another state. + */ +template +class BypassState : public State { +public: + /** + * @brief Constructs a new BypassState object. + * Initializes the strategies for various Modbus points that are active + * during the Bypass state, such as setting fan speed behaviors. + */ + BypassState(); + + /** + * @brief Executes the Bypass state's logic for one update cycle. + * This method applies all active strategies (e.g., for fan speeds, temperatures) + * and checks for conditions that would trigger a state transition, such as a + * command to stop or a fault condition. + * @param equipment Pointer to the Equipment instance. + * @return A pointer to a new State if a transition should occur, otherwise nullptr. + */ + State* update(Equipment* equipment) override; + /** + * @brief Logic to execute once when entering the Bypass state. + * Typically sets status bits to indicate the equipment is active (e.g., + * setting an "On/Off" point to 1). + * @param equipment Pointer to the Equipment instance. + */ + void enterState(Equipment* equipment) override; + /** + * @brief Logic to execute once when exiting the Bypass state. + * Typically resets status bits to indicate the equipment is no longer + * active before transitioning to the next state. + * @param equipment Pointer to the Equipment instance. + */ + void exitState(Equipment* equipment) override; +}; +#endif \ No newline at end of file diff --git a/platformio.ini b/platformio.ini index 02a5517..b198ccc 100644 --- a/platformio.ini +++ b/platformio.ini @@ -9,7 +9,7 @@ ; https://docs.platformio.org/page/projectconf.html [platformio] -default_envs = ATS_Eaton_ATC900_RPD_TCP ; Select here the name of the configuration you want to download +default_envs = UPS_Vertiv_APM2_TCP ; Select here the name of the configuration you want to download [env] upload_port = COM15 diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp new file mode 100644 index 0000000..9e471aa --- /dev/null +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Battery.cpp @@ -0,0 +1,199 @@ +/** + * @file State_Battery.cpp + * @brief Implementation of the BatteryState class. + * @author Emmanuel Hernandez Cruz + * @date 2025-09-05 + * + * This file contains the implementation for the BatteryState, which defines + * the behavior of the equipment when it is actively Battery. + */ +#include "ModbusPoints/Modbus_Point.h" +#include "ModbusPoints/Modbus_FloatDecorator.h" +#include "Equipment/Equipment.h" +#include "Strategies/Strategy_Ramp.h" +#include "Strategies/Strategy_Random.h" +#include "Strategies/Strategy_Saw.h" +#include "Strategies/Strategy_SingleValue.h" +#include "Strategies/Strategy_Square.h" +#include "Strategies/Strategy_PID.h" +#include "Strategies/Strategy_Totalizer.h" +#include "States/State_Standby.h" +#include "States/State_Running.h" +#include "States/State_Fail.h" +#include "States/State_Battery.h" +#include "States/State.h" +#include +#include +#if defined(USE_MODBUS_IP) + #include +#else + #include +#endif + +/** + * @brief Constructs a new BatteryState object. + * + * This constructor initializes behavior strategies active during the Battery + * state, such as a PID controller for the 'CW Valve Position' and totalizers + * for the run-hours of each EC fan. + */ +template<> +BatteryState::BatteryState() { + addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("System Output RMS Current Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("System Output Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0F, 5.0f, 1000)); + + addStrategy("System Output Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("Battery Time Remaining", new RampStrategy(0.0F, 0.3f, 1000)); +} + +/** + * @brief Executes the Battery state's logic for one update cycle. + * + * This method first checks for state transition commands: + * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState. + * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState, + * passing the corresponding alarm description. + * + * If no transition occurs, it applies the strategies defined for the Battery state. + * + * @param equipment Pointer to the Equipment instance. + * @return A pointer to a new State if a transition should occur, otherwise nullptr. + */ +template<> +State* BatteryState::update(Equipment* equipment) { + // STATE control, add conditions if change to a different state is needed + Serial.println("Battery update function"); + float State_Ctrl = getPointValue(equipment, "Px State"); + switch (static_cast(State_Ctrl)) { + case 1: + return new StandbyState(); + break; + case 2: + return new RunningState(); + break; + case 4: + return new BatteryState(); + break; + default: + break; + } + + float rating = getPointValue(equipment, "Px Rating"); + float load = getPointValue(equipment, "Px Load"); + float real_load = rating * (load/100.f); + + Strategy_Behavior* ramp_strat; + //Output strategies + float Out_Vab = getPointValue(equipment, "System Output RMS A-B"); + ramp_strat = getStrategy("System Output RMS Current Phase A"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vab); + float Out_Vbc = getPointValue(equipment, "System Output RMS B-C"); + ramp_strat = getStrategy("System Output RMS Current Phase B"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vbc); + float Out_Vca = getPointValue(equipment, "System Output RMS C-A"); + ramp_strat = getStrategy("System Output RMS Current Phase C"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vca); + + float Out_Van = getPointValue(equipment, "System Output RMS A-N"); + float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A"); + float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A"); + ramp_strat = getStrategy("System Output Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia); + ramp_strat = getStrategy("System Output Apparent Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia * Out_PFa); + + float Out_Vbn = getPointValue(equipment, "System Output RMS B-N"); + float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B"); + float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B"); + ramp_strat = getStrategy("System Output Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib); + ramp_strat = getStrategy("System Output Apparent Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib * Out_PFb); + + float Out_Vcn = getPointValue(equipment, "System Output RMS C-N"); + float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C"); + float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C"); + ramp_strat = getStrategy("System Output Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic); + ramp_strat = getStrategy("System Output Apparent Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic * Out_PFc); + + float Battery_time = getPointValue(equipment, "Battery Time Remaining"); + float Bat_Percent = Battery_time /4.80f; + if (Bat_Percent > 98.0f){ + setPointValue(equipment, "UPS Battery Status2", 0.0f); + } + if (Bat_Percent > 20.0f) { + setPointValue(equipment, "UPS Battery Status1", 2.0f); + setPointValue(equipment, "Battery Low", 0.0f); + } + if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 3.0f); + setPointValue(equipment, "Battery Low", 1.0f); + } + if (Bat_Percent < 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 4.0f); + } + // Apply any strategies defined for the standby state + _applyStrategies(equipment); + return nullptr; +} + +/** + * @brief Logic to execute once when entering the Battery state. + * Sets the "Run Status" for all EC fans to 1 to indicate they are active. + * @param equipment Pointer to the Equipment instance. + */ +template<> +void BatteryState::enterState(Equipment* equipment) { + // Logic to run when the equipment enters this state + Serial.println("Enter Battery State..."); + + setPointValue(equipment, "Bypass Input Voltage RMS A-B", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS B-C", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS C-A", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS A-N", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS B-N", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS C-N", 0.0f); + setPointValue(equipment, "Bypass Input Frequency", 0.0f); + setPointValue(equipment, "Bypass Power Phase A", 0.0f); + setPointValue(equipment, "Bypass Power Phase B", 0.0f); + setPointValue(equipment, "Bypass Power Phase C", 0.0f); + + setPointValue(equipment, "UPS Loading Status", 6.0f); + setPointValue(equipment, "UPS Battery Status2", 2.0f); + // You could also update a Modbus register to show the "standby" state + +} + +/** + * @brief Logic to execute once when exiting the Battery state. + * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state. + * @param equipment Pointer to the Equipment instance. + */ +template<> +void BatteryState::exitState(Equipment* equipment) { + // Cleanup logic to run when the equipment leaves this state + Serial.println("Exit Battery State..."); + +} \ No newline at end of file diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp new file mode 100644 index 0000000..2796ebd --- /dev/null +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Bypass.cpp @@ -0,0 +1,271 @@ +/** + * @file State_Bypass.cpp + * @brief Implementation of the BypassState class. + * @author Emmanuel Hernandez Cruz + * @date 2025-09-05 + * + * This file contains the implementation for the BypassState, which defines + * the behavior of the equipment when it is actively Bypass. + */ +#include "ModbusPoints/Modbus_Point.h" +#include "ModbusPoints/Modbus_FloatDecorator.h" +#include "Equipment/Equipment.h" +#include "Strategies/Strategy_Ramp.h" +#include "Strategies/Strategy_Random.h" +#include "Strategies/Strategy_Saw.h" +#include "Strategies/Strategy_SingleValue.h" +#include "Strategies/Strategy_Square.h" +#include "Strategies/Strategy_PID.h" +#include "Strategies/Strategy_Totalizer.h" +#include "States/State_Standby.h" +#include "States/State_Running.h" +#include "States/State_Fail.h" +#include "States/State_Bypass.h" +#include "States/State.h" +#include +#include +#if defined(USE_MODBUS_IP) + #include +#else + #include +#endif + +/** + * @brief Constructs a new BypassState object. + * + * This constructor initializes behavior strategies active during the Bypass + * state, such as a PID controller for the 'CW Valve Position' and totalizers + * for the run-hours of each EC fan. + */ +template<> +BypassState::BypassState() { + + //Input System + addStrategy("System Input RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Input RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Input RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("System Input RMS Current Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input RMS Current Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input RMS Current Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("System Input Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("System Input Power Factor Phs A", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Input Power Factor Phs B", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Input Power Factor Phs C", new SingleValueStrategy(93.0F, 5.0f, 1000)); + + addStrategy("System Input Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + //Bypass System + + addStrategy("Bypass Input Voltage RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("Bypass Input Voltage RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("Bypass Input Voltage RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("Bypass Input Voltage RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("Bypass Input Voltage RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("Bypass Input Voltage RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("Bypass Input Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("Bypass Input Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("Bypass Input Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("Bypass Input Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + //Output System + addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("System Output RMS Current Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("System Output Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0F, 5.0f, 1000)); + + addStrategy("System Output Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("Battery Time Remaining", new RampStrategy(480.0F, 0.3f, 1000)); + addStrategy("DC Bus Voltage", new SingleValueStrategy(518.0F, 5.0f, 1000)); +} + +/** + * @brief Executes the Bypass state's logic for one update cycle. + * + * This method first checks for state transition commands: + * 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState. + * 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState, + * passing the corresponding alarm description. + * + * If no transition occurs, it applies the strategies defined for the Bypass state. + * + * @param equipment Pointer to the Equipment instance. + * @return A pointer to a new State if a transition should occur, otherwise nullptr. + */ +template<> +State* BypassState::update(Equipment* equipment) { + // STATE control, add conditions if change to a different state is needed + Serial.println("Battery update function"); + float State_Ctrl = getPointValue(equipment, "Px State"); + switch (static_cast(State_Ctrl)) { + case 1: + return new StandbyState(); + break; + case 2: + return new RunningState(); + break; + case 3: + return new BypassState(); + break; + default: + break; + } + float rating = getPointValue(equipment, "Px Rating"); + float load = getPointValue(equipment, "Px Load"); + float real_load = rating * (load/100.f); + + Strategy_Behavior* ramp_strat; + + //Input strategies + float In_Vab = getPointValue(equipment, "System Input RMS A-B"); + ramp_strat = getStrategy("System Input RMS Current Phase A"); + static_cast(ramp_strat)->setTarget(real_load/In_Vab); + float In_Vbc = getPointValue(equipment, "System Input RMS B-C"); + ramp_strat = getStrategy("System Input RMS Current Phase B"); + static_cast(ramp_strat)->setTarget(real_load/In_Vbc); + float In_Vca = getPointValue(equipment, "System Input RMS C-A"); + ramp_strat = getStrategy("System Input RMS Current Phase C"); + static_cast(ramp_strat)->setTarget(real_load/In_Vca); + + float In_Van = getPointValue(equipment, "System Input RMS A-N"); + float In_Ia = getPointValue(equipment, "System Input RMS Current Phase A"); + float In_PFa = getPointValue(equipment, "System Input Power Factor Phs A"); + ramp_strat = getStrategy("System Input Power Phase A"); + static_cast(ramp_strat)->setTarget(In_Van * In_Ia); + ramp_strat = getStrategy("Bypass Power Phase A"); + static_cast(ramp_strat)->setTarget(In_Van * In_Ia); + ramp_strat = getStrategy("System Input Apparent Power Phase A"); + static_cast(ramp_strat)->setTarget(In_Van * In_Ia * In_PFa); + + float In_Vbn = getPointValue(equipment, "System Input RMS B-N"); + float In_Ib = getPointValue(equipment, "System Input RMS Current Phase B"); + float In_PFb = getPointValue(equipment, "System Input Power Factor Phs B"); + ramp_strat = getStrategy("System Input Power Phase B"); + static_cast(ramp_strat)->setTarget(In_Vbn * In_Ib); + ramp_strat = getStrategy("Bypass Power Phase B"); + static_cast(ramp_strat)->setTarget(In_Vbn * In_Ib); + ramp_strat = getStrategy("System Input Apparent Power Phase B"); + static_cast(ramp_strat)->setTarget(In_Vbn * In_Ib * In_PFb); + + float In_Vcn = getPointValue(equipment, "System Input RMS C-N"); + float In_Ic = getPointValue(equipment, "System Input RMS Current Phase C"); + float In_PFc = getPointValue(equipment, "System Input Power Factor Phs C"); + ramp_strat = getStrategy("System Input Power Phase C"); + static_cast(ramp_strat)->setTarget(In_Vcn * In_Ic); + ramp_strat = getStrategy("Bypass Power Phase C"); + static_cast(ramp_strat)->setTarget(In_Vcn * In_Ic); + ramp_strat = getStrategy("System Input Apparent Power Phase C"); + static_cast(ramp_strat)->setTarget(In_Vcn * In_Ic * In_PFc); + + //Output strategies + float Out_Vab = getPointValue(equipment, "System Output RMS A-B"); + ramp_strat = getStrategy("System Output RMS Current Phase A"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vab); + float Out_Vbc = getPointValue(equipment, "System Output RMS B-C"); + ramp_strat = getStrategy("System Output RMS Current Phase B"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vbc); + float Out_Vca = getPointValue(equipment, "System Output RMS C-A"); + ramp_strat = getStrategy("System Output RMS Current Phase C"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vca); + + float Out_Van = getPointValue(equipment, "System Output RMS A-N"); + float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A"); + float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A"); + ramp_strat = getStrategy("System Output Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia); + ramp_strat = getStrategy("System Output Apparent Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia * Out_PFa); + + float Out_Vbn = getPointValue(equipment, "System Output RMS B-N"); + float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B"); + float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B"); + ramp_strat = getStrategy("System Output Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib); + ramp_strat = getStrategy("System Output Apparent Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib * Out_PFb); + + float Out_Vcn = getPointValue(equipment, "System Output RMS C-N"); + float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C"); + float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C"); + ramp_strat = getStrategy("System Output Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic); + ramp_strat = getStrategy("System Output Apparent Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic * Out_PFc); + + float Battery_time = getPointValue(equipment, "Battery Time Remaining"); + float Bat_Percent = Battery_time /4.80f; + if (Bat_Percent > 98.0f){ + setPointValue(equipment, "UPS Battery Status2", 0.0f); + } + if (Bat_Percent > 20.0f) { + setPointValue(equipment, "UPS Battery Status1", 2.0f); + setPointValue(equipment, "Battery Low", 0.0f); + } + if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 3.0f); + setPointValue(equipment, "Battery Low", 1.0f); + } + if (Bat_Percent < 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 4.0f); + } + // Apply any strategies defined for the standby state + _applyStrategies(equipment); + return nullptr; +} + +/** + * @brief Logic to execute once when entering the Bypass state. + * Sets the "Run Status" for all EC fans to 1 to indicate they are active. + * @param equipment Pointer to the Equipment instance. + */ +template<> +void BypassState::enterState(Equipment* equipment) { + // Logic to run when the equipment enters this state + Serial.println("Enter Battery State..."); + setPointValue(equipment, "UPS Loading Status", 4.0f); + setPointValue(equipment, "UPS Battery Status2", 3.0f); + // You could also update a Modbus register to show the "standby" state + +} + +/** + * @brief Logic to execute once when exiting the Bypass state. + * Sets the "Run Status" for all EC fans to 0 before transitioning to the next state. + * @param equipment Pointer to the Equipment instance. + */ +template<> +void BypassState::exitState(Equipment* equipment) { + // Cleanup logic to run when the equipment leaves this state + Serial.println("Exit Bypass State..."); + +} \ No newline at end of file diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp index 8bc0385..66cafd6 100644 --- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Fail.cpp @@ -14,6 +14,7 @@ #include "Strategies/Strategy_PID.h" #include "States/State_Standby.h" #include "States/State_Running.h" +#include "States/State_Battery.h" #include "States/State_Fail.h" #if defined(USE_MODBUS_IP) #include @@ -53,7 +54,13 @@ template<> State* FailState::update(Equipment* equipment) { // STATE control, add conditions if change to a different state is needed Serial.println("Fail update function"); - + float State_Ctrl = getPointValue(equipment, "Px State"); + if (State_Ctrl == 2){ + return new RunningState(); + } + if (State_Ctrl == 1){ + return new StandbyState(); + } _applyStrategies(equipment); return nullptr; } diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp index b9e4a99..9e65712 100644 --- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Running.cpp @@ -20,6 +20,8 @@ #include "States/State_Standby.h" #include "States/State_Running.h" #include "States/State_Fail.h" +#include "States/State_Battery.h" +#include "States/State_Bypass.h" #include "States/State.h" #include #include @@ -38,6 +40,60 @@ */ template<> RunningState::RunningState() { + addStrategy("System Input RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Input RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Input RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Input RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("System Input RMS Current Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input RMS Current Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input RMS Current Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("System Input Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("System Input Power Factor Phs A", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Input Power Factor Phs B", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Input Power Factor Phs C", new SingleValueStrategy(93.0F, 5.0f, 1000)); + + addStrategy("System Input Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Input Apparent Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + + addStrategy("System Output RMS A-B", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-C", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-A", new SingleValueStrategy(480.0F, 5.0f, 1000)); + addStrategy("System Output RMS A-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS B-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + addStrategy("System Output RMS C-N", new SingleValueStrategy(270.0F, 5.0f, 1000)); + + addStrategy("System Output RMS Current Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output RMS Current Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("System Output Frequency", new SingleValueStrategy(60.0F, 2.0f, 1000)); + + addStrategy("System Output Power Factor Phs A", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs B", new SingleValueStrategy(93.0F, 5.0f, 1000)); + addStrategy("System Output Power Factor Phs C", new SingleValueStrategy(93.0F, 5.0f, 1000)); + + addStrategy("System Output Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase A", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase B", new RampStrategy(10.0F, 5.0f, 1000)); + addStrategy("System Output Apparent Power Phase C", new RampStrategy(10.0F, 5.0f, 1000)); + + addStrategy("Battery Time Remaining", new RampStrategy(480.0F, 1.0f, 1000)); + + + addStrategy("DC Bus Voltage", new SingleValueStrategy(518.0F, 5.0f, 1000)); + } /** @@ -55,12 +111,118 @@ RunningState::RunningState() { */ template<> State* RunningState::update(Equipment* equipment) { - // STATE control, add conditions if change to a different state is needed - Serial.println("Running update function"); - - // Apply any strategies defined for the standby state - _applyStrategies(equipment); - return nullptr; + // STATE control, add conditions if change to a different state is needed + Serial.println("Running update function"); + float State_Ctrl = getPointValue(equipment, "Px State"); + switch (static_cast(State_Ctrl)) { + case 1: + return new StandbyState(); + break; + case 3: + return new BatteryState(); + break; + case 4: + return new BypassState(); + break; + default: + break; + } + + float rating = getPointValue(equipment, "Px Rating"); + float load = getPointValue(equipment, "Px Load"); + float real_load = (rating*1000.0f) * (load/100.f); + + Strategy_Behavior* ramp_strat; + + //Input strategies + float In_Vab = getPointValue(equipment, "System Input RMS A-B"); + ramp_strat = getStrategy("System Input RMS Current Phase A"); + static_cast(ramp_strat)->setTarget(real_load/In_Vab); + float In_Vbc = getPointValue(equipment, "System Input RMS B-C"); + ramp_strat = getStrategy("System Input RMS Current Phase B"); + static_cast(ramp_strat)->setTarget(real_load/In_Vbc); + float In_Vca = getPointValue(equipment, "System Input RMS C-A"); + ramp_strat = getStrategy("System Input RMS Current Phase C"); + static_cast(ramp_strat)->setTarget(real_load/In_Vca); + + float In_Van = getPointValue(equipment, "System Input RMS A-N"); + float In_Ia = getPointValue(equipment, "System Input RMS Current Phase A"); + float In_PFa = getPointValue(equipment, "System Input Power Factor Phs A"); + ramp_strat = getStrategy("System Input Power Phase A"); + static_cast(ramp_strat)->setTarget(In_Van * In_Ia); + ramp_strat = getStrategy("System Input Apparent Power Phase A"); + static_cast(ramp_strat)->setTarget(In_Van * In_Ia * (In_PFa/100.0f)); + + float In_Vbn = getPointValue(equipment, "System Input RMS B-N"); + float In_Ib = getPointValue(equipment, "System Input RMS Current Phase B"); + float In_PFb = getPointValue(equipment, "System Input Power Factor Phs B"); + ramp_strat = getStrategy("System Input Power Phase B"); + static_cast(ramp_strat)->setTarget(In_Vbn * In_Ib); + ramp_strat = getStrategy("System Input Apparent Power Phase B"); + static_cast(ramp_strat)->setTarget(In_Vbn * In_Ib * (In_PFb/100.0f)); + + float In_Vcn = getPointValue(equipment, "System Input RMS C-N"); + float In_Ic = getPointValue(equipment, "System Input RMS Current Phase C"); + float In_PFc = getPointValue(equipment, "System Input Power Factor Phs C"); + ramp_strat = getStrategy("System Input Power Phase C"); + static_cast(ramp_strat)->setTarget(In_Vcn * In_Ic); + ramp_strat = getStrategy("System Input Apparent Power Phase C"); + static_cast(ramp_strat)->setTarget(In_Vcn * In_Ic * (In_PFc/100.0f)); + + //Output strategies + float Out_Vab = getPointValue(equipment, "System Output RMS A-B"); + ramp_strat = getStrategy("System Output RMS Current Phase A"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vab); + float Out_Vbc = getPointValue(equipment, "System Output RMS B-C"); + ramp_strat = getStrategy("System Output RMS Current Phase B"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vbc); + float Out_Vca = getPointValue(equipment, "System Output RMS C-A"); + ramp_strat = getStrategy("System Output RMS Current Phase C"); + static_cast(ramp_strat)->setTarget(real_load/Out_Vca); + + float Out_Van = getPointValue(equipment, "System Output RMS A-N"); + float Out_Ia = getPointValue(equipment, "System Output RMS Current Phase A"); + float Out_PFa = getPointValue(equipment, "System Output Power Factor Phs A"); + ramp_strat = getStrategy("System Output Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia); + ramp_strat = getStrategy("System Output Apparent Power Phase A"); + static_cast(ramp_strat)->setTarget(Out_Van * Out_Ia * (Out_PFa/100.0f)); + + float Out_Vbn = getPointValue(equipment, "System Output RMS B-N"); + float Out_Ib = getPointValue(equipment, "System Output RMS Current Phase B"); + float Out_PFb = getPointValue(equipment, "System Output Power Factor Phs B"); + ramp_strat = getStrategy("System Output Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib); + ramp_strat = getStrategy("System Output Apparent Power Phase B"); + static_cast(ramp_strat)->setTarget(Out_Vbn * Out_Ib * (Out_PFb/100.0f)); + + float Out_Vcn = getPointValue(equipment, "System Output RMS C-N"); + float Out_Ic = getPointValue(equipment, "System Output RMS Current Phase C"); + float Out_PFc = getPointValue(equipment, "System Output Power Factor Phs C"); + ramp_strat = getStrategy("System Output Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic); + ramp_strat = getStrategy("System Output Apparent Power Phase C"); + static_cast(ramp_strat)->setTarget(Out_Vcn * Out_Ic * (Out_PFc/100.0f)); + + float Battery_time = getPointValue(equipment, "Battery Time Remaining"); + float Bat_Percent = Battery_time /4.80f; + if (Bat_Percent > 98.0f){ + setPointValue(equipment, "UPS Battery Status2", 0.0f); + } + if (Bat_Percent > 20.0f) { + setPointValue(equipment, "UPS Battery Status1", 2.0f); + setPointValue(equipment, "Battery Low", 0.0f); + } + if (Bat_Percent <= 20.0f && Bat_Percent >= 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 3.0f); + setPointValue(equipment, "Battery Low", 1.0f); + } + if (Bat_Percent < 5.0f){ + setPointValue(equipment, "UPS Battery Status1", 4.0f); + } + // Apply any strategies defined for the standby state + _applyStrategies(equipment); + return nullptr; } /** @@ -74,6 +236,20 @@ void RunningState::enterState(Equipment* equipment) { Serial.println("Enter Running State..."); // You could also update a Modbus register to show the "standby" state + setPointValue(equipment, "Bypass Input Voltage RMS A-B", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS B-C", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS C-A", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS A-N", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS B-N", 0.0f); + setPointValue(equipment, "Bypass Input Voltage RMS C-N", 0.0f); + setPointValue(equipment, "Bypass Input Frequency", 0.0f); + setPointValue(equipment, "Bypass Power Phase A", 0.0f); + setPointValue(equipment, "Bypass Power Phase B", 0.0f); + setPointValue(equipment, "Bypass Power Phase C", 0.0f); + + setPointValue(equipment, "UPS Loading Status", 3.0f); + setPointValue(equipment, "UPS Battery Status2", 1.0f); + } /** diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp index 20029d1..3ce2bbd 100644 --- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/State_Standby.cpp @@ -19,6 +19,8 @@ #include "States/State_Standby.h" #include "States/State_Running.h" #include "States/State_Fail.h" +#include "States/State_Battery.h" +#include "States/State_Bypass.h" #include "States/State.h" #include #include @@ -57,6 +59,20 @@ State* StandbyState::update(Equipment* equipment) // STATE control, add conditions if change to a different state is needed Serial.println("Standby update function"); + float State_Ctrl = getPointValue(equipment, "Px State"); + switch (static_cast(State_Ctrl)) { + case 2: + return new RunningState(); + break; + case 3: + return new BatteryState(); + break; + case 4: + return new BypassState(); + break; + default: + break; + } // Apply any strategies defined for the standby state _applyStrategies(equipment); return nullptr; @@ -72,6 +88,7 @@ template<> void StandbyState::enterState(Equipment* equipment) { // Logic to run when the equipment enters this state Serial.println("Enter Standby State..."); + setPointValue(equipment, "UPS Loading Status", 2.0f); } /** diff --git a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h index 26d65a9..a318702 100644 --- a/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h +++ b/src/EPMS/UPS/UPS_Vertiv_APM2_TCP/config.h @@ -21,10 +21,10 @@ * @{ */ #include - const char *ssid = "wifi_name"; /**< @brief The SSID of the WiFi network. */ - const char *password = "wifi_password"; /**< @brief The password for the WiFi network. */ - IPAddress local_IP(192, 168, 1, 234); /**< @brief The static IP address for the device. */ - IPAddress gateway(192, 168, 1, 1); /**< @brief The gateway IP address. */ + const char *ssid = "esrlok_network"; /**< @brief The SSID of the WiFi network. */ + const char *password = "m7g6eNMe?cy8S@z"; /**< @brief The password for the WiFi network. */ + IPAddress local_IP(192, 168, 0, 234); /**< @brief The static IP address for the device. */ + IPAddress gateway(192, 168, 0, 1); /**< @brief The gateway IP address. */ IPAddress subnet(255, 255, 255, 0); /**< @brief The subnet mask. */ ModbusIP mb; @@ -60,8 +60,9 @@ */ modbusMap mb_map[] = { - {HR, 15, 0, "State Control"}, //Internal to control from Modscan - {HR, 16, 0, "Fault Code"}, //Internal Fault code from Modscan + {HR, 9, 0, "Px State"}, //1-standby, 2 Running (Normal - charging), 3 Battery, 4 Bypass + {HR, 10, 0, "Px Load"}, //% Internal Fault code from Modscan + {HR, 11, 0, "Px Rating"}, //kVA Internal Fault code from Modscan {DI, 11, 0, "Output Overload"}, {DI, 20, 0, "Bypass Not Ready"}, @@ -73,60 +74,61 @@ modbusMap mb_map[] = {DI, 254, 0, "UPS Output on Bypass"}, {DI, 263, 0, "Battery Low"}, - {IR, 1, 0, "System Input RMS A-B"}, - {IR, 2, 0, "System Input RMS B-C"}, - {IR, 3, 0, "System Input RMS C-A"}, - {IR, 4, 0, "System Input RMS A-N"}, - {IR, 5, 0, "System Input RMS B-N"}, - {IR, 6, 0, "System Input RMS C-N"}, - {IR, 7, 0, "System Input RMS Current Phase A"}, - {IR, 8, 0, "System Input RMS Current Phase B"}, - {IR, 9, 0, "System Input RMS Current Phase C"}, - {IR, 10, 0, "System Input Frequency"}, - {IR, 11, 0, "System Input Power Factor Phs A"}, - {IR, 12, 0, "System Input Power Factor Phs B"}, - {IR, 13, 0, "System Input Power Factor Phs C"}, - {IR, 14, 0, "System Input Power Phase A"}, - {IR, 15, 0, "System Input Power Phase B"}, - {IR, 16, 0, "System Input Power Phase C"}, - {IR, 17, 0, "System Input Apparent Power Phs A"}, - {IR, 18, 0, "System Input Apparent Power Phs B"}, - {IR, 19, 0, "System Input Apparent Power Phs C"}, - {IR, 23, 0, "Bypass Input Voltage RMS A-B"}, - {IR, 24, 0, "Bypass Input Voltage RMS B-C"}, - {IR, 25, 0, "Bypass Input Voltage RMS C-A"}, - {IR, 26, 0, "Bypass Input Voltage RMS A-N"}, - {IR, 27, 0, "Bypass Input Voltage RMS B-N"}, - {IR, 28, 0, "Bypass Input Voltage RMS C-N"}, - {IR, 29, 0, "Bypass Input Frequency"}, - {IR, 30, 0, "Bypass Power Phase A"}, - {IR, 31, 0, "Bypass Power Phase B"}, - {IR, 32, 0, "Bypass Power Phase C"}, - {IR, 38, 0, "System Output Voltage RMS A-B"}, - {IR, 39, 0, "System Output Voltage RMS B-C"}, - {IR, 40, 0, "System Output Voltage RMS C-A"}, - {IR, 41, 0, "System Output Voltage RMS A-N"}, - {IR, 42, 0, "System Output Voltage RMS B-N"}, - {IR, 43, 0, "System Output Voltage RMS C-N"}, - {IR, 44, 0, "System Output RMS Current Phase A"}, - {IR, 45, 0, "System Output RMS Current Phase B"}, - {IR, 46, 0, "System Output RMS Current Phase C"}, - {IR, 50, 0, "System Output Frequency"}, - {IR, 51, 0, "System Output Power Factor Phs A"}, - {IR, 52, 0, "System Output Power Factor Phs B"}, - {IR, 53, 0, "System Output Power Factor Phs C"}, - {IR, 54, 0, "System Output Power Phase A"}, - {IR, 55, 0, "System Output Power Phase B"}, - {IR, 56, 0, "System Output Power Phase C"}, - {IR, 57, 0, "System Output Apparent Power Phs A"}, - {IR, 58, 0, "System Output Apparent Power Phs B"}, - {IR, 59, 0, "System Output Apparent Power Phs C"}, - {IR, 60, 0, "System Output Power"}, - {IR, 61, 0, "System Output Apparent Power"}, - {IR, 164, 0, "UPS Loading Status"}, - {IR, 175, 0, "DC Bus Voltage"}, - {IR, 180, 0, "Battery Time Remaining"}, - {IR, 183, 0, "UPS Battery Status"}, + {IR_10x, 1, 0, "System Input RMS A-B"}, + {IR_10x, 2, 0, "System Input RMS B-C"}, + {IR_10x, 3, 0, "System Input RMS C-A"}, + {IR_10x, 4, 0, "System Input RMS A-N"}, + {IR_10x, 5, 0, "System Input RMS B-N"}, + {IR_10x, 6, 0, "System Input RMS C-N"}, + {IR_10x, 7, 0, "System Input RMS Current Phase A"}, + {IR_10x, 8, 0, "System Input RMS Current Phase B"}, + {IR_10x, 9, 0, "System Input RMS Current Phase C"}, + {IR_10x, 10, 0, "System Input Frequency"}, + {IR_10x, 11, 0, "System Input Power Factor Phs A"}, + {IR_10x, 12, 0, "System Input Power Factor Phs B"}, + {IR_10x, 13, 0, "System Input Power Factor Phs C"}, + {IR_10x, 14, 0, "System Input Power Phase A"}, + {IR_10x, 15, 0, "System Input Power Phase B"}, + {IR_10x, 16, 0, "System Input Power Phase C"}, + {IR_10x, 17, 0, "System Input Apparent Power Phs A"}, + {IR_10x, 18, 0, "System Input Apparent Power Phs B"}, + {IR_10x, 19, 0, "System Input Apparent Power Phs C"}, + {IR_10x, 23, 0, "Bypass Input Voltage RMS A-B"}, + {IR_10x, 24, 0, "Bypass Input Voltage RMS B-C"}, + {IR_10x, 25, 0, "Bypass Input Voltage RMS C-A"}, + {IR_10x, 26, 0, "Bypass Input Voltage RMS A-N"}, + {IR_10x, 27, 0, "Bypass Input Voltage RMS B-N"}, + {IR_10x, 28, 0, "Bypass Input Voltage RMS C-N"}, + {IR_10x, 29, 0, "Bypass Input Frequency"}, + {IR_10x, 30, 0, "Bypass Power Phase A"}, + {IR_10x, 31, 0, "Bypass Power Phase B"}, + {IR_10x, 32, 0, "Bypass Power Phase C"}, + {IR_10x, 38, 0, "System Output RMS A-B"}, + {IR_10x, 39, 0, "System Output RMS B-C"}, + {IR_10x, 40, 0, "System Output RMS C-A"}, + {IR_10x, 41, 0, "System Output RMS A-N"}, + {IR_10x, 42, 0, "System Output RMS B-N"}, + {IR_10x, 43, 0, "System Output RMS C-N"}, + {IR_10x, 44, 0, "System Output RMS Current Phase A"}, + {IR_10x, 45, 0, "System Output RMS Current Phase B"}, + {IR_10x, 46, 0, "System Output RMS Current Phase C"}, + {IR_10x, 50, 0, "System Output Frequency"}, + {IR_10x, 51, 0, "System Output Power Factor Phs A"}, + {IR_10x, 52, 0, "System Output Power Factor Phs B"}, + {IR_10x, 53, 0, "System Output Power Factor Phs C"}, + {IR_10x, 54, 0, "System Output Power Phase A"}, + {IR_10x, 55, 0, "System Output Power Phase B"}, + {IR_10x, 56, 0, "System Output Power Phase C"}, + {IR_10x, 57, 0, "System Output Apparent Power Phs A"}, + {IR_10x, 58, 0, "System Output Apparent Power Phs B"}, + {IR_10x, 59, 0, "System Output Apparent Power Phs C"}, + {IR_10x, 60, 0, "System Output Power"}, + {IR_10x, 61, 0, "System Output Apparent Power"}, + {IR_10x, 164, 0, "UPS Loading Status"}, + {IR_10x, 175, 0, "DC Bus Voltage"}, + {IR_10x, 180, 0, "Battery Time Remaining"}, + {IR_10x, 183, 0, "UPS Battery Status1"}, + {IR_10x, 184, 0, "UPS Battery Status2"}, }; //Size of modbus map used in FOR cycles, automatically calculated. @@ -140,4 +142,4 @@ const int map_size = sizeof(mb_map) / sizeof(mb_map[0]); int interval = 250; /** @} */ // End of ModbusMapConfig group -#endif // CONFIG_H +#endif // CONFIG_H \ No newline at end of file