Tony
3969 lines
150 KiB
C++
3969 lines
150 KiB
C++
#include "gateway_bridge.hpp"
|
|
|
|
#include "gateway_bacnet_bridge.hpp"
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
#include "gateway_bacnet.hpp"
|
|
#endif
|
|
#include "bridge.hpp"
|
|
#include "bridge_model.hpp"
|
|
#include "bridge_provisioning.hpp"
|
|
#include "dali_comm.hpp"
|
|
#include "dali_define.hpp"
|
|
#include "dali_domain.hpp"
|
|
#include "gateway_cache.hpp"
|
|
#include "gateway_cloud.hpp"
|
|
#include "gateway_knx.hpp"
|
|
#include "gateway_modbus.hpp"
|
|
#include "gateway_provisioning.hpp"
|
|
|
|
#include "cJSON.h"
|
|
#include "driver/uart.h"
|
|
#include "esp_log.h"
|
|
#include "freertos/semphr.h"
|
|
#include "lwip/inet.h"
|
|
#include "lwip/sockets.h"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <atomic>
|
|
#include <cctype>
|
|
#include <cstdint>
|
|
#include <cstdlib>
|
|
#include <cstring>
|
|
#include <map>
|
|
#include <optional>
|
|
#include <set>
|
|
#include <string_view>
|
|
#include <sys/time.h>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
namespace gateway {
|
|
|
|
namespace {
|
|
|
|
constexpr const char* kTag = "gateway_bridge";
|
|
constexpr const char* kBridgeConfigKey = "bridge_cfg";
|
|
constexpr const char* kDiscoveryInventoryKey = "bridge_disc";
|
|
constexpr int kMaxDaliShortAddress = 63;
|
|
constexpr uint16_t kModbusUnknownRegister = 0xFFFF;
|
|
constexpr uint16_t kModbusDiscreteInputBase = 10001;
|
|
constexpr uint32_t kDiagnosticSnapshotCacheTtlMs = 500;
|
|
constexpr uint32_t kBacnetGeneratedBinaryInputBase = 1000000;
|
|
constexpr uint32_t kBacnetGeneratedBinaryInputChannelStride = 32768;
|
|
constexpr uint32_t kBacnetMaxObjectInstance = 4194303;
|
|
constexpr uint32_t kBacnetReliabilityNoFaultDetected = 0;
|
|
constexpr uint32_t kBacnetReliabilityCommunicationFailure = 12;
|
|
constexpr const char* kModbusManagementPrefix = "@DALIGW";
|
|
|
|
struct GatewayBridgeStoredConfig {
|
|
BridgeRuntimeConfig bridge;
|
|
std::optional<GatewayModbusConfig> modbus;
|
|
std::optional<GatewayKnxConfig> knx;
|
|
std::optional<GatewayBacnetBridgeConfig> bacnet_server;
|
|
};
|
|
|
|
struct BridgeDiscoveryEntry {
|
|
int short_address{0};
|
|
bool online{true};
|
|
DaliDomainSnapshot discovery;
|
|
};
|
|
|
|
using BridgeDiscoveryInventory = std::map<int, BridgeDiscoveryEntry>;
|
|
|
|
class LockGuard {
|
|
public:
|
|
explicit LockGuard(SemaphoreHandle_t lock) : lock_(lock) {
|
|
if (lock_ != nullptr) {
|
|
xSemaphoreTakeRecursive(lock_, portMAX_DELAY);
|
|
}
|
|
}
|
|
|
|
~LockGuard() {
|
|
if (lock_ != nullptr) {
|
|
xSemaphoreGiveRecursive(lock_);
|
|
}
|
|
}
|
|
|
|
private:
|
|
SemaphoreHandle_t lock_;
|
|
};
|
|
|
|
std::string PrintJson(cJSON* node) {
|
|
if (node == nullptr) {
|
|
return "{}";
|
|
}
|
|
char* rendered = cJSON_PrintUnformatted(node);
|
|
if (rendered == nullptr) {
|
|
return "{}";
|
|
}
|
|
std::string out(rendered);
|
|
cJSON_free(rendered);
|
|
return out;
|
|
}
|
|
|
|
GatewayBridgeHttpResponse JsonOk(cJSON* node) {
|
|
const std::string body = PrintJson(node);
|
|
cJSON_Delete(node);
|
|
return GatewayBridgeHttpResponse{ESP_OK, body};
|
|
}
|
|
|
|
GatewayBridgeHttpResponse ErrorResponse(esp_err_t err, const char* message) {
|
|
cJSON* root = cJSON_CreateObject();
|
|
if (root != nullptr) {
|
|
cJSON_AddBoolToObject(root, "ok", false);
|
|
cJSON_AddStringToObject(root, "error", message == nullptr ? "error" : message);
|
|
cJSON_AddNumberToObject(root, "espErr", static_cast<double>(err));
|
|
}
|
|
const std::string body = PrintJson(root);
|
|
cJSON_Delete(root);
|
|
return GatewayBridgeHttpResponse{err, body};
|
|
}
|
|
|
|
const char* JsonString(const cJSON* parent, const char* name) {
|
|
const cJSON* item = cJSON_GetObjectItemCaseSensitive(parent, name);
|
|
return cJSON_IsString(item) && item->valuestring != nullptr ? item->valuestring : nullptr;
|
|
}
|
|
|
|
std::optional<int> JsonInt(const cJSON* parent, const char* name) {
|
|
const cJSON* item = cJSON_GetObjectItemCaseSensitive(parent, name);
|
|
if (!cJSON_IsNumber(item)) {
|
|
return std::nullopt;
|
|
}
|
|
return item->valueint;
|
|
}
|
|
|
|
std::optional<uint8_t> JsonGatewayId(const cJSON* root) {
|
|
if (root == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto gateway = JsonInt(root, "gw").value_or(JsonInt(root, "gatewayId").value_or(-1));
|
|
if (gateway < 0 || gateway > 255) {
|
|
return std::nullopt;
|
|
}
|
|
return static_cast<uint8_t>(gateway);
|
|
}
|
|
|
|
std::string QueryValue(std::string_view query, std::string_view key) {
|
|
if (query.empty() || key.empty()) {
|
|
return {};
|
|
}
|
|
size_t start = 0;
|
|
while (start < query.size()) {
|
|
const size_t end = query.find('&', start);
|
|
const size_t segment_end = end == std::string_view::npos ? query.size() : end;
|
|
const std::string_view segment = query.substr(start, segment_end - start);
|
|
const size_t equals = segment.find('=');
|
|
if (equals != std::string_view::npos && segment.substr(0, equals) == key) {
|
|
return std::string(segment.substr(equals + 1));
|
|
}
|
|
if (end == std::string_view::npos) {
|
|
break;
|
|
}
|
|
start = end + 1;
|
|
}
|
|
return {};
|
|
}
|
|
|
|
std::optional<int> ParseInt(std::string_view raw) {
|
|
if (raw.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
std::string text(raw);
|
|
char* end = nullptr;
|
|
const long parsed = std::strtol(text.c_str(), &end, 10);
|
|
if (end == text.c_str() || *end != '\0') {
|
|
return std::nullopt;
|
|
}
|
|
return static_cast<int>(parsed);
|
|
}
|
|
|
|
std::optional<int> QueryInt(std::string_view query, std::string_view primary,
|
|
std::string_view fallback = {}) {
|
|
auto value = ParseInt(QueryValue(query, primary));
|
|
if (value.has_value() || fallback.empty()) {
|
|
return value;
|
|
}
|
|
return ParseInt(QueryValue(query, fallback));
|
|
}
|
|
|
|
std::optional<int> JsonIntAny(const cJSON* parent, const char* primary, const char* fallback) {
|
|
auto value = JsonInt(parent, primary);
|
|
if (value.has_value() || fallback == nullptr) {
|
|
return value;
|
|
}
|
|
return JsonInt(parent, fallback);
|
|
}
|
|
|
|
bool ValidDaliAddress(int address) {
|
|
return address >= 0 && address <= 127;
|
|
}
|
|
|
|
bool ValidShortAddress(int address) {
|
|
return address >= 0 && address <= kMaxDaliShortAddress;
|
|
}
|
|
|
|
uint8_t RawArcAddressFromDec(int dec_address) {
|
|
if (dec_address >= 0 && dec_address < 64) {
|
|
return static_cast<uint8_t>(dec_address * 2);
|
|
}
|
|
if (dec_address >= 64 && dec_address < 80) {
|
|
return static_cast<uint8_t>(0x80 + (dec_address - 64) * 2);
|
|
}
|
|
return 0xfe;
|
|
}
|
|
|
|
uint8_t RawCommandAddressFromDec(int dec_address) {
|
|
if (dec_address >= 0 && dec_address < 64) {
|
|
return static_cast<uint8_t>(dec_address * 2 + 1);
|
|
}
|
|
if (dec_address >= 64 && dec_address < 80) {
|
|
return static_cast<uint8_t>(0x80 + (dec_address - 64) * 2 + 1);
|
|
}
|
|
return 0xff;
|
|
}
|
|
|
|
uint16_t DeviceTypeMask(const DaliDomainSnapshot& snapshot) {
|
|
uint16_t mask = 0;
|
|
const auto types = snapshot.int_arrays.find("types");
|
|
if (types != snapshot.int_arrays.end()) {
|
|
for (const int type : types->second) {
|
|
if (type >= 0 && type < 16) {
|
|
mask |= static_cast<uint16_t>(1U << type);
|
|
}
|
|
}
|
|
}
|
|
return mask;
|
|
}
|
|
|
|
bool IsRawBridgeOperation(BridgeOperation operation) {
|
|
switch (operation) {
|
|
case BridgeOperation::send:
|
|
case BridgeOperation::sendExt:
|
|
case BridgeOperation::query:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool SnapshotHasDeviceType(const DaliDomainSnapshot& snapshot, int device_type) {
|
|
const auto primary = snapshot.ints.find("primaryType");
|
|
if (primary != snapshot.ints.end() && primary->second == device_type) {
|
|
return true;
|
|
}
|
|
const auto types = snapshot.int_arrays.find("types");
|
|
return types != snapshot.int_arrays.end() &&
|
|
std::find(types->second.begin(), types->second.end(), device_type) !=
|
|
types->second.end();
|
|
}
|
|
|
|
std::optional<bool> SnapshotBoolValue(const DaliDomainSnapshot& snapshot,
|
|
std::string_view key) {
|
|
for (const auto& entry : snapshot.bools) {
|
|
if (std::string_view(entry.first) == key) {
|
|
return entry.second;
|
|
}
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
std::optional<int> SnapshotIntValue(const DaliDomainSnapshot& snapshot,
|
|
const std::string& key) {
|
|
const auto found = snapshot.ints.find(key);
|
|
return found == snapshot.ints.end() ? std::nullopt : std::optional<int>(found->second);
|
|
}
|
|
|
|
bool OperationRequiresDt1(BridgeOperation operation) {
|
|
switch (operation) {
|
|
case BridgeOperation::getEmergencyLevel:
|
|
case BridgeOperation::getEmergencyStatus:
|
|
case BridgeOperation::getEmergencyFailureStatus:
|
|
case BridgeOperation::startEmergencyFunctionTest:
|
|
case BridgeOperation::stopEmergencyTest:
|
|
case BridgeOperation::startEmergencyDurationTest:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool OperationRequiresDt8(BridgeOperation operation) {
|
|
switch (operation) {
|
|
case BridgeOperation::setColorTemperature:
|
|
case BridgeOperation::getColorTemperature:
|
|
case BridgeOperation::getColorStatus:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool BridgeOperationReadable(BridgeOperation operation) {
|
|
switch (operation) {
|
|
case BridgeOperation::query:
|
|
case BridgeOperation::getBrightness:
|
|
case BridgeOperation::getStatus:
|
|
case BridgeOperation::getColorTemperature:
|
|
case BridgeOperation::getColorStatus:
|
|
case BridgeOperation::getEmergencyLevel:
|
|
case BridgeOperation::getEmergencyStatus:
|
|
case BridgeOperation::getEmergencyFailureStatus:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::optional<int> BridgeTargetValue(const BridgeDaliTarget& target) {
|
|
switch (target.kind) {
|
|
case BridgeDaliTargetKind::shortAddress:
|
|
return target.shortAddress;
|
|
case BridgeDaliTargetKind::group:
|
|
return target.groupAddress;
|
|
case BridgeDaliTargetKind::broadcast:
|
|
return std::nullopt;
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
cJSON* IntArrayToCjson(const std::vector<int>& values) {
|
|
cJSON* array = cJSON_CreateArray();
|
|
if (array == nullptr) {
|
|
return nullptr;
|
|
}
|
|
for (const int value : values) {
|
|
cJSON_AddItemToArray(array, cJSON_CreateNumber(value));
|
|
}
|
|
return array;
|
|
}
|
|
|
|
cJSON* NumberArrayToCjson(const std::vector<double>& values) {
|
|
cJSON* array = cJSON_CreateArray();
|
|
if (array == nullptr) {
|
|
return nullptr;
|
|
}
|
|
for (const double value : values) {
|
|
cJSON_AddItemToArray(array, cJSON_CreateNumber(value));
|
|
}
|
|
return array;
|
|
}
|
|
|
|
cJSON* SnapshotToCjson(const DaliDomainSnapshot& snapshot) {
|
|
cJSON* root = cJSON_CreateObject();
|
|
if (root == nullptr) {
|
|
return nullptr;
|
|
}
|
|
cJSON_AddNumberToObject(root, "gatewayId", snapshot.gateway_id);
|
|
cJSON_AddNumberToObject(root, "address", snapshot.address);
|
|
cJSON_AddStringToObject(root, "kind", snapshot.kind.c_str());
|
|
for (const auto& entry : snapshot.bools) {
|
|
cJSON_AddBoolToObject(root, entry.first.c_str(), entry.second);
|
|
}
|
|
for (const auto& entry : snapshot.ints) {
|
|
cJSON_AddNumberToObject(root, entry.first.c_str(), entry.second);
|
|
}
|
|
for (const auto& entry : snapshot.numbers) {
|
|
cJSON_AddNumberToObject(root, entry.first.c_str(), entry.second);
|
|
}
|
|
for (const auto& entry : snapshot.int_arrays) {
|
|
cJSON_AddItemToObject(root, entry.first.c_str(), IntArrayToCjson(entry.second));
|
|
}
|
|
for (const auto& entry : snapshot.number_arrays) {
|
|
cJSON_AddItemToObject(root, entry.first.c_str(), NumberArrayToCjson(entry.second));
|
|
}
|
|
return root;
|
|
}
|
|
|
|
DaliValue::Object SnapshotToValue(const DaliDomainSnapshot& snapshot) {
|
|
DaliValue::Object out;
|
|
out["gatewayId"] = snapshot.gateway_id;
|
|
out["address"] = snapshot.address;
|
|
out["kind"] = snapshot.kind;
|
|
|
|
if (!snapshot.bools.empty()) {
|
|
DaliValue::Object bools;
|
|
for (const auto& entry : snapshot.bools) {
|
|
bools[entry.first] = entry.second;
|
|
}
|
|
out["bools"] = std::move(bools);
|
|
}
|
|
if (!snapshot.ints.empty()) {
|
|
DaliValue::Object ints;
|
|
for (const auto& entry : snapshot.ints) {
|
|
ints[entry.first] = entry.second;
|
|
}
|
|
out["ints"] = std::move(ints);
|
|
}
|
|
if (!snapshot.numbers.empty()) {
|
|
DaliValue::Object numbers;
|
|
for (const auto& entry : snapshot.numbers) {
|
|
numbers[entry.first] = entry.second;
|
|
}
|
|
out["numbers"] = std::move(numbers);
|
|
}
|
|
if (!snapshot.int_arrays.empty()) {
|
|
DaliValue::Object arrays;
|
|
for (const auto& entry : snapshot.int_arrays) {
|
|
DaliValue::Array values;
|
|
values.reserve(entry.second.size());
|
|
for (const int value : entry.second) {
|
|
values.emplace_back(value);
|
|
}
|
|
arrays[entry.first] = std::move(values);
|
|
}
|
|
out["intArrays"] = std::move(arrays);
|
|
}
|
|
if (!snapshot.number_arrays.empty()) {
|
|
DaliValue::Object arrays;
|
|
for (const auto& entry : snapshot.number_arrays) {
|
|
DaliValue::Array values;
|
|
values.reserve(entry.second.size());
|
|
for (const double value : entry.second) {
|
|
values.emplace_back(value);
|
|
}
|
|
arrays[entry.first] = std::move(values);
|
|
}
|
|
out["numberArrays"] = std::move(arrays);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::optional<DaliDomainSnapshot> SnapshotFromValue(const DaliValue* value) {
|
|
if (value == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto* object = value->asObject();
|
|
if (object == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
DaliDomainSnapshot snapshot;
|
|
snapshot.gateway_id = static_cast<uint8_t>(getObjectInt(*object, "gatewayId").value_or(0));
|
|
snapshot.address = getObjectInt(*object, "address").value_or(0);
|
|
snapshot.kind = getObjectString(*object, "kind").value_or("device");
|
|
|
|
if (const auto* bools = getObjectValue(*object, "bools")) {
|
|
if (const auto* bool_object = bools->asObject()) {
|
|
for (const auto& entry : *bool_object) {
|
|
if (const auto parsed = entry.second.asBool()) {
|
|
snapshot.bools[entry.first] = parsed.value();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (const auto* ints = getObjectValue(*object, "ints")) {
|
|
if (const auto* int_object = ints->asObject()) {
|
|
for (const auto& entry : *int_object) {
|
|
if (const auto parsed = entry.second.asInt()) {
|
|
snapshot.ints[entry.first] = parsed.value();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (const auto* numbers = getObjectValue(*object, "numbers")) {
|
|
if (const auto* number_object = numbers->asObject()) {
|
|
for (const auto& entry : *number_object) {
|
|
if (const auto parsed = entry.second.asDouble()) {
|
|
snapshot.numbers[entry.first] = parsed.value();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (const auto* int_arrays = getObjectValue(*object, "intArrays")) {
|
|
if (const auto* array_object = int_arrays->asObject()) {
|
|
for (const auto& entry : *array_object) {
|
|
const auto* array = entry.second.asArray();
|
|
if (array == nullptr) {
|
|
continue;
|
|
}
|
|
std::vector<int> values;
|
|
values.reserve(array->size());
|
|
for (const auto& item : *array) {
|
|
values.push_back(item.asInt().value_or(0));
|
|
}
|
|
snapshot.int_arrays[entry.first] = std::move(values);
|
|
}
|
|
}
|
|
}
|
|
if (const auto* number_arrays = getObjectValue(*object, "numberArrays")) {
|
|
if (const auto* array_object = number_arrays->asObject()) {
|
|
for (const auto& entry : *array_object) {
|
|
const auto* array = entry.second.asArray();
|
|
if (array == nullptr) {
|
|
continue;
|
|
}
|
|
std::vector<double> values;
|
|
values.reserve(array->size());
|
|
for (const auto& item : *array) {
|
|
values.push_back(item.asDouble().value_or(0.0));
|
|
}
|
|
snapshot.number_arrays[entry.first] = std::move(values);
|
|
}
|
|
}
|
|
}
|
|
|
|
return snapshot;
|
|
}
|
|
|
|
const char* DiscoveryStateString(bool online) {
|
|
return online ? "online" : "offline";
|
|
}
|
|
|
|
const char* BacnetReliabilityToString(uint32_t reliability) {
|
|
switch (reliability) {
|
|
case kBacnetReliabilityCommunicationFailure:
|
|
return "communication_failure";
|
|
case kBacnetReliabilityNoFaultDetected:
|
|
default:
|
|
return "no_fault_detected";
|
|
}
|
|
}
|
|
|
|
bool SnapshotSupportsDeviceType(const DaliDomainSnapshot& snapshot, int device_type) {
|
|
return SnapshotHasDeviceType(snapshot, device_type);
|
|
}
|
|
|
|
void AddDiscoveryCapabilities(cJSON* root, const DaliDomainSnapshot& snapshot) {
|
|
if (root == nullptr) {
|
|
return;
|
|
}
|
|
cJSON_AddBoolToObject(root, "supportsDt1", SnapshotSupportsDeviceType(snapshot, 1));
|
|
cJSON_AddBoolToObject(root, "supportsDt4", SnapshotSupportsDeviceType(snapshot, 4));
|
|
cJSON_AddBoolToObject(root, "supportsDt5", SnapshotSupportsDeviceType(snapshot, 5));
|
|
cJSON_AddBoolToObject(root, "supportsDt6", SnapshotSupportsDeviceType(snapshot, 6));
|
|
cJSON_AddBoolToObject(root, "supportsDt8", SnapshotSupportsDeviceType(snapshot, 8));
|
|
}
|
|
|
|
cJSON* DiscoveryEntryToCjson(const BridgeDiscoveryEntry& entry) {
|
|
cJSON* root = SnapshotToCjson(entry.discovery);
|
|
if (root == nullptr) {
|
|
return nullptr;
|
|
}
|
|
cJSON_AddBoolToObject(root, "discovered", true);
|
|
cJSON_AddBoolToObject(root, "online", entry.online);
|
|
cJSON_AddStringToObject(root, "inventoryState", DiscoveryStateString(entry.online));
|
|
AddDiscoveryCapabilities(root, entry.discovery);
|
|
return root;
|
|
}
|
|
|
|
cJSON* MissingDiscoveryEntryToCjson(uint8_t gateway_id, int short_address) {
|
|
cJSON* root = cJSON_CreateObject();
|
|
if (root == nullptr) {
|
|
return nullptr;
|
|
}
|
|
cJSON_AddNumberToObject(root, "gatewayId", gateway_id);
|
|
cJSON_AddNumberToObject(root, "address", short_address);
|
|
cJSON_AddStringToObject(root, "kind", "device");
|
|
cJSON_AddBoolToObject(root, "discovered", false);
|
|
cJSON_AddBoolToObject(root, "online", false);
|
|
cJSON_AddStringToObject(root, "inventoryState", "never_seen");
|
|
return root;
|
|
}
|
|
|
|
DaliValue::Object DiscoveryEntryToValue(const BridgeDiscoveryEntry& entry) {
|
|
DaliValue::Object out;
|
|
out["shortAddress"] = entry.short_address;
|
|
out["state"] = DiscoveryStateString(entry.online);
|
|
out["snapshot"] = SnapshotToValue(entry.discovery);
|
|
return out;
|
|
}
|
|
|
|
std::optional<BridgeDiscoveryEntry> DiscoveryEntryFromValue(const DaliValue& value) {
|
|
const auto* object = value.asObject();
|
|
if (object == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto short_address = getObjectInt(*object, "shortAddress");
|
|
const auto snapshot = SnapshotFromValue(getObjectValue(*object, "snapshot"));
|
|
if (!short_address.has_value() || !snapshot.has_value() ||
|
|
!ValidShortAddress(short_address.value())) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
const std::string state = getObjectString(*object, "state").value_or("online");
|
|
BridgeDiscoveryEntry entry;
|
|
entry.short_address = short_address.value();
|
|
entry.online = state != "offline";
|
|
entry.discovery = snapshot.value();
|
|
entry.discovery.address = short_address.value();
|
|
return entry;
|
|
}
|
|
|
|
DaliValue::Object DiscoveryInventoryToValue(const BridgeDiscoveryInventory& inventory) {
|
|
DaliValue::Object out;
|
|
DaliValue::Array entries;
|
|
entries.reserve(inventory.size());
|
|
for (const auto& item : inventory) {
|
|
entries.emplace_back(DiscoveryEntryToValue(item.second));
|
|
}
|
|
out["entries"] = std::move(entries);
|
|
return out;
|
|
}
|
|
|
|
BridgeDiscoveryInventory DiscoveryInventoryFromValue(const DaliValue::Object& object) {
|
|
BridgeDiscoveryInventory inventory;
|
|
const auto* entries = getObjectValue(object, "entries");
|
|
if (entries == nullptr || entries->asArray() == nullptr) {
|
|
return inventory;
|
|
}
|
|
for (const auto& item : *entries->asArray()) {
|
|
const auto entry = DiscoveryEntryFromValue(item);
|
|
if (!entry.has_value()) {
|
|
continue;
|
|
}
|
|
inventory[entry->short_address] = entry.value();
|
|
}
|
|
return inventory;
|
|
}
|
|
|
|
GatewayBridgeHttpResponse SnapshotResponse(const std::optional<DaliDomainSnapshot>& snapshot,
|
|
const char* missing_message) {
|
|
if (!snapshot.has_value()) {
|
|
return ErrorResponse(ESP_ERR_NOT_FOUND, missing_message);
|
|
}
|
|
return JsonOk(SnapshotToCjson(snapshot.value()));
|
|
}
|
|
|
|
GatewayBridgeHttpResponse StoredSnapshotResponse(
|
|
const std::optional<DaliDomainSnapshot>& snapshot, uint8_t gateway_id, int address,
|
|
const char* kind) {
|
|
if (snapshot.has_value()) {
|
|
return JsonOk(SnapshotToCjson(snapshot.value()));
|
|
}
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(root, "ok", true);
|
|
cJSON_AddBoolToObject(root, "stored", true);
|
|
cJSON_AddBoolToObject(root, "reportAvailable", false);
|
|
cJSON_AddNumberToObject(root, "gatewayId", gateway_id);
|
|
cJSON_AddNumberToObject(root, "address", address);
|
|
cJSON_AddStringToObject(root, "kind", kind == nullptr ? "dt8_snapshot" : kind);
|
|
return JsonOk(root);
|
|
}
|
|
|
|
DaliDt8SceneColorMode JsonColorMode(const cJSON* root) {
|
|
const cJSON* item = cJSON_GetObjectItemCaseSensitive(root, "colorMode");
|
|
if (item == nullptr) {
|
|
item = cJSON_GetObjectItemCaseSensitive(root, "color_mode");
|
|
}
|
|
if (cJSON_IsNumber(item)) {
|
|
if (item->valueint == 1) {
|
|
return DaliDt8SceneColorMode::kColorTemperature;
|
|
}
|
|
if (item->valueint == 2) {
|
|
return DaliDt8SceneColorMode::kRgb;
|
|
}
|
|
return DaliDt8SceneColorMode::kDisabled;
|
|
}
|
|
if (!cJSON_IsString(item) || item->valuestring == nullptr) {
|
|
return DaliDt8SceneColorMode::kDisabled;
|
|
}
|
|
const std::string_view mode(item->valuestring);
|
|
if (mode == "colorTemperature" || mode == "color_temperature" || mode == "ct") {
|
|
return DaliDt8SceneColorMode::kColorTemperature;
|
|
}
|
|
if (mode == "rgb") {
|
|
return DaliDt8SceneColorMode::kRgb;
|
|
}
|
|
return DaliDt8SceneColorMode::kDisabled;
|
|
}
|
|
|
|
GatewayBridgeHttpResponse StoreDt8SceneSnapshot(DaliDomainService& domain, uint8_t gateway_id,
|
|
std::string_view body) {
|
|
cJSON* root = cJSON_ParseWithLength(body.data(), body.size());
|
|
if (root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid DT8 scene snapshot JSON");
|
|
}
|
|
const auto address = JsonIntAny(root, "addr", "address");
|
|
const auto scene = JsonInt(root, "scene");
|
|
const auto brightness = JsonInt(root, "brightness");
|
|
const auto color_mode = JsonColorMode(root);
|
|
const int color_temperature = JsonIntAny(root, "colorTemperature", "color_temperature").value_or(0);
|
|
const int red = JsonIntAny(root, "red", "r").value_or(0);
|
|
const int green = JsonIntAny(root, "green", "g").value_or(0);
|
|
const int blue = JsonIntAny(root, "blue", "b").value_or(0);
|
|
cJSON_Delete(root);
|
|
|
|
if (!address.has_value() || !scene.has_value() || !brightness.has_value() ||
|
|
!ValidDaliAddress(address.value()) || scene.value() < 0 || scene.value() > 15) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "addr, scene, and brightness are required");
|
|
}
|
|
if (!domain.storeDt8SceneSnapshot(gateway_id, address.value(), scene.value(),
|
|
brightness.value(), color_mode, color_temperature, red,
|
|
green, blue)) {
|
|
return ErrorResponse(ESP_FAIL, "failed to store DT8 scene snapshot");
|
|
}
|
|
return StoredSnapshotResponse(domain.dt8SceneColorReport(gateway_id, address.value(),
|
|
scene.value()),
|
|
gateway_id, address.value(), "dt8_scene");
|
|
}
|
|
|
|
GatewayBridgeHttpResponse StoreDt8LevelSnapshot(DaliDomainService& domain, uint8_t gateway_id,
|
|
std::string_view body, bool power_on) {
|
|
cJSON* root = cJSON_ParseWithLength(body.data(), body.size());
|
|
if (root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid DT8 level snapshot JSON");
|
|
}
|
|
const auto address = JsonIntAny(root, "addr", "address");
|
|
const auto level = JsonInt(root, "level");
|
|
cJSON_Delete(root);
|
|
|
|
if (!address.has_value() || !level.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "addr and level are required");
|
|
}
|
|
|
|
const bool stored = power_on
|
|
? domain.storeDt8PowerOnLevelSnapshot(gateway_id, address.value(),
|
|
level.value())
|
|
: domain.storeDt8SystemFailureLevelSnapshot(gateway_id, address.value(),
|
|
level.value());
|
|
if (!stored) {
|
|
return ErrorResponse(ESP_FAIL, power_on ? "failed to store DT8 power-on snapshot"
|
|
: "failed to store DT8 system-failure snapshot");
|
|
}
|
|
return StoredSnapshotResponse(power_on ? domain.dt8PowerOnLevelColorReport(gateway_id,
|
|
address.value())
|
|
: domain.dt8SystemFailureLevelColorReport(
|
|
gateway_id, address.value()),
|
|
gateway_id, address.value(),
|
|
power_on ? "dt8_power_on" : "dt8_system_failure");
|
|
}
|
|
|
|
DaliValue FromCjson(const cJSON* item) {
|
|
if (item == nullptr || cJSON_IsNull(item)) {
|
|
return DaliValue();
|
|
}
|
|
if (cJSON_IsBool(item)) {
|
|
return DaliValue(cJSON_IsTrue(item));
|
|
}
|
|
if (cJSON_IsNumber(item)) {
|
|
const double value = item->valuedouble;
|
|
if (value == static_cast<double>(item->valueint)) {
|
|
return DaliValue(item->valueint);
|
|
}
|
|
return DaliValue(value);
|
|
}
|
|
if (cJSON_IsString(item) && item->valuestring != nullptr) {
|
|
return DaliValue(std::string(item->valuestring));
|
|
}
|
|
if (cJSON_IsArray(item)) {
|
|
DaliValue::Array out;
|
|
for (const cJSON* child = item->child; child != nullptr; child = child->next) {
|
|
out.push_back(FromCjson(child));
|
|
}
|
|
return DaliValue(std::move(out));
|
|
}
|
|
if (cJSON_IsObject(item)) {
|
|
DaliValue::Object out;
|
|
for (const cJSON* child = item->child; child != nullptr; child = child->next) {
|
|
if (child->string != nullptr) {
|
|
out[child->string] = FromCjson(child);
|
|
}
|
|
}
|
|
return DaliValue(std::move(out));
|
|
}
|
|
return DaliValue();
|
|
}
|
|
|
|
cJSON* ToCjson(const DaliValue& value) {
|
|
if (value.isNull()) {
|
|
return cJSON_CreateNull();
|
|
}
|
|
if (value.isBool()) {
|
|
return cJSON_CreateBool(value.asBool().value_or(false));
|
|
}
|
|
if (value.isInt()) {
|
|
return cJSON_CreateNumber(value.asInt().value_or(0));
|
|
}
|
|
if (value.isDouble()) {
|
|
return cJSON_CreateNumber(value.asDouble().value_or(0.0));
|
|
}
|
|
if (value.isString()) {
|
|
return cJSON_CreateString(value.asString().value_or("").c_str());
|
|
}
|
|
if (const auto* array = value.asArray()) {
|
|
cJSON* out = cJSON_CreateArray();
|
|
for (const auto& item : *array) {
|
|
cJSON_AddItemToArray(out, ToCjson(item));
|
|
}
|
|
return out;
|
|
}
|
|
if (const auto* object = value.asObject()) {
|
|
cJSON* out = cJSON_CreateObject();
|
|
for (const auto& entry : *object) {
|
|
cJSON_AddItemToObject(out, entry.first.c_str(), ToCjson(entry.second));
|
|
}
|
|
return out;
|
|
}
|
|
return cJSON_CreateNull();
|
|
}
|
|
|
|
DaliValue::Object GatewayBridgeStoredConfigToValue(
|
|
const BridgeRuntimeConfig& bridge_config,
|
|
const std::optional<GatewayModbusConfig>& modbus_config,
|
|
const std::optional<GatewayKnxConfig>& knx_config,
|
|
const std::optional<GatewayBacnetBridgeConfig>& bacnet_server_config) {
|
|
DaliValue::Object out = bridge_config.toJson();
|
|
if (modbus_config.has_value()) {
|
|
out["modbus"] = GatewayModbusConfigToValue(modbus_config.value());
|
|
}
|
|
if (knx_config.has_value()) {
|
|
out["knx"] = GatewayKnxConfigToValue(knx_config.value());
|
|
}
|
|
if (bacnet_server_config.has_value()) {
|
|
DaliValue::Object bacnet;
|
|
bacnet["deviceInstance"] = static_cast<int64_t>(bacnet_server_config->deviceInstance);
|
|
bacnet["localAddress"] = bacnet_server_config->localAddress;
|
|
bacnet["udpPort"] = static_cast<int>(bacnet_server_config->udpPort);
|
|
out["bacnetServer"] = std::move(bacnet);
|
|
}
|
|
return out;
|
|
}
|
|
|
|
std::string GatewayBridgeStoredConfigToJson(
|
|
const BridgeRuntimeConfig& bridge_config,
|
|
const std::optional<GatewayModbusConfig>& modbus_config,
|
|
const std::optional<GatewayKnxConfig>& knx_config,
|
|
const std::optional<GatewayBacnetBridgeConfig>& bacnet_server_config) {
|
|
cJSON* root = ToCjson(DaliValue(GatewayBridgeStoredConfigToValue(
|
|
bridge_config, modbus_config, knx_config, bacnet_server_config)));
|
|
const std::string body = PrintJson(root);
|
|
cJSON_Delete(root);
|
|
return body;
|
|
}
|
|
|
|
std::optional<GatewayBacnetBridgeConfig> GatewayBacnetBridgeConfigFromValue(
|
|
const DaliValue* value) {
|
|
if (value == nullptr || value->asObject() == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto& json = *value->asObject();
|
|
GatewayBacnetBridgeConfig config;
|
|
config.deviceInstance = static_cast<uint32_t>(
|
|
getObjectInt(json, "deviceInstance").value_or(4194303));
|
|
config.localAddress = getObjectString(json, "localAddress").value_or("");
|
|
config.udpPort = static_cast<uint16_t>(getObjectInt(json, "udpPort").value_or(47808));
|
|
return config;
|
|
}
|
|
|
|
GatewayBridgeStoredConfig GatewayBridgeStoredConfigFromValue(const DaliValue::Object& object) {
|
|
GatewayBridgeStoredConfig config;
|
|
config.bridge = BridgeRuntimeConfig::fromJson(object);
|
|
config.modbus = GatewayModbusConfigFromValue(getObjectValue(object, "modbus"));
|
|
config.knx = GatewayKnxConfigFromValue(getObjectValue(object, "knx"));
|
|
config.bacnet_server = GatewayBacnetBridgeConfigFromValue(
|
|
getObjectValue(object, "bacnetServer"));
|
|
return config;
|
|
}
|
|
|
|
std::optional<GatewayBridgeStoredConfig> GatewayBridgeStoredConfigFromJson(std::string_view json) {
|
|
cJSON* root = cJSON_ParseWithLength(json.data(), json.size());
|
|
if (root == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const DaliValue value = FromCjson(root);
|
|
cJSON_Delete(root);
|
|
const auto* object = value.asObject();
|
|
if (object == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
return GatewayBridgeStoredConfigFromValue(*object);
|
|
}
|
|
|
|
GatewayCloudConfig GatewayCloudConfigFromJson(cJSON* root) {
|
|
GatewayCloudConfig config;
|
|
if (const char* value = JsonString(root, "brokerURI")) {
|
|
config.brokerURI = value;
|
|
}
|
|
if (const char* value = JsonString(root, "deviceID")) {
|
|
config.deviceID = value;
|
|
}
|
|
if (const char* value = JsonString(root, "username")) {
|
|
config.username = value;
|
|
}
|
|
if (const char* value = JsonString(root, "password")) {
|
|
config.password = value;
|
|
}
|
|
if (const char* value = JsonString(root, "topicPrefix")) {
|
|
config.topicPrefix = value;
|
|
}
|
|
if (const auto qos = JsonInt(root, "qos")) {
|
|
config.qos = qos.value();
|
|
}
|
|
return config;
|
|
}
|
|
|
|
cJSON* GatewayCloudConfigToCjson(const GatewayCloudConfig& config) {
|
|
cJSON* root = cJSON_CreateObject();
|
|
if (root == nullptr) {
|
|
return nullptr;
|
|
}
|
|
cJSON_AddStringToObject(root, "brokerURI", config.brokerURI.c_str());
|
|
cJSON_AddStringToObject(root, "deviceID", config.deviceID.c_str());
|
|
cJSON_AddStringToObject(root, "username", config.username.c_str());
|
|
cJSON_AddStringToObject(root, "password", config.password.c_str());
|
|
cJSON_AddStringToObject(root, "topicPrefix", config.topicPrefix.c_str());
|
|
cJSON_AddNumberToObject(root, "qos", config.qos);
|
|
return root;
|
|
}
|
|
|
|
bool IsKnownBridgeRequestKey(const char* key) {
|
|
if (key == nullptr) return true;
|
|
static const char* known[] = {"type", "seq", "sequence", "model",
|
|
"modelID", "modelId", "op", "operation",
|
|
"addr", "rawAddress", "cmd", "rawCommand",
|
|
"shortAddress", "short_address", "value", "meta"};
|
|
for (const char* item : known) {
|
|
if (std::strcmp(key, item) == 0) return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
DaliBridgeRequest BridgeRequestFromJson(cJSON* root) {
|
|
DaliBridgeRequest request;
|
|
if (const char* seq = JsonString(root, "seq")) {
|
|
request.sequence = seq;
|
|
}
|
|
if (request.sequence.empty()) {
|
|
if (const char* seq = JsonString(root, "sequence")) {
|
|
request.sequence = seq;
|
|
}
|
|
}
|
|
if (const char* model = JsonString(root, "model")) {
|
|
request.modelID = model;
|
|
}
|
|
if (request.modelID.empty()) {
|
|
if (const char* model = JsonString(root, "modelID")) {
|
|
request.modelID = model;
|
|
}
|
|
}
|
|
if (const char* op = JsonString(root, "op")) {
|
|
request.operation = bridgeOperationFromString(op);
|
|
}
|
|
if (!request.operation.has_value()) {
|
|
if (const char* op = JsonString(root, "operation")) {
|
|
request.operation = bridgeOperationFromString(op);
|
|
}
|
|
}
|
|
if (const auto addr = JsonInt(root, "addr")) {
|
|
request.rawAddress = addr.value();
|
|
}
|
|
if (!request.rawAddress.has_value()) {
|
|
if (const auto addr = JsonInt(root, "rawAddress")) {
|
|
request.rawAddress = addr.value();
|
|
}
|
|
}
|
|
if (const auto cmd = JsonInt(root, "cmd")) {
|
|
request.rawCommand = cmd.value();
|
|
}
|
|
if (!request.rawCommand.has_value()) {
|
|
if (const auto cmd = JsonInt(root, "rawCommand")) {
|
|
request.rawCommand = cmd.value();
|
|
}
|
|
}
|
|
if (const auto short_address = JsonInt(root, "shortAddress")) {
|
|
request.shortAddress = short_address.value();
|
|
}
|
|
if (!request.shortAddress.has_value()) {
|
|
if (const auto short_address = JsonInt(root, "short_address")) {
|
|
request.shortAddress = short_address.value();
|
|
}
|
|
}
|
|
if (const cJSON* value = cJSON_GetObjectItemCaseSensitive(root, "value")) {
|
|
request.value = FromCjson(value);
|
|
}
|
|
if (const cJSON* meta = cJSON_GetObjectItemCaseSensitive(root, "meta")) {
|
|
const auto meta_value = FromCjson(meta);
|
|
if (const auto* object = meta_value.asObject()) {
|
|
request.metadata = *object;
|
|
}
|
|
}
|
|
for (const cJSON* child = root != nullptr ? root->child : nullptr; child != nullptr;
|
|
child = child->next) {
|
|
if (!IsKnownBridgeRequestKey(child->string)) {
|
|
request.metadata[child->string] = FromCjson(child);
|
|
}
|
|
}
|
|
return request;
|
|
}
|
|
|
|
cJSON* BridgeResultToCjson(const DaliBridgeResult& result) {
|
|
return ToCjson(DaliValue(result.toJson()));
|
|
}
|
|
|
|
uint16_t ReadBe16(const uint8_t* data) {
|
|
return static_cast<uint16_t>((static_cast<uint16_t>(data[0]) << 8) | data[1]);
|
|
}
|
|
|
|
void WriteBe16(uint8_t* data, uint16_t value) {
|
|
data[0] = static_cast<uint8_t>((value >> 8) & 0xFF);
|
|
data[1] = static_cast<uint8_t>(value & 0xFF);
|
|
}
|
|
|
|
bool RecvAll(int sock, uint8_t* buffer, size_t len) {
|
|
size_t received = 0;
|
|
while (received < len) {
|
|
const int ret = recv(sock, buffer + received, len - received, 0);
|
|
if (ret <= 0) {
|
|
return false;
|
|
}
|
|
received += static_cast<size_t>(ret);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SendAll(int sock, const uint8_t* buffer, size_t len) {
|
|
size_t sent = 0;
|
|
while (sent < len) {
|
|
const int ret = send(sock, buffer + sent, len - sent, 0);
|
|
if (ret <= 0) {
|
|
return false;
|
|
}
|
|
sent += static_cast<size_t>(ret);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool SendModbusFrame(int sock, const uint8_t* mbap, const std::vector<uint8_t>& pdu) {
|
|
std::vector<uint8_t> frame(7 + pdu.size());
|
|
std::memcpy(frame.data(), mbap, 7);
|
|
WriteBe16(&frame[4], static_cast<uint16_t>(pdu.size() + 1));
|
|
std::memcpy(frame.data() + 7, pdu.data(), pdu.size());
|
|
return SendAll(sock, frame.data(), frame.size());
|
|
}
|
|
|
|
std::vector<uint8_t> ModbusExceptionPdu(uint8_t function_code, uint8_t exception_code) {
|
|
return {static_cast<uint8_t>(function_code | 0x80), exception_code};
|
|
}
|
|
|
|
uint16_t ModbusCrc16(const uint8_t* data, size_t len) {
|
|
uint16_t crc = 0xFFFF;
|
|
for (size_t i = 0; i < len; ++i) {
|
|
crc ^= data[i];
|
|
for (int bit = 0; bit < 8; ++bit) {
|
|
if ((crc & 0x0001) != 0) {
|
|
crc = static_cast<uint16_t>((crc >> 1) ^ 0xA001);
|
|
} else {
|
|
crc = static_cast<uint16_t>(crc >> 1);
|
|
}
|
|
}
|
|
}
|
|
return crc;
|
|
}
|
|
|
|
uint8_t ModbusAsciiLrc(const uint8_t* data, size_t len) {
|
|
uint8_t sum = 0;
|
|
for (size_t i = 0; i < len; ++i) {
|
|
sum = static_cast<uint8_t>(sum + data[i]);
|
|
}
|
|
return static_cast<uint8_t>(-sum);
|
|
}
|
|
|
|
std::optional<uint8_t> HexNibble(char ch) {
|
|
if (ch >= '0' && ch <= '9') {
|
|
return static_cast<uint8_t>(ch - '0');
|
|
}
|
|
if (ch >= 'A' && ch <= 'F') {
|
|
return static_cast<uint8_t>(ch - 'A' + 10);
|
|
}
|
|
if (ch >= 'a' && ch <= 'f') {
|
|
return static_cast<uint8_t>(ch - 'a' + 10);
|
|
}
|
|
return std::nullopt;
|
|
}
|
|
|
|
std::optional<std::vector<uint8_t>> DecodeModbusAsciiLine(std::string_view line) {
|
|
while (!line.empty() && (line.back() == '\r' || line.back() == '\n')) {
|
|
line.remove_suffix(1);
|
|
}
|
|
if (line.size() < 7 || line.front() != ':' || ((line.size() - 1) % 2) != 0) {
|
|
return std::nullopt;
|
|
}
|
|
std::vector<uint8_t> bytes;
|
|
bytes.reserve((line.size() - 1) / 2);
|
|
for (size_t i = 1; i + 1 < line.size(); i += 2) {
|
|
const auto high = HexNibble(line[i]);
|
|
const auto low = HexNibble(line[i + 1]);
|
|
if (!high.has_value() || !low.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
bytes.push_back(static_cast<uint8_t>((high.value() << 4) | low.value()));
|
|
}
|
|
uint8_t sum = 0;
|
|
for (const auto byte : bytes) {
|
|
sum = static_cast<uint8_t>(sum + byte);
|
|
}
|
|
if (sum != 0) {
|
|
return std::nullopt;
|
|
}
|
|
return bytes;
|
|
}
|
|
|
|
std::string EncodeModbusAsciiLine(const std::vector<uint8_t>& bytes) {
|
|
constexpr char kHex[] = "0123456789ABCDEF";
|
|
std::string out;
|
|
out.reserve(1 + bytes.size() * 2 + 2);
|
|
out.push_back(':');
|
|
for (const auto byte : bytes) {
|
|
out.push_back(kHex[(byte >> 4) & 0x0F]);
|
|
out.push_back(kHex[byte & 0x0F]);
|
|
}
|
|
out.append("\r\n");
|
|
return out;
|
|
}
|
|
|
|
bool LineStartsWith(std::string_view line, std::string_view prefix) {
|
|
return line.size() >= prefix.size() && line.substr(0, prefix.size()) == prefix;
|
|
}
|
|
|
|
uart_word_length_t UartWordLength(int bits) {
|
|
return bits <= 7 ? UART_DATA_7_BITS : UART_DATA_8_BITS;
|
|
}
|
|
|
|
uart_parity_t UartParity(const std::string& parity) {
|
|
if (parity == "even") {
|
|
return UART_PARITY_EVEN;
|
|
}
|
|
if (parity == "odd") {
|
|
return UART_PARITY_ODD;
|
|
}
|
|
return UART_PARITY_DISABLE;
|
|
}
|
|
|
|
uart_stop_bits_t UartStopBits(int bits) {
|
|
return bits >= 2 ? UART_STOP_BITS_2 : UART_STOP_BITS_1;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
struct GatewayBridgeService::ChannelRuntime {
|
|
explicit ChannelRuntime(DaliDomainService& domain, GatewayCache& cache, DaliChannelInfo channel,
|
|
GatewayBridgeServiceConfig service_config)
|
|
: domain(domain), cache(cache), channel(std::move(channel)), service_config(service_config),
|
|
lock(xSemaphoreCreateRecursiveMutex()) {}
|
|
|
|
~ChannelRuntime() {
|
|
if (cloud != nullptr) {
|
|
cloud->stop();
|
|
}
|
|
if (lock != nullptr) {
|
|
vSemaphoreDelete(lock);
|
|
lock = nullptr;
|
|
}
|
|
}
|
|
|
|
DaliDomainService& domain;
|
|
GatewayCache& cache;
|
|
DaliChannelInfo channel;
|
|
GatewayBridgeServiceConfig service_config;
|
|
SemaphoreHandle_t lock{nullptr};
|
|
std::unique_ptr<DaliComm> comm;
|
|
std::unique_ptr<DaliBridgeEngine> engine;
|
|
std::unique_ptr<GatewayModbusBridge> modbus;
|
|
std::unique_ptr<GatewayKnxBridge> knx;
|
|
std::unique_ptr<GatewayKnxTpIpRouter> knx_router;
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
std::unique_ptr<GatewayBacnetBridgeAdapter> bacnet;
|
|
#endif
|
|
std::unique_ptr<DaliCloudBridge> cloud;
|
|
BridgeRuntimeConfig bridge_config;
|
|
std::optional<GatewayModbusConfig> modbus_config;
|
|
std::optional<GatewayKnxConfig> knx_config;
|
|
std::optional<GatewayBacnetBridgeConfig> bacnet_server_config;
|
|
BridgeDiscoveryInventory discovery_inventory;
|
|
std::optional<GatewayCloudConfig> cloud_config;
|
|
bool bridge_config_loaded{false};
|
|
bool discovery_inventory_loaded{false};
|
|
bool cloud_config_loaded{false};
|
|
bool cloud_started{false};
|
|
bool modbus_started{false};
|
|
bool knx_started{false};
|
|
bool bacnet_started{false};
|
|
TaskHandle_t modbus_task_handle{nullptr};
|
|
std::atomic_bool modbus_stop_requested{false};
|
|
std::atomic_bool modbus_restart_requested{false};
|
|
int modbus_listen_sock{-1};
|
|
int modbus_client_sock{-1};
|
|
int modbus_uart_port{-1};
|
|
std::string modbus_last_error;
|
|
std::string knx_last_error;
|
|
|
|
struct DiagnosticSnapshotCacheEntry {
|
|
DaliDomainSnapshot snapshot;
|
|
TickType_t captured_ticks{0};
|
|
};
|
|
std::map<std::string, DiagnosticSnapshotCacheEntry> diagnostic_snapshot_cache;
|
|
|
|
static void ModbusTaskEntry(void* arg) {
|
|
static_cast<ChannelRuntime*>(arg)->modbusTaskLoop();
|
|
}
|
|
|
|
std::string bridgeNamespace() const {
|
|
return "dali_bridge_" + std::to_string(channel.gateway_id);
|
|
}
|
|
|
|
std::string cloudNamespace() const {
|
|
return "dali_cloud_" + std::to_string(channel.gateway_id);
|
|
}
|
|
|
|
esp_err_t start() {
|
|
comm = std::make_unique<DaliComm>(
|
|
[this](const uint8_t* data, size_t len) {
|
|
return domain.writeBridgeFrame(channel.gateway_id, data, len);
|
|
},
|
|
nullptr,
|
|
[this](const uint8_t* data, size_t len) {
|
|
return domain.transactBridgeFrame(channel.gateway_id, data, len);
|
|
},
|
|
[](uint32_t ms) { vTaskDelay(pdMS_TO_TICKS(ms)); });
|
|
|
|
BridgeProvisioningStore bridge_store(bridgeNamespace());
|
|
DaliValue::Object bridge_object;
|
|
if (bridge_store.loadObject(kBridgeConfigKey, &bridge_object) == ESP_OK) {
|
|
const auto stored_config = GatewayBridgeStoredConfigFromValue(bridge_object);
|
|
bridge_config = stored_config.bridge;
|
|
modbus_config = stored_config.modbus;
|
|
knx_config = stored_config.knx;
|
|
bacnet_server_config = stored_config.bacnet_server;
|
|
bridge_config_loaded = true;
|
|
}
|
|
DaliValue::Object discovery_object;
|
|
if (bridge_store.loadObject(kDiscoveryInventoryKey, &discovery_object) == ESP_OK) {
|
|
discovery_inventory = DiscoveryInventoryFromValue(discovery_object);
|
|
discovery_inventory_loaded = true;
|
|
}
|
|
applyBridgeConfigLocked();
|
|
|
|
GatewayProvisioningStore cloud_store(cloudNamespace());
|
|
GatewayCloudConfig loaded_cloud;
|
|
if (cloud_store.load(&loaded_cloud) == ESP_OK) {
|
|
cloud_config = loaded_cloud;
|
|
cloud_config_loaded = true;
|
|
}
|
|
applyCloudModelsLocked();
|
|
|
|
if (service_config.cloud_enabled && service_config.cloud_startup_enabled) {
|
|
startCloudLocked();
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
void applyBridgeConfigLocked() {
|
|
engine = std::make_unique<DaliBridgeEngine>(*comm);
|
|
for (const auto& model : bridge_config.models) {
|
|
engine->upsertModel(model);
|
|
}
|
|
|
|
modbus = std::make_unique<GatewayModbusBridge>(*engine);
|
|
if (modbus_config.has_value()) {
|
|
modbus->setConfig(modbus_config.value());
|
|
}
|
|
|
|
knx = std::make_unique<GatewayKnxBridge>(*engine);
|
|
knx_router = std::make_unique<GatewayKnxTpIpRouter>(
|
|
*knx, [this](const uint8_t* data, size_t len) {
|
|
LockGuard guard(lock);
|
|
if (knx == nullptr) {
|
|
DaliBridgeResult result;
|
|
result.error = "KNX bridge is not ready";
|
|
return result;
|
|
}
|
|
return knx->handleCemiFrame(data, len);
|
|
});
|
|
if (knx_config.has_value()) {
|
|
knx->setConfig(knx_config.value());
|
|
knx_router->setConfig(knx_config.value());
|
|
}
|
|
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
if (service_config.bacnet_enabled) {
|
|
bacnet = std::make_unique<GatewayBacnetBridgeAdapter>(*engine);
|
|
if (bacnet_server_config.has_value()) {
|
|
bacnet->setConfig(bacnet_server_config.value());
|
|
}
|
|
} else {
|
|
bacnet.reset();
|
|
}
|
|
#endif
|
|
|
|
applyCloudModelsLocked();
|
|
knx_started = false;
|
|
bacnet_started = false;
|
|
diagnostic_snapshot_cache.clear();
|
|
}
|
|
|
|
std::optional<DaliDomainSnapshot> diagnosticSnapshotLocked(int short_address,
|
|
std::string_view kind) {
|
|
if (!ValidShortAddress(short_address) || kind.empty()) {
|
|
return std::nullopt;
|
|
}
|
|
std::string key(kind.data(), kind.size());
|
|
key += ":";
|
|
key += std::to_string(short_address);
|
|
const TickType_t now = xTaskGetTickCount();
|
|
const auto cached = diagnostic_snapshot_cache.find(key);
|
|
if (cached != diagnostic_snapshot_cache.end() &&
|
|
(now - cached->second.captured_ticks) <= pdMS_TO_TICKS(kDiagnosticSnapshotCacheTtlMs)) {
|
|
return cached->second.snapshot;
|
|
}
|
|
|
|
std::optional<DaliDomainSnapshot> snapshot;
|
|
if (kind == "base_status") {
|
|
snapshot = domain.baseStatusSnapshot(channel.gateway_id, short_address);
|
|
} else if (kind == "dt1") {
|
|
snapshot = domain.dt1Snapshot(channel.gateway_id, short_address);
|
|
} else if (kind == "dt4") {
|
|
snapshot = domain.dt4Snapshot(channel.gateway_id, short_address);
|
|
} else if (kind == "dt5") {
|
|
snapshot = domain.dt5Snapshot(channel.gateway_id, short_address);
|
|
} else if (kind == "dt6") {
|
|
snapshot = domain.dt6Snapshot(channel.gateway_id, short_address);
|
|
} else if (kind == "dt8_status") {
|
|
snapshot = domain.dt8StatusSnapshot(channel.gateway_id, short_address);
|
|
}
|
|
|
|
if (snapshot.has_value()) {
|
|
diagnostic_snapshot_cache[key] = DiagnosticSnapshotCacheEntry{snapshot.value(), now};
|
|
}
|
|
return snapshot;
|
|
}
|
|
|
|
std::optional<bool> readSnapshotBoolLocked(int short_address, std::string_view kind,
|
|
std::string_view bool_key) {
|
|
const auto snapshot = diagnosticSnapshotLocked(short_address, kind);
|
|
if (!snapshot.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
return SnapshotBoolValue(snapshot.value(), bool_key);
|
|
}
|
|
|
|
std::optional<bool> readDiagnosticBoolPointLocked(const GatewayModbusPoint& point) {
|
|
if (point.diagnostic_device_type > 0) {
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
if (discovery == nullptr ||
|
|
!SnapshotHasDeviceType(discovery->discovery, point.diagnostic_device_type)) {
|
|
return false;
|
|
}
|
|
}
|
|
return readSnapshotBoolLocked(point.short_address, point.diagnostic_snapshot,
|
|
point.diagnostic_bool);
|
|
}
|
|
|
|
esp_err_t saveDiscoveryInventoryLocked() const {
|
|
BridgeProvisioningStore store(bridgeNamespace());
|
|
if (discovery_inventory.empty()) {
|
|
return store.clearKey(kDiscoveryInventoryKey);
|
|
}
|
|
return store.saveObject(kDiscoveryInventoryKey, DiscoveryInventoryToValue(discovery_inventory));
|
|
}
|
|
|
|
const BridgeDiscoveryEntry* findDiscoveryEntryLocked(int short_address) const {
|
|
const auto entry = discovery_inventory.find(short_address);
|
|
return entry == discovery_inventory.end() ? nullptr : &entry->second;
|
|
}
|
|
|
|
BridgeDiscoveryEntry* findDiscoveryEntryLocked(int short_address) {
|
|
const auto entry = discovery_inventory.find(short_address);
|
|
return entry == discovery_inventory.end() ? nullptr : &entry->second;
|
|
}
|
|
|
|
const BridgeDiscoveryEntry* updateDiscoveryEntryLocked(int short_address, bool persist) {
|
|
if (!ValidShortAddress(short_address)) {
|
|
return nullptr;
|
|
}
|
|
|
|
const auto snapshot = domain.discoverDeviceTypes(channel.gateway_id, short_address);
|
|
if (snapshot.has_value()) {
|
|
auto& entry = discovery_inventory[short_address];
|
|
entry.short_address = short_address;
|
|
entry.online = true;
|
|
entry.discovery = snapshot.value();
|
|
entry.discovery.address = short_address;
|
|
entry.discovery.gateway_id = channel.gateway_id;
|
|
if (persist) {
|
|
saveDiscoveryInventoryLocked();
|
|
}
|
|
return &entry;
|
|
}
|
|
|
|
auto* existing = findDiscoveryEntryLocked(short_address);
|
|
if (existing != nullptr) {
|
|
existing->online = false;
|
|
if (persist) {
|
|
saveDiscoveryInventoryLocked();
|
|
}
|
|
}
|
|
return existing;
|
|
}
|
|
|
|
const BridgeDiscoveryEntry* ensureDiscoveryEntryLocked(int short_address) {
|
|
const auto* existing = findDiscoveryEntryLocked(short_address);
|
|
if (existing != nullptr) {
|
|
return existing;
|
|
}
|
|
return updateDiscoveryEntryLocked(short_address, true);
|
|
}
|
|
|
|
std::vector<int> referencedShortAddressesLocked() const {
|
|
std::set<int> addresses;
|
|
for (const auto& model : bridge_config.models) {
|
|
if (model.dali.kind != BridgeDaliTargetKind::shortAddress ||
|
|
!model.dali.shortAddress.has_value() ||
|
|
!ValidShortAddress(model.dali.shortAddress.value())) {
|
|
continue;
|
|
}
|
|
addresses.insert(model.dali.shortAddress.value());
|
|
}
|
|
return std::vector<int>(addresses.begin(), addresses.end());
|
|
}
|
|
|
|
esp_err_t syncBacnetServerLocked() {
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
if (!service_config.bacnet_enabled) {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
if (bacnet == nullptr) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
const auto bindings = bacnetObjectBindingsLocked();
|
|
if (bindings.empty() && !bacnet_started) {
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
const auto server_config = bacnetServerConfigLocked();
|
|
return GatewayBacnetServer::instance().registerChannel(
|
|
channel.gateway_id, server_config, bindings,
|
|
[this](BridgeObjectType object_type, uint32_t object_instance,
|
|
const std::string& property, const DaliValue& value) {
|
|
return handleBacnetWrite(object_type, object_instance, property, value);
|
|
},
|
|
[this](BridgeObjectType object_type, uint32_t object_instance,
|
|
const std::string& property) -> std::optional<DaliValue> {
|
|
return readBacnetValue(object_type, object_instance, property);
|
|
});
|
|
#else
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
#endif
|
|
}
|
|
|
|
void applyCloudModelsLocked() {
|
|
if (cloud_started && cloud != nullptr) {
|
|
cloud->stop();
|
|
cloud_started = false;
|
|
}
|
|
cloud = std::make_unique<DaliCloudBridge>(*comm);
|
|
for (const auto& model : bridge_config.models) {
|
|
cloud->bridge().upsertModel(model);
|
|
}
|
|
}
|
|
|
|
esp_err_t saveBridgeConfig(std::string_view json) {
|
|
auto parsed = GatewayBridgeStoredConfigFromJson(json);
|
|
if (!parsed.has_value()) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
{
|
|
LockGuard guard(lock);
|
|
const esp_err_t validation_err = validateStoredBridgeConfigLocked(parsed.value());
|
|
if (validation_err != ESP_OK) {
|
|
return validation_err;
|
|
}
|
|
}
|
|
BridgeProvisioningStore store(bridgeNamespace());
|
|
const esp_err_t err = store.saveObject(
|
|
kBridgeConfigKey,
|
|
GatewayBridgeStoredConfigToValue(parsed->bridge, parsed->modbus, parsed->knx,
|
|
parsed->bacnet_server));
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
LockGuard guard(lock);
|
|
bridge_config = parsed->bridge;
|
|
modbus_config = parsed->modbus;
|
|
knx_config = parsed->knx;
|
|
bacnet_server_config = parsed->bacnet_server;
|
|
bridge_config_loaded = true;
|
|
applyBridgeConfigLocked();
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t clearBridgeConfig() {
|
|
BridgeProvisioningStore store(bridgeNamespace());
|
|
const esp_err_t err = store.clear();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
LockGuard guard(lock);
|
|
bridge_config = BridgeRuntimeConfig{};
|
|
modbus_config.reset();
|
|
knx_config.reset();
|
|
bacnet_server_config.reset();
|
|
bridge_config_loaded = false;
|
|
applyBridgeConfigLocked();
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t saveCloudConfig(std::string_view json) {
|
|
cJSON* root = cJSON_ParseWithLength(json.data(), json.size());
|
|
if (root == nullptr) {
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
const GatewayCloudConfig parsed = GatewayCloudConfigFromJson(root);
|
|
cJSON_Delete(root);
|
|
GatewayProvisioningStore store(cloudNamespace());
|
|
const esp_err_t err = store.save(parsed);
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
LockGuard guard(lock);
|
|
cloud_config = parsed;
|
|
cloud_config_loaded = true;
|
|
if (cloud_started) {
|
|
startCloudLocked();
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t clearCloudConfig() {
|
|
GatewayProvisioningStore store(cloudNamespace());
|
|
const esp_err_t err = store.clear();
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
LockGuard guard(lock);
|
|
if (cloud != nullptr) {
|
|
cloud->stop();
|
|
}
|
|
cloud_config.reset();
|
|
cloud_config_loaded = false;
|
|
cloud_started = false;
|
|
applyCloudModelsLocked();
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t startCloud() {
|
|
LockGuard guard(lock);
|
|
return startCloudLocked();
|
|
}
|
|
|
|
esp_err_t startCloudLocked() {
|
|
if (!service_config.cloud_enabled) {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
if (!cloud_config.has_value()) {
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
if (cloud == nullptr) {
|
|
applyCloudModelsLocked();
|
|
}
|
|
if (cloud->start(cloud_config.value())) {
|
|
cloud_started = true;
|
|
return ESP_OK;
|
|
}
|
|
cloud_started = false;
|
|
return ESP_FAIL;
|
|
}
|
|
|
|
esp_err_t stopCloud() {
|
|
LockGuard guard(lock);
|
|
if (cloud != nullptr) {
|
|
cloud->stop();
|
|
}
|
|
cloud_started = false;
|
|
return ESP_OK;
|
|
}
|
|
|
|
std::string modelName(const std::string& model_id) const {
|
|
const auto model = std::find_if(bridge_config.models.begin(), bridge_config.models.end(),
|
|
[&model_id](const auto& item) { return item.id == model_id; });
|
|
return model == bridge_config.models.end() ? model_id : model->displayName();
|
|
}
|
|
|
|
bool shouldPublishBacnetBindingLocked(const GatewayBacnetModelBinding& binding) {
|
|
if (binding.objectInstance < 0) {
|
|
return false;
|
|
}
|
|
if (IsRawBridgeOperation(binding.operation) ||
|
|
binding.target.kind != BridgeDaliTargetKind::shortAddress) {
|
|
return true;
|
|
}
|
|
if (!binding.target.shortAddress.has_value()) {
|
|
return false;
|
|
}
|
|
|
|
const int short_address = binding.target.shortAddress.value();
|
|
const auto* discovered = ensureDiscoveryEntryLocked(short_address);
|
|
if (discovered == nullptr) {
|
|
return false;
|
|
}
|
|
if (OperationRequiresDt1(binding.operation)) {
|
|
return SnapshotHasDeviceType(discovered->discovery, 1);
|
|
}
|
|
if (OperationRequiresDt8(binding.operation)) {
|
|
return SnapshotHasDeviceType(discovered->discovery, 8);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
std::vector<GatewayBacnetModelBinding> effectiveBacnetObjectsLocked() {
|
|
std::vector<GatewayBacnetModelBinding> bindings;
|
|
if (bacnet == nullptr) {
|
|
return bindings;
|
|
}
|
|
for (const auto& binding : bacnet->describeObjects()) {
|
|
if (shouldPublishBacnetBindingLocked(binding)) {
|
|
bindings.push_back(binding);
|
|
}
|
|
}
|
|
return bindings;
|
|
}
|
|
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
GatewayBacnetServerConfig bacnetServerConfigLocked() const {
|
|
GatewayBacnetServerConfig config;
|
|
config.device_name = channel.name.empty() ? "DALI Gateway " + std::to_string(channel.gateway_id)
|
|
: channel.name;
|
|
config.task_stack_size = service_config.bacnet_task_stack_size;
|
|
config.task_priority = service_config.bacnet_task_priority;
|
|
if (bacnet_server_config.has_value()) {
|
|
config.device_instance = bacnet_server_config->deviceInstance;
|
|
config.local_address = bacnet_server_config->localAddress;
|
|
config.udp_port = bacnet_server_config->udpPort;
|
|
}
|
|
return config;
|
|
}
|
|
|
|
std::optional<uint32_t> generatedBacnetBinaryInputInstance(uint16_t modbus_address) const {
|
|
if (modbus_address < kModbusDiscreteInputBase) {
|
|
return std::nullopt;
|
|
}
|
|
const uint32_t relative = static_cast<uint32_t>(modbus_address - kModbusDiscreteInputBase);
|
|
if (relative >= kBacnetGeneratedBinaryInputChannelStride) {
|
|
return std::nullopt;
|
|
}
|
|
const uint32_t instance = kBacnetGeneratedBinaryInputBase +
|
|
static_cast<uint32_t>(channel.channel_index) *
|
|
kBacnetGeneratedBinaryInputChannelStride +
|
|
relative;
|
|
if (instance > kBacnetMaxObjectInstance) {
|
|
return std::nullopt;
|
|
}
|
|
return instance;
|
|
}
|
|
|
|
std::optional<GatewayModbusPoint> generatedBacnetPointForObjectLocked(
|
|
BridgeObjectType object_type, uint32_t object_instance) const {
|
|
if (object_type != BridgeObjectType::binaryInput || modbus == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const uint32_t channel_base = kBacnetGeneratedBinaryInputBase +
|
|
static_cast<uint32_t>(channel.channel_index) *
|
|
kBacnetGeneratedBinaryInputChannelStride;
|
|
if (object_instance < channel_base ||
|
|
object_instance >= channel_base + kBacnetGeneratedBinaryInputChannelStride) {
|
|
return std::nullopt;
|
|
}
|
|
const uint32_t relative = object_instance - channel_base;
|
|
if (relative > UINT16_MAX - kModbusDiscreteInputBase) {
|
|
return std::nullopt;
|
|
}
|
|
const auto point = modbus->findPoint(
|
|
GatewayModbusSpace::kDiscreteInput,
|
|
static_cast<uint16_t>(kModbusDiscreteInputBase + relative));
|
|
if (!point.has_value() || !point->generated) {
|
|
return std::nullopt;
|
|
}
|
|
return point;
|
|
}
|
|
|
|
bool shouldPublishGeneratedBacnetPointLocked(const GatewayModbusPoint& point) {
|
|
if (!point.generated || point.space != GatewayModbusSpace::kDiscreteInput ||
|
|
point.access != GatewayModbusAccess::kReadOnly ||
|
|
!ValidShortAddress(point.short_address)) {
|
|
return false;
|
|
}
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
if (discovery == nullptr) {
|
|
return false;
|
|
}
|
|
if (point.diagnostic_device_type > 0 &&
|
|
!SnapshotHasDeviceType(discovery->discovery, point.diagnostic_device_type)) {
|
|
return false;
|
|
}
|
|
return generatedBacnetBinaryInputInstance(point.address).has_value();
|
|
}
|
|
|
|
std::vector<GatewayBacnetObjectBinding> generatedBacnetObjectBindingsLocked() {
|
|
std::vector<GatewayBacnetObjectBinding> bindings;
|
|
if (modbus == nullptr) {
|
|
return bindings;
|
|
}
|
|
std::vector<GatewayModbusPoint> generated_points;
|
|
generated_points.reserve(192);
|
|
for (const auto& inventory_entry : discovery_inventory) {
|
|
if (!ValidShortAddress(inventory_entry.first)) {
|
|
continue;
|
|
}
|
|
generated_points.clear();
|
|
modbus->appendGeneratedPointsForShortAddress(
|
|
static_cast<uint8_t>(inventory_entry.first), &generated_points);
|
|
for (const auto& point : generated_points) {
|
|
if (!shouldPublishGeneratedBacnetPointLocked(point)) {
|
|
continue;
|
|
}
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
const auto object_instance = generatedBacnetBinaryInputInstance(point.address);
|
|
if (discovery == nullptr || !object_instance.has_value()) {
|
|
continue;
|
|
}
|
|
const auto binding = modbus->describePoint(point);
|
|
const bool out_of_service = !discovery->online;
|
|
bindings.push_back(GatewayBacnetObjectBinding{channel.gateway_id,
|
|
binding.id,
|
|
binding.name,
|
|
BridgeObjectType::binaryInput,
|
|
object_instance.value(),
|
|
"presentValue",
|
|
out_of_service,
|
|
out_of_service
|
|
? kBacnetReliabilityCommunicationFailure
|
|
: kBacnetReliabilityNoFaultDetected,
|
|
true});
|
|
}
|
|
}
|
|
return bindings;
|
|
}
|
|
|
|
std::vector<GatewayBacnetObjectBinding> bacnetObjectBindingsLocked() {
|
|
std::vector<GatewayBacnetObjectBinding> bindings;
|
|
for (const auto& binding : effectiveBacnetObjectsLocked()) {
|
|
if (binding.objectInstance < 0) {
|
|
continue;
|
|
}
|
|
bool out_of_service = false;
|
|
uint32_t reliability = kBacnetReliabilityNoFaultDetected;
|
|
if (binding.target.kind == BridgeDaliTargetKind::shortAddress &&
|
|
binding.target.shortAddress.has_value()) {
|
|
if (const auto* discovery = findDiscoveryEntryLocked(binding.target.shortAddress.value())) {
|
|
if (!discovery->online) {
|
|
out_of_service = true;
|
|
reliability = kBacnetReliabilityCommunicationFailure;
|
|
}
|
|
}
|
|
}
|
|
bindings.push_back(GatewayBacnetObjectBinding{channel.gateway_id,
|
|
binding.modelID,
|
|
modelName(binding.modelID),
|
|
binding.objectType,
|
|
static_cast<uint32_t>(binding.objectInstance),
|
|
binding.property.empty() ? "presentValue"
|
|
: binding.property,
|
|
out_of_service,
|
|
reliability,
|
|
BridgeOperationReadable(binding.operation)});
|
|
}
|
|
auto generated = generatedBacnetObjectBindingsLocked();
|
|
bindings.insert(bindings.end(), generated.begin(), generated.end());
|
|
return bindings;
|
|
}
|
|
|
|
bool handleBacnetWrite(BridgeObjectType object_type, uint32_t object_instance,
|
|
const std::string& property, const DaliValue& value) {
|
|
LockGuard guard(lock);
|
|
if (bacnet == nullptr) {
|
|
return false;
|
|
}
|
|
const DaliBridgeResult result = bacnet->handlePropertyWrite(
|
|
object_type, static_cast<int>(object_instance), property, value);
|
|
if (!result.ok) {
|
|
ESP_LOGW(kTag, "gateway=%u BACnet write rejected: %s", channel.gateway_id,
|
|
result.error.c_str());
|
|
}
|
|
return result.ok;
|
|
}
|
|
|
|
std::optional<DaliValue> readBacnetValue(BridgeObjectType object_type,
|
|
uint32_t object_instance,
|
|
const std::string& property) {
|
|
LockGuard guard(lock);
|
|
if (const auto point = generatedBacnetPointForObjectLocked(object_type, object_instance)) {
|
|
const auto value = readGeneratedBoolPointLocked(point.value());
|
|
return value.has_value() ? std::optional<DaliValue>(DaliValue(value.value()))
|
|
: std::nullopt;
|
|
}
|
|
if (bacnet == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto binding = bacnet->findObject(object_type, static_cast<int>(object_instance),
|
|
property.empty() ? "presentValue" : property);
|
|
if (!binding.has_value() || !BridgeOperationReadable(binding->operation)) {
|
|
return std::nullopt;
|
|
}
|
|
const DaliBridgeResult result = bacnet->readProperty(
|
|
object_type, static_cast<int>(object_instance),
|
|
property.empty() ? "presentValue" : property);
|
|
if (!result.ok || !result.data.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
if ((object_type == BridgeObjectType::binaryInput ||
|
|
object_type == BridgeObjectType::binaryValue ||
|
|
object_type == BridgeObjectType::binaryOutput) &&
|
|
binding->bitIndex.has_value()) {
|
|
const int bit = binding->bitIndex.value();
|
|
if (bit < 0 || bit >= 32) {
|
|
return std::nullopt;
|
|
}
|
|
return DaliValue(((result.data.value() >> bit) & 0x1) != 0);
|
|
}
|
|
if (object_type == BridgeObjectType::binaryInput ||
|
|
object_type == BridgeObjectType::binaryValue ||
|
|
object_type == BridgeObjectType::binaryOutput) {
|
|
return DaliValue(result.data.value() != 0);
|
|
}
|
|
return DaliValue(result.data.value());
|
|
}
|
|
|
|
esp_err_t startBacnet() {
|
|
LockGuard guard(lock);
|
|
if (!service_config.bacnet_enabled) {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
if (bacnet == nullptr) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
const esp_err_t err = syncBacnetServerLocked();
|
|
bacnet_started = err == ESP_OK;
|
|
return err;
|
|
}
|
|
#else
|
|
esp_err_t startBacnet() {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
#endif
|
|
|
|
esp_err_t startKnx(std::set<uint16_t>* used_ports = nullptr,
|
|
std::set<int>* used_uarts = nullptr) {
|
|
LockGuard guard(lock);
|
|
if (!service_config.knx_enabled) {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
if (knx == nullptr || knx_router == nullptr) {
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
const auto config = activeKnxConfigLocked();
|
|
if (!config.has_value()) {
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
std::string validation_error;
|
|
const esp_err_t validation_err = validateKnxConfigLocked(
|
|
config.value(), activeModbusConfigLocked(), &validation_error);
|
|
if (validation_err != ESP_OK) {
|
|
knx_last_error = validation_error;
|
|
return validation_err;
|
|
}
|
|
if (config->ip_router_enabled && used_ports != nullptr) {
|
|
if (used_ports->find(config->udp_port) != used_ports->end()) {
|
|
knx_last_error = "duplicate KNXnet/IP UDP port " + std::to_string(config->udp_port);
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
used_ports->insert(config->udp_port);
|
|
}
|
|
if (config->ip_router_enabled && used_uarts != nullptr) {
|
|
const int uart_port = config->tp_uart.uart_port;
|
|
if (used_uarts->find(uart_port) != used_uarts->end()) {
|
|
knx_last_error = "KNX TP-UART UART" + std::to_string(uart_port) +
|
|
" is already used by another runtime";
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
used_uarts->insert(uart_port);
|
|
}
|
|
knx->setConfig(config.value());
|
|
knx_router->setConfig(config.value());
|
|
if (!config->ip_router_enabled) {
|
|
knx_started = false;
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
knx_last_error.clear();
|
|
const esp_err_t err = knx_router->start(service_config.knx_task_stack_size,
|
|
service_config.knx_task_priority);
|
|
knx_started = err == ESP_OK;
|
|
if (err != ESP_OK) {
|
|
knx_last_error = knx_router->lastError().empty()
|
|
? "failed to start KNX TP-UART router"
|
|
: knx_router->lastError();
|
|
}
|
|
return err;
|
|
}
|
|
|
|
esp_err_t stopKnx() {
|
|
LockGuard guard(lock);
|
|
if (knx_router != nullptr) {
|
|
const esp_err_t err = knx_router->stop();
|
|
knx_started = false;
|
|
return err;
|
|
}
|
|
knx_started = false;
|
|
return ESP_OK;
|
|
}
|
|
|
|
GatewayBridgeHttpResponse execute(std::string_view json) {
|
|
cJSON* root = cJSON_ParseWithLength(json.data(), json.size());
|
|
if (root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid execute JSON");
|
|
}
|
|
const DaliBridgeRequest request = BridgeRequestFromJson(root);
|
|
cJSON_Delete(root);
|
|
|
|
LockGuard guard(lock);
|
|
if (engine == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_STATE, "bridge engine is not ready");
|
|
}
|
|
const DaliBridgeResult result = engine->execute(request);
|
|
return JsonOk(BridgeResultToCjson(result));
|
|
}
|
|
|
|
cJSON* statusCjson() const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
if (root == nullptr) {
|
|
return nullptr;
|
|
}
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON_AddNumberToObject(root, "channel", channel.channel_index);
|
|
cJSON_AddStringToObject(root, "name", channel.name.c_str());
|
|
cJSON_AddBoolToObject(root, "bridgeConfigLoaded", bridge_config_loaded);
|
|
cJSON_AddBoolToObject(root, "discoveryInventoryLoaded", discovery_inventory_loaded);
|
|
cJSON_AddNumberToObject(root, "inventoryCount",
|
|
static_cast<double>(discovery_inventory.size()));
|
|
cJSON_AddNumberToObject(root, "modelCount", static_cast<double>(bridge_config.models.size()));
|
|
|
|
cJSON* modbus_json = cJSON_CreateObject();
|
|
if (modbus_json != nullptr) {
|
|
cJSON_AddBoolToObject(modbus_json, "enabled", service_config.modbus_enabled);
|
|
cJSON_AddBoolToObject(modbus_json, "started", modbus_started);
|
|
cJSON_AddStringToObject(modbus_json, "lastError", modbus_last_error.c_str());
|
|
if (modbus_config.has_value()) {
|
|
cJSON_AddStringToObject(modbus_json, "transport", modbus_config->transport.c_str());
|
|
cJSON_AddNumberToObject(modbus_json, "port", modbus_config->port);
|
|
cJSON_AddNumberToObject(modbus_json, "unitID", modbus_config->unit_id);
|
|
if (GatewayModbusTransportIsSerial(modbus_config->transport)) {
|
|
cJSON* serial_json = cJSON_CreateObject();
|
|
if (serial_json != nullptr) {
|
|
cJSON_AddNumberToObject(serial_json, "uartPort", modbus_config->serial.uart_port);
|
|
cJSON_AddNumberToObject(serial_json, "txPin", modbus_config->serial.tx_pin);
|
|
cJSON_AddNumberToObject(serial_json, "rxPin", modbus_config->serial.rx_pin);
|
|
cJSON_AddNumberToObject(serial_json, "baudrate", modbus_config->serial.baudrate);
|
|
cJSON_AddStringToObject(serial_json, "parity", modbus_config->serial.parity.c_str());
|
|
cJSON_AddNumberToObject(serial_json, "stopBits", modbus_config->serial.stop_bits);
|
|
cJSON* rs485_json = cJSON_CreateObject();
|
|
if (rs485_json != nullptr) {
|
|
cJSON_AddBoolToObject(rs485_json, "enabled", modbus_config->serial.rs485.enabled);
|
|
cJSON_AddNumberToObject(rs485_json, "dePin", modbus_config->serial.rs485.de_pin);
|
|
cJSON_AddItemToObject(serial_json, "rs485", rs485_json);
|
|
}
|
|
cJSON_AddItemToObject(modbus_json, "serial", serial_json);
|
|
}
|
|
}
|
|
}
|
|
cJSON_AddItemToObject(root, "modbus", modbus_json);
|
|
}
|
|
|
|
cJSON* bacnet_json = cJSON_CreateObject();
|
|
if (bacnet_json != nullptr) {
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
const auto server_status = GatewayBacnetServer::instance().status();
|
|
#endif
|
|
cJSON_AddBoolToObject(bacnet_json, "enabled", service_config.bacnet_enabled);
|
|
cJSON_AddBoolToObject(bacnet_json, "startupEnabled", service_config.bacnet_startup_enabled);
|
|
cJSON_AddBoolToObject(bacnet_json, "started", bacnet_started);
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
cJSON_AddBoolToObject(bacnet_json, "serverStarted", server_status.started);
|
|
cJSON_AddNumberToObject(bacnet_json, "serverObjectCount",
|
|
static_cast<double>(server_status.object_count));
|
|
#else
|
|
cJSON_AddBoolToObject(bacnet_json, "serverStarted", false);
|
|
cJSON_AddNumberToObject(bacnet_json, "serverObjectCount", 0);
|
|
#endif
|
|
if (bacnet_server_config.has_value()) {
|
|
cJSON_AddNumberToObject(bacnet_json, "deviceInstance",
|
|
bacnet_server_config->deviceInstance);
|
|
cJSON_AddStringToObject(bacnet_json, "localAddress",
|
|
bacnet_server_config->localAddress.c_str());
|
|
cJSON_AddNumberToObject(bacnet_json, "udpPort", bacnet_server_config->udpPort);
|
|
}
|
|
cJSON_AddItemToObject(root, "bacnet", bacnet_json);
|
|
}
|
|
|
|
cJSON* knx_json = cJSON_CreateObject();
|
|
if (knx_json != nullptr) {
|
|
const auto effective_knx = knx_config.has_value() ? knx_config : service_config.default_knx_config;
|
|
cJSON_AddBoolToObject(knx_json, "enabled", service_config.knx_enabled);
|
|
cJSON_AddBoolToObject(knx_json, "startupEnabled", service_config.knx_startup_enabled);
|
|
cJSON_AddBoolToObject(knx_json, "started", knx_started);
|
|
cJSON_AddBoolToObject(knx_json, "routerReady", knx_router != nullptr && knx_router->started());
|
|
const std::string router_error = knx_router == nullptr ? "" : knx_router->lastError();
|
|
cJSON_AddStringToObject(knx_json, "lastError",
|
|
knx_last_error.empty() ? router_error.c_str()
|
|
: knx_last_error.c_str());
|
|
if (effective_knx.has_value()) {
|
|
cJSON_AddBoolToObject(knx_json, "daliRouterEnabled",
|
|
effective_knx->dali_router_enabled);
|
|
cJSON_AddBoolToObject(knx_json, "ipRouterEnabled",
|
|
effective_knx->ip_router_enabled);
|
|
cJSON_AddBoolToObject(knx_json, "tunnelEnabled", effective_knx->tunnel_enabled);
|
|
cJSON_AddBoolToObject(knx_json, "multicastEnabled",
|
|
effective_knx->multicast_enabled);
|
|
cJSON_AddNumberToObject(knx_json, "mainGroup", effective_knx->main_group);
|
|
cJSON_AddNumberToObject(knx_json, "udpPort", effective_knx->udp_port);
|
|
cJSON_AddStringToObject(knx_json, "multicastAddress",
|
|
effective_knx->multicast_address.c_str());
|
|
cJSON_AddNumberToObject(knx_json, "individualAddress",
|
|
effective_knx->individual_address);
|
|
cJSON* serial_json = cJSON_CreateObject();
|
|
if (serial_json != nullptr) {
|
|
cJSON_AddNumberToObject(serial_json, "uartPort", effective_knx->tp_uart.uart_port);
|
|
cJSON_AddNumberToObject(serial_json, "txPin", effective_knx->tp_uart.tx_pin);
|
|
cJSON_AddNumberToObject(serial_json, "rxPin", effective_knx->tp_uart.rx_pin);
|
|
cJSON_AddNumberToObject(serial_json, "baudrate", effective_knx->tp_uart.baudrate);
|
|
cJSON_AddItemToObject(knx_json, "tpUart", serial_json);
|
|
}
|
|
}
|
|
cJSON_AddItemToObject(root, "knx", knx_json);
|
|
}
|
|
|
|
cJSON* cloud_json = cJSON_CreateObject();
|
|
if (cloud_json != nullptr) {
|
|
cJSON_AddBoolToObject(cloud_json, "enabled", service_config.cloud_enabled);
|
|
cJSON_AddBoolToObject(cloud_json, "configured", cloud_config_loaded);
|
|
cJSON_AddBoolToObject(cloud_json, "started", cloud_started);
|
|
cJSON_AddBoolToObject(cloud_json, "connected", cloud != nullptr && cloud->isConnected());
|
|
if (cloud_config.has_value()) {
|
|
cJSON_AddStringToObject(cloud_json, "deviceID", cloud_config->deviceID.c_str());
|
|
cJSON_AddStringToObject(cloud_json, "topicPrefix", cloud_config->topicPrefix.c_str());
|
|
}
|
|
cJSON_AddItemToObject(root, "cloud", cloud_json);
|
|
}
|
|
|
|
return root;
|
|
}
|
|
|
|
GatewayBridgeHttpResponse configJson() const {
|
|
return GatewayBridgeHttpResponse{ESP_OK,
|
|
GatewayBridgeStoredConfigToJson(bridge_config, modbus_config,
|
|
knx_config,
|
|
bacnet_server_config)};
|
|
}
|
|
|
|
GatewayBridgeHttpResponse inventoryJson() const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON_AddBoolToObject(root, "loaded", discovery_inventory_loaded);
|
|
cJSON_AddNumberToObject(root, "count", static_cast<double>(discovery_inventory.size()));
|
|
cJSON* inventory = cJSON_CreateArray();
|
|
if (inventory != nullptr) {
|
|
for (const auto& entry : discovery_inventory) {
|
|
cJSON_AddItemToArray(inventory, DiscoveryEntryToCjson(entry.second));
|
|
}
|
|
cJSON_AddItemToObject(root, "inventory", inventory);
|
|
}
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse effectiveModelJsonLocked() {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON_AddStringToObject(root, "name", channel.name.c_str());
|
|
cJSON* models = cJSON_CreateArray();
|
|
const auto effective_bacnet = effectiveBacnetObjectsLocked();
|
|
if (models != nullptr) {
|
|
for (const auto& model : bridge_config.models) {
|
|
cJSON* item = ToCjson(DaliValue(model.toJson()));
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
cJSON_AddStringToObject(item, "displayName", model.displayName().c_str());
|
|
if (model.dali.kind == BridgeDaliTargetKind::shortAddress &&
|
|
model.dali.shortAddress.has_value() &&
|
|
ValidShortAddress(model.dali.shortAddress.value())) {
|
|
const int short_address = model.dali.shortAddress.value();
|
|
if (const auto* entry = findDiscoveryEntryLocked(short_address)) {
|
|
cJSON_AddBoolToObject(item, "discovered", true);
|
|
cJSON_AddBoolToObject(item, "online", entry->online);
|
|
cJSON_AddStringToObject(item, "inventoryState", DiscoveryStateString(entry->online));
|
|
cJSON_AddItemToObject(item, "discovery", DiscoveryEntryToCjson(*entry));
|
|
} else {
|
|
cJSON_AddBoolToObject(item, "discovered", false);
|
|
cJSON_AddBoolToObject(item, "online", false);
|
|
cJSON_AddStringToObject(item, "inventoryState", "never_seen");
|
|
}
|
|
}
|
|
if (model.protocol == BridgeProtocolKind::bacnet &&
|
|
model.external.objectInstance.has_value()) {
|
|
const auto binding = std::find_if(
|
|
effective_bacnet.begin(), effective_bacnet.end(),
|
|
[&model](const auto& item) { return item.modelID == model.id; });
|
|
const bool published = binding != effective_bacnet.end();
|
|
cJSON_AddBoolToObject(item, "bacnetPublished", published);
|
|
if (published && model.dali.kind == BridgeDaliTargetKind::shortAddress &&
|
|
model.dali.shortAddress.has_value()) {
|
|
const auto* entry = findDiscoveryEntryLocked(model.dali.shortAddress.value());
|
|
const bool out_of_service = entry != nullptr && !entry->online;
|
|
cJSON_AddBoolToObject(item, "bacnetOutOfService", out_of_service);
|
|
cJSON_AddStringToObject(item, "bacnetReliability",
|
|
BacnetReliabilityToString(out_of_service
|
|
? kBacnetReliabilityCommunicationFailure
|
|
: kBacnetReliabilityNoFaultDetected));
|
|
}
|
|
}
|
|
cJSON_AddItemToArray(models, item);
|
|
}
|
|
cJSON_AddItemToObject(root, "models", models);
|
|
}
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse effectiveModelJson() {
|
|
LockGuard guard(lock);
|
|
return effectiveModelJsonLocked();
|
|
}
|
|
|
|
GatewayBridgeHttpResponse scanInventory(std::string_view body) {
|
|
std::string mode = "referenced";
|
|
if (!body.empty()) {
|
|
cJSON* root = cJSON_ParseWithLength(body.data(), body.size());
|
|
if (root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid scan JSON");
|
|
}
|
|
if (const char* mode_value = JsonString(root, "mode")) {
|
|
mode = mode_value;
|
|
} else if (const char* mode_value = JsonString(root, "scanMode")) {
|
|
mode = mode_value;
|
|
}
|
|
cJSON_Delete(root);
|
|
}
|
|
|
|
LockGuard guard(lock);
|
|
std::vector<int> addresses;
|
|
if (mode == "all" || mode == "full") {
|
|
addresses.reserve(kMaxDaliShortAddress + 1);
|
|
for (int address = 0; address <= kMaxDaliShortAddress; ++address) {
|
|
addresses.push_back(address);
|
|
}
|
|
mode = "all";
|
|
} else {
|
|
addresses = referencedShortAddressesLocked();
|
|
mode = "referenced";
|
|
}
|
|
|
|
size_t online_count = 0;
|
|
size_t offline_count = 0;
|
|
size_t unseen_count = 0;
|
|
cJSON* results = cJSON_CreateArray();
|
|
for (const int address : addresses) {
|
|
const auto* entry = updateDiscoveryEntryLocked(address, false);
|
|
if (entry != nullptr) {
|
|
if (entry->online) {
|
|
++online_count;
|
|
} else {
|
|
++offline_count;
|
|
}
|
|
cJSON_AddItemToArray(results, DiscoveryEntryToCjson(*entry));
|
|
} else {
|
|
++unseen_count;
|
|
cJSON_AddItemToArray(results, MissingDiscoveryEntryToCjson(channel.gateway_id, address));
|
|
}
|
|
}
|
|
|
|
const esp_err_t persist_err = saveDiscoveryInventoryLocked();
|
|
if (persist_err != ESP_OK) {
|
|
cJSON_Delete(results);
|
|
return ErrorResponse(persist_err, "failed to persist discovery inventory");
|
|
}
|
|
discovery_inventory_loaded = discovery_inventory_loaded || !discovery_inventory.empty();
|
|
|
|
if (bacnet_started) {
|
|
const esp_err_t err = syncBacnetServerLocked();
|
|
if (err != ESP_OK && err != ESP_ERR_NOT_FOUND) {
|
|
cJSON_Delete(results);
|
|
return ErrorResponse(err, "failed to refresh BACnet bridge after scan");
|
|
}
|
|
bacnet_started = err == ESP_OK;
|
|
}
|
|
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(root, "ok", true);
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON_AddStringToObject(root, "mode", mode.c_str());
|
|
cJSON_AddNumberToObject(root, "scanned", static_cast<double>(addresses.size()));
|
|
cJSON_AddNumberToObject(root, "onlineCount", static_cast<double>(online_count));
|
|
cJSON_AddNumberToObject(root, "offlineCount", static_cast<double>(offline_count));
|
|
cJSON_AddNumberToObject(root, "neverSeenCount", static_cast<double>(unseen_count));
|
|
cJSON_AddItemToObject(root, "inventory", results);
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse modbusBindingsJson() const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON* bindings = cJSON_CreateArray();
|
|
if (bindings != nullptr && modbus != nullptr) {
|
|
for (const auto& binding : modbus->describePoints()) {
|
|
cJSON* item = cJSON_CreateObject();
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
if (!binding.model_id.empty()) {
|
|
cJSON_AddStringToObject(item, "model", binding.model_id.c_str());
|
|
}
|
|
cJSON_AddStringToObject(item, "space", GatewayModbusSpaceToString(binding.space));
|
|
cJSON_AddNumberToObject(item, "address", binding.address);
|
|
cJSON_AddStringToObject(item, "id", binding.id.c_str());
|
|
cJSON_AddStringToObject(item, "name", binding.name.c_str());
|
|
cJSON_AddStringToObject(item, "access", GatewayModbusAccessToString(binding.access));
|
|
cJSON_AddBoolToObject(item, "generated", binding.generated);
|
|
if (binding.generated) {
|
|
cJSON_AddStringToObject(item, "generatedKind",
|
|
GatewayModbusGeneratedKindToString(binding.generated_kind));
|
|
}
|
|
if (binding.short_address >= 0) {
|
|
cJSON_AddNumberToObject(item, "shortAddress", binding.short_address);
|
|
}
|
|
if (binding.bit_index.has_value()) {
|
|
cJSON_AddNumberToObject(item, "bitIndex", binding.bit_index.value());
|
|
}
|
|
if (!binding.diagnostic_snapshot.empty()) {
|
|
cJSON_AddStringToObject(item, "diagnosticSnapshot",
|
|
binding.diagnostic_snapshot.c_str());
|
|
}
|
|
if (!binding.diagnostic_bool.empty()) {
|
|
cJSON_AddStringToObject(item, "diagnosticBool", binding.diagnostic_bool.c_str());
|
|
}
|
|
if (binding.diagnostic_device_type >= 0) {
|
|
cJSON_AddNumberToObject(item, "diagnosticDeviceType",
|
|
binding.diagnostic_device_type);
|
|
}
|
|
cJSON_AddItemToArray(bindings, item);
|
|
}
|
|
}
|
|
cJSON_AddItemToObject(root, "bindings", bindings);
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse knxBindingsJson() const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON* bindings = cJSON_CreateArray();
|
|
if (bindings != nullptr && knx != nullptr) {
|
|
for (const auto& binding : knx->describeDaliBindings()) {
|
|
cJSON* item = cJSON_CreateObject();
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
cJSON_AddStringToObject(item, "address", binding.address.c_str());
|
|
cJSON_AddNumberToObject(item, "rawAddress", binding.group_address);
|
|
cJSON_AddNumberToObject(item, "mainGroup", binding.main_group);
|
|
cJSON_AddNumberToObject(item, "middleGroup", binding.middle_group);
|
|
cJSON_AddNumberToObject(item, "subGroup", binding.sub_group);
|
|
cJSON_AddStringToObject(item, "name", binding.name.c_str());
|
|
cJSON_AddStringToObject(item, "datapointType", binding.datapoint_type.c_str());
|
|
cJSON_AddStringToObject(item, "dataType",
|
|
GatewayKnxDataTypeToString(binding.data_type));
|
|
cJSON_AddStringToObject(item, "targetKind",
|
|
GatewayKnxTargetKindToString(binding.target.kind));
|
|
if (binding.target.address >= 0) {
|
|
cJSON_AddNumberToObject(item, "targetAddress", binding.target.address);
|
|
}
|
|
cJSON_AddItemToArray(bindings, item);
|
|
}
|
|
}
|
|
cJSON_AddItemToObject(root, "bindings", bindings);
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse bacnetBindingsJson() {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON* bindings = cJSON_CreateArray();
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
if (bindings != nullptr && bacnet != nullptr) {
|
|
for (const auto& binding : effectiveBacnetObjectsLocked()) {
|
|
cJSON* item = cJSON_CreateObject();
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
cJSON_AddStringToObject(item, "model", binding.modelID.c_str());
|
|
cJSON_AddStringToObject(item, "objectType", bridgeObjectTypeToString(binding.objectType));
|
|
cJSON_AddNumberToObject(item, "objectInstance", binding.objectInstance);
|
|
cJSON_AddStringToObject(item, "property", binding.property.c_str());
|
|
cJSON_AddStringToObject(item, "operation", bridgeOperationToString(binding.operation));
|
|
cJSON_AddStringToObject(item, "targetKind",
|
|
bridgeDaliTargetKindToString(binding.target.kind));
|
|
if (const auto target_value = BridgeTargetValue(binding.target)) {
|
|
cJSON_AddNumberToObject(item, "targetAddress", target_value.value());
|
|
}
|
|
if (binding.target.rawAddress.has_value()) {
|
|
cJSON_AddNumberToObject(item, "rawAddress", binding.target.rawAddress.value());
|
|
}
|
|
if (binding.target.rawCommand.has_value()) {
|
|
cJSON_AddNumberToObject(item, "rawCommand", binding.target.rawCommand.value());
|
|
}
|
|
if (binding.target.kind == BridgeDaliTargetKind::shortAddress &&
|
|
binding.target.shortAddress.has_value()) {
|
|
if (const auto* discovery = findDiscoveryEntryLocked(binding.target.shortAddress.value())) {
|
|
const bool out_of_service = !discovery->online;
|
|
cJSON_AddBoolToObject(item, "outOfService", out_of_service);
|
|
cJSON_AddStringToObject(item, "reliability",
|
|
BacnetReliabilityToString(out_of_service
|
|
? kBacnetReliabilityCommunicationFailure
|
|
: kBacnetReliabilityNoFaultDetected));
|
|
cJSON_AddStringToObject(item, "inventoryState",
|
|
DiscoveryStateString(discovery->online));
|
|
} else {
|
|
cJSON_AddBoolToObject(item, "outOfService", false);
|
|
cJSON_AddStringToObject(item, "reliability",
|
|
BacnetReliabilityToString(kBacnetReliabilityNoFaultDetected));
|
|
cJSON_AddStringToObject(item, "inventoryState", "never_seen");
|
|
}
|
|
}
|
|
cJSON_AddItemToArray(bindings, item);
|
|
}
|
|
if (modbus != nullptr) {
|
|
std::vector<GatewayModbusPoint> generated_points;
|
|
generated_points.reserve(192);
|
|
for (const auto& inventory_entry : discovery_inventory) {
|
|
if (!ValidShortAddress(inventory_entry.first)) {
|
|
continue;
|
|
}
|
|
generated_points.clear();
|
|
modbus->appendGeneratedPointsForShortAddress(
|
|
static_cast<uint8_t>(inventory_entry.first), &generated_points);
|
|
for (const auto& point : generated_points) {
|
|
if (!shouldPublishGeneratedBacnetPointLocked(point)) {
|
|
continue;
|
|
}
|
|
const auto object_instance = generatedBacnetBinaryInputInstance(point.address);
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
if (!object_instance.has_value() || discovery == nullptr) {
|
|
continue;
|
|
}
|
|
cJSON* item = cJSON_CreateObject();
|
|
if (item == nullptr) {
|
|
continue;
|
|
}
|
|
const auto binding = modbus->describePoint(point);
|
|
cJSON_AddStringToObject(item, "model", binding.id.c_str());
|
|
cJSON_AddStringToObject(item, "name", binding.name.c_str());
|
|
cJSON_AddStringToObject(item, "objectType", "binaryInput");
|
|
cJSON_AddNumberToObject(item, "objectInstance", object_instance.value());
|
|
cJSON_AddStringToObject(item, "property", "presentValue");
|
|
cJSON_AddBoolToObject(item, "generated", true);
|
|
cJSON_AddStringToObject(item, "generatedKind",
|
|
GatewayModbusGeneratedKindToString(binding.generated_kind));
|
|
cJSON_AddNumberToObject(item, "shortAddress", binding.short_address);
|
|
if (!binding.diagnostic_snapshot.empty()) {
|
|
cJSON_AddStringToObject(item, "diagnosticSnapshot",
|
|
binding.diagnostic_snapshot.c_str());
|
|
}
|
|
if (!binding.diagnostic_bool.empty()) {
|
|
cJSON_AddStringToObject(item, "diagnosticBool", binding.diagnostic_bool.c_str());
|
|
}
|
|
if (binding.diagnostic_device_type >= 0) {
|
|
cJSON_AddNumberToObject(item, "diagnosticDeviceType",
|
|
binding.diagnostic_device_type);
|
|
}
|
|
const bool out_of_service = !discovery->online;
|
|
cJSON_AddBoolToObject(item, "outOfService", out_of_service);
|
|
cJSON_AddStringToObject(item, "reliability",
|
|
BacnetReliabilityToString(out_of_service
|
|
? kBacnetReliabilityCommunicationFailure
|
|
: kBacnetReliabilityNoFaultDetected));
|
|
cJSON_AddStringToObject(item, "inventoryState",
|
|
DiscoveryStateString(discovery->online));
|
|
cJSON_AddItemToArray(bindings, item);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
cJSON_AddItemToObject(root, "bindings", bindings);
|
|
cJSON* server_json = cJSON_CreateObject();
|
|
if (server_json != nullptr) {
|
|
#if defined(CONFIG_GATEWAY_BACNET_BRIDGE_SUPPORTED)
|
|
const auto server_status = GatewayBacnetServer::instance().status();
|
|
cJSON_AddBoolToObject(server_json, "started", server_status.started);
|
|
cJSON_AddNumberToObject(server_json, "deviceInstance", server_status.device_instance);
|
|
cJSON_AddNumberToObject(server_json, "udpPort", server_status.udp_port);
|
|
cJSON_AddNumberToObject(server_json, "channelCount",
|
|
static_cast<double>(server_status.channel_count));
|
|
cJSON_AddNumberToObject(server_json, "objectCount",
|
|
static_cast<double>(server_status.object_count));
|
|
#else
|
|
cJSON_AddBoolToObject(server_json, "started", false);
|
|
cJSON_AddNumberToObject(server_json, "deviceInstance", 0);
|
|
cJSON_AddNumberToObject(server_json, "udpPort", 0);
|
|
cJSON_AddNumberToObject(server_json, "channelCount", 0);
|
|
cJSON_AddNumberToObject(server_json, "objectCount", 0);
|
|
#endif
|
|
cJSON_AddItemToObject(root, "server", server_json);
|
|
}
|
|
return JsonOk(root);
|
|
}
|
|
|
|
GatewayBridgeHttpResponse cloudJson() const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddNumberToObject(root, "gatewayId", channel.gateway_id);
|
|
cJSON_AddBoolToObject(root, "configured", cloud_config_loaded);
|
|
cJSON_AddBoolToObject(root, "started", cloud_started);
|
|
cJSON_AddBoolToObject(root, "connected", cloud != nullptr && cloud->isConnected());
|
|
if (cloud_config.has_value()) {
|
|
cJSON_AddItemToObject(root, "config", GatewayCloudConfigToCjson(cloud_config.value()));
|
|
}
|
|
return JsonOk(root);
|
|
}
|
|
|
|
std::optional<bool> readGeneratedBoolPointLocked(const GatewayModbusPoint& point) {
|
|
if (!point.generated || !ValidShortAddress(point.short_address)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
const auto state = cache.daliAddressState(channel.gateway_id,
|
|
static_cast<uint8_t>(point.short_address));
|
|
switch (point.generated_kind) {
|
|
case GatewayModbusGeneratedKind::kShortDiscovered:
|
|
return discovery != nullptr;
|
|
case GatewayModbusGeneratedKind::kShortOnline:
|
|
return discovery != nullptr && discovery->online;
|
|
case GatewayModbusGeneratedKind::kShortSupportsDt1:
|
|
return discovery != nullptr && SnapshotHasDeviceType(discovery->discovery, 1);
|
|
case GatewayModbusGeneratedKind::kShortSupportsDt4:
|
|
return discovery != nullptr && SnapshotHasDeviceType(discovery->discovery, 4);
|
|
case GatewayModbusGeneratedKind::kShortSupportsDt5:
|
|
return discovery != nullptr && SnapshotHasDeviceType(discovery->discovery, 5);
|
|
case GatewayModbusGeneratedKind::kShortSupportsDt6:
|
|
return discovery != nullptr && SnapshotHasDeviceType(discovery->discovery, 6);
|
|
case GatewayModbusGeneratedKind::kShortSupportsDt8:
|
|
return discovery != nullptr && SnapshotHasDeviceType(discovery->discovery, 8);
|
|
case GatewayModbusGeneratedKind::kShortGroupMaskKnown:
|
|
return state.group_mask_known;
|
|
case GatewayModbusGeneratedKind::kShortActualLevelKnown:
|
|
return state.status.actual_level.has_value();
|
|
case GatewayModbusGeneratedKind::kShortSceneKnown:
|
|
return state.status.scene_id.has_value();
|
|
case GatewayModbusGeneratedKind::kShortSettingsKnown:
|
|
return state.settings.anyKnown();
|
|
case GatewayModbusGeneratedKind::kShortControlGearPresent:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "controlGearPresent");
|
|
case GatewayModbusGeneratedKind::kShortLampFailure:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "lampFailure");
|
|
case GatewayModbusGeneratedKind::kShortLampPowerOn:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "lampPowerOn");
|
|
case GatewayModbusGeneratedKind::kShortLimitError:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "limitError");
|
|
case GatewayModbusGeneratedKind::kShortFadingCompleted:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "fadingCompleted");
|
|
case GatewayModbusGeneratedKind::kShortResetState:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "resetState");
|
|
case GatewayModbusGeneratedKind::kShortMissingShortAddress:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "missingShortAddress");
|
|
case GatewayModbusGeneratedKind::kShortPowerSupplyFault:
|
|
return readSnapshotBoolLocked(point.short_address, "base_status", "powerSupplyFault");
|
|
case GatewayModbusGeneratedKind::kShortDiagnosticBit:
|
|
return readDiagnosticBoolPointLocked(point);
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
std::optional<uint16_t> readGeneratedRegisterPointLocked(const GatewayModbusPoint& point) {
|
|
if (!point.generated || !ValidShortAddress(point.short_address)) {
|
|
return std::nullopt;
|
|
}
|
|
|
|
const auto* discovery = findDiscoveryEntryLocked(point.short_address);
|
|
const auto state = cache.daliAddressState(channel.gateway_id,
|
|
static_cast<uint8_t>(point.short_address));
|
|
switch (point.generated_kind) {
|
|
case GatewayModbusGeneratedKind::kShortInventoryState:
|
|
if (discovery == nullptr) {
|
|
return 0;
|
|
}
|
|
return discovery->online ? 2 : 1;
|
|
case GatewayModbusGeneratedKind::kShortPrimaryType: {
|
|
if (discovery == nullptr) {
|
|
return kModbusUnknownRegister;
|
|
}
|
|
const auto primary = discovery->discovery.ints.find("primaryType");
|
|
return primary == discovery->discovery.ints.end()
|
|
? kModbusUnknownRegister
|
|
: static_cast<uint16_t>(primary->second);
|
|
}
|
|
case GatewayModbusGeneratedKind::kShortTypeMask:
|
|
return discovery == nullptr ? kModbusUnknownRegister : DeviceTypeMask(discovery->discovery);
|
|
case GatewayModbusGeneratedKind::kShortBrightness:
|
|
case GatewayModbusGeneratedKind::kShortActualLevel:
|
|
return state.status.actual_level.has_value()
|
|
? static_cast<uint16_t>(state.status.actual_level.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortSceneId:
|
|
return state.status.scene_id.has_value()
|
|
? static_cast<uint16_t>(state.status.scene_id.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortRawStatus: {
|
|
const auto snapshot = diagnosticSnapshotLocked(point.short_address, "base_status");
|
|
if (snapshot.has_value()) {
|
|
const auto raw_status = SnapshotIntValue(snapshot.value(), "rawStatus");
|
|
return raw_status.has_value() ? static_cast<uint16_t>(raw_status.value() & 0xFF)
|
|
: kModbusUnknownRegister;
|
|
}
|
|
return kModbusUnknownRegister;
|
|
}
|
|
case GatewayModbusGeneratedKind::kShortGroupMask:
|
|
return state.group_mask_known ? state.group_mask : kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortPowerOnLevel:
|
|
return state.settings.power_on_level.has_value()
|
|
? static_cast<uint16_t>(state.settings.power_on_level.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortSystemFailureLevel:
|
|
return state.settings.system_failure_level.has_value()
|
|
? static_cast<uint16_t>(state.settings.system_failure_level.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortMinLevel:
|
|
return state.settings.min_level.has_value()
|
|
? static_cast<uint16_t>(state.settings.min_level.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortMaxLevel:
|
|
return state.settings.max_level.has_value()
|
|
? static_cast<uint16_t>(state.settings.max_level.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortFadeTime:
|
|
return state.settings.fade_time.has_value()
|
|
? static_cast<uint16_t>(state.settings.fade_time.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortFadeRate:
|
|
return state.settings.fade_rate.has_value()
|
|
? static_cast<uint16_t>(state.settings.fade_rate.value())
|
|
: kModbusUnknownRegister;
|
|
case GatewayModbusGeneratedKind::kShortColorTemperature:
|
|
return kModbusUnknownRegister;
|
|
default:
|
|
return std::nullopt;
|
|
}
|
|
}
|
|
|
|
bool writeGeneratedCoilPointLocked(const GatewayModbusPoint& point, bool value) {
|
|
if (!point.generated || !ValidShortAddress(point.short_address)) {
|
|
return false;
|
|
}
|
|
if (!value) {
|
|
return true;
|
|
}
|
|
|
|
const uint8_t raw_command_address = RawCommandAddressFromDec(point.short_address);
|
|
bool sent = false;
|
|
uint8_t mirrored_command = 0;
|
|
switch (point.generated_kind) {
|
|
case GatewayModbusGeneratedKind::kShortOn:
|
|
case GatewayModbusGeneratedKind::kShortRecallMax:
|
|
sent = domain.on(channel.gateway_id, point.short_address);
|
|
mirrored_command = DALI_CMD_RECALL_MAX;
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortOff:
|
|
sent = domain.off(channel.gateway_id, point.short_address);
|
|
mirrored_command = DALI_CMD_OFF;
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortRecallMin:
|
|
sent = domain.sendRaw(channel.gateway_id, raw_command_address, DALI_CMD_RECALL_MIN);
|
|
mirrored_command = DALI_CMD_RECALL_MIN;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
if (sent) {
|
|
cache.mirrorDaliCommand(channel.gateway_id, raw_command_address, mirrored_command);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
bool writeGeneratedRegisterPointLocked(const GatewayModbusPoint& point, uint16_t value) {
|
|
if (!point.generated || !ValidShortAddress(point.short_address)) {
|
|
return false;
|
|
}
|
|
|
|
switch (point.generated_kind) {
|
|
case GatewayModbusGeneratedKind::kShortBrightness:
|
|
if (value > 254) {
|
|
return false;
|
|
}
|
|
if (domain.setBright(channel.gateway_id, point.short_address, value)) {
|
|
cache.mirrorDaliCommand(channel.gateway_id, RawArcAddressFromDec(point.short_address),
|
|
static_cast<uint8_t>(value));
|
|
return true;
|
|
}
|
|
return false;
|
|
case GatewayModbusGeneratedKind::kShortColorTemperature:
|
|
return domain.setColTemp(channel.gateway_id, point.short_address, value);
|
|
case GatewayModbusGeneratedKind::kShortGroupMask:
|
|
if (domain.applyGroupMask(channel.gateway_id, point.short_address, value)) {
|
|
cache.setDaliGroupMask(channel.gateway_id, static_cast<uint8_t>(point.short_address),
|
|
value);
|
|
return true;
|
|
}
|
|
return false;
|
|
case GatewayModbusGeneratedKind::kShortPowerOnLevel:
|
|
case GatewayModbusGeneratedKind::kShortSystemFailureLevel:
|
|
case GatewayModbusGeneratedKind::kShortMinLevel:
|
|
case GatewayModbusGeneratedKind::kShortMaxLevel:
|
|
case GatewayModbusGeneratedKind::kShortFadeTime:
|
|
case GatewayModbusGeneratedKind::kShortFadeRate: {
|
|
if (value > 255) {
|
|
return false;
|
|
}
|
|
auto current = cache.daliAddressState(channel.gateway_id,
|
|
static_cast<uint8_t>(point.short_address)).settings;
|
|
switch (point.generated_kind) {
|
|
case GatewayModbusGeneratedKind::kShortPowerOnLevel:
|
|
current.power_on_level = static_cast<uint8_t>(value);
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortSystemFailureLevel:
|
|
current.system_failure_level = static_cast<uint8_t>(value);
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortMinLevel:
|
|
current.min_level = static_cast<uint8_t>(value);
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortMaxLevel:
|
|
current.max_level = static_cast<uint8_t>(value);
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortFadeTime:
|
|
current.fade_time = static_cast<uint8_t>(value);
|
|
break;
|
|
case GatewayModbusGeneratedKind::kShortFadeRate:
|
|
current.fade_rate = static_cast<uint8_t>(value);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
DaliAddressSettingsSnapshot domain_settings;
|
|
domain_settings.power_on_level = current.power_on_level;
|
|
domain_settings.system_failure_level = current.system_failure_level;
|
|
domain_settings.min_level = current.min_level;
|
|
domain_settings.max_level = current.max_level;
|
|
domain_settings.fade_time = current.fade_time;
|
|
domain_settings.fade_rate = current.fade_rate;
|
|
if (domain.applyAddressSettings(channel.gateway_id, point.short_address, domain_settings)) {
|
|
cache.setDaliSettings(channel.gateway_id, static_cast<uint8_t>(point.short_address),
|
|
current);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
std::optional<bool> readModbusBoolPoint(GatewayModbusSpace space, uint16_t address) {
|
|
LockGuard guard(lock);
|
|
if (modbus == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto point = modbus->findPoint(space, address);
|
|
if (!point.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
if (point->generated) {
|
|
return readGeneratedBoolPointLocked(point.value()).value_or(false);
|
|
}
|
|
const DaliBridgeResult result = modbus->readModelPoint(point.value());
|
|
if (!result.ok || !result.data.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
if (point->bit_index.has_value() && point->bit_index.value() >= 0 &&
|
|
point->bit_index.value() < 16) {
|
|
return (result.data.value() & (1 << point->bit_index.value())) != 0;
|
|
}
|
|
return result.data.value() != 0;
|
|
}
|
|
|
|
std::optional<uint16_t> readModbusRegisterPoint(GatewayModbusSpace space, uint16_t address) {
|
|
LockGuard guard(lock);
|
|
if (modbus == nullptr) {
|
|
return std::nullopt;
|
|
}
|
|
const auto point = modbus->findPoint(space, address);
|
|
if (!point.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
if (point->generated) {
|
|
return readGeneratedRegisterPointLocked(point.value()).value_or(kModbusUnknownRegister);
|
|
}
|
|
const DaliBridgeResult result = modbus->readModelPoint(point.value());
|
|
if (!result.ok || !result.data.has_value()) {
|
|
return std::nullopt;
|
|
}
|
|
return static_cast<uint16_t>(result.data.value() & 0xFFFF);
|
|
}
|
|
|
|
bool writeModbusCoilPoint(uint16_t address, bool value) {
|
|
LockGuard guard(lock);
|
|
if (modbus == nullptr) {
|
|
return false;
|
|
}
|
|
const auto point = modbus->findPoint(GatewayModbusSpace::kCoil, address);
|
|
if (!point.has_value()) {
|
|
return false;
|
|
}
|
|
if (point->generated) {
|
|
return writeGeneratedCoilPointLocked(point.value(), value);
|
|
}
|
|
const DaliBridgeResult result = modbus->writeCoilPoint(point.value(), value);
|
|
return result.ok;
|
|
}
|
|
|
|
bool writeModbusRegisterPoint(uint16_t address, uint16_t value) {
|
|
LockGuard guard(lock);
|
|
if (modbus == nullptr) {
|
|
return false;
|
|
}
|
|
const auto point = modbus->findPoint(GatewayModbusSpace::kHoldingRegister, address);
|
|
if (!point.has_value()) {
|
|
return false;
|
|
}
|
|
if (point->generated) {
|
|
return writeGeneratedRegisterPointLocked(point.value(), value);
|
|
}
|
|
const DaliBridgeResult result = modbus->writeRegisterPoint(point.value(), value);
|
|
return result.ok;
|
|
}
|
|
|
|
std::optional<GatewayModbusConfig> activeModbusConfigLocked() const {
|
|
if (modbus_config.has_value()) {
|
|
return modbus_config;
|
|
}
|
|
return service_config.default_modbus_config;
|
|
}
|
|
|
|
std::optional<GatewayModbusConfig> activeModbusConfig() const {
|
|
LockGuard guard(lock);
|
|
return activeModbusConfigLocked();
|
|
}
|
|
|
|
bool isReservedUartLocked(int uart_port) const {
|
|
return std::find(service_config.reserved_uart_ports.begin(),
|
|
service_config.reserved_uart_ports.end(), uart_port) !=
|
|
service_config.reserved_uart_ports.end();
|
|
}
|
|
|
|
esp_err_t validateSerialModbusConfigLocked(
|
|
const GatewayModbusConfig& config,
|
|
const std::optional<GatewayKnxConfig>& candidate_knx,
|
|
std::string* error_message = nullptr) const {
|
|
const int uart_port = config.serial.uart_port;
|
|
if (uart_port < 0 || uart_port > 2) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "Modbus serial UART port must be 0, 1, or 2";
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
if (uart_port == 0 && !service_config.allow_modbus_uart0) {
|
|
if (error_message != nullptr) {
|
|
*error_message =
|
|
"Modbus serial on UART0 requires moving the ESP-IDF console and UART0 control off UART0";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (isReservedUartLocked(uart_port)) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "Modbus serial UART" + std::to_string(uart_port) +
|
|
" is already reserved by a DALI serial PHY";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (service_config.knx_enabled && candidate_knx.has_value() &&
|
|
candidate_knx->ip_router_enabled && candidate_knx->tp_uart.uart_port == uart_port) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "Modbus serial UART" + std::to_string(uart_port) +
|
|
" conflicts with KNX TP-UART; choose another free UART for RS485";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t validateKnxConfigLocked(const GatewayKnxConfig& config,
|
|
const std::optional<GatewayModbusConfig>& candidate_modbus,
|
|
std::string* error_message = nullptr) const {
|
|
if (!config.ip_router_enabled) {
|
|
return ESP_OK;
|
|
}
|
|
const int uart_port = config.tp_uart.uart_port;
|
|
if (uart_port < 0 || uart_port > 2) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "KNX TP-UART port must be 0, 1, or 2";
|
|
}
|
|
return ESP_ERR_INVALID_ARG;
|
|
}
|
|
if (uart_port == 0 && !service_config.allow_knx_uart0) {
|
|
if (error_message != nullptr) {
|
|
*error_message =
|
|
"KNX TP-UART on UART0 requires moving the ESP-IDF console and UART0 control off UART0";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (isReservedUartLocked(uart_port)) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "KNX TP-UART UART" + std::to_string(uart_port) +
|
|
" is already reserved by a DALI serial PHY";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (service_config.modbus_enabled && candidate_modbus.has_value() &&
|
|
GatewayModbusTransportIsSerial(candidate_modbus->transport) &&
|
|
candidate_modbus->serial.uart_port == uart_port) {
|
|
if (error_message != nullptr) {
|
|
*error_message = "KNX TP-UART UART" + std::to_string(uart_port) +
|
|
" conflicts with Modbus serial UART";
|
|
}
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t validateStoredBridgeConfigLocked(const GatewayBridgeStoredConfig& config) {
|
|
const auto candidate_modbus = config.modbus.has_value() ? config.modbus
|
|
: service_config.default_modbus_config;
|
|
const auto candidate_knx = config.knx.has_value() ? config.knx
|
|
: service_config.default_knx_config;
|
|
std::string validation_error;
|
|
if (candidate_modbus.has_value() &&
|
|
GatewayModbusTransportIsSerial(candidate_modbus->transport)) {
|
|
const esp_err_t err = validateSerialModbusConfigLocked(
|
|
candidate_modbus.value(), candidate_knx, &validation_error);
|
|
if (err != ESP_OK) {
|
|
modbus_last_error = validation_error;
|
|
return err;
|
|
}
|
|
}
|
|
if (candidate_knx.has_value()) {
|
|
const esp_err_t err = validateKnxConfigLocked(candidate_knx.value(), candidate_modbus,
|
|
&validation_error);
|
|
if (err != ESP_OK) {
|
|
knx_last_error = validation_error;
|
|
return err;
|
|
}
|
|
}
|
|
modbus_last_error.clear();
|
|
knx_last_error.clear();
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t saveModbusConfig(const GatewayModbusConfig& config) {
|
|
LockGuard guard(lock);
|
|
if (GatewayModbusTransportIsSerial(config.transport)) {
|
|
std::string validation_error;
|
|
const esp_err_t validation_err = validateSerialModbusConfigLocked(
|
|
config, activeKnxConfigLocked(), &validation_error);
|
|
if (validation_err != ESP_OK) {
|
|
modbus_last_error = validation_error;
|
|
return validation_err;
|
|
}
|
|
}
|
|
BridgeProvisioningStore store(bridgeNamespace());
|
|
const esp_err_t err = store.saveObject(
|
|
kBridgeConfigKey,
|
|
GatewayBridgeStoredConfigToValue(bridge_config, config, knx_config,
|
|
bacnet_server_config));
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
modbus_config = config;
|
|
bridge_config_loaded = true;
|
|
if (modbus != nullptr) {
|
|
modbus->setConfig(config);
|
|
}
|
|
modbus_last_error.clear();
|
|
return ESP_OK;
|
|
}
|
|
|
|
std::optional<GatewayKnxConfig> activeKnxConfigLocked() const {
|
|
if (knx_config.has_value()) {
|
|
return knx_config;
|
|
}
|
|
return service_config.default_knx_config;
|
|
}
|
|
|
|
esp_err_t saveKnxConfig(const GatewayKnxConfig& config,
|
|
std::set<uint16_t>* used_ports = nullptr,
|
|
std::set<int>* used_uarts = nullptr) {
|
|
LockGuard guard(lock);
|
|
std::string validation_error;
|
|
const esp_err_t validation_err = validateKnxConfigLocked(
|
|
config, activeModbusConfigLocked(), &validation_error);
|
|
if (validation_err != ESP_OK) {
|
|
knx_last_error = validation_error;
|
|
return validation_err;
|
|
}
|
|
const bool restart_router = knx_started || (knx_router != nullptr && knx_router->started());
|
|
if (restart_router && config.ip_router_enabled && used_ports != nullptr &&
|
|
used_ports->find(config.udp_port) != used_ports->end()) {
|
|
knx_last_error = "duplicate KNXnet/IP UDP port " + std::to_string(config.udp_port);
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (restart_router && config.ip_router_enabled && used_uarts != nullptr &&
|
|
used_uarts->find(config.tp_uart.uart_port) != used_uarts->end()) {
|
|
knx_last_error = "KNX TP-UART UART" + std::to_string(config.tp_uart.uart_port) +
|
|
" is already used by another runtime";
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
if (restart_router && knx_router != nullptr) {
|
|
knx_router->stop();
|
|
knx_started = false;
|
|
}
|
|
BridgeProvisioningStore store(bridgeNamespace());
|
|
const esp_err_t err = store.saveObject(
|
|
kBridgeConfigKey,
|
|
GatewayBridgeStoredConfigToValue(bridge_config, modbus_config, config,
|
|
bacnet_server_config));
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
knx_config = config;
|
|
bridge_config_loaded = true;
|
|
if (knx != nullptr) {
|
|
knx->setConfig(config);
|
|
}
|
|
if (knx_router != nullptr) {
|
|
knx_router->setConfig(config);
|
|
}
|
|
if (restart_router) {
|
|
return startKnx(used_ports, used_uarts);
|
|
}
|
|
knx_last_error.clear();
|
|
return ESP_OK;
|
|
}
|
|
|
|
std::vector<uint8_t> processModbusPdu(const GatewayModbusConfig& config,
|
|
uint8_t unit_id,
|
|
const std::vector<uint8_t>& pdu) {
|
|
if (pdu.empty()) {
|
|
return {};
|
|
}
|
|
if (config.unit_id != 0 && unit_id != config.unit_id) {
|
|
return ModbusExceptionPdu(pdu[0], 0x0B);
|
|
}
|
|
|
|
if ((pdu[0] == 0x01 || pdu[0] == 0x02) && pdu.size() == 5) {
|
|
const auto space = GatewayModbusReadSpaceForFunction(pdu[0]);
|
|
const uint16_t start_address = ReadBe16(&pdu[1]);
|
|
const uint16_t quantity = ReadBe16(&pdu[3]);
|
|
if (!space.has_value() || quantity == 0 || quantity > kGatewayModbusMaxReadBits) {
|
|
return ModbusExceptionPdu(pdu[0], 0x03);
|
|
}
|
|
const uint8_t byte_count = static_cast<uint8_t>((quantity + 7U) / 8U);
|
|
std::vector<uint8_t> response(2 + byte_count, 0);
|
|
response[0] = pdu[0];
|
|
response[1] = byte_count;
|
|
for (uint16_t index = 0; index < quantity; ++index) {
|
|
const auto human_address = static_cast<uint16_t>(
|
|
GatewayModbusHumanAddressFromWire(space.value(), start_address + index));
|
|
const auto value = readModbusBoolPoint(space.value(), human_address);
|
|
if (!value.has_value()) {
|
|
return ModbusExceptionPdu(pdu[0], 0x02);
|
|
}
|
|
if (value.value()) {
|
|
response[2 + (index / 8)] |= static_cast<uint8_t>(1U << (index % 8));
|
|
}
|
|
}
|
|
return response;
|
|
}
|
|
|
|
if ((pdu[0] == 0x03 || pdu[0] == 0x04) && pdu.size() == 5) {
|
|
const auto space = GatewayModbusReadSpaceForFunction(pdu[0]);
|
|
const uint16_t start_address = ReadBe16(&pdu[1]);
|
|
const uint16_t quantity = ReadBe16(&pdu[3]);
|
|
if (!space.has_value() || quantity == 0 || quantity > kGatewayModbusMaxReadRegisters) {
|
|
return ModbusExceptionPdu(pdu[0], 0x03);
|
|
}
|
|
std::vector<uint8_t> response(2 + quantity * 2);
|
|
response[0] = pdu[0];
|
|
response[1] = static_cast<uint8_t>(quantity * 2);
|
|
for (uint16_t index = 0; index < quantity; ++index) {
|
|
const auto human_address = static_cast<uint16_t>(
|
|
GatewayModbusHumanAddressFromWire(space.value(), start_address + index));
|
|
const auto value = readModbusRegisterPoint(space.value(), human_address);
|
|
if (!value.has_value()) {
|
|
return ModbusExceptionPdu(pdu[0], 0x02);
|
|
}
|
|
WriteBe16(&response[2 + index * 2], value.value());
|
|
}
|
|
return response;
|
|
}
|
|
|
|
if (pdu[0] == 0x05 && pdu.size() == 5) {
|
|
const uint16_t wire_address = ReadBe16(&pdu[1]);
|
|
const uint16_t raw_value = ReadBe16(&pdu[3]);
|
|
if (raw_value != 0x0000 && raw_value != 0xFF00) {
|
|
return ModbusExceptionPdu(pdu[0], 0x03);
|
|
}
|
|
const auto coil = static_cast<uint16_t>(GatewayModbusHumanAddressFromWire(
|
|
GatewayModbusSpace::kCoil, wire_address));
|
|
if (!writeModbusCoilPoint(coil, raw_value == 0xFF00)) {
|
|
return ModbusExceptionPdu(pdu[0], 0x04);
|
|
}
|
|
return pdu;
|
|
}
|
|
|
|
if (pdu[0] == 0x06 && pdu.size() == 5) {
|
|
const uint16_t wire_register = ReadBe16(&pdu[1]);
|
|
const uint16_t value = ReadBe16(&pdu[3]);
|
|
const auto holding_register = static_cast<uint16_t>(GatewayModbusHumanAddressFromWire(
|
|
GatewayModbusSpace::kHoldingRegister, wire_register));
|
|
if (!writeModbusRegisterPoint(holding_register, value)) {
|
|
return ModbusExceptionPdu(pdu[0], 0x04);
|
|
}
|
|
return pdu;
|
|
}
|
|
|
|
if (pdu[0] == 0x0F && pdu.size() >= 6) {
|
|
const uint16_t start_address = ReadBe16(&pdu[1]);
|
|
const uint16_t quantity = ReadBe16(&pdu[3]);
|
|
const uint8_t byte_count = pdu[5];
|
|
if (quantity == 0 || quantity > kGatewayModbusMaxWriteBits ||
|
|
pdu.size() != static_cast<size_t>(6 + byte_count) ||
|
|
byte_count != static_cast<uint8_t>((quantity + 7U) / 8U)) {
|
|
return ModbusExceptionPdu(pdu[0], 0x03);
|
|
}
|
|
for (uint16_t index = 0; index < quantity; ++index) {
|
|
const bool value = (pdu[6 + (index / 8)] & (1U << (index % 8))) != 0;
|
|
const auto coil = static_cast<uint16_t>(GatewayModbusHumanAddressFromWire(
|
|
GatewayModbusSpace::kCoil, start_address + index));
|
|
if (!writeModbusCoilPoint(coil, value)) {
|
|
return ModbusExceptionPdu(pdu[0], 0x04);
|
|
}
|
|
}
|
|
std::vector<uint8_t> response(5);
|
|
response[0] = pdu[0];
|
|
WriteBe16(&response[1], start_address);
|
|
WriteBe16(&response[3], quantity);
|
|
return response;
|
|
}
|
|
|
|
if (pdu[0] == 0x10 && pdu.size() >= 6) {
|
|
const uint16_t start_register = ReadBe16(&pdu[1]);
|
|
const uint16_t quantity = ReadBe16(&pdu[3]);
|
|
const uint8_t byte_count = pdu[5];
|
|
if (quantity == 0 || quantity > kGatewayModbusMaxWriteRegisters ||
|
|
pdu.size() != static_cast<size_t>(6 + byte_count) || byte_count != quantity * 2) {
|
|
return ModbusExceptionPdu(pdu[0], 0x03);
|
|
}
|
|
for (uint16_t index = 0; index < quantity; ++index) {
|
|
const size_t offset = 6 + (index * 2);
|
|
const uint16_t value = ReadBe16(&pdu[offset]);
|
|
const auto holding_register = static_cast<uint16_t>(GatewayModbusHumanAddressFromWire(
|
|
GatewayModbusSpace::kHoldingRegister, start_register + index));
|
|
if (!writeModbusRegisterPoint(holding_register, value)) {
|
|
return ModbusExceptionPdu(pdu[0], 0x04);
|
|
}
|
|
}
|
|
std::vector<uint8_t> response(5);
|
|
response[0] = pdu[0];
|
|
WriteBe16(&response[1], start_register);
|
|
WriteBe16(&response[3], quantity);
|
|
return response;
|
|
}
|
|
|
|
return ModbusExceptionPdu(pdu[0], 0x01);
|
|
}
|
|
|
|
esp_err_t startModbus(std::set<uint16_t>* used_ports = nullptr,
|
|
std::set<int>* used_uarts = nullptr) {
|
|
LockGuard guard(lock);
|
|
if (!service_config.modbus_enabled) {
|
|
return ESP_ERR_NOT_SUPPORTED;
|
|
}
|
|
if (modbus_started || modbus_task_handle != nullptr) {
|
|
return ESP_OK;
|
|
}
|
|
const auto config = activeModbusConfigLocked();
|
|
if (!config.has_value()) {
|
|
return ESP_ERR_NOT_FOUND;
|
|
}
|
|
if (GatewayModbusTransportIsSerial(config->transport)) {
|
|
std::string validation_error;
|
|
const esp_err_t serial_err = validateSerialModbusConfigLocked(
|
|
config.value(), activeKnxConfigLocked(), &validation_error);
|
|
if (serial_err != ESP_OK) {
|
|
modbus_last_error = validation_error;
|
|
return serial_err;
|
|
}
|
|
if (used_uarts != nullptr) {
|
|
const int uart_port = config->serial.uart_port;
|
|
if (used_uarts->find(uart_port) != used_uarts->end()) {
|
|
modbus_last_error = "Modbus serial UART" + std::to_string(uart_port) +
|
|
" is already used by another runtime";
|
|
ESP_LOGW(kTag, "gateway=%u skips duplicate Modbus serial UART%d", channel.gateway_id,
|
|
uart_port);
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
used_uarts->insert(uart_port);
|
|
}
|
|
}
|
|
const uint16_t port = config->port == 0 ? kGatewayModbusDefaultTcpPort : config->port;
|
|
if (GatewayModbusTransportIsTcp(config->transport) && used_ports != nullptr) {
|
|
if (used_ports->find(port) != used_ports->end()) {
|
|
modbus_last_error = "duplicate Modbus TCP port " + std::to_string(port);
|
|
ESP_LOGW(kTag, "gateway=%u skips duplicate Modbus TCP port %u", channel.gateway_id, port);
|
|
return ESP_ERR_INVALID_STATE;
|
|
}
|
|
used_ports->insert(port);
|
|
}
|
|
modbus_stop_requested = false;
|
|
modbus_restart_requested = false;
|
|
modbus_last_error.clear();
|
|
const char* task_name = GatewayModbusTransportIsTcp(config->transport)
|
|
? "gw_modbus_tcp"
|
|
: (GatewayModbusTransportIsAscii(config->transport)
|
|
? "gw_modbus_ascii"
|
|
: "gw_modbus_rtu");
|
|
const BaseType_t created = xTaskCreate(&ChannelRuntime::ModbusTaskEntry, task_name,
|
|
service_config.modbus_task_stack_size, this,
|
|
service_config.modbus_task_priority,
|
|
&modbus_task_handle);
|
|
if (created != pdPASS) {
|
|
modbus_task_handle = nullptr;
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
modbus_started = true;
|
|
return ESP_OK;
|
|
}
|
|
|
|
esp_err_t stopModbus() {
|
|
LockGuard guard(lock);
|
|
if (!modbus_started && modbus_task_handle == nullptr) {
|
|
return ESP_OK;
|
|
}
|
|
modbus_stop_requested = true;
|
|
modbus_restart_requested = false;
|
|
if (modbus_client_sock >= 0) {
|
|
shutdown(modbus_client_sock, SHUT_RDWR);
|
|
}
|
|
if (modbus_listen_sock >= 0) {
|
|
shutdown(modbus_listen_sock, SHUT_RDWR);
|
|
}
|
|
return ESP_OK;
|
|
}
|
|
|
|
void modbusTaskLoop() {
|
|
const auto config = activeModbusConfig();
|
|
if (!config.has_value()) {
|
|
modbus_last_error = "missing Modbus config";
|
|
finishModbusTask();
|
|
return;
|
|
}
|
|
if (GatewayModbusTransportIsTcp(config->transport)) {
|
|
modbusTcpTaskLoop(config.value());
|
|
} else if (GatewayModbusTransportIsSerial(config->transport)) {
|
|
modbusSerialTaskLoop(config.value());
|
|
} else {
|
|
modbus_last_error = "unsupported Modbus transport";
|
|
ESP_LOGE(kTag, "gateway=%u unsupported Modbus transport %s", channel.gateway_id,
|
|
config->transport.c_str());
|
|
}
|
|
finishModbusTask();
|
|
}
|
|
|
|
void finishModbusTask() {
|
|
const bool restart = modbus_restart_requested.exchange(false);
|
|
{
|
|
LockGuard guard(lock);
|
|
modbus_started = false;
|
|
modbus_task_handle = nullptr;
|
|
modbus_stop_requested = false;
|
|
modbus_listen_sock = -1;
|
|
modbus_client_sock = -1;
|
|
modbus_uart_port = -1;
|
|
}
|
|
if (restart) {
|
|
startModbus();
|
|
}
|
|
vTaskDelete(nullptr);
|
|
}
|
|
|
|
void modbusTcpTaskLoop(const GatewayModbusConfig& config) {
|
|
const uint16_t port = config.port != 0 ? config.port : kGatewayModbusDefaultTcpPort;
|
|
const int listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
|
|
if (listen_sock < 0) {
|
|
ESP_LOGE(kTag, "gateway=%u failed to create Modbus socket", channel.gateway_id);
|
|
modbus_last_error = "failed to create Modbus TCP socket";
|
|
return;
|
|
}
|
|
modbus_listen_sock = listen_sock;
|
|
|
|
int reuse = 1;
|
|
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
|
|
timeval timeout{};
|
|
timeout.tv_sec = 1;
|
|
timeout.tv_usec = 0;
|
|
setsockopt(listen_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
|
|
|
|
sockaddr_in address = {};
|
|
address.sin_family = AF_INET;
|
|
address.sin_addr.s_addr = htonl(INADDR_ANY);
|
|
address.sin_port = htons(port);
|
|
|
|
if (bind(listen_sock, reinterpret_cast<sockaddr*>(&address), sizeof(address)) != 0 ||
|
|
listen(listen_sock, 2) != 0) {
|
|
ESP_LOGE(kTag, "gateway=%u failed to bind Modbus TCP port %u", channel.gateway_id, port);
|
|
modbus_last_error = "failed to bind Modbus TCP port";
|
|
close(listen_sock);
|
|
return;
|
|
}
|
|
|
|
ESP_LOGI(kTag, "gateway=%u Modbus TCP listening on port %u", channel.gateway_id, port);
|
|
while (!modbus_stop_requested) {
|
|
sockaddr_in client_address = {};
|
|
socklen_t client_len = sizeof(client_address);
|
|
const int client_sock = accept(listen_sock, reinterpret_cast<sockaddr*>(&client_address),
|
|
&client_len);
|
|
if (client_sock < 0) {
|
|
continue;
|
|
}
|
|
setsockopt(client_sock, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));
|
|
modbus_client_sock = client_sock;
|
|
handleModbusClient(config, client_sock);
|
|
modbus_client_sock = -1;
|
|
close(client_sock);
|
|
}
|
|
close(listen_sock);
|
|
modbus_listen_sock = -1;
|
|
}
|
|
|
|
void handleModbusClient(const GatewayModbusConfig& config, int client_sock) {
|
|
uint8_t header[7] = {};
|
|
while (!modbus_stop_requested && RecvAll(client_sock, header, sizeof(header))) {
|
|
const uint16_t protocol_id = ReadBe16(&header[2]);
|
|
const uint16_t length = ReadBe16(&header[4]);
|
|
if (protocol_id != 0 || length < 2 || length > kGatewayModbusMaxPduBytes) {
|
|
break;
|
|
}
|
|
|
|
std::vector<uint8_t> pdu(length - 1);
|
|
if (!RecvAll(client_sock, pdu.data(), pdu.size()) || pdu.empty()) {
|
|
break;
|
|
}
|
|
SendModbusFrame(client_sock, header, processModbusPdu(config, header[6], pdu));
|
|
}
|
|
}
|
|
|
|
esp_err_t installSerialModbus(const GatewayModbusConfig& config) {
|
|
const auto uart_port = static_cast<uart_port_t>(config.serial.uart_port);
|
|
uart_config_t uart_config{};
|
|
uart_config.baud_rate = static_cast<int>(config.serial.baudrate);
|
|
uart_config.data_bits = UartWordLength(config.serial.data_bits);
|
|
uart_config.parity = UartParity(config.serial.parity);
|
|
uart_config.stop_bits = UartStopBits(config.serial.stop_bits);
|
|
uart_config.flow_ctrl = UART_HW_FLOWCTRL_DISABLE;
|
|
uart_config.source_clk = UART_SCLK_DEFAULT;
|
|
|
|
esp_err_t err = uart_param_config(uart_port, &uart_config);
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
const int rts_pin = config.serial.rs485.enabled ? config.serial.rs485.de_pin
|
|
: UART_PIN_NO_CHANGE;
|
|
err = uart_set_pin(uart_port, config.serial.tx_pin, config.serial.rx_pin, rts_pin,
|
|
UART_PIN_NO_CHANGE);
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
err = uart_driver_install(uart_port, static_cast<int>(config.serial.rx_buffer_size),
|
|
static_cast<int>(config.serial.tx_buffer_size), 0, nullptr, 0);
|
|
if (err != ESP_OK) {
|
|
return err;
|
|
}
|
|
if (config.serial.rs485.enabled) {
|
|
err = uart_set_mode(uart_port, UART_MODE_RS485_HALF_DUPLEX);
|
|
if (err != ESP_OK) {
|
|
uart_driver_delete(uart_port);
|
|
return err;
|
|
}
|
|
}
|
|
modbus_uart_port = config.serial.uart_port;
|
|
return ESP_OK;
|
|
}
|
|
|
|
void modbusSerialTaskLoop(const GatewayModbusConfig& config) {
|
|
const esp_err_t err = installSerialModbus(config);
|
|
if (err != ESP_OK) {
|
|
modbus_last_error = "failed to install Modbus serial UART";
|
|
ESP_LOGE(kTag, "gateway=%u failed to install Modbus serial UART%d: %s",
|
|
channel.gateway_id, config.serial.uart_port, esp_err_to_name(err));
|
|
return;
|
|
}
|
|
ESP_LOGI(kTag, "gateway=%u Modbus %s listening on UART%d baud=%lu", channel.gateway_id,
|
|
GatewayModbusTransportIsAscii(config.transport) ? "ASCII" : "RTU",
|
|
config.serial.uart_port, static_cast<unsigned long>(config.serial.baudrate));
|
|
if (GatewayModbusTransportIsAscii(config.transport)) {
|
|
modbusAsciiTaskLoop(config);
|
|
} else {
|
|
modbusRtuTaskLoop(config);
|
|
}
|
|
uart_driver_delete(static_cast<uart_port_t>(config.serial.uart_port));
|
|
}
|
|
|
|
void modbusRtuTaskLoop(const GatewayModbusConfig& config) {
|
|
const auto uart_port = static_cast<uart_port_t>(config.serial.uart_port);
|
|
std::vector<uint8_t> frame;
|
|
std::array<uint8_t, 128> read_buffer{};
|
|
const TickType_t timeout = pdMS_TO_TICKS(config.serial.response_timeout_ms);
|
|
while (!modbus_stop_requested) {
|
|
const int read_len = uart_read_bytes(uart_port, read_buffer.data(), read_buffer.size(), timeout);
|
|
if (read_len > 0) {
|
|
frame.insert(frame.end(), read_buffer.begin(), read_buffer.begin() + read_len);
|
|
if (!frame.empty() && frame.front() == '@' &&
|
|
std::find(frame.begin(), frame.end(), '\n') != frame.end()) {
|
|
const std::string line(frame.begin(), frame.end());
|
|
handleModbusManagementLine(config.serial.uart_port, line);
|
|
frame.clear();
|
|
} else if (frame.size() > 512) {
|
|
frame.clear();
|
|
}
|
|
continue;
|
|
}
|
|
if (frame.empty() || frame.front() == '@') {
|
|
continue;
|
|
}
|
|
handleModbusRtuFrame(config, frame);
|
|
frame.clear();
|
|
}
|
|
}
|
|
|
|
void handleModbusRtuFrame(const GatewayModbusConfig& config, const std::vector<uint8_t>& frame) {
|
|
if (frame.size() < 4) {
|
|
return;
|
|
}
|
|
const uint16_t received_crc = static_cast<uint16_t>(frame[frame.size() - 2] |
|
|
(frame[frame.size() - 1] << 8));
|
|
if (ModbusCrc16(frame.data(), frame.size() - 2) != received_crc) {
|
|
return;
|
|
}
|
|
const uint8_t unit_id = frame[0];
|
|
if (unit_id == 0) {
|
|
return;
|
|
}
|
|
const std::vector<uint8_t> pdu(frame.begin() + 1, frame.end() - 2);
|
|
const auto response_pdu = processModbusPdu(config, unit_id, pdu);
|
|
if (response_pdu.empty()) {
|
|
return;
|
|
}
|
|
std::vector<uint8_t> response;
|
|
response.reserve(1 + response_pdu.size() + 2);
|
|
response.push_back(unit_id);
|
|
response.insert(response.end(), response_pdu.begin(), response_pdu.end());
|
|
const uint16_t crc = ModbusCrc16(response.data(), response.size());
|
|
response.push_back(static_cast<uint8_t>(crc & 0xFF));
|
|
response.push_back(static_cast<uint8_t>((crc >> 8) & 0xFF));
|
|
uart_write_bytes(static_cast<uart_port_t>(config.serial.uart_port), response.data(),
|
|
response.size());
|
|
}
|
|
|
|
void modbusAsciiTaskLoop(const GatewayModbusConfig& config) {
|
|
const auto uart_port = static_cast<uart_port_t>(config.serial.uart_port);
|
|
std::string line;
|
|
std::array<uint8_t, 128> read_buffer{};
|
|
const TickType_t timeout = pdMS_TO_TICKS(config.serial.response_timeout_ms);
|
|
while (!modbus_stop_requested) {
|
|
const int read_len = uart_read_bytes(uart_port, read_buffer.data(), read_buffer.size(), timeout);
|
|
if (read_len <= 0) {
|
|
continue;
|
|
}
|
|
for (int i = 0; i < read_len; ++i) {
|
|
const char ch = static_cast<char>(read_buffer[i]);
|
|
if (line.empty()) {
|
|
if (ch != ':' && ch != '@') {
|
|
continue;
|
|
}
|
|
}
|
|
line.push_back(ch);
|
|
if (ch == '\n') {
|
|
if (LineStartsWith(line, kModbusManagementPrefix)) {
|
|
handleModbusManagementLine(config.serial.uart_port, line);
|
|
} else if (!line.empty() && line.front() == ':') {
|
|
handleModbusAsciiFrame(config, line);
|
|
}
|
|
line.clear();
|
|
} else if (line.size() > 1024) {
|
|
line.clear();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void handleModbusAsciiFrame(const GatewayModbusConfig& config, std::string_view line) {
|
|
const auto decoded = DecodeModbusAsciiLine(line);
|
|
if (!decoded.has_value() || decoded->size() < 4) {
|
|
return;
|
|
}
|
|
const uint8_t unit_id = decoded->front();
|
|
if (unit_id == 0) {
|
|
return;
|
|
}
|
|
const std::vector<uint8_t> pdu(decoded->begin() + 1, decoded->end() - 1);
|
|
const auto response_pdu = processModbusPdu(config, unit_id, pdu);
|
|
if (response_pdu.empty()) {
|
|
return;
|
|
}
|
|
std::vector<uint8_t> response;
|
|
response.reserve(1 + response_pdu.size() + 1);
|
|
response.push_back(unit_id);
|
|
response.insert(response.end(), response_pdu.begin(), response_pdu.end());
|
|
response.push_back(ModbusAsciiLrc(response.data(), response.size()));
|
|
const std::string encoded = EncodeModbusAsciiLine(response);
|
|
uart_write_bytes(static_cast<uart_port_t>(config.serial.uart_port), encoded.data(),
|
|
encoded.size());
|
|
}
|
|
|
|
void handleModbusManagementLine(int uart_port, std::string_view line) {
|
|
while (!line.empty() && (line.back() == '\r' || line.back() == '\n')) {
|
|
line.remove_suffix(1);
|
|
}
|
|
if (!LineStartsWith(line, kModbusManagementPrefix)) {
|
|
return;
|
|
}
|
|
line.remove_prefix(std::char_traits<char>::length(kModbusManagementPrefix));
|
|
while (!line.empty() && line.front() == ' ') {
|
|
line.remove_prefix(1);
|
|
}
|
|
cJSON* root = line.empty() ? cJSON_CreateObject() : cJSON_ParseWithLength(line.data(), line.size());
|
|
if (root == nullptr || !cJSON_IsObject(root)) {
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, false, "unknown", "invalid JSON");
|
|
return;
|
|
}
|
|
const auto gateway_id = JsonGatewayId(root);
|
|
if (gateway_id.has_value() && gateway_id.value() != channel.gateway_id) {
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, false, "unknown", "gateway id mismatch");
|
|
return;
|
|
}
|
|
const char* action_raw = JsonString(root, "action");
|
|
const std::string action = action_raw == nullptr ? "modbus_status" : action_raw;
|
|
if (action == "modbus_config") {
|
|
const cJSON* modbus_node = cJSON_GetObjectItemCaseSensitive(root, "modbus");
|
|
if (modbus_node == nullptr) {
|
|
modbus_node = root;
|
|
}
|
|
const DaliValue modbus_value = FromCjson(modbus_node);
|
|
const auto parsed = GatewayModbusConfigFromValue(&modbus_value);
|
|
if (!parsed.has_value()) {
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, false, action.c_str(), "invalid modbus config");
|
|
return;
|
|
}
|
|
const esp_err_t err = saveModbusConfig(parsed.value());
|
|
cJSON_Delete(root);
|
|
if (err != ESP_OK) {
|
|
writeModbusManagementResponse(
|
|
uart_port, false, action.c_str(),
|
|
modbus_last_error.empty() ? esp_err_to_name(err) : modbus_last_error.c_str());
|
|
return;
|
|
}
|
|
writeModbusManagementResponse(uart_port, true, action.c_str(), nullptr);
|
|
modbus_restart_requested = true;
|
|
modbus_stop_requested = true;
|
|
return;
|
|
}
|
|
if (action == "modbus_stop") {
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, true, action.c_str(), nullptr);
|
|
modbus_stop_requested = true;
|
|
return;
|
|
}
|
|
if (action == "modbus_start" || action == "modbus_status") {
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, true, action.c_str(), nullptr);
|
|
return;
|
|
}
|
|
cJSON_Delete(root);
|
|
writeModbusManagementResponse(uart_port, false, action.c_str(), "unknown action");
|
|
}
|
|
|
|
void writeModbusManagementResponse(int uart_port, const bool ok, const char* action,
|
|
const char* error) const {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(root, "ok", ok);
|
|
cJSON_AddNumberToObject(root, "gw", channel.gateway_id);
|
|
cJSON_AddStringToObject(root, "action", action == nullptr ? "unknown" : action);
|
|
if (const auto config = activeModbusConfig()) {
|
|
cJSON_AddStringToObject(root, "transport", config->transport.c_str());
|
|
cJSON_AddNumberToObject(root, "unitID", config->unit_id);
|
|
if (GatewayModbusTransportIsSerial(config->transport)) {
|
|
cJSON_AddNumberToObject(root, "uartPort", config->serial.uart_port);
|
|
cJSON_AddNumberToObject(root, "baudrate", config->serial.baudrate);
|
|
} else {
|
|
cJSON_AddNumberToObject(root, "port", config->port);
|
|
}
|
|
}
|
|
if (error != nullptr) {
|
|
cJSON_AddStringToObject(root, "error", error);
|
|
}
|
|
const std::string body = "@DALIGW " + PrintJson(root) + "\n";
|
|
cJSON_Delete(root);
|
|
uart_write_bytes(static_cast<uart_port_t>(uart_port), body.data(), body.size());
|
|
}
|
|
|
|
};
|
|
|
|
GatewayBridgeService::GatewayBridgeService(DaliDomainService& dali_domain,
|
|
GatewayCache& cache,
|
|
GatewayBridgeServiceConfig config)
|
|
: dali_domain_(dali_domain), cache_(cache), config_(config) {}
|
|
|
|
GatewayBridgeService::~GatewayBridgeService() = default;
|
|
|
|
esp_err_t GatewayBridgeService::start() {
|
|
if (!config_.bridge_enabled) {
|
|
ESP_LOGI(kTag, "bridge service disabled");
|
|
return ESP_OK;
|
|
}
|
|
if (!runtimes_.empty()) {
|
|
return ESP_OK;
|
|
}
|
|
|
|
const auto channels = dali_domain_.channelInfo();
|
|
runtimes_.reserve(channels.size());
|
|
for (const auto& channel : channels) {
|
|
auto runtime = std::make_unique<ChannelRuntime>(dali_domain_, cache_, channel, config_);
|
|
const esp_err_t err = runtime->start();
|
|
if (err != ESP_OK) {
|
|
ESP_LOGE(kTag, "failed to start bridge runtime gateway=%u: %s", channel.gateway_id,
|
|
esp_err_to_name(err));
|
|
return err;
|
|
}
|
|
runtimes_.push_back(std::move(runtime));
|
|
}
|
|
|
|
std::set<int> used_serial_uarts;
|
|
if (config_.modbus_enabled && config_.modbus_startup_enabled) {
|
|
std::set<uint16_t> used_modbus_ports;
|
|
for (const auto& runtime : runtimes_) {
|
|
const esp_err_t err = runtime->startModbus(&used_modbus_ports, &used_serial_uarts);
|
|
if (err != ESP_OK && err != ESP_ERR_NOT_FOUND && err != ESP_ERR_NOT_SUPPORTED) {
|
|
ESP_LOGW(kTag, "gateway=%u Modbus startup skipped: %s", runtime->channel.gateway_id,
|
|
esp_err_to_name(err));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (config_.knx_enabled && config_.knx_startup_enabled) {
|
|
std::set<uint16_t> used_knx_ports;
|
|
for (const auto& runtime : runtimes_) {
|
|
const esp_err_t err = runtime->startKnx(&used_knx_ports, &used_serial_uarts);
|
|
if (err != ESP_OK && err != ESP_ERR_NOT_FOUND && err != ESP_ERR_NOT_SUPPORTED) {
|
|
ESP_LOGW(kTag, "gateway=%u KNX/IP startup skipped: %s", runtime->channel.gateway_id,
|
|
esp_err_to_name(err));
|
|
}
|
|
}
|
|
}
|
|
|
|
if (config_.bacnet_enabled && config_.bacnet_startup_enabled) {
|
|
for (const auto& runtime : runtimes_) {
|
|
const esp_err_t err = runtime->startBacnet();
|
|
if (err != ESP_OK && err != ESP_ERR_NOT_FOUND && err != ESP_ERR_NOT_SUPPORTED) {
|
|
ESP_LOGW(kTag, "gateway=%u BACnet startup skipped: %s", runtime->channel.gateway_id,
|
|
esp_err_to_name(err));
|
|
}
|
|
}
|
|
}
|
|
|
|
ESP_LOGI(kTag, "bridge service started channels=%u", static_cast<unsigned>(runtimes_.size()));
|
|
return ESP_OK;
|
|
}
|
|
|
|
GatewayBridgeService::ChannelRuntime* GatewayBridgeService::findRuntime(uint8_t gateway_id) {
|
|
for (const auto& runtime : runtimes_) {
|
|
if (runtime->channel.gateway_id == gateway_id) {
|
|
return runtime.get();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
const GatewayBridgeService::ChannelRuntime* GatewayBridgeService::findRuntime(
|
|
uint8_t gateway_id) const {
|
|
for (const auto& runtime : runtimes_) {
|
|
if (runtime->channel.gateway_id == gateway_id) {
|
|
return runtime.get();
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void GatewayBridgeService::collectUsedRuntimeResources(
|
|
uint8_t except_gateway_id,
|
|
std::set<uint16_t>* modbus_tcp_ports,
|
|
std::set<uint16_t>* knx_udp_ports,
|
|
std::set<int>* serial_uarts) const {
|
|
for (const auto& runtime : runtimes_) {
|
|
if (runtime->channel.gateway_id == except_gateway_id) {
|
|
continue;
|
|
}
|
|
LockGuard guard(runtime->lock);
|
|
if (runtime->modbus_started) {
|
|
const auto modbus_config = runtime->activeModbusConfigLocked();
|
|
if (modbus_config.has_value()) {
|
|
if (GatewayModbusTransportIsSerial(modbus_config->transport) && serial_uarts != nullptr) {
|
|
serial_uarts->insert(modbus_config->serial.uart_port);
|
|
} else if (GatewayModbusTransportIsTcp(modbus_config->transport) &&
|
|
modbus_tcp_ports != nullptr) {
|
|
const uint16_t port = modbus_config->port == 0 ? kGatewayModbusDefaultTcpPort
|
|
: modbus_config->port;
|
|
modbus_tcp_ports->insert(port);
|
|
}
|
|
}
|
|
}
|
|
if (runtime->knx_started ||
|
|
(runtime->knx_router != nullptr && runtime->knx_router->started())) {
|
|
const auto knx_config = runtime->activeKnxConfigLocked();
|
|
if (knx_config.has_value() && knx_config->ip_router_enabled) {
|
|
if (knx_udp_ports != nullptr) {
|
|
knx_udp_ports->insert(knx_config->udp_port);
|
|
}
|
|
if (serial_uarts != nullptr) {
|
|
serial_uarts->insert(knx_config->tp_uart.uart_port);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
GatewayBridgeHttpResponse GatewayBridgeService::handleGet(
|
|
const std::string& action_arg, int gateway_id_arg, const std::string& query_arg) {
|
|
if (!config_.bridge_enabled) {
|
|
return ErrorResponse(ESP_ERR_NOT_SUPPORTED, "bridge service is disabled");
|
|
}
|
|
std::string_view action(action_arg);
|
|
std::string_view query(query_arg);
|
|
std::optional<uint8_t> gateway_id;
|
|
if (gateway_id_arg >= 0 && gateway_id_arg <= 255) {
|
|
gateway_id = static_cast<uint8_t>(gateway_id_arg);
|
|
}
|
|
if (action.empty()) {
|
|
action = "status";
|
|
}
|
|
|
|
if (action == "status" && !gateway_id.has_value()) {
|
|
cJSON* root = cJSON_CreateObject();
|
|
cJSON_AddBoolToObject(root, "enabled", true);
|
|
cJSON_AddNumberToObject(root, "count", static_cast<double>(runtimes_.size()));
|
|
cJSON* channels = cJSON_CreateArray();
|
|
if (channels != nullptr) {
|
|
for (const auto& runtime : runtimes_) {
|
|
cJSON_AddItemToArray(channels, runtime->statusCjson());
|
|
}
|
|
cJSON_AddItemToObject(root, "channels", channels);
|
|
}
|
|
return JsonOk(root);
|
|
}
|
|
|
|
if (!gateway_id.has_value()) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "gateway id is required");
|
|
}
|
|
auto* runtime = findRuntime(gateway_id.value());
|
|
if (runtime == nullptr) {
|
|
return ErrorResponse(ESP_ERR_NOT_FOUND, "unknown gateway id");
|
|
}
|
|
|
|
if (action == "status") {
|
|
return JsonOk(runtime->statusCjson());
|
|
}
|
|
if (action == "config") {
|
|
return runtime->configJson();
|
|
}
|
|
if (action == "modbus") {
|
|
return runtime->modbusBindingsJson();
|
|
}
|
|
if (action == "knx") {
|
|
return runtime->knxBindingsJson();
|
|
}
|
|
if (action == "bacnet") {
|
|
return runtime->bacnetBindingsJson();
|
|
}
|
|
if (action == "inventory") {
|
|
return runtime->inventoryJson();
|
|
}
|
|
if (action == "effective_model") {
|
|
return runtime->effectiveModelJson();
|
|
}
|
|
if (action == "cloud") {
|
|
return runtime->cloudJson();
|
|
}
|
|
if (action == "device") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
if (!address.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr is required");
|
|
}
|
|
{
|
|
LockGuard guard(runtime->lock);
|
|
const auto* entry = runtime->updateDiscoveryEntryLocked(address.value(), true);
|
|
if (entry != nullptr && runtime->bacnet_started) {
|
|
const esp_err_t err = runtime->syncBacnetServerLocked();
|
|
if (err != ESP_OK && err != ESP_ERR_NOT_FOUND) {
|
|
return ErrorResponse(err, "failed to refresh BACnet bridge after discovery");
|
|
}
|
|
runtime->bacnet_started = err == ESP_OK;
|
|
}
|
|
if (entry != nullptr) {
|
|
return JsonOk(DiscoveryEntryToCjson(*entry));
|
|
}
|
|
}
|
|
return ErrorResponse(ESP_ERR_NOT_FOUND, "device did not respond to type discovery");
|
|
}
|
|
if (action == "base_status" || action == "status_bits") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
if (!address.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr is required");
|
|
}
|
|
return SnapshotResponse(dali_domain_.baseStatusSnapshot(gateway_id.value(), address.value()),
|
|
"base status snapshot is unavailable");
|
|
}
|
|
if (action == "dt1" || action == "dt4" || action == "dt5" || action == "dt6" ||
|
|
action == "dt8_status") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
if (!address.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr is required");
|
|
}
|
|
if (action == "dt1") {
|
|
return SnapshotResponse(dali_domain_.dt1Snapshot(gateway_id.value(), address.value()),
|
|
"DT1 snapshot is unavailable");
|
|
}
|
|
if (action == "dt4") {
|
|
return SnapshotResponse(dali_domain_.dt4Snapshot(gateway_id.value(), address.value()),
|
|
"DT4 snapshot is unavailable");
|
|
}
|
|
if (action == "dt5") {
|
|
return SnapshotResponse(dali_domain_.dt5Snapshot(gateway_id.value(), address.value()),
|
|
"DT5 snapshot is unavailable");
|
|
}
|
|
if (action == "dt6") {
|
|
return SnapshotResponse(dali_domain_.dt6Snapshot(gateway_id.value(), address.value()),
|
|
"DT6 snapshot is unavailable");
|
|
}
|
|
return SnapshotResponse(dali_domain_.dt8StatusSnapshot(gateway_id.value(), address.value()),
|
|
"DT8 status snapshot is unavailable");
|
|
}
|
|
if (action == "dt8_scene") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
const auto scene = QueryInt(query, "scene");
|
|
if (!address.has_value() || !scene.has_value() || !ValidDaliAddress(address.value()) ||
|
|
scene.value() < 0 || scene.value() > 15) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr and scene are required");
|
|
}
|
|
return SnapshotResponse(dali_domain_.dt8SceneColorReport(gateway_id.value(), address.value(),
|
|
scene.value()),
|
|
"DT8 scene color report is unavailable");
|
|
}
|
|
if (action == "dt8_power_on") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
if (!address.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr is required");
|
|
}
|
|
return SnapshotResponse(dali_domain_.dt8PowerOnLevelColorReport(gateway_id.value(),
|
|
address.value()),
|
|
"DT8 power-on color report is unavailable");
|
|
}
|
|
if (action == "dt8_system_failure") {
|
|
const auto address = QueryInt(query, "addr", "address");
|
|
if (!address.has_value() || !ValidDaliAddress(address.value())) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "valid addr is required");
|
|
}
|
|
return SnapshotResponse(dali_domain_.dt8SystemFailureLevelColorReport(gateway_id.value(),
|
|
address.value()),
|
|
"DT8 system-failure color report is unavailable");
|
|
}
|
|
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "unknown bridge GET action");
|
|
}
|
|
|
|
GatewayBridgeHttpResponse GatewayBridgeService::handlePost(
|
|
const std::string& action_arg, int gateway_id_arg, const std::string& body_arg) {
|
|
if (!config_.bridge_enabled) {
|
|
return ErrorResponse(ESP_ERR_NOT_SUPPORTED, "bridge service is disabled");
|
|
}
|
|
|
|
std::string_view action(action_arg);
|
|
std::string_view body(body_arg);
|
|
std::optional<uint8_t> gateway_id;
|
|
if (gateway_id_arg >= 0 && gateway_id_arg <= 255) {
|
|
gateway_id = static_cast<uint8_t>(gateway_id_arg);
|
|
}
|
|
|
|
cJSON* root = body.empty() ? nullptr : cJSON_ParseWithLength(body.data(), body.size());
|
|
if (!body.empty() && root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid JSON body");
|
|
}
|
|
if (action.empty() && root != nullptr) {
|
|
if (const char* body_action = JsonString(root, "action")) {
|
|
action = body_action;
|
|
}
|
|
}
|
|
if (!gateway_id.has_value()) {
|
|
gateway_id = JsonGatewayId(root);
|
|
}
|
|
cJSON_Delete(root);
|
|
|
|
if (action.empty()) {
|
|
action = "execute";
|
|
}
|
|
if (!gateway_id.has_value()) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "gateway id is required");
|
|
}
|
|
|
|
auto* runtime = findRuntime(gateway_id.value());
|
|
if (runtime == nullptr) {
|
|
return ErrorResponse(ESP_ERR_NOT_FOUND, "unknown gateway id");
|
|
}
|
|
|
|
if (action == "dt8_scene_snapshot" || action == "store_dt8_scene_snapshot") {
|
|
return StoreDt8SceneSnapshot(dali_domain_, gateway_id.value(), body);
|
|
}
|
|
if (action == "dt8_power_on_snapshot" || action == "store_dt8_power_on_snapshot") {
|
|
return StoreDt8LevelSnapshot(dali_domain_, gateway_id.value(), body, true);
|
|
}
|
|
if (action == "dt8_system_failure_snapshot" ||
|
|
action == "store_dt8_system_failure_snapshot") {
|
|
return StoreDt8LevelSnapshot(dali_domain_, gateway_id.value(), body, false);
|
|
}
|
|
|
|
if (action == "execute") {
|
|
return runtime->execute(body);
|
|
}
|
|
if (action == "config" || action == "save_config") {
|
|
const esp_err_t err = runtime->saveBridgeConfig(body);
|
|
if (err != ESP_OK) {
|
|
const char* message = !runtime->knx_last_error.empty()
|
|
? runtime->knx_last_error.c_str()
|
|
: (!runtime->modbus_last_error.empty()
|
|
? runtime->modbus_last_error.c_str()
|
|
: "failed to save bridge config");
|
|
return ErrorResponse(err, message);
|
|
}
|
|
return handleGet("config", gateway_id.value());
|
|
}
|
|
if (action == "clear_config") {
|
|
const esp_err_t err = runtime->clearBridgeConfig();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to clear bridge config");
|
|
}
|
|
return handleGet("config", gateway_id.value());
|
|
}
|
|
if (action == "cloud" || action == "save_cloud") {
|
|
const esp_err_t err = runtime->saveCloudConfig(body);
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to save cloud config");
|
|
}
|
|
return handleGet("cloud", gateway_id.value());
|
|
}
|
|
if (action == "cloud_start") {
|
|
const esp_err_t err = runtime->startCloud();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to start cloud bridge");
|
|
}
|
|
return handleGet("cloud", gateway_id.value());
|
|
}
|
|
if (action == "cloud_stop") {
|
|
const esp_err_t err = runtime->stopCloud();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to stop cloud bridge");
|
|
}
|
|
return handleGet("cloud", gateway_id.value());
|
|
}
|
|
if (action == "cloud_clear") {
|
|
const esp_err_t err = runtime->clearCloudConfig();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to clear cloud config");
|
|
}
|
|
return handleGet("cloud", gateway_id.value());
|
|
}
|
|
if (action == "modbus_start") {
|
|
std::set<uint16_t> used_modbus_ports;
|
|
std::set<int> used_serial_uarts;
|
|
collectUsedRuntimeResources(gateway_id.value(), &used_modbus_ports, nullptr,
|
|
&used_serial_uarts);
|
|
const esp_err_t err = runtime->startModbus(&used_modbus_ports, &used_serial_uarts);
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, runtime->modbus_last_error.empty()
|
|
? "failed to start Modbus bridge"
|
|
: runtime->modbus_last_error.c_str());
|
|
}
|
|
return handleGet("modbus", gateway_id.value());
|
|
}
|
|
if (action == "modbus_stop") {
|
|
const esp_err_t err = runtime->stopModbus();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to stop Modbus bridge");
|
|
}
|
|
return handleGet("modbus", gateway_id.value());
|
|
}
|
|
if (action == "knx_config" || action == "save_knx") {
|
|
cJSON* knx_root = cJSON_ParseWithLength(body.data(), body.size());
|
|
if (knx_root == nullptr) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid KNX config JSON");
|
|
}
|
|
const cJSON* knx_node = cJSON_GetObjectItemCaseSensitive(knx_root, "knx");
|
|
if (knx_node == nullptr) {
|
|
knx_node = knx_root;
|
|
}
|
|
const DaliValue knx_value = FromCjson(knx_node);
|
|
cJSON_Delete(knx_root);
|
|
const auto parsed = GatewayKnxConfigFromValue(&knx_value);
|
|
if (!parsed.has_value()) {
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "invalid KNX config");
|
|
}
|
|
std::set<uint16_t> used_knx_ports;
|
|
std::set<int> used_serial_uarts;
|
|
collectUsedRuntimeResources(gateway_id.value(), nullptr, &used_knx_ports,
|
|
&used_serial_uarts);
|
|
const esp_err_t err = runtime->saveKnxConfig(parsed.value(), &used_knx_ports,
|
|
&used_serial_uarts);
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, runtime->knx_last_error.empty()
|
|
? "failed to save KNX bridge config"
|
|
: runtime->knx_last_error.c_str());
|
|
}
|
|
return handleGet("knx", gateway_id.value());
|
|
}
|
|
if (action == "knx_start") {
|
|
std::set<uint16_t> used_knx_ports;
|
|
std::set<int> used_serial_uarts;
|
|
collectUsedRuntimeResources(gateway_id.value(), nullptr, &used_knx_ports,
|
|
&used_serial_uarts);
|
|
const esp_err_t err = runtime->startKnx(&used_knx_ports, &used_serial_uarts);
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, runtime->knx_last_error.empty()
|
|
? "failed to start KNX/IP bridge"
|
|
: runtime->knx_last_error.c_str());
|
|
}
|
|
return handleGet("knx", gateway_id.value());
|
|
}
|
|
if (action == "knx_stop") {
|
|
const esp_err_t err = runtime->stopKnx();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to stop KNX/IP bridge");
|
|
}
|
|
return handleGet("knx", gateway_id.value());
|
|
}
|
|
if (action == "bacnet_start") {
|
|
const esp_err_t err = runtime->startBacnet();
|
|
if (err != ESP_OK) {
|
|
return ErrorResponse(err, "failed to start BACnet/IP bridge");
|
|
}
|
|
return handleGet("bacnet", gateway_id.value());
|
|
}
|
|
if (action == "scan") {
|
|
return runtime->scanInventory(body);
|
|
}
|
|
|
|
return ErrorResponse(ESP_ERR_INVALID_ARG, "unknown bridge POST action");
|
|
}
|
|
|
|
} // namespace gateway
|