Merge pull request #14 from emmanuelsrlok/ecruz/Breakers

Susol Breaker

platformio.ini

@@ -9,7 +9,8 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = ATS_800_RPD  ; Select here the name of the configuration you want to download
+default_envs = Susol_Smart_MCCB_TCP  ; Select here the name of the configuration you want to download
+
 
 [common_env_options]
 framework = arduino
@@ -133,3 +134,10 @@ extends = common_env_options
 build_flags = -D USE_MODBUS_IP
 build_src_filter = -<*> +<EPMS/ATS/ATS_800_RPD>
 
+
+[env:Susol_Smart_MCCB_TCP]
+platform = espressif32
+board = dfrobot_firebeetle2_esp32e
+extends = common_env_options
+build_flags = -D USE_MODBUS_IP
+build_src_filter = -<*> +<EPMS/Breaker/Susol_Smart_MCCB_TCP>

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/README.md

@@ -0,0 +1,33 @@
+# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
+
+## Brief Introduction
+Equipment specifc details that make it different from other devices
+
+## List of Equipmentt
+This cofiguration has been used for these models:
+* **Model**: 09-15-22 
+* **Model**: 09-15-23 
+* **Model**: 09-15-25 
+
+## Hardware Prerequisites
+
+The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
+* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
+
+---
+
+## States and Strategies
+Provide a brief description of what variables and strategies were used in this configuraiton
+
+### Standby State
+* **Equipment running**: set to 0
+* **Common Alarm**: set to 0
+* **SAT temperature**: set to 85
+
+### Running State
+* **Equipment running**: set to 1
+* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
+
+### Fail State
+* **Commong Alarm**: set to 1
+* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Fail.cpp

@@ -0,0 +1,81 @@
+/**
+ * @file State_Fail.cpp
+ * @brief Implementation of the FailState class.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-05
+ *
+ * This file contains the implementation for the FailState, which defines
+ * the behavior of the equipment when it has entered a fault condition.
+ */
+#include "ModbusPoints/Modbus_Point.h"
+#include "Equipment/Equipment.h"
+#include "Strategies/Strategy_Ramp.h"
+#include "Strategies/Strategy_SingleValue.h"
+#include "Strategies/Strategy_PID.h"
+#include "States/State_Standby.h"
+#include "States/State_Running.h"
+#include "States/State_Fail.h"
+#if defined(USE_MODBUS_IP)
+  #include <ModbusIP_ESP8266.h>
+#else
+  #include <ModbusRTU.h>
+#endif
+
+/**
+ * @brief Constructs a new FailState object with a list of active alarms.
+ *
+ * This constructor receives a list of alarm descriptions and creates strategies
+ * to set the corresponding Modbus points to a value of 1, indicating an
+ * active alarm. It also initializes a PID strategy for the 'CW Valve Position'
+ * to maintain its state during the fault.
+ * @param activeAlarms A vector of strings, where each string is the
+ *                     description of a Modbus point to be set as an active alarm.
+ */
+template<>
+FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
+    // Simulate a failure: set common alarm and a specific fan alarm.
+
+    
+}
+
+/**
+ * @brief Executes the fail state's logic for one update cycle.
+ *
+ * This method checks the "Alarm Reset" Modbus point for a command to
+ * transition back to Standby, which would typically happen after a fault
+ * is cleared by a user. If no transition is requested, it continues to apply
+ * the failure strategies (e.g., keeping alarm bits active).
+ *
+ * @param equipment Pointer to the Equipment instance.
+ * @return A pointer to a new State if a transition should occur, otherwise nullptr.
+ */
+template<>
+State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
+    // STATE control, add conditions if change to a different state is needed
+    Serial.println("Fail update function");
+    
+    _applyStrategies(equipment);
+    return nullptr;
+}
+
+/**
+ * @brief Logic to execute once when entering the fail state.
+ * Sets the "Alarm Common" point to 1 to indicate a general fault condition.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
+    // Logic to run when the equipment enters this state
+    Serial.println("Enter Fail State...");
+}
+
+/**
+ * @brief Logic to execute once when exiting the fail state.
+ * Clears the "Alarm Common" point to 0 before transitioning to the next state.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+    Serial.println("Exit Fail State...");
+}

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Running.cpp

@@ -0,0 +1,129 @@
+/**
+ * @file State_Running.cpp
+ * @brief Implementation of the RunningState class.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-05
+ *
+ * This file contains the implementation for the RunningState, which defines
+ * the behavior of the equipment when it is actively running.
+ */
+#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.h"
+#include <vector>
+#include <string>
+#if defined(USE_MODBUS_IP)
+  #include <ModbusIP_ESP8266.h>
+#else
+  #include <ModbusRTU.h>
+#endif
+
+/**
+ * @brief Constructs a new RunningState object.
+ *
+ * This constructor initializes behavior strategies active during the runnings
+ * state, such as a PID controller for the 'CW Valve Position' and totalizers
+ * for the run-hours of each EC fan.
+ */
+template<>
+RunningState<ModbusIP>::RunningState() {
+  addStrategy("Volts AB", new SingleValueStrategy(480.0F, 5.0f, 1000));
+  addStrategy("Volts BC", new SingleValueStrategy(480.0F, 5.0f, 1000));
+  addStrategy("Volts CA", new SingleValueStrategy(480.0F, 5.0f, 1000));
+
+  addStrategy("PF", new SingleValueStrategy(0.9f, 0.05f, 1000));
+
+  addStrategy("Amps A", new SingleValueStrategy(1.0f, 10.0f, 1000));
+  addStrategy("Amps B", new SingleValueStrategy(1.0f, 10.0f, 1000));
+  addStrategy("Amps C", new SingleValueStrategy(1.0f, 10.0f, 1000));
+
+}
+
+/**
+ * @brief Executes the running 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 running state.
+ *
+ * @param equipment Pointer to the Equipment instance.
+ * @return A pointer to a new State if a transition should occur, otherwise nullptr.
+ */
+template<>
+State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
+    // STATE control, add conditions if change to a different state is needed
+    Serial.println("Running update function");
+    float State_Ctrl = getPointValue(equipment, "State Control");
+    if (State_Ctrl == 1){
+      return new StandbyState<ModbusIP>();
+    }
+    // Apply any strategies defined for the standby state
+    float volts_AB = getPointValue(equipment, "Volts AB");
+    float volts_BC = getPointValue(equipment, "Volts BC");
+    float volts_AC = getPointValue(equipment, "Volts CA");
+
+    setPointValue(equipment, "Volts AN", volts_AB/1.732);
+    setPointValue(equipment, "Volts BN", volts_BC/1.732);
+    setPointValue(equipment, "Volts CN", volts_AC/1.732);
+
+
+    int I_load = getPointValue(equipment, "Load");
+    int I_rating = getPointValue(equipment, "Rating");
+    float load = static_cast<float>(I_load);
+    float rating = static_cast<float>(I_rating);
+    float real_load = rating * (load/100.0f);
+    setPointValue(equipment, "Amps A", real_load);
+    setPointValue(equipment, "Amps B", real_load);
+    setPointValue(equipment, "Amps C", real_load);
+
+    float pf = getPointValue(equipment, "PF");
+
+
+    float kw = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load * pf)/1000;
+    float kva = (1.732f * ((volts_AB + volts_BC + volts_AC)/3.0f) * real_load)/1000;
+
+    setPointValue(equipment, "kW", kw);
+    setPointValue(equipment, "kVA", kva);
+    _applyStrategies(equipment);
+    return nullptr;
+}
+
+/**
+ * @brief Logic to execute once when entering the running 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 RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
+    // Logic to run when the equipment enters this state
+    Serial.println("Enter Running State...");
+    // You could also update a Modbus register to show the "standby" state
+    setPointValue(equipment, "CB Position", 2048);
+
+}
+
+/**
+ * @brief Logic to execute once when exiting the running 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 RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+    Serial.println("Exit Running State...");
+   
+}

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/State_Standby.cpp

@@ -0,0 +1,99 @@
+/**
+ * @file State_Standby.cpp
+ * @brief Implementation of the StandbyState class.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-05
+ *
+ * This file contains the implementation for the StandbyState, which defines
+ * the behavior of the equipment when it is in an idle or standby mode.
+ */
+#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 "States/State_Standby.h"
+#include "States/State_Running.h"
+#include "States/State_Fail.h"
+#include "States/State.h"
+#include <vector>
+#include <string>
+#if defined(USE_MODBUS_IP)
+  #include <ModbusIP_ESP8266.h>
+#else
+  #include <ModbusRTU.h>
+#endif
+/**
+ * @brief Constructs a new StandbyState object.
+ *
+ * In this state, the equipment is idle. This constructor initializes strategies
+ * to bring the system to a safe, idle condition. It sets a stable value for
+ * the SAT reading and creates ramp strategies to bring the CW valve and all
+ * EC fan speeds down to zero.
+ */
+template<>
+StandbyState<ModbusIP>::StandbyState() {
+  // You can add initialization code here if needed
+  
+
+}
+
+/**
+ * @brief Executes the standby state's logic for one update cycle.
+ *
+ * This method applies the strategies defined for the standby state (e.g.,
+ * ramping values to zero).
+ *
+ * @warning This method currently does not check for a command to transition to the
+ *          Running state. This logic needs to be added to allow the unit to start.
+ * @return A pointer to a new State if a transition should occur, otherwise nullptr.
+ */
+template<>
+State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
+    // STATE control, add conditions if change to a different state is needed
+    Serial.println("Standby update function");
+    float State_Ctrl = getPointValue(equipment, "State Control");
+    if (State_Ctrl == 2){
+      return new RunningState<ModbusIP>();
+    }
+    // Apply any strategies defined for the standby state
+    _applyStrategies(equipment);
+    return nullptr;
+}
+
+/**
+ * @brief Logic to execute once when entering the standby state.
+ * This method performs cleanup by setting all alarm points and all EC fan
+ * run status points to 0.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
+    // Logic to run when the equipment enters this state
+    Serial.println("Enter Standby State...");
+    setPointValue(equipment, "CB Position", 0);
+    setPointValue(equipment, "Volts AB", 0.0f);
+    setPointValue(equipment, "Volts BC", 0.0f);
+    setPointValue(equipment, "Volts CA", 0.0f);
+    setPointValue(equipment, "Volts AN", 0.0f);
+    setPointValue(equipment, "Volts BN", 0.0f);
+    setPointValue(equipment, "Volts CN", 0.0f);
+    setPointValue(equipment, "PF", 0.0f);
+    setPointValue(equipment, "Amps A", 0.0f);
+    setPointValue(equipment, "Amps B", 0.0f);
+    setPointValue(equipment, "Amps C", 0.0f);
+}
+
+/**
+ * @brief Logic to execute once when exiting the standby state.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+    Serial.println("Exit Standby State...");
+}

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/config.h

@@ -0,0 +1,97 @@
+/**
+ * @file config.h
+ * @brief Main configuration file for the CRAH Unit (TCP) emulator.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-02
+ *
+ * This file contains two important configurations: WiFi network parameters
+ * and the Modbus register map for the device.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+
+#include "core.h"
+#include "Equipment/Equipment.h"
+
+#if defined(USE_MODBUS_IP)
+/**
+   * @defgroup ModbusTCPConfig Modbus IP Configuration
+   * @brief Parameters for Modbus TCP communication.
+   * @{
+   */
+  #include <ModbusIP_ESP8266.h>
+  const char *ssid = "QTS_CDR_Arduino";       /**< @brief The SSID of the WiFi network. */
+  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
+  IPAddress local_IP(172, 17, 30, 241);       /**< @brief The static IP address for the device. */
+  IPAddress gateway(172, 17, 30, 1);          /**< @brief The gateway IP address. */
+  IPAddress subnet(255, 255, 255, 0);         /**< @brief The subnet mask. */
+  
+  ModbusIP mb;
+#else
+  /**
+   * @defgroup ModbusRTUConfig Modbus RTU Configuration
+   * @brief Parameters for serial Modbus RTU communication.
+   * @{
+   */
+  #include <ModbusRTU.h>
+  const int BAUDRATE = 19200;   /**< @brief The serial communication speed in bits per second. */
+  const int RX_PIN = 17;        /**< @brief The GPIO pin used for receiving data (RX). */
+  const int TX_PIN = 16;        /**< @brief The GPIO pin used for transmitting data (TX). */
+  const int RST_PIN = 4;        /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
+  const int MODBUS_ID = 1;      /**< @brief The unique slave ID for this device on the Modbus bus. */
+  /** @} */
+
+  /** @brief Global instance of the Modbus RTU server. */
+  ModbusRTU mb;
+#endif
+
+
+
+/**
+ * @defgroup ModbusMapConfig Modbus Map Configuration
+ * @brief Defines the Modbus register map and related parameters for the emulator.
+ * @{
+ */
+/**
+ * @brief The Modbus map for the Equipment device.
+ * This array defines all the Modbus points available on the emulated device.
+ * The `description` field is crucial as it's used to look up points within the application logic.
+ */
+modbusMap mb_map[] =
+{   
+  {HR,            9,    0,    "State Control"},
+  {HR,            10,    0,   "Load"},
+  {HR,            11,    0,   "Rating"},
+  
+  {IR,            207,    0,  "CB Position"},
+  {IR_FLOAT,      215,    0,  "Amps A"},
+  {IR_FLOAT,      217,    0,  "Amps B"},
+  {IR_FLOAT,      219,    0,  "Amps C"},
+  {IR_FLOAT,      221,    0,  "Amps N"},
+  {IR_FLOAT,      223,    0,  "Amps G"},
+  {IR_FLOAT,      231,    0,  "Volts AN"},
+  {IR_FLOAT,      233,    0,  "Volts BN"},
+  {IR_FLOAT,      235,    0,  "Volts CN"},
+  {IR_FLOAT,      237,    0,  "Volts AB"},
+  {IR_FLOAT,      239,    0,  "Volts BC"},
+  {IR_FLOAT,      241,    0,  "Volts CA"},
+  {IR_FLOAT,      249,    0,  "PF"},
+  {IR_FLOAT,      251,    0,  "kW"},
+  {IR_FLOAT,      255,    0,  "kVA"},
+  {IR_FLOAT,      265,    0,  "kWh reg1"},
+  {IR_FLOAT,      267,    0,  "kWh reg2"},
+}; 
+//Size of modbus map used in FOR cycles, automatically calculated.
+
+/**
+ * @brief The total number of entries in the `mb_map` array.
+ * This is calculated at compile time and used for iterating over the map.
+ */
+const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
+
+/** @brief The main loop update interval in milliseconds. */
+int interval = 250; 
+/** @} */ // End of ModbusMapConfig group
+
+#endif // CONFIG_H

src/EPMS/Breaker/Susol_Smart_MCCB_TCP/main.cpp

@@ -0,0 +1,86 @@
+/**
+ * @file main.cpp
+ * @brief Main execution program for the CRAH Unit (TCP) Emulator.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-02
+ *
+ * @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit. 
+ * The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
+ *
+ * The setup() function initializes the following:
+ * - Serial communication for debugging.
+ * - Wi-Fi connection using credentials from config.h.
+ * - A Modbus TCP server.
+ * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
+ *
+ * The loop() function continuously:
+ * - Services the Modbus TCP server to handle incoming requests.
+ * - Periodically calls the main update loop for the emulated equipment, which
+ *   manages state transitions and behavior strategies.
+ *
+ * @see config.h for Wi-Fi and Modbus configuration.
+ * @see Equipment.h for the main equipment logic.
+ * @see State.h for different equipment states.
+ * @see Strategies/Strategy_Behavior.h for value generation strategies.
+ * @see Modbus_Point.h for the base class for all Modbus points.
+ */
+//=================================================================================================================================
+//Libraries and declaration of variables.
+#include <WiFi.h>
+#include "config.h"
+#include "ModbusPoints/Modbus_PointFactory.h"
+#if defined(USE_MODBUS_IP)
+  #include <ModbusIP_ESP8266.h>
+#else
+  #include <ModbusRTU.h>
+#endif
+//=================================================================================================================================
+/** 
+ * @brief Initializes the application.
+ * @details This function runs once at startup. It configures the serial communication, 
+ * Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points 
+ * based on the `mb_map` array in `config.h`.
+ */
+void setup() {
+  Serial.begin(115200);                       //Serial comm start
+  WiFi.config(local_IP, gateway, subnet);     // Wifi service start
+  WiFi.begin(ssid, password);
+  while (WiFi.status() != WL_CONNECTED) {
+    delay(1000);
+    Serial.print(".");
+  }
+  Serial.println("Connected!!");
+  mb.server();                                //Modbus server start
+  Serial.println("Server Created");
+  Serial.println(map_size);
+  for(int i = 0; i < map_size; i++){
+    Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
+    if (point) {
+      point->addToModbusServer();
+      EquipmentInstance.addModbus_Point(mb_map[i].description, point);
+    }
+  }
+  Serial.println("All modbus Points created");
+  Serial.println("Setup function ended");
+}
+//=================================================================================================================================
+/** 
+ * @brief The main application loop.
+ * @details This function runs repeatedly after setup() has completed. It performs two main actions:
+ * 1. It continuously services the Modbus server by calling `mb.task()` to handle
+ *    incoming requests from a Modbus master.
+ * 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
+ *    to run the emulator's internal state machine and behavior logic.
+ */
+void loop() {
+  mb.task();
+  unsigned long currentMillis = millis();
+  if (currentMillis - previousMillis >= interval) {
+    previousMillis = currentMillis;
+    unsigned long startTime = millis();
+    EquipmentInstance.update();
+    unsigned long endTime = millis();
+    unsigned long elapsedTime = endTime - startTime;
+    Serial.printf("Control Execution time: %d ms\n", elapsedTime);
+  } 
+}