comment

platformio.ini

@@ -9,7 +9,13 @@
 ; https://docs.platformio.org/page/projectconf.html
 
 [platformio]
-default_envs = Testing_RTU   ; Select here the name of the configuration you want to download
+default_envs = CH_York_XXXXX_RTU  ; Select here the name of the configuration you want to download
+
+[env:CH_York_XXXXX_RTU]
+platform = espressif32
+board = dfrobot_firebeetle2_esp32e
+extends = common_env_options
+build_src_filter = -<*> +<BMS/CHILLER/CH_York_XXXXX_RTU>
 
 [env]
 upload_port = COM100
@@ -66,3 +72,5 @@ platform = espressif32
 board = dfrobot_firebeetle2_esp32e
 extends = common_env_options
 build_src_filter = -<*> +<BMS/VFD/VFD_ABB_ACH580_RTU>
+
+

src/BMS/CHILLER/CH_York_XXXXX_RTU/README.md

@@ -0,0 +1,35 @@
+# EQUIPMENT_TYPE MANUFACTURER MODEL RTU
+
+## 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 and at least one hardware serial port for RS485 communication.
+
+* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) 
+* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.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/BMS/CHILLER/CH_York_XXXXX_RTU/State_Fail.cpp

@@ -0,0 +1,77 @@
+/**
+ * @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 "States/State_Standby.h"
+#include "States/State_Fail.h"
+#include "ModbusPoints/Modbus_Point.h"
+#include "Equipment/Equipment.h"
+#include "Strategies/Strategy_SingleValue.h"
+#include "Strategies/Strategy_PID.h"
+
+#include <vector>
+#include <string>
+
+#if defined(USE_MODBUS_IP)
+  #include <ModbusIP_ESP8266.h>
+#else
+  #include <ModbusRTU.h>
+#endif
+
+/**
+ * @brief Constructs a new FailState object.
+ *
+ * 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 valve position.
+ */
+template<>
+FailState<ModbusRTU>::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 "Clear Alm" 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.
+ *
+ * @param equipment Pointer to the Equipment instance.
+ * @return A pointer to a new State if a transition should occur, otherwise nullptr.
+ */
+template<>
+State<ModbusRTU>* FailState<ModbusRTU>::update(Equipment<ModbusRTU>* 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 main alarm bit.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void FailState<ModbusRTU>::enterState(Equipment<ModbusRTU>* 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 main alarm bit.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void FailState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+    Serial.println("Exit Fail State...");
+    
+}

src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Running.cpp

@@ -0,0 +1,89 @@
+/**
+ * @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 "States/State_Standby.h"
+#include "States/State_Running.h"
+#include "States/State_Fail.h"
+#include "Strategies/Strategy_Behavior.h"
+#include "Strategies/Strategy_PID.h"
+#include "Strategies/Strategy_Ramp.h"
+#include "Strategies/Strategy_Totalizer.h"
+#include "Equipment/Equipment.h"
+#include "ModbusPoints/Modbus_Point.h"
+#include "ModbusPoints/Modbus_FloatDecorator.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<ModbusRTU>::RunningState() {
+    //Add strategies 
+    //addStrategy("Actual Capacity", new PIDStrategy("Active SP", 1000, "Supply Temp"));
+    
+}
+
+/**
+ * @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<ModbusRTU>* RunningState<ModbusRTU>::update(Equipment<ModbusRTU>* 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;
+}
+
+/**
+ * @brief Logic to execute once when entering the running state.
+ * Sets the "Chiller Sts" point to indicate the unit is running.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void RunningState<ModbusRTU>::enterState(Equipment<ModbusRTU>* equipment) {
+    // Logic to run when the equipment enters this state
+    Serial.println("Enter Running State...");
+    
+}
+
+/**
+ * @brief Logic to execute once when exiting the running state.
+ * Sets the "Chiller Sts" point to indicate the unit is no longer running.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void RunningState<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+    Serial.println("Exit Running State...");
+}

src/BMS/CHILLER/CH_York_XXXXX_RTU/State_Standby.cpp

@@ -0,0 +1,79 @@
+/**
+ * @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 "States/State_Running.h"
+#include "States/State_Fail.h"
+#include "ModbusPoints/Modbus_Point.h"
+#include "ModbusPoints/Modbus_FloatDecorator.h"
+#include "Equipment/Equipment.h"
+#include "Strategies/Strategy_Ramp.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 several
+ * strategies to generate random values for various status points, simulating
+ * a live but non-operational unit.
+ */
+template<>
+StandbyState<ModbusRTU>::StandbyState() {
+
+  addStrategy("HR1", new RampStrategy(200.0f, 5.0f, 1000));
+  
+}
+
+/**
+ * @brief Executes the standby state's logic for one update cycle.
+ *
+ * This method checks the "Chiller On-Off" Modbus point for a command to
+ * transition to the Running state. If no transition is requested, it applies
+ * the strategies defined for the standby state.
+ *
+ * @param equipment Pointer to the Equipment instance.
+ * @return A pointer to a new State if a transition should occur, otherwise nullptr.
+ */
+template<>
+State<ModbusRTU>* StandbyState<ModbusRTU>::update(Equipment<ModbusRTU>* equipment) {
+    // STATE control, add conditions if change to a different state is needed
+    Serial.println("Standby update function");
+    
+    // Apply any strategies defined for the standby state
+    _applyStrategies(equipment);
+    return nullptr;
+}
+
+/**
+ * @brief Logic to execute once when entering the standby state.
+ * Sets the "Chiller Sts" point to indicate the unit is not running.
+ * @param equipment Pointer to the Equipment instance.
+ */
+template<>
+void StandbyState<ModbusRTU>::enterState(Equipment<ModbusRTU>* 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<ModbusRTU>::exitState(Equipment<ModbusRTU>* equipment) {
+    // Cleanup logic to run when the equipment leaves this state
+   
+}

src/BMS/CHILLER/CH_York_XXXXX_RTU/config.h

@@ -0,0 +1,74 @@
+/**
+ * @file config.h
+ * @brief Main configuration file for the Daikin Chiller (RTU) emulator.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-02
+ *
+ * This file contains important configurations for the Modbus RTU communication
+ * and the specific register map for the emulated device.
+ */
+
+#ifndef CONFIG_H
+#define CONFIG_H
+#include <ModbusRTU.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 = "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. */
+  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
+
+/**
+ * @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,        0,  0,  "HR1"},  //Internal to control from Modscan
+  {HR_10x,    1,  0,  "HR2"},  //Internal to control from Modscan
+  {HR_FLOAT,  2,  0,  "HR3"},  //Internal to control from Modscan
+  {HR_LONG,   4,  0,  "HR4"},  //Internal to control from Modscan  
+};
+//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; 
+
+#endif // CONFIG_H

src/BMS/CHILLER/CH_York_XXXXX_RTU/main.cpp

@@ -0,0 +1,78 @@
+/**
+ * @file main.cpp
+ * @brief Main execution program for the Daikin Chiller (RTU) Emulator.
+ * @author Emmanuel Hernandez Cruz
+ * @date 2025-09-02
+ *
+ * @details This file contains the main execution program for an Arduino-based
+ * emulator of a Daikin Chiller unit. The program communicates via the
+ * Modbus RTU protocol over a serial connection.
+ *
+ * The setup() function initializes the following:
+ * - Serial communication for debugging.
+ * - A Modbus RTU server with parameters from config.h.
+ * - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
+ *
+ * The loop() function continuously:
+ * - Services the Modbus RTU 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 Modbus RTU and register map 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 <Arduino.h>
+#include "config.h"
+#include "ModbusPoints/Modbus_PointFactory.h"
+
+//=================================================================================================================================
+/** 
+ * @brief Initializes the application.
+ * @details This function runs once at startup. It configures the serial communication
+ * for debugging and the Modbus RTU server. It then creates and initializes all
+ * the Modbus points based on the `mb_map` array in `config.h`.
+ */
+const int rtsPin = 4;
+void setup() {
+  Serial.begin(115200);
+  Serial.println("Setup function started");
+
+  Serial2.begin(BAUDRATE, SERIAL_8N1, RX_PIN, TX_PIN);
+  mb.begin(&Serial2, RST_PIN); // Start the server
+  mb.slave(MODBUS_ID); // Set the slave ID
+   
+  for(int i = 0; i < map_size; i++){
+    Modbus_Point<ModbusRTU>* 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("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);
+  } 
+}