MVG template added
This commit is contained in:
Emmanuel HC
33
src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
Normal file
33
src/EPMS/MVG/MVG_SC_EC_M505_TCP/README.md
Normal file
@@ -0,0 +1,33 @@
|
||||
# EQUIPMENT_TYPE MANUFACTURER MODEL TCP
|
||||
|
||||
## Brief Introduction
|
||||
Equipment specifc details that make it different from other devices
|
||||
|
||||
## List of Equipmentt
|
||||
This cofiguration has been used for these models:
|
||||
* **Model**: 09-15-22
|
||||
* **Model**: 09-15-23
|
||||
* **Model**: 09-15-25
|
||||
|
||||
## Hardware Prerequisites
|
||||
|
||||
The code is written for an ESP8266/ESP32-style microcontroller with WiFi capabilities.
|
||||
* **Microcontroller**: [Firebeetle 2 ESP32.](https://www.dfrobot.com/product-2231.html)
|
||||
|
||||
---
|
||||
|
||||
## States and Strategies
|
||||
Provide a brief description of what variables and strategies were used in this configuraiton
|
||||
|
||||
### Standby State
|
||||
* **Equipment running**: set to 0
|
||||
* **Common Alarm**: set to 0
|
||||
* **SAT temperature**: set to 85
|
||||
|
||||
### Running State
|
||||
* **Equipment running**: set to 1
|
||||
* **SAT temperature**: **Ramp Strategy** set to 65 deg setpoint
|
||||
|
||||
### Fail State
|
||||
* **Commong Alarm**: set to 1
|
||||
* **SAT temperature**: **Ramp Strategy** set to 105 deg setpointset
|
||||
81
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp
Normal file
81
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Fail.cpp
Normal file
@@ -0,0 +1,81 @@
|
||||
/**
|
||||
* @file State_Fail.cpp
|
||||
* @brief Implementation of the FailState class.
|
||||
* @author Emmanuel Hernandez Cruz
|
||||
* @date 2025-09-05
|
||||
*
|
||||
* This file contains the implementation for the FailState, which defines
|
||||
* the behavior of the equipment when it has entered a fault condition.
|
||||
*/
|
||||
#include "ModbusPoints/Modbus_Point.h"
|
||||
#include "Equipment/Equipment.h"
|
||||
#include "Strategies/Strategy_Ramp.h"
|
||||
#include "Strategies/Strategy_SingleValue.h"
|
||||
#include "Strategies/Strategy_PID.h"
|
||||
#include "States/State_Standby.h"
|
||||
#include "States/State_Running.h"
|
||||
#include "States/State_Fail.h"
|
||||
#if defined(USE_MODBUS_IP)
|
||||
#include <ModbusIP_ESP8266.h>
|
||||
#else
|
||||
#include <ModbusRTU.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Constructs a new FailState object with a list of active alarms.
|
||||
*
|
||||
* This constructor receives a list of alarm descriptions and creates strategies
|
||||
* to set the corresponding Modbus points to a value of 1, indicating an
|
||||
* active alarm. It also initializes a PID strategy for the 'CW Valve Position'
|
||||
* to maintain its state during the fault.
|
||||
* @param activeAlarms A vector of strings, where each string is the
|
||||
* description of a Modbus point to be set as an active alarm.
|
||||
*/
|
||||
template<>
|
||||
FailState<ModbusIP>::FailState(const std::vector<std::string>& activeAlarms) {
|
||||
// Simulate a failure: set common alarm and a specific fan alarm.
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Executes the fail state's logic for one update cycle.
|
||||
*
|
||||
* This method checks the "Alarm Reset" Modbus point for a command to
|
||||
* transition back to Standby, which would typically happen after a fault
|
||||
* is cleared by a user. If no transition is requested, it continues to apply
|
||||
* the failure strategies (e.g., keeping alarm bits active).
|
||||
*
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
* @return A pointer to a new State if a transition should occur, otherwise nullptr.
|
||||
*/
|
||||
template<>
|
||||
State<ModbusIP>* FailState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
|
||||
// STATE control, add conditions if change to a different state is needed
|
||||
Serial.println("Fail update function");
|
||||
|
||||
_applyStrategies(equipment);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when entering the fail state.
|
||||
* Sets the "Alarm Common" point to 1 to indicate a general fault condition.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void FailState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
|
||||
// Logic to run when the equipment enters this state
|
||||
Serial.println("Enter Fail State...");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when exiting the fail state.
|
||||
* Clears the "Alarm Common" point to 0 before transitioning to the next state.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void FailState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
|
||||
// Cleanup logic to run when the equipment leaves this state
|
||||
Serial.println("Exit Fail State...");
|
||||
}
|
||||
272
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
Normal file
272
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Running.cpp
Normal file
@@ -0,0 +1,272 @@
|
||||
/**
|
||||
* @file State_Running.cpp
|
||||
* @brief Implementation of the RunningState class.
|
||||
* @author Emmanuel Hernandez Cruz
|
||||
* @date 2025-09-05
|
||||
*
|
||||
* This file contains the implementation for the RunningState, which defines
|
||||
* the behavior of the equipment when it is actively running.
|
||||
*/
|
||||
#include "ModbusPoints/Modbus_Point.h"
|
||||
#include "ModbusPoints/Modbus_FloatDecorator.h"
|
||||
#include "Equipment/Equipment.h"
|
||||
#include "Strategies/Strategy_Ramp.h"
|
||||
#include "Strategies/Strategy_Random.h"
|
||||
#include "Strategies/Strategy_Saw.h"
|
||||
#include "Strategies/Strategy_SingleValue.h"
|
||||
#include "Strategies/Strategy_Square.h"
|
||||
#include "Strategies/Strategy_PID.h"
|
||||
#include "Strategies/Strategy_Totalizer.h"
|
||||
#include "States/State_Standby.h"
|
||||
#include "States/State_Running.h"
|
||||
#include "States/State_Fail.h"
|
||||
#include "States/State.h"
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#if defined(USE_MODBUS_IP)
|
||||
#include <ModbusIP_ESP8266.h>
|
||||
#else
|
||||
#include <ModbusRTU.h>
|
||||
#endif
|
||||
|
||||
/**
|
||||
* @brief Constructs a new RunningState object.
|
||||
*
|
||||
* This constructor initializes behavior strategies active during the running
|
||||
* state, such as a PID controller for the 'CW Valve Position' and totalizers
|
||||
* for the run-hours of each EC fan.
|
||||
*/
|
||||
template<>
|
||||
RunningState<ModbusIP>::RunningState() {
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Executes the running state's logic for one update cycle.
|
||||
*
|
||||
* This method first checks for state transition commands:
|
||||
* 1. It reads the "ON/OFF Command By BMS" point. If it's 0, it transitions to StandbyState.
|
||||
* 2. It reads the "Fault Code" point. If it's non-zero, it transitions to FailState,
|
||||
* passing the corresponding alarm description.
|
||||
*
|
||||
* If no transition occurs, it applies the strategies defined for the running state.
|
||||
*
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
* @return A pointer to a new State if a transition should occur, otherwise nullptr.
|
||||
*/
|
||||
template<>
|
||||
State<ModbusIP>* RunningState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
|
||||
// STATE control, add conditions if change to a different state is needed
|
||||
Serial.println("Running update function");
|
||||
float StateCtrl = getPointValue(equipment, "Px_Mode");
|
||||
if (StateCtrl == 1.0f) {
|
||||
return new RunningState<ModbusIP>();
|
||||
}
|
||||
|
||||
float W1 = getPointValue(equipment, "Px_W1");
|
||||
float W2 = getPointValue(equipment, "Px_W2");
|
||||
float W3 = getPointValue(equipment, "Px_W3");
|
||||
float W4 = getPointValue(equipment, "Px_W4");
|
||||
float W5 = getPointValue(equipment, "Px_W5");
|
||||
float W6 = getPointValue(equipment, "Px_W6");
|
||||
|
||||
switch (static_cast<int>(W1)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_01", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 2, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_01", 0, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 2, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_01", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 1, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 2, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_01", 0, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 2, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_01", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 2, false);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (static_cast<int>(W2)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_01", 3, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 5, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_01", 3, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 5, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_01", 3, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 4, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 5, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_01", 3, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 5, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_01", 3, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 5, false);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (static_cast<int>(W3)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_01", 6, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 0, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_01", 6, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 0, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_01", 6, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 7, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 0, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_01", 6, true);
|
||||
setBitValue(equipment, "MVG_STS_01", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 0, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_01", 6, false);
|
||||
setBitValue(equipment, "MVG_STS_01", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 0, false);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (static_cast<int>(W4)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_02", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 2, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 3, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_02", 1, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 2, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 3, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_02", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 2, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 3, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_02", 1, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 2, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 3, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_02", 1, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 2, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 3, false);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (static_cast<int>(W5)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_02", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 5, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 6, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_02", 4, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 5, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 6, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_02", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 5, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 6, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_02", 4, true);
|
||||
setBitValue(equipment, "MVG_STS_02", 5, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 6, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_02", 4, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 5, false);
|
||||
setBitValue(equipment, "MVG_STS_02", 6, false);
|
||||
break;
|
||||
}
|
||||
|
||||
switch (static_cast<int>(W6)){
|
||||
case 0:
|
||||
setBitValue(equipment, "MVG_STS_02", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 1, false);
|
||||
break;
|
||||
case 1:
|
||||
setBitValue(equipment, "MVG_STS_02", 7, true);
|
||||
setBitValue(equipment, "MVG_STS_03", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 1, false);
|
||||
break;
|
||||
case 2:
|
||||
setBitValue(equipment, "MVG_STS_02", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 0, true);
|
||||
setBitValue(equipment, "MVG_STS_03", 1, false);
|
||||
break;
|
||||
case 3:
|
||||
setBitValue(equipment, "MVG_STS_02", 7, true);
|
||||
setBitValue(equipment, "MVG_STS_03", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 1, true);
|
||||
break;
|
||||
default:
|
||||
setBitValue(equipment, "MVG_STS_02", 7, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 0, false);
|
||||
setBitValue(equipment, "MVG_STS_03", 1, false);
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
|
||||
// Apply any strategies defined for the standby state
|
||||
_applyStrategies(equipment);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when entering the running state.
|
||||
* Sets the "Run Status" for all EC fans to 1 to indicate they are active.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void RunningState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
|
||||
// Logic to run when the equipment enters this state
|
||||
Serial.println("Enter Running State...");
|
||||
// You could also update a Modbus register to show the "standby" state
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when exiting the running state.
|
||||
* Sets the "Run Status" for all EC fans to 0 before transitioning to the next state.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void RunningState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
|
||||
// Cleanup logic to run when the equipment leaves this state
|
||||
Serial.println("Exit Running State...");
|
||||
setPointValue(equipment, "MVG_STS_01", 0);
|
||||
setPointValue(equipment, "MVG_STS_02", 0);
|
||||
setPointValue(equipment, "MVG_STS_03", 0);
|
||||
}
|
||||
90
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
Normal file
90
src/EPMS/MVG/MVG_SC_EC_M505_TCP/State_Standby.cpp
Normal file
@@ -0,0 +1,90 @@
|
||||
/**
|
||||
* @file State_Standby.cpp
|
||||
* @brief Implementation of the StandbyState class.
|
||||
* @author Emmanuel Hernandez Cruz
|
||||
* @date 2025-09-05
|
||||
*
|
||||
* This file contains the implementation for the StandbyState, which defines
|
||||
* the behavior of the equipment when it is in an idle or standby mode.
|
||||
*/
|
||||
#include "ModbusPoints/Modbus_Point.h"
|
||||
#include "ModbusPoints/Modbus_FloatDecorator.h"
|
||||
#include "Equipment/Equipment.h"
|
||||
#include "Strategies/Strategy_Ramp.h"
|
||||
#include "Strategies/Strategy_Random.h"
|
||||
#include "Strategies/Strategy_Saw.h"
|
||||
#include "Strategies/Strategy_SingleValue.h"
|
||||
#include "Strategies/Strategy_Square.h"
|
||||
#include "Strategies/Strategy_PID.h"
|
||||
#include "States/State_Standby.h"
|
||||
#include "States/State_Running.h"
|
||||
#include "States/State_Fail.h"
|
||||
#include "States/State.h"
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#if defined(USE_MODBUS_IP)
|
||||
#include <ModbusIP_ESP8266.h>
|
||||
#else
|
||||
#include <ModbusRTU.h>
|
||||
#endif
|
||||
/**
|
||||
* @brief Constructs a new StandbyState object.
|
||||
*
|
||||
* In this state, the equipment is idle. This constructor initializes strategies
|
||||
* to bring the system to a safe, idle condition. It sets a stable value for
|
||||
* the SAT reading and creates ramp strategies to bring the CW valve and all
|
||||
* EC fan speeds down to zero.
|
||||
*/
|
||||
template<>
|
||||
StandbyState<ModbusIP>::StandbyState() {
|
||||
// You can add initialization code here if needed
|
||||
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Executes the standby state's logic for one update cycle.
|
||||
*
|
||||
* This method applies the strategies defined for the standby state (e.g.,
|
||||
* ramping values to zero).
|
||||
*
|
||||
* @warning This method currently does not check for a command to transition to the
|
||||
* Running state. This logic needs to be added to allow the unit to start.
|
||||
* @return A pointer to a new State if a transition should occur, otherwise nullptr.
|
||||
*/
|
||||
template<>
|
||||
State<ModbusIP>* StandbyState<ModbusIP>::update(Equipment<ModbusIP>* equipment) {
|
||||
// STATE control, add conditions if change to a different state is needed
|
||||
Serial.println("Standby update function");
|
||||
float StateCtrl = getPointValue(equipment, "Px_Mode");
|
||||
if (StateCtrl == 2.0f) {
|
||||
return new RunningState<ModbusIP>();
|
||||
}
|
||||
|
||||
|
||||
// Apply any strategies defined for the standby state
|
||||
_applyStrategies(equipment);
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when entering the standby state.
|
||||
* This method performs cleanup by setting all alarm points and all EC fan
|
||||
* run status points to 0.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void StandbyState<ModbusIP>::enterState(Equipment<ModbusIP>* equipment) {
|
||||
// Logic to run when the equipment enters this state
|
||||
Serial.println("Enter Standby State...");
|
||||
}
|
||||
|
||||
/**
|
||||
* @brief Logic to execute once when exiting the standby state.
|
||||
* @param equipment Pointer to the Equipment instance.
|
||||
*/
|
||||
template<>
|
||||
void StandbyState<ModbusIP>::exitState(Equipment<ModbusIP>* equipment) {
|
||||
// Cleanup logic to run when the equipment leaves this state
|
||||
Serial.println("Exit Standby State...");
|
||||
}
|
||||
86
src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
Normal file
86
src/EPMS/MVG/MVG_SC_EC_M505_TCP/config.h
Normal file
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* @file config.h
|
||||
* @brief Main configuration file for the CRAH Unit (TCP) emulator.
|
||||
* @author Emmanuel Hernandez Cruz
|
||||
* @date 2025-09-02
|
||||
*
|
||||
* This file contains two important configurations: WiFi network parameters
|
||||
* and the Modbus register map for the device.
|
||||
*/
|
||||
|
||||
#ifndef CONFIG_H
|
||||
#define CONFIG_H
|
||||
|
||||
#include "core.h"
|
||||
#include "Equipment/Equipment.h"
|
||||
|
||||
#if defined(USE_MODBUS_IP)
|
||||
/**
|
||||
* @defgroup ModbusTCPConfig Modbus IP Configuration
|
||||
* @brief Parameters for Modbus TCP communication.
|
||||
* @{
|
||||
*/
|
||||
#include <ModbusIP_ESP8266.h>
|
||||
const char *ssid = "wifi_name"; /**< @brief The SSID of the WiFi network. */
|
||||
const char *password = "wifi_password"; /**< @brief The password for the WiFi network. */
|
||||
IPAddress local_IP(192, 168, 1, 234); /**< @brief The static IP address for the device. */
|
||||
IPAddress gateway(192, 168, 1, 1); /**< @brief The gateway IP address. */
|
||||
IPAddress subnet(255, 255, 255, 0); /**< @brief The subnet mask. */
|
||||
|
||||
ModbusIP mb;
|
||||
#else
|
||||
/**
|
||||
* @defgroup ModbusRTUConfig Modbus RTU Configuration
|
||||
* @brief Parameters for serial Modbus RTU communication.
|
||||
* @{
|
||||
*/
|
||||
#include <ModbusRTU.h>
|
||||
const int BAUDRATE = 19200; /**< @brief The serial communication speed in bits per second. */
|
||||
const int RX_PIN = 17; /**< @brief The GPIO pin used for receiving data (RX). */
|
||||
const int TX_PIN = 16; /**< @brief The GPIO pin used for transmitting data (TX). */
|
||||
const int RST_PIN = 4; /**< @brief The GPIO pin connected to the RS485 driver's DE/RE pins for direction control. */
|
||||
const int MODBUS_ID = 1; /**< @brief The unique slave ID for this device on the Modbus bus. */
|
||||
/** @} */
|
||||
|
||||
/** @brief Global instance of the Modbus RTU server. */
|
||||
ModbusRTU mb;
|
||||
#endif
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* @defgroup ModbusMapConfig Modbus Map Configuration
|
||||
* @brief Defines the Modbus register map and related parameters for the emulator.
|
||||
* @{
|
||||
*/
|
||||
/**
|
||||
* @brief The Modbus map for the Equipment device.
|
||||
* This array defines all the Modbus points available on the emulated device.
|
||||
* The `description` field is crucial as it's used to look up points within the application logic.
|
||||
*/
|
||||
modbusMap mb_map[] =
|
||||
{
|
||||
{HR, 9, 0, "Px_Mode"},
|
||||
{HR, 10, 0, "Px_W1"},
|
||||
{HR, 11, 0, "Px_W2"},
|
||||
{HR, 12, 0, "Px_W3"},
|
||||
{HR, 13, 0, "Px_W4"},
|
||||
{HR, 14, 0, "Px_W5"},
|
||||
{HR, 15, 0, "Px_W6"},
|
||||
{HR, 1049, 0, "MVG_STS_01"},
|
||||
{HR, 1050, 0, "MVG_STS_02"},
|
||||
{HR, 1051, 0, "MVG_STS_03"},
|
||||
};
|
||||
//Size of modbus map used in FOR cycles, automatically calculated.
|
||||
|
||||
/**
|
||||
* @brief The total number of entries in the `mb_map` array.
|
||||
* This is calculated at compile time and used for iterating over the map.
|
||||
*/
|
||||
const int map_size = sizeof(mb_map) / sizeof(mb_map[0]);
|
||||
|
||||
/** @brief The main loop update interval in milliseconds. */
|
||||
int interval = 250;
|
||||
/** @} */ // End of ModbusMapConfig group
|
||||
|
||||
#endif // CONFIG_H
|
||||
86
src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp
Normal file
86
src/EPMS/MVG/MVG_SC_EC_M505_TCP/main.cpp
Normal file
@@ -0,0 +1,86 @@
|
||||
/**
|
||||
* @file main.cpp
|
||||
* @brief Main execution program for the CRAH Unit (TCP) Emulator.
|
||||
* @author Emmanuel Hernandez Cruz
|
||||
* @date 2025-09-02
|
||||
*
|
||||
* @details This file contains the main execution program for an Arduino-based emulator of a CRAH unit.
|
||||
* The program uses a Wi-Fi connection to communicate via the Modbus IP protocol.
|
||||
*
|
||||
* The setup() function initializes the following:
|
||||
* - Serial communication for debugging.
|
||||
* - Wi-Fi connection using credentials from config.h.
|
||||
* - A Modbus TCP server.
|
||||
* - Modbus points (Coils, Holding Registers, etc.) based on a predefined map in config.h.
|
||||
*
|
||||
* The loop() function continuously:
|
||||
* - Services the Modbus TCP server to handle incoming requests.
|
||||
* - Periodically calls the main update loop for the emulated equipment, which
|
||||
* manages state transitions and behavior strategies.
|
||||
*
|
||||
* @see config.h for Wi-Fi and Modbus configuration.
|
||||
* @see Equipment.h for the main equipment logic.
|
||||
* @see State.h for different equipment states.
|
||||
* @see Strategies/Strategy_Behavior.h for value generation strategies.
|
||||
* @see Modbus_Point.h for the base class for all Modbus points.
|
||||
*/
|
||||
//=================================================================================================================================
|
||||
//Libraries and declaration of variables.
|
||||
#include <WiFi.h>
|
||||
#include "config.h"
|
||||
#include "ModbusPoints/Modbus_PointFactory.h"
|
||||
#if defined(USE_MODBUS_IP)
|
||||
#include <ModbusIP_ESP8266.h>
|
||||
#else
|
||||
#include <ModbusRTU.h>
|
||||
#endif
|
||||
//=================================================================================================================================
|
||||
/**
|
||||
* @brief Initializes the application.
|
||||
* @details This function runs once at startup. It configures the serial communication,
|
||||
* Wi-Fi, and the Modbus server. It also creates and initializes all the Modbus points
|
||||
* based on the `mb_map` array in `config.h`.
|
||||
*/
|
||||
void setup() {
|
||||
Serial.begin(115200); //Serial comm start
|
||||
WiFi.config(local_IP, gateway, subnet); // Wifi service start
|
||||
WiFi.begin(ssid, password);
|
||||
while (WiFi.status() != WL_CONNECTED) {
|
||||
delay(1000);
|
||||
Serial.print(".");
|
||||
}
|
||||
Serial.println("Connected!!");
|
||||
mb.server(); //Modbus server start
|
||||
Serial.println("Server Created");
|
||||
Serial.println(map_size);
|
||||
for(int i = 0; i < map_size; i++){
|
||||
Modbus_Point<ModbusIP>* point = createModbus_Point(&mb, mb_map[i].category, mb_map[i].address, mb_map[i].value, mb_map[i].description);
|
||||
if (point) {
|
||||
point->addToModbusServer();
|
||||
EquipmentInstance.addModbus_Point(mb_map[i].description, point);
|
||||
}
|
||||
}
|
||||
Serial.println("All modbus Points created");
|
||||
Serial.println("Setup function ended");
|
||||
}
|
||||
//=================================================================================================================================
|
||||
/**
|
||||
* @brief The main application loop.
|
||||
* @details This function runs repeatedly after setup() has completed. It performs two main actions:
|
||||
* 1. It continuously services the Modbus server by calling `mb.task()` to handle
|
||||
* incoming requests from a Modbus master.
|
||||
* 2. At a fixed interval (defined in `config.h`), it calls `EquipmentInstance.update()`
|
||||
* to run the emulator's internal state machine and behavior logic.
|
||||
*/
|
||||
void loop() {
|
||||
mb.task();
|
||||
unsigned long currentMillis = millis();
|
||||
if (currentMillis - previousMillis >= interval) {
|
||||
previousMillis = currentMillis;
|
||||
unsigned long startTime = millis();
|
||||
EquipmentInstance.update();
|
||||
unsigned long endTime = millis();
|
||||
unsigned long elapsedTime = endTime - startTime;
|
||||
Serial.printf("Control Execution time: %d ms\n", elapsedTime);
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user