diff --git a/README.md b/README.md index 7f3fafe..462b2ee 100644 --- a/README.md +++ b/README.md @@ -14,8 +14,6 @@ In industrial automation, a machine has different operating modes: **Standby**, The **State Pattern** organizes the code to mirror these real-world machine modes. -* **Analogy:** Think of a PLC program. Instead of having one massive ladder logic routine with dozens of branches checking `IF machine_is_running THEN... ELSE IF machine_is_in_standby THEN...`, you create separate routines for each mode. - * **How it works here:** * The `Equipment` class is our main "machine". * We have separate classes for each state: `State_Standby`, `State_Running`, `State_Fail`. @@ -95,6 +93,9 @@ The **Decorator Pattern** lets us "wrap" a basic Modbus point to add this extra ## How to Modify or Extend the Emulator +### Use Equipment library +Look for the equipment type you want to use in the `src` folder, equipments are organized in BMS or EPMS type, there are subfolders for specify types. + 1. **To add or change a Modbus point:** * Open `config.h`. * Set Wifi parameters to communicate to the network. @@ -110,4 +111,22 @@ The **Decorator Pattern** lets us "wrap" a basic Modbus point to add this extra * Implement the logic for that mode, including adding strategies for how points should behave. * Update the state-switching logic (e.g., in `State_Running.cpp` or `State_Standby.cpp`) to allow transitioning into your new `CleaningState`. +### Create a new Equipment type + +1. **Copy the base** + * Copy one of the base folders in `src`, depending on the communication you need RTU or TCP, both configurations works with Firebeetle 2 ESP32. + +2. **Save it into the correct folder** + * Save that folder into the correct type location. + * Use a standar name, using this stucture + Type_Manufacturer_Series_Protocol + Example: + VFD_ABB_ACH580_RTU + +3. **Modify `platformio.ini` file** + * Copy a base configuration depending it's RTU or TCP + * Paste it within the same file + * Change the name of the configuration, preferrably using the same folder name + * Add the folder to the configuration +<`folder_name'> + --- \ No newline at end of file diff --git a/lib/Core/ModbusPoints/Modbus_Coil.h b/lib/Core/ModbusPoints/Modbus_Coil.h index 6873530..9fcfe25 100644 --- a/lib/Core/ModbusPoints/Modbus_Coil.h +++ b/lib/Core/ModbusPoints/Modbus_Coil.h @@ -24,7 +24,7 @@ class Modbus_Coil : public Modbus_Point{ public: /** * @brief Constructor for the Modbus_Coil class. - * @param server Pointer to the ModbusIP server instance. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). * @param address The Modbus address of the coil. * @param value The initial value of the coil. * @param description A description of the coil. @@ -48,7 +48,13 @@ public: */ int getValue() const override; }; - +/** + * @brief Constructor implementation for the Modbus_Coil class. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). + * @param address The Modbus address of the coil. + * @param value The initial value of the coil. + * @param description A description of the coil. + */ template Modbus_Coil::Modbus_Coil(T* server, int address, int value, const char* description) : Modbus_Point(server, address, value, description) {} diff --git a/lib/Core/ModbusPoints/Modbus_Hreg.h b/lib/Core/ModbusPoints/Modbus_Hreg.h index cf63acd..97b35b2 100644 --- a/lib/Core/ModbusPoints/Modbus_Hreg.h +++ b/lib/Core/ModbusPoints/Modbus_Hreg.h @@ -25,7 +25,7 @@ class Modbus_Hreg : public Modbus_Point{ public: /** * @brief Constructor for the Modbus_Hreg class. - * @param server Pointer to the ModbusIP server instance. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). * @param address The Modbus address of the holding register. * @param value The initial value of the holding register. * @param description A description of the holding register. @@ -53,7 +53,13 @@ public: }; - +/** + * @brief Constructor implementation for the Modbus_Hreg class. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). + * @param address The Modbus address of the holding register. + * @param value The initial value of the holding register. + * @param description A description of the holding register. + */ template Modbus_Hreg::Modbus_Hreg(T* server, int address, int value, const char* description) : Modbus_Point(server, address, value, description) {} diff --git a/lib/Core/ModbusPoints/Modbus_Ireg.h b/lib/Core/ModbusPoints/Modbus_Ireg.h index 32d5c30..8d1fd59 100644 --- a/lib/Core/ModbusPoints/Modbus_Ireg.h +++ b/lib/Core/ModbusPoints/Modbus_Ireg.h @@ -25,7 +25,7 @@ class Modbus_Ireg : public Modbus_Point{ public: /** * @brief Constructor for the Modbus_Ireg class. - * @param server Pointer to the ModbusIP server instance. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). * @param address The Modbus address of the input register. * @param value The initial value of the input register. * @param description A description of the input register. @@ -48,7 +48,13 @@ public: */ int getValue() const override; }; - +/** + * @brief Constructor for the Modbus_Ireg class. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). + * @param address The Modbus address of the holding register. + * @param value The initial value of the holding register. + * @param description A description of the holding register. + */ template Modbus_Ireg::Modbus_Ireg(T* server, int address, int value, const char* description) : Modbus_Point(server, address, value, description){} diff --git a/lib/Core/ModbusPoints/Modbus_Ists.h b/lib/Core/ModbusPoints/Modbus_Ists.h index 705178d..e5841bb 100644 --- a/lib/Core/ModbusPoints/Modbus_Ists.h +++ b/lib/Core/ModbusPoints/Modbus_Ists.h @@ -25,7 +25,7 @@ class Modbus_Ists : public Modbus_Point{ public: /** * @brief Constructor for the Modbus_Ists class. - * @param server Pointer to the ModbusIP server instance. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). * @param address The Modbus address of the discrete input. * @param value The initial value of the discrete input. * @param description A description of the discrete input. @@ -49,7 +49,13 @@ public: int getValue() const override; }; - +/** + * @brief Constructor for the Modbus_Ists class. + * @param server Pointer to the Modbus server instance (e.g., ModbusIP, ModbusRTU). + * @param address The Modbus address of the holding register. + * @param value The initial value of the holding register. + * @param description A description of the holding register. + */ template Modbus_Ists::Modbus_Ists(T* server, int address, int value, const char* description) : Modbus_Point(server, address, value, description) {} diff --git a/platformio.ini b/platformio.ini index f6c7cd5..e2130f3 100644 --- a/platformio.ini +++ b/platformio.ini @@ -9,10 +9,10 @@ ; https://docs.platformio.org/page/projectconf.html [platformio] -default_envs = VFD_ABB_ACH580_RTU +default_envs = CH_Daikin_AWV026B_RTU ; Select here the name of the configuration you want to download [env] -upload_port = COM15 +upload_port = COM100 [common_env_options] framework = arduino @@ -20,10 +20,25 @@ monitor_speed = 115200 lib_ldf_mode = chain+ lib_compat_mode = soft +;Base configuration for RTU equipment +[env:Base_RTU] +platform = espressif32 +board = dfrobot_firebeetle2_esp32e +extends = common_env_options +build_src_filter = -<*> + ;Add the specific folder path here +;Base configuration for TCP equipment +[env:Base_TCP] +platform = espressif32 +board = dfrobot_firebeetle2_esp32e +extends = common_env_options +build_flags = -D USE_MODBUS_IP ;Importat configuration, this flags is used to configure the program +build_src_filter = -<*> + ;Add the specific folder path here + [env:CH_Daikin_AWV026B_RTU] platform = espressif32 board = dfrobot_firebeetle2_esp32e extends = common_env_options +upload_port = COM100 build_src_filter = -<*> + [env:CRAH_PAHHC_600_C6_TCP] diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md index 4f156e3..9d48406 100644 --- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md +++ b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md @@ -1,48 +1,45 @@ -# Daikin Chiller (RTU) Emulator +# Chiller Daikin AWV026B RTU -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## List of Equipmentt +This cofiguration has been used for these models: +* **AWV026B**: 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**: 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`. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) +* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuration -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Comp1 Percent RLA**: **Ramp Strategy** set to 0. +* **Comp2 Percent RLA**: **Ramp Strategy** set to 0. +* **Chiller Enable SP**: Used to change to Running State (1). +* **Outdoor Air Temp**: Read value to select between Ice or Cool mode, fixed 50 deg limit. +* **Run Enabled**: set to 0 on enter state function. -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Comp1 Percent RLA**: **Ramp Strategy** set to 0, this setpoint will change on update. +* **Comp2 Percent RLA**: **Ramp Strategy** set to 0, this setpoint will change on update. +* **Actual Capacity**: **PID Strategy** Emulate actual speed control based on **Supply Temp**, this strategy uses **Active SP** as setpoint, this is modified based on outdoor temp, if it's below 50 it uses Ice setpoint, otherwise it uses Cool setpoint. +* **Chiller Enable SP**: Used to change to Running State (0). -Open `CH_Daikin_AWV026B_RTU/config.h`. This is the main file for device-specific settings. +**Active Capacity Limit**: to set the max capacity of the motors. + +* **Comp1 Percent RLA**: **Ramp Strategy** setpoint based on actual capacity, if its below 50%, the only compressor 1 goes from 0 to limit. If capacity is above 50% then load is divided between both compressors. +* **Comp2 Percent RLA**: **Ramp Strategy** setpoint based on actual capacity, if its below 50%, only compressor 1 runs, compressor 2 will maintain off (0 setpoint), if capacity is above 50% then load is divided between both compressors. +* **Outddor Air Temp** constant reading of this value to change the setpoint from ice to cool. + +* **Run Enabled**: Set to 1 on enter state. + + +### Fail State -#### 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 \ No newline at end of file diff --git a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp index c7d74e7..0def2bb 100644 --- a/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp +++ b/src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/State_Running.cpp @@ -100,7 +100,7 @@ State* RunningState::update(Equipment* equipmen if (actualCapacity2 > 100) actualCapacity2 = 100; static_cast(ramp_strategy2)->setTarget(actualCapacity2); } - + // 1. Get the strategy by its name. Strategy_Behavior* strategy = getStrategy("Actual Capacity"); // 2. Check if the strategy exists and is a PID type. @@ -108,7 +108,7 @@ State* RunningState::update(Equipment* equipmen // 3. Cast it to a PIDStrategy pointer and call setSetpoint. static_cast(strategy)->setSetpoint(currentSP); } - + float OutdoorTemp = getPointValue(equipment, "Outdoor Air Temp"); Serial.printf("Outdoor Temp: %f\n", OutdoorTemp); if (OutdoorTemp >50.0f) { @@ -118,8 +118,8 @@ State* RunningState::update(Equipment* equipmen setPointValue(equipment, "Chiller Mode SP", 2.0f); setPointValue(equipment, "Chiller Mode Output", 2.0f); } - - + + setPointValue(equipment, "Active SP", currentSP); // Apply any strategies defined for the standby state _applyStrategies(equipment); diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md index 4f156e3..355156f 100644 --- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md +++ b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp index 1ee0de6..f122906 100644 --- a/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp +++ b/src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/State_Standby.cpp @@ -72,9 +72,9 @@ State* StandbyState::update(Equipment* equipment) return new RunningState(); } - - + + // Apply any strategies defined for the standby state _applyStrategies(equipment); return nullptr; diff --git a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md index 4f156e3..355156f 100644 --- a/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md +++ b/src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md b/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md index 4f156e3..630cf02 100644 --- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md +++ b/src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md @@ -1,48 +1,35 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL RTU -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) +* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h b/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h index b3e5847..ed8d18b 100644 --- a/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h +++ b/src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h @@ -56,6 +56,7 @@ modbusMap mb_map[] = { {HR, 149, 0, "Speed Cmd"}, {HR, 151, 0, "Start/Stop"}, + {HR, 152, 0, "HOA Command"}, {HR, 100, 0, "Motor Speed Used"}, {HR, 101, 0, "Motor Speed estimated"}, {HR_10x, 105, 0, "Output Frequency"}, diff --git a/src/Base_RTU/README.md b/src/Base_RTU/README.md index 4f156e3..630cf02 100644 --- a/src/Base_RTU/README.md +++ b/src/Base_RTU/README.md @@ -1,48 +1,35 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL RTU -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) +* **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/Base_TCP/README.md b/src/Base_TCP/README.md index 4f156e3..355156f 100644 --- a/src/Base_TCP/README.md +++ b/src/Base_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/ATS/ATS_Manufacturer_Model_TCP/README.md b/src/EPMS/ATS/ATS_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/ATS/ATS_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/ATS/ATS_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/Breaker/BKR_Manufacturer_Model_TCP/README.md b/src/EPMS/Breaker/BKR_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/Breaker/BKR_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/Breaker/BKR_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/GEN/GEN_Manufacturer_Model_TCP/README.md b/src/EPMS/GEN/GEN_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/GEN/GEN_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/GEN/GEN_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/MVG/MVG_Manufacturer_Model_TCP/README.md b/src/EPMS/MVG/MVG_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/MVG/MVG_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/MVG/MVG_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/README.md b/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/PDU/PDU_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/PQM/PQM_Manufacturer_Model_TCP/README.md b/src/EPMS/PQM/PQM_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/PQM/PQM_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/PQM/PQM_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/STS/STS_Manufacturer_Model_TCP/README.md b/src/EPMS/STS/STS_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/STS/STS_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/STS/STS_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/UPS/UPS_Manufacturer_Model_TCP/README.md b/src/EPMS/UPS/UPS_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/UPS/UPS_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/UPS/UPS_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md index 4f156e3..355156f 100644 --- a/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md +++ b/src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md @@ -1,48 +1,33 @@ -# Daikin Chiller (RTU) Emulator +# EQUIPMENT_TYPE MANUFACTURER MODEL TCP -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. +## Brief Introduction +Equipment specifc details that make it different from other devices -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. +## 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**: 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`. +The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities. +* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html) --- -## How to Customize for a New Chiller +## States and Strategies +Provide a brief description of what variables and strategies were used in this configuraiton -To adapt this template for a new chiller, follow these steps. +### Standby State +* **Equipment running**: set to 0 +* **Common Alarm**: set to 0 +* **SAT temperature**: set to 85 -### 1. Configure Device-Specific Parameters (`config.h`) +### Running State +* **Equipment running**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint -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 \ No newline at end of file +### Fail State +* **Commong Alarm**: set to 1 +* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset diff --git a/src/README.md b/src/README.md new file mode 100644 index 0000000..16d02de --- /dev/null +++ b/src/README.md @@ -0,0 +1,22 @@ +# Core Concepts + +## Brief Introduction +This file explains the concepts of States and strategies, needed to modify the different programs. + +## State concepts +The emulator operates on a state machine with three core states: +* **Standby**: The equipment is idle but ready. +* **Running**: The equipment is active and operational. +* **Fail**: The equipment has encountered a fault condition. +* **Other**: It's possible to add more states, but new states need to be generated in the core library as well; consider use the 3 basic states before adding more. + +## Strategy concepts +The emulator is able to run different predefined strategies to control the modbus registers, this is the list of available strategies: +* **Single Value**: This strategy will set a value to a setpoint, it has the option to add noise to the value. +* **Random**: Random value between 0 and 100, can be used to L1 testing. +* **Ramp**: The selected value is going to be adjusted in a constant step rate, to a setpoint, setpoint can be updated in execution time. +* **Saw Wave**: Moves the value between two sepoints with constart increments, once it reaches the limit it will reverse direction. +* **Square Wave**: Constant change between two sepoints with instant change between them. +* **PID**: Full PID controller, you need to give a output, input and setpoint modbus address, PID calculate the output based on the input and the PID constants. +* **Totalizer**: Constant increment of a value, to emulate run hours. +For more details read the specific strategy implementation \ No newline at end of file