e.cruz/Industrial_Emulator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 1 Wiki Activity

Readme files updates

Browse Source
This commit is contained in:
Emmanuel HC
2025-09-21 17:58:42 -05:00
parent 6dffd66af2
commit a60b0cb3ed
24 changed files with 454 additions and 597 deletions
Download Patch File Download Diff File Expand all files Collapse all files

23
README.md
View File

@@ -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. 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:** * **How it works here:**
* The `Equipment` class is our main "machine". * The `Equipment` class is our main "machine".
* We have separate classes for each state: `State_Standby`, `State_Running`, `State_Fail`. * 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 ## 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:** 1. **To add or change a Modbus point:**
* Open `config.h`. * Open `config.h`.
* Set Wifi parameters to communicate to the network. * 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. * 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`. * 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'>
--- ---

10
lib/Core/ModbusPoints/Modbus_Coil.h
View File

@@ -24,7 +24,7 @@ class Modbus_Coil : public Modbus_Point<T>{
public: public:
/** /**
* @brief Constructor for the Modbus_Coil class. * @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 address The Modbus address of the coil.
* @param value The initial value of the coil. * @param value The initial value of the coil.
* @param description A description of the coil. * @param description A description of the coil.
@@ -48,7 +48,13 @@ public:
*/ */
int getValue() const override; 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<typename T> template<typename T>
Modbus_Coil<T>::Modbus_Coil(T* server, int address, int value, const char* description) Modbus_Coil<T>::Modbus_Coil(T* server, int address, int value, const char* description)
: Modbus_Point<T>(server, address, value, description) {} : Modbus_Point<T>(server, address, value, description) {}

10
lib/Core/ModbusPoints/Modbus_Hreg.h
View File

@@ -25,7 +25,7 @@ class Modbus_Hreg : public Modbus_Point<T>{
public: public:
/** /**
* @brief Constructor for the Modbus_Hreg class. * @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 address The Modbus address of the holding register.
* @param value The initial value of the holding register. * @param value The initial value of the holding register.
* @param description A description 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<typename T> template<typename T>
Modbus_Hreg<T>::Modbus_Hreg(T* server, int address, int value, const char* description) Modbus_Hreg<T>::Modbus_Hreg(T* server, int address, int value, const char* description)
: Modbus_Point<T>(server, address, value, description) {} : Modbus_Point<T>(server, address, value, description) {}

10
lib/Core/ModbusPoints/Modbus_Ireg.h
View File

@@ -25,7 +25,7 @@ class Modbus_Ireg : public Modbus_Point<T>{
public: public:
/** /**
* @brief Constructor for the Modbus_Ireg class. * @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 address The Modbus address of the input register.
* @param value The initial value of the input register. * @param value The initial value of the input register.
* @param description A description of the input register. * @param description A description of the input register.
@@ -48,7 +48,13 @@ public:
*/ */
int getValue() const override; 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<typename T> template<typename T>
Modbus_Ireg<T>::Modbus_Ireg(T* server, int address, int value, const char* description) Modbus_Ireg<T>::Modbus_Ireg(T* server, int address, int value, const char* description)
: Modbus_Point<T>(server, address, value, description){} : Modbus_Point<T>(server, address, value, description){}

10
lib/Core/ModbusPoints/Modbus_Ists.h
View File

@@ -25,7 +25,7 @@ class Modbus_Ists : public Modbus_Point<T>{
public: public:
/** /**
* @brief Constructor for the Modbus_Ists class. * @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 address The Modbus address of the discrete input.
* @param value The initial value of the discrete input. * @param value The initial value of the discrete input.
* @param description A description of the discrete input. * @param description A description of the discrete input.
@@ -49,7 +49,13 @@ public:
int getValue() const override; 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<typename T> template<typename T>
Modbus_Ists<T>::Modbus_Ists(T* server, int address, int value, const char* description) Modbus_Ists<T>::Modbus_Ists(T* server, int address, int value, const char* description)
: Modbus_Point<T>(server, address, value, description) {} : Modbus_Point<T>(server, address, value, description) {}

19
platformio.ini
View File

@@ -9,10 +9,10 @@
; https://docs.platformio.org/page/projectconf.html ; https://docs.platformio.org/page/projectconf.html
[platformio] [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] [env]
upload_port = COM15 upload_port = COM100
[common_env_options] [common_env_options]
framework = arduino framework = arduino
@@ -20,10 +20,25 @@ monitor_speed = 115200
lib_ldf_mode = chain+ lib_ldf_mode = chain+
lib_compat_mode = soft 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 = -<*> +<Folder/path/to/equipment> ;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 = -<*> +<Folder/path/to/equipment> ;Add the specific folder path here
[env:CH_Daikin_AWV026B_RTU] [env:CH_Daikin_AWV026B_RTU]
platform = espressif32 platform = espressif32
board = dfrobot_firebeetle2_esp32e board = dfrobot_firebeetle2_esp32e
extends = common_env_options extends = common_env_options
upload_port = COM100
build_src_filter = -<*> +<BMS/CHILLER/CH_Daikin_AWV026B_RTU> build_src_filter = -<*> +<BMS/CHILLER/CH_Daikin_AWV026B_RTU>
[env:CRAH_PAHHC_600_C6_TCP] [env:CRAH_PAHHC_600_C6_TCP]

65
src/BMS/CHILLER/CH_Daikin_AWV026B_RTU/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **AWV026B**: 09-15-25
* **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 ## 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. 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. * **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus. * **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
## 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 ## 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

59
src/BMS/CRAH/CRAH_LIEBERT_80_125_SLAB_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/BMS/CRAH/CRAH_PETRA_PAHHC_600_C6_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

57
src/BMS/VFD/VFD_ABB_ACH580_RTU/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. 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. * **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus. * **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
## 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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

1
src/BMS/VFD/VFD_ABB_ACH580_RTU/config.h
View File

@@ -56,6 +56,7 @@ modbusMap mb_map[] =
{ {
{HR, 149, 0, "Speed Cmd"}, {HR, 149, 0, "Speed Cmd"},
{HR, 151, 0, "Start/Stop"}, {HR, 151, 0, "Start/Stop"},
{HR, 152, 0, "HOA Command"},
{HR, 100, 0, "Motor Speed Used"}, {HR, 100, 0, "Motor Speed Used"},
{HR, 101, 0, "Motor Speed estimated"}, {HR, 101, 0, "Motor Speed estimated"},
{HR_10x, 105, 0, "Output Frequency"}, {HR_10x, 105, 0, "Output Frequency"},

57
src/Base_RTU/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. 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. * **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **RS485 Transceiver**: A module like the MAX485 to interface with the Modbus RTU bus. * **RS485 Transceiver**: [RS485 Shield for Arduino.](https://www.dfrobot.com/product-1024.html)
## 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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/Base_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/ATS/ATS_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/Breaker/BKR_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/GEN/GEN_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/MVG/MVG_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/PDU/PDU_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/PQM/PQM_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/SCP/SCP_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/STS/STS_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/UPS/UPS_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

59
src/EPMS/XFMR/XFMR_Manufacturer_Model_TCP/README.md
View File

@@ -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: ## List of Equipmentt
* **Standby**: The chiller is idle but ready. This cofiguration has been used for these models:
* **Running**: The chiller is active and operational. * **Model**: 09-15-22
* **Fail**: The chiller has encountered a fault condition. * **Model**: 09-15-23
* **Model**: 09-15-25
## 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 ## 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. The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
* **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 ## 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. ### Fail State
* **Commong Alarm**: set to 1
#### Modbus RTU Settings * **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
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

22
src/README.md Normal file
View File

@@ -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