dali/dali_cpp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Refactor DALI component: remove Modbus bridge support, update documentation, and enhance bridge model handling

Browse Source
This commit is contained in:
Tony
2026-05-04 01:19:24 +08:00
parent 307c480aa0
commit 402d6a451b
11 changed files with 76 additions and 388 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/bridge_model.cpp
+12
View File
@@ -245,16 +245,24 @@ const char* bridgeObjectTypeToString(BridgeObjectType type) {
return "coil";
case BridgeObjectType::discreteInput:
return "discrete_input";
case BridgeObjectType::analogInput:
return "analog_input";
case BridgeObjectType::analogValue:
return "analog_value";
case BridgeObjectType::analogOutput:
return "analog_output";
case BridgeObjectType::binaryInput:
return "binary_input";
case BridgeObjectType::binaryValue:
return "binary_value";
case BridgeObjectType::binaryOutput:
return "binary_output";
case BridgeObjectType::multiStateInput:
return "multi_state_input";
case BridgeObjectType::multiStateValue:
return "multi_state_value";
case BridgeObjectType::multiStateOutput:
return "multi_state_output";
case BridgeObjectType::unknown:
default:
return "unknown";
@@ -267,11 +275,15 @@ BridgeObjectType bridgeObjectTypeFromString(const std::string& value) {
if (normalized == "input_register") return BridgeObjectType::inputRegister;
if (normalized == "coil") return BridgeObjectType::coil;
if (normalized == "discrete_input") return BridgeObjectType::discreteInput;
if (normalized == "analog_input") return BridgeObjectType::analogInput;
if (normalized == "analog_value") return BridgeObjectType::analogValue;
if (normalized == "analog_output") return BridgeObjectType::analogOutput;
if (normalized == "binary_input") return BridgeObjectType::binaryInput;
if (normalized == "binary_value") return BridgeObjectType::binaryValue;
if (normalized == "binary_output") return BridgeObjectType::binaryOutput;
if (normalized == "multi_state_input") return BridgeObjectType::multiStateInput;
if (normalized == "multi_state_value") return BridgeObjectType::multiStateValue;
if (normalized == "multi_state_output") return BridgeObjectType::multiStateOutput;
return BridgeObjectType::unknown;
}
src/bridge_provisioning.cpp
-24
View File
@@ -101,28 +101,6 @@ esp_err_t readString(nvs_handle_t handle, const char* key, std::string* value) {
return ESP_OK;
}
std::optional<ModbusBridgeConfig> modbusFromJson(const DaliValue* value) {
if (value == nullptr || value->asObject() == nullptr) {
return std::nullopt;
}
const auto& json = *value->asObject();
ModbusBridgeConfig config;
config.transport = getObjectString(json, "transport").value_or("tcp");
config.host = getObjectString(json, "host").value_or("");
config.port = static_cast<uint16_t>(getObjectInt(json, "port").value_or(502));
config.unitID = static_cast<uint8_t>(getObjectInt(json, "unitID").value_or(1));
return config;
}
DaliValue modbusToJson(const ModbusBridgeConfig& config) {
DaliValue::Object out;
out["transport"] = config.transport;
out["host"] = config.host;
out["port"] = static_cast<int>(config.port);
out["unitID"] = static_cast<int>(config.unitID);
return DaliValue(std::move(out));
}
std::optional<BacnetBridgeConfig> bacnetFromJson(const DaliValue* value) {
if (value == nullptr || value->asObject() == nullptr) {
return std::nullopt;
@@ -249,7 +227,6 @@ BridgeRuntimeConfig BridgeRuntimeConfig::fromJson(const DaliValue::Object& json)
}
}
}
config.modbus = modbusFromJson(getObjectValue(json, "modbus"));
config.bacnet = bacnetFromJson(getObjectValue(json, "bacnet"));
if (const auto* metadata = getObjectValue(json, "meta")) {
if (const auto* object = metadata->asObject()) {
@@ -267,7 +244,6 @@ DaliValue::Object BridgeRuntimeConfig::toJson() const {
modelsValue.emplace_back(model.toJson());
}
out["models"] = std::move(modelsValue);
if (modbus.has_value()) out["modbus"] = modbusToJson(modbus.value());
if (bacnet.has_value()) out["bacnet"] = bacnetToJson(bacnet.value());
if (!metadata.empty()) out["meta"] = metadata;
return out;
src/modbus_bridge.cpp
-55
View File
@@ -1,55 +0,0 @@
#include "modbus_bridge.hpp"
#include <utility>
DaliModbusBridge::DaliModbusBridge(DaliBridgeEngine& engine) : engine_(engine) {}
void DaliModbusBridge::setConfig(const ModbusBridgeConfig& config) { config_ = config; }
const ModbusBridgeConfig& DaliModbusBridge::config() const { return config_; }
DaliBridgeResult DaliModbusBridge::handleHoldingRegisterWrite(int registerAddress, int value) const {
const auto binding = findHoldingRegister(registerAddress);
DaliBridgeRequest request;
request.sequence = "modbus-" + std::to_string(registerAddress);
request.value = value;
if (!binding.has_value()) {
DaliBridgeResult result;
result.sequence = request.sequence;
result.error = "unmapped holding register";
return result;
}
request.modelID = binding->modelID;
return engine_.execute(request);
}
std::optional<ModbusRegisterBinding> DaliModbusBridge::findHoldingRegister(int registerAddress) const {
for (const auto& model : engine_.listModels()) {
if (model.protocol != BridgeProtocolKind::modbus) {
continue;
}
if (model.external.objectType != BridgeObjectType::holdingRegister) {
continue;
}
if (model.external.registerAddress.value_or(-1) != registerAddress) {
continue;
}
return ModbusRegisterBinding{model.id, registerAddress};
}
return std::nullopt;
}
std::vector<ModbusRegisterBinding> DaliModbusBridge::describeHoldingRegisters() const {
std::vector<ModbusRegisterBinding> bindings;
for (const auto& model : engine_.listModels()) {
if (model.protocol != BridgeProtocolKind::modbus ||
model.external.objectType != BridgeObjectType::holdingRegister ||
!model.external.registerAddress.has_value()) {
continue;
}
bindings.push_back(ModbusRegisterBinding{model.id, model.external.registerAddress.value()});
}
return bindings;
}