Merge pull request #44 from emmanuelsrlok/ecruz/MVG

Ecruz/mvg
2025-11-10 09:25:38 -06:00
parent aa204e615e 587945cf1f
commit b7e7107a2b
7 changed files with 671 additions and 3 deletions
--- a/platformio.ini
+++ b/platformio.ini
@@ -9,10 +9,10 @@

 [platformio]

-default_envs = CH_York_YVAA_RTU ; Select here the name of the configuration you want to download
+default_envs = MVG_SC_EC_M505_TCP ; Select here the name of the configuration you want to download

 [env]
-upload_port = COM16
+upload_port = COM26

 [common_env_options]
 framework = arduino
@@ -245,4 +245,12 @@ platform = espressif32
 board = dfrobot_firebeetle2_esp32e
 extends = common_env_options
 build_flags = -D USE_MODBUS_IP 
-build_src_filter = -<*> +<Base_TCP>
+build_src_filter = -<*> +<Base_TCP>
+
+[env:MVG_SC_EC_M505_TCP]
+platform = espressif32
+board = dfrobot_firebeetle2_esp32e
+extends = common_env_options
+build_flags = -D USE_MODBUS_IP,
+build_src_filter = -<*> +<EPMS/MVG/MVG_SC_EC_M505_TCP>
+
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
@@ -0,0 +1,48 @@
+# Daikin Chiller (RTU) Emulator
+
+This project is an Arduino-based emulator for a Daikin Chiller unit, communicating over Modbus RTU. It is designed to be a flexible template that can be adapted to simulate different types of chillers by modifying the configuration and state logic.
+
+The emulator operates on a state machine with three core states:
+* **Standby**: The chiller is idle but ready.
+* **Running**: The chiller is active and operational.
+* **Fail**: The chiller has encountered a fault condition.
+
+## Features
+
+* **Modbus RTU Communication**: Emulates a Modbus slave device.
+* **State Machine Logic**: Simulates different operational states (Standby, Running, Fail).
+* **Dynamic Value Simulation**: Uses "Strategies" (e.g., PID, Ramp) to generate realistic, changing values for Modbus points.
+* **Configurable Modbus Map**: The entire Modbus register map is defined in a single, easy-to-modify file (`config.h`).
+* **Extensible Design**: The structure allows for the addition of new states and behaviors.
+
+## Hardware Prerequisites
+
+The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities and at least one hardware serial port for RS485 communication.
+
+* **Microcontroller**: ESP8266, ESP32, or similar.
+* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus.
+
+## Software Dependencies
+
+This project relies on a Modbus library. Ensure you have the correct library installed in your Arduino IDE.
+
+* **Modbus Library**: The code uses a library that provides `ModbusRTU.h` and optionally `ModbusIP_ESP8266.h`.
+
+---
+
+## How to Customize for a New Chiller
+
+To adapt this template for a new chiller, follow these steps.
+
+### 1. Configure Device-Specific Parameters (`config.h`)
+
+Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings.
+
+#### Modbus RTU Settings
+Update the following constants for your device's serial communication setup.
+```c++
+const int BAUDRATE = 19200;   // The serial communication speed
+const int RX_PIN = 17;        // The GPIO pin for receiving data (RX)
+const int TX_PIN = 16;        // The GPIO pin for transmitting data (TX)
+const int RST_PIN = 4;        // The GPIO pin for RS485 direction control
+const int MODBUS_ID = 1;      // The unique slave ID for this device
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_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...");
+}
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
@@ -0,0 +1,271 @@
+/**
+ * @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 running
+ * 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() {
+
+}
+
+/**
+ * @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 StateCtrl = getPointValue(equipment, "Px_Mode");
+    if (StateCtrl == 1.0f) {
+      return new StandbyState<ModbusIP>();
+    }
+
+    float W1 = getPointValue(equipment, "Px_W1");
+    float W2 = getPointValue(equipment, "Px_W2");
+    float W3 = getPointValue(equipment, "Px_W3");
+    float W4 = getPointValue(equipment, "Px_W4");
+    float W5 = getPointValue(equipment, "Px_W5");
+    float W6 = getPointValue(equipment, "Px_W6");
+    // Apply any strategies defined for the standby state
+
+    switch (static_cast<int>(W1)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_01", 0, false);
+        setBitValue(equipment, "MVG_STS_01", 1, false);
+        setBitValue(equipment, "MVG_STS_01", 2, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_01", 0, true);
+        setBitValue(equipment, "MVG_STS_01", 1, false);
+        setBitValue(equipment, "MVG_STS_01", 2, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_01", 0, false);
+        setBitValue(equipment, "MVG_STS_01", 1, true);
+        setBitValue(equipment, "MVG_STS_01", 2, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_01", 0, true);
+        setBitValue(equipment, "MVG_STS_01", 1, false);
+        setBitValue(equipment, "MVG_STS_01", 2, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_01", 0, false);
+        setBitValue(equipment, "MVG_STS_01", 1, false);
+        setBitValue(equipment, "MVG_STS_01", 2, false);
+        break;
+    }
+
+    switch (static_cast<int>(W2)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_01", 3, false);
+        setBitValue(equipment, "MVG_STS_01", 4, false);
+        setBitValue(equipment, "MVG_STS_01", 5, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_01", 3, true);
+        setBitValue(equipment, "MVG_STS_01", 4, false);
+        setBitValue(equipment, "MVG_STS_01", 5, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_01", 3, false);
+        setBitValue(equipment, "MVG_STS_01", 4, true);
+        setBitValue(equipment, "MVG_STS_01", 5, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_01", 3, true);
+        setBitValue(equipment, "MVG_STS_01", 4, false);
+        setBitValue(equipment, "MVG_STS_01", 5, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_01", 3, false);
+        setBitValue(equipment, "MVG_STS_01", 4, false);
+        setBitValue(equipment, "MVG_STS_01", 5, false);
+        break;
+    }
+
+    switch (static_cast<int>(W3)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_01", 6, false);
+        setBitValue(equipment, "MVG_STS_01", 7, false);
+        setBitValue(equipment, "MVG_STS_02", 0, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_01", 6, true);
+        setBitValue(equipment, "MVG_STS_01", 7, false);
+        setBitValue(equipment, "MVG_STS_02", 0, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_01", 6, false);
+        setBitValue(equipment, "MVG_STS_01", 7, true);
+        setBitValue(equipment, "MVG_STS_02", 0, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_01", 6, true);
+        setBitValue(equipment, "MVG_STS_01", 7, false);
+        setBitValue(equipment, "MVG_STS_02", 0, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_01", 6, false);
+        setBitValue(equipment, "MVG_STS_01", 7, false);
+        setBitValue(equipment, "MVG_STS_02", 0, false);
+        break;
+    }
+
+    switch (static_cast<int>(W4)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_02", 1, false);
+        setBitValue(equipment, "MVG_STS_02", 2, false);
+        setBitValue(equipment, "MVG_STS_02", 3, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_02", 1, true);
+        setBitValue(equipment, "MVG_STS_02", 2, false);
+        setBitValue(equipment, "MVG_STS_02", 3, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_02", 1, false);
+        setBitValue(equipment, "MVG_STS_02", 2, true);
+        setBitValue(equipment, "MVG_STS_02", 3, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_02", 1, true);
+        setBitValue(equipment, "MVG_STS_02", 2, false);
+        setBitValue(equipment, "MVG_STS_02", 3, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_02", 1, false);
+        setBitValue(equipment, "MVG_STS_02", 2, false);
+        setBitValue(equipment, "MVG_STS_02", 3, false);
+        break;
+    }
+
+    switch (static_cast<int>(W5)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_02", 4, false);
+        setBitValue(equipment, "MVG_STS_02", 5, false);
+        setBitValue(equipment, "MVG_STS_02", 6, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_02", 4, true);
+        setBitValue(equipment, "MVG_STS_02", 5, false);
+        setBitValue(equipment, "MVG_STS_02", 6, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_02", 4, false);
+        setBitValue(equipment, "MVG_STS_02", 5, true);
+        setBitValue(equipment, "MVG_STS_02", 6, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_02", 4, true);
+        setBitValue(equipment, "MVG_STS_02", 5, false);
+        setBitValue(equipment, "MVG_STS_02", 6, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_02", 4, false);
+        setBitValue(equipment, "MVG_STS_02", 5, false);
+        setBitValue(equipment, "MVG_STS_02", 6, false);
+        break;
+    }
+
+    switch (static_cast<int>(W6)){
+      case 0:
+        setBitValue(equipment, "MVG_STS_02", 7, false);
+        setBitValue(equipment, "MVG_STS_03", 0, false);
+        setBitValue(equipment, "MVG_STS_03", 1, false);
+        break;
+      case 1:
+        setBitValue(equipment, "MVG_STS_02", 7, true);
+        setBitValue(equipment, "MVG_STS_03", 0, false);
+        setBitValue(equipment, "MVG_STS_03", 1, false);
+        break;
+      case 2:
+        setBitValue(equipment, "MVG_STS_02", 7, false);
+        setBitValue(equipment, "MVG_STS_03", 0, true);
+        setBitValue(equipment, "MVG_STS_03", 1, false);
+        break;
+      case 3:
+        setBitValue(equipment, "MVG_STS_02", 7, true);
+        setBitValue(equipment, "MVG_STS_03", 0, false);
+        setBitValue(equipment, "MVG_STS_03", 1, true);
+        break;
+      default:
+        setBitValue(equipment, "MVG_STS_02", 7, false);
+        setBitValue(equipment, "MVG_STS_03", 0, false);
+        setBitValue(equipment, "MVG_STS_03", 1, false);
+        break;
+    }
+    _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
+    
+}
+
+/**
+ * @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...");
+    setPointValue(equipment, "MVG_STS_01", 0);
+    setPointValue(equipment, "MVG_STS_02", 0);
+    setPointValue(equipment, "MVG_STS_03", 0);
+   
+}
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
@@ -0,0 +1,88 @@
+/**
+ * @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 StateCtrl = getPointValue(equipment, "Px_Mode");
+    if (StateCtrl == 2.0f) {
+      return new RunningState<ModbusIP>();
+    }
+    _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...");
+
+    
+    
+}
+/**
+ * @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...");
+}
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
@@ -0,0 +1,86 @@
+/**
+ * @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 = "ArduinoWifiB";       /**< @brief The SSID of the WiFi network. */
+  const char *password = "123abc456";   /**< @brief The password for the WiFi network. */
+  IPAddress local_IP(172, 17, 32, 82);       /**< @brief The static IP address for the device. */
+  IPAddress gateway(172, 17, 32, 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,  "Px_Mode"},
+  {HR,          10,    0,  "Px_W1"},
+  {HR,          11,    0,  "Px_W2"},
+  {HR,          12,    0,  "Px_W3"},
+  {HR,          13,    0,  "Px_W4"},
+  {HR,          14,    0,  "Px_W5"},
+  {HR,          15,    0,  "Px_W6"},
+  {HR,        1049,    0,  "MVG_STS_01"},
+  {HR,        1050,    0,  "MVG_STS_02"},
+  {HR,        1051,    0,  "MVG_STS_03"},
+};
+//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
--- a/src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp
+++ b/src/EPMS/MVG/MVG_SC_EC_M505_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);
+  } 
+}