Tony
1234 lines
43 KiB
C++
1234 lines
43 KiB
C++
#include "gateway_controller.hpp"
|
|
|
|
#include "dali_domain.hpp"
|
|
#include "esp_log.h"
|
|
#include "esp_system.h"
|
|
#include "gateway_runtime.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <cstdio>
|
|
#include <cstdlib>
|
|
#include <utility>
|
|
|
|
namespace gateway {
|
|
|
|
namespace {
|
|
|
|
constexpr const char* kTag = "gateway_controller";
|
|
constexpr size_t kMaxNameBytes = 32;
|
|
constexpr uint8_t kDaliShortAddressCount = 64;
|
|
constexpr uint8_t kDaliSceneCount = 16;
|
|
constexpr uint8_t kDaliCmdOff = 0x00;
|
|
constexpr uint8_t kDaliCmdRecallMax = 0x05;
|
|
constexpr TickType_t kMaintenancePollTicks = pdMS_TO_TICKS(20);
|
|
|
|
class LockGuard {
|
|
public:
|
|
explicit LockGuard(SemaphoreHandle_t lock) : lock_(lock) {
|
|
if (lock_ != nullptr) {
|
|
xSemaphoreTake(lock_, portMAX_DELAY);
|
|
}
|
|
}
|
|
|
|
~LockGuard() {
|
|
if (lock_ != nullptr) {
|
|
xSemaphoreGive(lock_);
|
|
}
|
|
}
|
|
|
|
private:
|
|
SemaphoreHandle_t lock_;
|
|
};
|
|
|
|
bool AnyFlagSet(const GatewayCacheChannelFlags& flags) {
|
|
return flags.need_update_group || flags.need_update_scene || flags.need_update_settings;
|
|
}
|
|
|
|
std::string NormalizeName(std::string_view name) {
|
|
std::string normalized(name);
|
|
if (normalized.size() > kMaxNameBytes) {
|
|
normalized.resize(kMaxNameBytes);
|
|
}
|
|
return normalized;
|
|
}
|
|
|
|
std::string AppendGatewaySuffix(std::string_view name, uint8_t gateway_id) {
|
|
std::string normalized = NormalizeName(name);
|
|
const std::string suffix = "_" + std::to_string(gateway_id);
|
|
if (normalized.size() > suffix.size() &&
|
|
normalized.compare(normalized.size() - suffix.size(), suffix.size(), suffix) == 0) {
|
|
return normalized;
|
|
}
|
|
const size_t max_base_len = kMaxNameBytes > suffix.size() ? kMaxNameBytes - suffix.size() : 0;
|
|
if (normalized.size() > max_base_len) {
|
|
normalized.resize(max_base_len);
|
|
}
|
|
normalized += suffix;
|
|
return normalized;
|
|
}
|
|
|
|
void AppendStringBytes(std::vector<uint8_t>& out, std::string_view value) {
|
|
for (const auto ch : value) {
|
|
out.push_back(static_cast<uint8_t>(ch));
|
|
}
|
|
}
|
|
|
|
void AppendPaddedName(std::vector<uint8_t>& out, std::string_view name) {
|
|
const auto normalized = NormalizeName(name);
|
|
out.push_back(static_cast<uint8_t>(normalized.size()));
|
|
AppendStringBytes(out, normalized);
|
|
while (out.size() < 5 + kMaxNameBytes) {
|
|
out.push_back(0x00);
|
|
}
|
|
}
|
|
|
|
const char* PhyKindToString(DaliPhyKind phy_kind) {
|
|
switch (phy_kind) {
|
|
case DaliPhyKind::kNativeHardware:
|
|
return "native";
|
|
case DaliPhyKind::kSerialUart:
|
|
return "serial";
|
|
case DaliPhyKind::kCustom:
|
|
default:
|
|
return "custom";
|
|
}
|
|
}
|
|
|
|
} // namespace
|
|
|
|
GatewayController::GatewayController(GatewayRuntime& runtime, DaliDomainService& dali_domain,
|
|
GatewayCache& cache, GatewayControllerConfig config)
|
|
: runtime_(runtime),
|
|
dali_domain_(dali_domain),
|
|
cache_(cache),
|
|
config_(config),
|
|
maintenance_lock_(xSemaphoreCreateMutex()) {}
|
|
|
|
GatewayController::~GatewayController() {
|
|
if (maintenance_lock_ != nullptr) {
|
|
vSemaphoreDelete(maintenance_lock_);
|
|
maintenance_lock_ = nullptr;
|
|
}
|
|
}
|
|
|
|
esp_err_t GatewayController::start() {
|
|
const auto device_info = runtime_.deviceInfo();
|
|
ble_enabled_ = device_info.ble_enabled;
|
|
refreshRuntimeGatewayNames();
|
|
runtime_.setCommandAddressResolver([this](uint8_t gateway_id, uint8_t raw_addr) {
|
|
return resolveInternalGroupRawAddress(gateway_id, raw_addr);
|
|
});
|
|
dali_domain_.addRawFrameSink([this](const DaliRawFrame& frame) { handleDaliRawFrame(frame); });
|
|
|
|
for (const auto& channel : dali_domain_.channelInfo()) {
|
|
cache_.preloadChannel(channel.gateway_id);
|
|
dali_domain_.resetBus(channel.gateway_id);
|
|
publishPayload(channel.gateway_id, {0x02, channel.gateway_id, 0x88});
|
|
}
|
|
|
|
if (task_handle_ != nullptr) {
|
|
return ESP_OK;
|
|
}
|
|
|
|
const BaseType_t created = xTaskCreate(&GatewayController::TaskEntry, "gateway_ctrl",
|
|
config_.task_stack_size, this, config_.task_priority,
|
|
&task_handle_);
|
|
if (created != pdPASS) {
|
|
task_handle_ = nullptr;
|
|
ESP_LOGE(kTag, "failed to create controller task");
|
|
return ESP_ERR_NO_MEM;
|
|
}
|
|
|
|
ESP_LOGI(kTag, "controller started channels=%u", static_cast<unsigned>(dali_domain_.channelCount()));
|
|
return ESP_OK;
|
|
}
|
|
|
|
bool GatewayController::enqueueCommandFrame(const std::vector<uint8_t>& frame) {
|
|
if (!GatewayRuntime::isGatewayCommandFrame(frame) || !GatewayRuntime::hasValidChecksum(frame)) {
|
|
ESP_LOGW(kTag, "dropped invalid command frame len=%u", static_cast<unsigned>(frame.size()));
|
|
return false;
|
|
}
|
|
if (!runtime_.enqueueCommand(frame, GatewayRuntime::classifyCommandPriority(frame))) {
|
|
if (runtime_.lastEnqueueDropReason() != GatewayRuntime::CommandDropReason::kDuplicate) {
|
|
ESP_LOGW(kTag, "dropped command frame reason=%d",
|
|
static_cast<int>(runtime_.lastEnqueueDropReason()));
|
|
}
|
|
return false;
|
|
}
|
|
if (task_handle_ != nullptr) {
|
|
xTaskNotifyGive(task_handle_);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
void GatewayController::addNotificationSink(NotificationSink sink) {
|
|
if (sink) {
|
|
notification_sinks_.push_back(std::move(sink));
|
|
}
|
|
}
|
|
|
|
void GatewayController::addBleStateSink(BleStateSink sink) {
|
|
if (sink) {
|
|
ble_state_sinks_.push_back(std::move(sink));
|
|
}
|
|
}
|
|
|
|
void GatewayController::addWifiStateSink(WifiStateSink sink) {
|
|
if (sink) {
|
|
wifi_state_sinks_.push_back(std::move(sink));
|
|
}
|
|
}
|
|
|
|
void GatewayController::addGatewayNameSink(GatewayNameSink sink) {
|
|
if (sink) {
|
|
gateway_name_sinks_.push_back(std::move(sink));
|
|
}
|
|
}
|
|
|
|
bool GatewayController::setupMode() const {
|
|
return setup_mode_;
|
|
}
|
|
|
|
bool GatewayController::wirelessSetupMode() const {
|
|
return wireless_setup_mode_;
|
|
}
|
|
|
|
void GatewayController::setWirelessSetupMode(bool enabled) {
|
|
wireless_setup_mode_ = enabled;
|
|
}
|
|
|
|
bool GatewayController::bleEnabled() const {
|
|
return ble_enabled_;
|
|
}
|
|
|
|
bool GatewayController::wifiEnabled() const {
|
|
return wifi_enabled_;
|
|
}
|
|
|
|
bool GatewayController::ipRouterEnabled() const {
|
|
return ip_router_enabled_;
|
|
}
|
|
|
|
GatewayControllerSnapshot GatewayController::snapshot() {
|
|
GatewayControllerSnapshot out;
|
|
out.setup_mode = setup_mode_;
|
|
out.wireless_setup_mode = wireless_setup_mode_;
|
|
out.ble_enabled = ble_enabled_;
|
|
out.wifi_enabled = wifi_enabled_;
|
|
out.ip_router_enabled = ip_router_enabled_;
|
|
out.internal_scene_supported = config_.internal_scene_supported;
|
|
out.internal_group_supported = config_.internal_group_supported;
|
|
|
|
const auto channels = dali_domain_.channelInfo();
|
|
out.channels.reserve(channels.size());
|
|
for (const auto& channel : channels) {
|
|
const auto [scene_low, scene_high] = sceneMask(channel.gateway_id);
|
|
const auto [group_low, group_high] = groupMask(channel.gateway_id);
|
|
GatewayChannelSnapshot channel_snapshot;
|
|
channel_snapshot.channel_index = channel.channel_index;
|
|
channel_snapshot.gateway_id = channel.gateway_id;
|
|
channel_snapshot.name = channel.name;
|
|
channel_snapshot.phy = PhyKindToString(channel.phy_kind);
|
|
channel_snapshot.scene_mask_low = scene_low;
|
|
channel_snapshot.scene_mask_high = scene_high;
|
|
channel_snapshot.group_mask_low = group_low;
|
|
channel_snapshot.group_mask_high = group_high;
|
|
channel_snapshot.allocating = dali_domain_.isAllocAddr(channel.gateway_id);
|
|
channel_snapshot.last_alloc_addr = dali_domain_.lastAllocAddr(channel.gateway_id);
|
|
out.channels.push_back(std::move(channel_snapshot));
|
|
}
|
|
return out;
|
|
}
|
|
|
|
void GatewayController::TaskEntry(void* arg) {
|
|
static_cast<GatewayController*>(arg)->taskLoop();
|
|
}
|
|
|
|
void GatewayController::taskLoop() {
|
|
while (true) {
|
|
bool worked = false;
|
|
if (auto command = runtime_.popNextCommand()) {
|
|
worked = true;
|
|
dispatchCommand(*command);
|
|
runtime_.completeCurrentCommand();
|
|
}
|
|
if (!worked) {
|
|
worked = runMaintenanceStep();
|
|
}
|
|
if (!worked) {
|
|
ulTaskNotifyTake(pdTRUE, hasPendingReconciliation() ? kMaintenancePollTicks : portMAX_DELAY);
|
|
}
|
|
}
|
|
}
|
|
|
|
void GatewayController::scheduleReconciliation(uint8_t gateway_id) {
|
|
if (!cache_.reconciliationEnabled()) {
|
|
return;
|
|
}
|
|
|
|
auto flags = cache_.pendingChannelFlags(gateway_id);
|
|
if (cache_.fullStateMirrorEnabled() && AnyFlagSet(flags)) {
|
|
flags = {true, true, true};
|
|
}
|
|
if (!AnyFlagSet(flags)) {
|
|
return;
|
|
}
|
|
|
|
{
|
|
LockGuard guard(maintenance_lock_);
|
|
reconciliation_jobs_.try_emplace(gateway_id);
|
|
}
|
|
|
|
if (task_handle_ != nullptr) {
|
|
xTaskNotifyGive(task_handle_);
|
|
}
|
|
}
|
|
|
|
bool GatewayController::hasPendingReconciliation() const {
|
|
LockGuard guard(maintenance_lock_);
|
|
return !reconciliation_jobs_.empty();
|
|
}
|
|
|
|
bool GatewayController::runMaintenanceStep() {
|
|
if (!cache_.reconciliationEnabled()) {
|
|
return false;
|
|
}
|
|
|
|
uint8_t gateway_id = 0;
|
|
ReconciliationJob job;
|
|
{
|
|
LockGuard guard(maintenance_lock_);
|
|
if (reconciliation_jobs_.empty()) {
|
|
return false;
|
|
}
|
|
const auto it = reconciliation_jobs_.begin();
|
|
gateway_id = it->first;
|
|
job = it->second;
|
|
}
|
|
|
|
if (runtime_.shouldYieldMaintenance(gateway_id)) {
|
|
return false;
|
|
}
|
|
|
|
const bool keep_job = runReconciliationStep(gateway_id, job);
|
|
|
|
{
|
|
LockGuard guard(maintenance_lock_);
|
|
auto it = reconciliation_jobs_.find(gateway_id);
|
|
if (it == reconciliation_jobs_.end()) {
|
|
return true;
|
|
}
|
|
if (keep_job) {
|
|
it->second = job;
|
|
} else {
|
|
reconciliation_jobs_.erase(it);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool GatewayController::runReconciliationStep(uint8_t gateway_id, ReconciliationJob& job) {
|
|
if (job.phase == ReconciliationJob::Phase::kReloadFlags) {
|
|
job.flags = cache_.pendingChannelFlags(gateway_id);
|
|
if (cache_.fullStateMirrorEnabled() && AnyFlagSet(job.flags)) {
|
|
job.flags = {true, true, true};
|
|
}
|
|
if (!AnyFlagSet(job.flags)) {
|
|
return false;
|
|
}
|
|
|
|
job.short_address = 0;
|
|
job.scene_id = 0;
|
|
if (job.flags.need_update_group) {
|
|
job.phase = ReconciliationJob::Phase::kGroups;
|
|
} else if (job.flags.need_update_scene) {
|
|
job.phase = ReconciliationJob::Phase::kScenes;
|
|
} else {
|
|
job.phase = ReconciliationJob::Phase::kSettings;
|
|
}
|
|
}
|
|
|
|
switch (job.phase) {
|
|
case ReconciliationJob::Phase::kGroups:
|
|
reconcileGroupStep(gateway_id, job.short_address++);
|
|
if (job.short_address >= kDaliShortAddressCount) {
|
|
job.short_address = 0;
|
|
if (job.flags.need_update_scene) {
|
|
job.phase = ReconciliationJob::Phase::kScenes;
|
|
} else if (job.flags.need_update_settings) {
|
|
job.phase = ReconciliationJob::Phase::kSettings;
|
|
} else if (!cache_.clearChannelFlagsIfMatched(gateway_id, job.flags)) {
|
|
job.phase = ReconciliationJob::Phase::kReloadFlags;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
case ReconciliationJob::Phase::kScenes:
|
|
reconcileSceneStep(gateway_id, job.short_address, job.scene_id);
|
|
++job.scene_id;
|
|
if (job.scene_id >= kDaliSceneCount) {
|
|
job.scene_id = 0;
|
|
++job.short_address;
|
|
}
|
|
if (job.short_address >= kDaliShortAddressCount) {
|
|
job.short_address = 0;
|
|
if (job.flags.need_update_settings) {
|
|
job.phase = ReconciliationJob::Phase::kSettings;
|
|
} else if (!cache_.clearChannelFlagsIfMatched(gateway_id, job.flags)) {
|
|
job.phase = ReconciliationJob::Phase::kReloadFlags;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
case ReconciliationJob::Phase::kSettings:
|
|
reconcileSettingsStep(gateway_id, job.short_address++);
|
|
if (job.short_address >= kDaliShortAddressCount) {
|
|
job.short_address = 0;
|
|
if (!cache_.clearChannelFlagsIfMatched(gateway_id, job.flags)) {
|
|
job.phase = ReconciliationJob::Phase::kReloadFlags;
|
|
} else {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
case ReconciliationJob::Phase::kReloadFlags:
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void GatewayController::reconcileGroupStep(uint8_t gateway_id, uint8_t short_address) {
|
|
const auto policy = cache_.priorityMode();
|
|
const auto state = cache_.daliAddressState(gateway_id, short_address);
|
|
|
|
if (policy == GatewayCachePriorityMode::kLocalGatewayFirst && state.group_mask_known) {
|
|
maintenance_activity_gateway_.store(gateway_id);
|
|
const bool applied = dali_domain_.applyGroupMask(gateway_id, short_address, state.group_mask);
|
|
maintenance_activity_gateway_.store(-1);
|
|
const auto verified_mask = dali_domain_.queryGroupMask(gateway_id, short_address);
|
|
cache_.setDaliGroupMask(gateway_id, short_address, verified_mask);
|
|
if (!applied && verified_mask.has_value()) {
|
|
ESP_LOGW(kTag, "group reconcile fallback gateway=%u short=%u", gateway_id, short_address);
|
|
}
|
|
return;
|
|
}
|
|
|
|
cache_.setDaliGroupMask(gateway_id, short_address,
|
|
dali_domain_.queryGroupMask(gateway_id, short_address));
|
|
}
|
|
|
|
void GatewayController::reconcileSceneStep(uint8_t gateway_id, uint8_t short_address,
|
|
uint8_t scene_id) {
|
|
const auto policy = cache_.priorityMode();
|
|
const auto state = cache_.daliAddressState(gateway_id, short_address);
|
|
|
|
if (policy == GatewayCachePriorityMode::kLocalGatewayFirst &&
|
|
state.scene_levels[scene_id].has_value()) {
|
|
maintenance_activity_gateway_.store(gateway_id);
|
|
dali_domain_.applySceneLevel(gateway_id, short_address, scene_id, state.scene_levels[scene_id]);
|
|
maintenance_activity_gateway_.store(-1);
|
|
}
|
|
|
|
cache_.setDaliSceneLevel(gateway_id, short_address, scene_id,
|
|
dali_domain_.querySceneLevel(gateway_id, short_address, scene_id));
|
|
}
|
|
|
|
void GatewayController::reconcileSettingsStep(uint8_t gateway_id, uint8_t short_address) {
|
|
const auto policy = cache_.priorityMode();
|
|
const auto state = cache_.daliAddressState(gateway_id, short_address);
|
|
|
|
if (policy == GatewayCachePriorityMode::kLocalGatewayFirst && state.settings.anyKnown()) {
|
|
maintenance_activity_gateway_.store(gateway_id);
|
|
dali_domain_.applyAddressSettings(gateway_id, short_address, {
|
|
state.settings.power_on_level,
|
|
state.settings.system_failure_level,
|
|
state.settings.min_level,
|
|
state.settings.max_level,
|
|
state.settings.fade_time,
|
|
state.settings.fade_rate,
|
|
});
|
|
maintenance_activity_gateway_.store(-1);
|
|
}
|
|
|
|
const auto settings = dali_domain_.queryAddressSettings(gateway_id, short_address);
|
|
if (settings.has_value()) {
|
|
cache_.setDaliSettings(gateway_id, short_address,
|
|
GatewayCacheDaliSettingsSnapshot{settings->power_on_level,
|
|
settings->system_failure_level,
|
|
settings->min_level,
|
|
settings->max_level,
|
|
settings->fade_time,
|
|
settings->fade_rate});
|
|
} else {
|
|
cache_.setDaliSettings(gateway_id, short_address, std::nullopt);
|
|
}
|
|
}
|
|
|
|
void GatewayController::dispatchCommand(const std::vector<uint8_t>& command) {
|
|
if (command.size() < 7) {
|
|
ESP_LOGW(kTag, "command too short len=%u", static_cast<unsigned>(command.size()));
|
|
return;
|
|
}
|
|
|
|
const uint8_t gateway_id = command[2];
|
|
const uint8_t opcode = command[3];
|
|
const uint8_t addr = command[4];
|
|
const uint8_t data = command[5];
|
|
if (!hasGateway(gateway_id)) {
|
|
ESP_LOGW(kTag, "command for unknown gateway=%u opcode=0x%02x", gateway_id, opcode);
|
|
return;
|
|
}
|
|
|
|
switch (opcode) {
|
|
case 0x00:
|
|
esp_restart();
|
|
break;
|
|
case 0x01:
|
|
setup_mode_ = true;
|
|
break;
|
|
case 0x02:
|
|
ESP_LOGI(kTag, "legacy opcode 0x02 requested for gateway=%u", gateway_id);
|
|
break;
|
|
case 0x03:
|
|
if (!config_.ble_supported) {
|
|
publishPayload(gateway_id, {0x03, gateway_id, 0xff});
|
|
} else if (addr == 0) {
|
|
if (runtime_.setBleEnabled(false)) {
|
|
ble_enabled_ = runtime_.bleEnabled();
|
|
for (const auto& sink : ble_state_sinks_) {
|
|
sink(ble_enabled_);
|
|
}
|
|
publishPayload(gateway_id, {0x03, gateway_id, 0x00});
|
|
} else {
|
|
publishPayload(gateway_id, {0x03, gateway_id,
|
|
static_cast<uint8_t>(ble_enabled_ ? 1 : 0)});
|
|
}
|
|
} else if (addr == 1) {
|
|
if (runtime_.setBleEnabled(true)) {
|
|
ble_enabled_ = runtime_.bleEnabled();
|
|
for (const auto& sink : ble_state_sinks_) {
|
|
sink(ble_enabled_);
|
|
}
|
|
publishPayload(gateway_id, {0x03, gateway_id, 0x01});
|
|
} else {
|
|
publishPayload(gateway_id, {0x03, gateway_id,
|
|
static_cast<uint8_t>(ble_enabled_ ? 1 : 0)});
|
|
}
|
|
} else if (addr == 2) {
|
|
publishPayload(gateway_id, {0x03, gateway_id, static_cast<uint8_t>(ble_enabled_ ? 1 : 0)});
|
|
}
|
|
break;
|
|
case 0x04:
|
|
if (addr == 0) {
|
|
wifi_enabled_ = false;
|
|
wireless_setup_mode_ = false;
|
|
} else if (addr == 1) {
|
|
wifi_enabled_ = true;
|
|
wireless_setup_mode_ = false;
|
|
} else if (addr == 100 || addr == 101) {
|
|
wifi_enabled_ = true;
|
|
wireless_setup_mode_ = true;
|
|
}
|
|
for (const auto& sink : wifi_state_sinks_) {
|
|
sink(addr);
|
|
}
|
|
break;
|
|
case 0x05:
|
|
handleGatewayNameCommand(gateway_id, command);
|
|
break;
|
|
case 0x06: {
|
|
uint8_t feature = 0;
|
|
if (setup_mode_ && config_.setup_supported) {
|
|
feature |= 0x01;
|
|
}
|
|
if (wireless_setup_mode_ && config_.wifi_supported) {
|
|
feature |= 0x02;
|
|
}
|
|
if (config_.ip_router_supported && ip_router_enabled_) {
|
|
feature |= 0x08;
|
|
}
|
|
if (config_.internal_scene_supported) {
|
|
feature |= 0x10;
|
|
}
|
|
if (config_.internal_group_supported) {
|
|
feature |= 0x20;
|
|
}
|
|
publishPayload(gateway_id, {0x03, gateway_id, feature});
|
|
break;
|
|
}
|
|
case 0x07:
|
|
case 0x08:
|
|
sendRawAndMirror(gateway_id, addr, data);
|
|
break;
|
|
case 0x09: {
|
|
const auto ids = gatewayIds();
|
|
if (addr >= 1 && addr <= ids.size()) {
|
|
const auto selected_gateway = ids[addr - 1];
|
|
publishPayload(gateway_id, {0x03, selected_gateway, selected_gateway});
|
|
} else {
|
|
publishPayload(gateway_id, {0x04, 0xff, 0x00});
|
|
}
|
|
break;
|
|
}
|
|
case 0x0A:
|
|
handleGatewayIdentityCommand(gateway_id, addr);
|
|
break;
|
|
case 0x10:
|
|
case 0x11:
|
|
sendRawAndMirror(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), data);
|
|
break;
|
|
case 0x12:
|
|
if (addr == 0xff && data >= 0x10 && data <= 0x1f) {
|
|
const uint8_t scene_id = static_cast<uint8_t>(data - 0x10);
|
|
if (!executeScene(gateway_id, shortAddressFromRaw(addr), scene_id)) {
|
|
sendRawAndMirror(gateway_id, addr, data);
|
|
}
|
|
} else {
|
|
sendRawAndMirror(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), data);
|
|
}
|
|
break;
|
|
case 0x13:
|
|
sendExtRawAndMirror(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), data);
|
|
break;
|
|
case 0x14: {
|
|
const auto result = dali_domain_.queryRaw(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), data);
|
|
if (result.has_value()) {
|
|
publishPayload(gateway_id, {0x03, gateway_id, result.value()});
|
|
} else {
|
|
publishPayload(gateway_id, {0x04, gateway_id, 0x00});
|
|
}
|
|
break;
|
|
}
|
|
case 0x15:
|
|
dali_domain_.queryRaw(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), data);
|
|
break;
|
|
case 0x16:
|
|
dali_domain_.queryRaw(gateway_id, 0, 0);
|
|
break;
|
|
case 0x17:
|
|
if (command.size() >= 8) {
|
|
const int mirek = command[5] * 256 + command[6];
|
|
const uint8_t target = resolveInternalGroupRawAddress(gateway_id, addr);
|
|
dali_domain_.setColTempRaw(gateway_id, shortAddressFromRaw(target), mirek);
|
|
}
|
|
break;
|
|
case 0x18:
|
|
if (command.size() >= 10) {
|
|
const int x = command[5] * 256 + command[6];
|
|
const int y = command[7] * 256 + command[8];
|
|
dali_domain_.setColourRaw(gateway_id, resolveInternalGroupRawAddress(gateway_id, addr), x, y);
|
|
}
|
|
break;
|
|
case 0x30:
|
|
handleAllocationCommand(gateway_id, command);
|
|
break;
|
|
case 0x31:
|
|
break;
|
|
case 0x32:
|
|
dali_domain_.resetAndAllocAddr(gateway_id);
|
|
break;
|
|
case 0x37:
|
|
if (command.size() >= 8) {
|
|
int kelvin = command[5] * 256 + command[6];
|
|
const uint8_t target = resolveInternalGroupRawAddress(gateway_id, addr);
|
|
if (config_.color_temperature_max < config_.color_temperature_min) {
|
|
kelvin = reverseInRange(kelvin, config_.color_temperature_min,
|
|
config_.color_temperature_max);
|
|
}
|
|
dali_domain_.setColTemp(gateway_id, shortAddressFromRaw(target), kelvin);
|
|
}
|
|
break;
|
|
case 0x38:
|
|
if (command.size() >= 9) {
|
|
const uint8_t r = command[5];
|
|
const uint8_t g = command[6];
|
|
const uint8_t b = command[7];
|
|
const int target = shortAddressFromRaw(resolveInternalGroupRawAddress(gateway_id, addr));
|
|
if (r == 0 && g == 0 && b == 0) {
|
|
offAndMirror(gateway_id, target);
|
|
} else {
|
|
dali_domain_.setColourRGB(gateway_id, target, r, g, b);
|
|
}
|
|
}
|
|
break;
|
|
case 0xA0:
|
|
handleInternalSceneCommand(gateway_id, command);
|
|
break;
|
|
case 0xA2:
|
|
handleInternalGroupCommand(gateway_id, command);
|
|
break;
|
|
default:
|
|
ESP_LOGW(kTag, "unhandled opcode=0x%02x gateway=%u", opcode, gateway_id);
|
|
break;
|
|
}
|
|
}
|
|
|
|
bool GatewayController::hasGateway(uint8_t gateway_id) const {
|
|
const auto channels = dali_domain_.channelInfo();
|
|
return std::any_of(channels.begin(), channels.end(), [gateway_id](const DaliChannelInfo& channel) {
|
|
return channel.gateway_id == gateway_id;
|
|
});
|
|
}
|
|
|
|
std::vector<uint8_t> GatewayController::gatewayIds() const {
|
|
std::vector<uint8_t> ids;
|
|
const auto channels = dali_domain_.channelInfo();
|
|
ids.reserve(channels.size());
|
|
for (const auto& channel : channels) {
|
|
ids.push_back(channel.gateway_id);
|
|
}
|
|
return ids;
|
|
}
|
|
|
|
std::string GatewayController::gatewayName(uint8_t gateway_id) const {
|
|
const auto channels = dali_domain_.channelInfo();
|
|
const auto it = std::find_if(channels.begin(), channels.end(), [gateway_id](const auto& channel) {
|
|
return channel.gateway_id == gateway_id;
|
|
});
|
|
if (it != channels.end()) {
|
|
return it->name;
|
|
}
|
|
return runtime_.gatewayName(gateway_id);
|
|
}
|
|
|
|
void GatewayController::refreshRuntimeGatewayNames() {
|
|
std::vector<std::string> assigned_names;
|
|
assigned_names.reserve(dali_domain_.channelCount());
|
|
|
|
for (const auto& channel : dali_domain_.channelInfo()) {
|
|
std::string runtime_name = NormalizeName(runtime_.gatewayName(channel.gateway_id));
|
|
if (std::any_of(assigned_names.begin(), assigned_names.end(),
|
|
[&runtime_name](const std::string& assigned_name) {
|
|
return assigned_name == runtime_name;
|
|
})) {
|
|
runtime_name = AppendGatewaySuffix(runtime_name, channel.gateway_id);
|
|
}
|
|
dali_domain_.updateChannelName(channel.gateway_id, runtime_name);
|
|
assigned_names.push_back(runtime_name);
|
|
}
|
|
}
|
|
|
|
void GatewayController::publishPayload(uint8_t, const std::vector<uint8_t>& payload) {
|
|
publishFrame(GatewayRuntime::buildNotificationFrame(payload));
|
|
}
|
|
|
|
void GatewayController::publishFrame(const std::vector<uint8_t>& frame) {
|
|
for (const auto& sink : notification_sinks_) {
|
|
sink(frame);
|
|
}
|
|
}
|
|
|
|
void GatewayController::handleDaliRawFrame(const DaliRawFrame& frame) {
|
|
if (frame.data.size() != 2 && frame.data.size() != 3) {
|
|
return;
|
|
}
|
|
|
|
uint8_t addr = 0;
|
|
uint8_t data = 0;
|
|
if (frame.data.size() == 2) {
|
|
addr = frame.data[0];
|
|
data = frame.data[1];
|
|
if (addr == 0xBE) {
|
|
return;
|
|
}
|
|
} else {
|
|
addr = frame.data[1];
|
|
data = frame.data[2];
|
|
}
|
|
|
|
const bool maintenance_activity = maintenance_activity_gateway_.load() == frame.gateway_id;
|
|
const bool local_activity = maintenance_activity || runtime_.hasActiveCommand(frame.gateway_id) ||
|
|
dali_domain_.isAllocAddr(frame.gateway_id);
|
|
const bool flagged = cache_.observeDaliCommand(frame.gateway_id, addr, data,
|
|
local_activity
|
|
? GatewayCacheRawFrameOrigin::kLocalGateway
|
|
: GatewayCacheRawFrameOrigin::kOutsideBus);
|
|
if (flagged) {
|
|
scheduleReconciliation(frame.gateway_id);
|
|
}
|
|
|
|
if (setup_mode_ || dali_domain_.isAllocAddr(frame.gateway_id) || maintenance_activity ||
|
|
runtime_.hasActiveQueryCommand(frame.gateway_id)) {
|
|
return;
|
|
}
|
|
|
|
publishPayload(frame.gateway_id, {0x01, frame.gateway_id, addr, data});
|
|
}
|
|
|
|
bool GatewayController::sendRawAndMirror(uint8_t gateway_id, uint8_t raw_addr, uint8_t command) {
|
|
const bool sent = dali_domain_.sendRaw(gateway_id, raw_addr, command);
|
|
if (sent) {
|
|
cache_.mirrorDaliCommand(gateway_id, raw_addr, command);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
bool GatewayController::sendExtRawAndMirror(uint8_t gateway_id, uint8_t raw_addr,
|
|
uint8_t command) {
|
|
const bool sent = dali_domain_.sendExtRaw(gateway_id, raw_addr, command);
|
|
if (sent) {
|
|
cache_.mirrorDaliCommand(gateway_id, raw_addr, command);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
bool GatewayController::setBrightAndMirror(uint8_t gateway_id, int dec_address, uint8_t level) {
|
|
const bool sent = dali_domain_.setBright(gateway_id, dec_address, level);
|
|
if (sent) {
|
|
cache_.mirrorDaliCommand(gateway_id, rawArcAddressFromDec(dec_address), level);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
bool GatewayController::offAndMirror(uint8_t gateway_id, int dec_address) {
|
|
const bool sent = dali_domain_.off(gateway_id, dec_address);
|
|
if (sent) {
|
|
cache_.mirrorDaliCommand(gateway_id, rawCommandAddressFromDec(dec_address), kDaliCmdOff);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
bool GatewayController::onAndMirror(uint8_t gateway_id, int dec_address) {
|
|
const bool sent = dali_domain_.on(gateway_id, dec_address);
|
|
if (sent) {
|
|
cache_.mirrorDaliCommand(gateway_id, rawCommandAddressFromDec(dec_address),
|
|
kDaliCmdRecallMax);
|
|
}
|
|
return sent;
|
|
}
|
|
|
|
uint8_t GatewayController::resolveInternalGroupRawAddress(uint8_t gateway_id, uint8_t raw_addr) {
|
|
if (raw_addr < 0x80 || raw_addr > 0x9f) {
|
|
return raw_addr;
|
|
}
|
|
const uint8_t slot = static_cast<uint8_t>((raw_addr - 0x80) / 2);
|
|
const auto group_data = cache_.group(gateway_id, slot);
|
|
if (!group_data.enabled) {
|
|
return raw_addr;
|
|
}
|
|
return internalGroupRawTargetAddress(group_data.target_type, group_data.target_value, raw_addr);
|
|
}
|
|
|
|
uint8_t GatewayController::normalizeGroupTargetType(uint8_t target_type) {
|
|
return target_type <= 2 ? target_type : 2;
|
|
}
|
|
|
|
uint8_t GatewayController::normalizeGroupTargetValue(uint8_t target_type, uint8_t target_value) {
|
|
const uint8_t normalized_type = normalizeGroupTargetType(target_type);
|
|
if (normalized_type == 0) {
|
|
return std::min<uint8_t>(target_value, 63);
|
|
}
|
|
if (normalized_type == 1) {
|
|
return std::min<uint8_t>(target_value, 15);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint8_t GatewayController::internalGroupRawTargetAddress(uint8_t target_type, uint8_t target_value,
|
|
uint8_t raw_addr) {
|
|
const uint8_t normalized_type = normalizeGroupTargetType(target_type);
|
|
const uint8_t normalized_value = normalizeGroupTargetValue(normalized_type, target_value);
|
|
const uint8_t lsb = raw_addr & 0x01;
|
|
if (normalized_type == 0) {
|
|
return static_cast<uint8_t>(normalized_value * 2 + lsb);
|
|
}
|
|
if (normalized_type == 1) {
|
|
return static_cast<uint8_t>(0x80 + normalized_value * 2 + lsb);
|
|
}
|
|
return lsb == 0 ? 0xfe : 0xff;
|
|
}
|
|
|
|
int GatewayController::internalGroupDecTargetAddress(uint8_t target_type, uint8_t target_value) {
|
|
const uint8_t normalized_type = normalizeGroupTargetType(target_type);
|
|
const uint8_t normalized_value = normalizeGroupTargetValue(normalized_type, target_value);
|
|
if (normalized_type == 0) {
|
|
return normalized_value;
|
|
}
|
|
if (normalized_type == 1) {
|
|
return 64 + normalized_value;
|
|
}
|
|
return 127;
|
|
}
|
|
|
|
uint8_t GatewayController::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 GatewayController::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;
|
|
}
|
|
|
|
int GatewayController::shortAddressFromRaw(uint8_t raw_addr) {
|
|
return raw_addr / 2;
|
|
}
|
|
|
|
int GatewayController::reverseInRange(int value, int min_value, int max_value) {
|
|
return min_value + max_value - value;
|
|
}
|
|
|
|
bool GatewayController::setSceneEnabled(uint8_t gateway_id, uint8_t scene_id, bool enabled) {
|
|
return cache_.setSceneEnabled(gateway_id, scene_id, enabled);
|
|
}
|
|
|
|
bool GatewayController::setSceneDetail(uint8_t gateway_id, uint8_t scene_id, uint8_t brightness,
|
|
uint8_t color_mode, uint8_t data1, uint8_t data2,
|
|
uint8_t data3) {
|
|
const uint8_t next_brightness = std::min<uint8_t>(brightness, 254);
|
|
const uint8_t next_color_mode = std::min<uint8_t>(color_mode, 2);
|
|
uint8_t next_data1 = 0;
|
|
uint8_t next_data2 = 0;
|
|
uint8_t next_data3 = 0;
|
|
if (next_color_mode == 0) {
|
|
next_data1 = data1;
|
|
next_data2 = data2;
|
|
} else if (next_color_mode == 1) {
|
|
next_data1 = data1;
|
|
next_data2 = data2;
|
|
next_data3 = data3;
|
|
}
|
|
return cache_.setSceneDetail(gateway_id, scene_id, next_brightness, next_color_mode,
|
|
next_data1, next_data2, next_data3);
|
|
}
|
|
|
|
bool GatewayController::setSceneName(uint8_t gateway_id, uint8_t scene_id, std::string_view name) {
|
|
const auto normalized = NormalizeName(name);
|
|
return cache_.setSceneName(gateway_id, scene_id, normalized);
|
|
}
|
|
|
|
bool GatewayController::deleteScene(uint8_t gateway_id, uint8_t scene_id) {
|
|
return cache_.deleteScene(gateway_id, scene_id);
|
|
}
|
|
|
|
std::pair<uint8_t, uint8_t> GatewayController::sceneMask(uint8_t gateway_id) {
|
|
return cache_.sceneMask(gateway_id);
|
|
}
|
|
|
|
bool GatewayController::executeScene(uint8_t gateway_id, int short_address, uint8_t scene_id) {
|
|
const auto scene_data = cache_.scene(gateway_id, scene_id);
|
|
if (!scene_data.enabled) {
|
|
return false;
|
|
}
|
|
if (scene_data.brightness <= 0) {
|
|
offAndMirror(gateway_id, short_address);
|
|
} else {
|
|
setBrightAndMirror(gateway_id, short_address, scene_data.brightness);
|
|
}
|
|
if (scene_data.color_mode == 0) {
|
|
int kelvin = scene_data.data1 * 256 + scene_data.data2;
|
|
if (kelvin > 0) {
|
|
if (config_.color_temperature_max < config_.color_temperature_min) {
|
|
kelvin = reverseInRange(kelvin, config_.color_temperature_min,
|
|
config_.color_temperature_max);
|
|
}
|
|
dali_domain_.setColTemp(gateway_id, short_address, kelvin);
|
|
}
|
|
} else if (scene_data.color_mode == 1) {
|
|
if (scene_data.data1 != 0 || scene_data.data2 != 0 || scene_data.data3 != 0) {
|
|
dali_domain_.setColourRGB(gateway_id, short_address, scene_data.data1, scene_data.data2,
|
|
scene_data.data3);
|
|
} else if (scene_data.brightness <= 0) {
|
|
offAndMirror(gateway_id, short_address);
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool GatewayController::setGroupEnabled(uint8_t gateway_id, uint8_t group_id, bool enabled) {
|
|
return cache_.setGroupEnabled(gateway_id, group_id, enabled);
|
|
}
|
|
|
|
bool GatewayController::setGroupDetail(uint8_t gateway_id, uint8_t group_id, uint8_t target_type,
|
|
uint8_t target_value) {
|
|
const uint8_t next_target_type = normalizeGroupTargetType(target_type);
|
|
const uint8_t next_target_value = normalizeGroupTargetValue(next_target_type, target_value);
|
|
return cache_.setGroupDetail(gateway_id, group_id, next_target_type, next_target_value);
|
|
}
|
|
|
|
bool GatewayController::setGroupName(uint8_t gateway_id, uint8_t group_id, std::string_view name) {
|
|
const auto normalized = NormalizeName(name);
|
|
return cache_.setGroupName(gateway_id, group_id, normalized);
|
|
}
|
|
|
|
bool GatewayController::deleteGroup(uint8_t gateway_id, uint8_t group_id) {
|
|
return cache_.deleteGroup(gateway_id, group_id);
|
|
}
|
|
|
|
std::pair<uint8_t, uint8_t> GatewayController::groupMask(uint8_t gateway_id) {
|
|
return cache_.groupMask(gateway_id);
|
|
}
|
|
|
|
bool GatewayController::executeGroup(uint8_t gateway_id, uint8_t group_id) {
|
|
const auto group_data = cache_.group(gateway_id, group_id);
|
|
if (!group_data.enabled) {
|
|
return false;
|
|
}
|
|
return onAndMirror(gateway_id,
|
|
internalGroupDecTargetAddress(group_data.target_type,
|
|
group_data.target_value));
|
|
}
|
|
|
|
void GatewayController::handleGatewayNameCommand(uint8_t gateway_id,
|
|
const std::vector<uint8_t>& command) {
|
|
const uint8_t op = command[4];
|
|
if (op == 0x00) {
|
|
const auto name = gatewayName(gateway_id);
|
|
std::vector<uint8_t> payload{0x05, gateway_id, op,
|
|
static_cast<uint8_t>(std::min(name.size(), kMaxNameBytes))};
|
|
AppendStringBytes(payload, NormalizeName(name));
|
|
publishPayload(gateway_id, payload);
|
|
return;
|
|
}
|
|
if (op != 0x01) {
|
|
return;
|
|
}
|
|
|
|
if (command.size() < 7) {
|
|
publishPayload(gateway_id, {0x05, gateway_id, op, 0x00});
|
|
return;
|
|
}
|
|
const size_t payload_end = command.size() - 1;
|
|
const size_t requested_len = std::min<size_t>(command[5], kMaxNameBytes);
|
|
const size_t available = payload_end > 6 ? payload_end - 6 : 0;
|
|
const size_t actual_len = std::min(requested_len, available);
|
|
std::string name;
|
|
name.reserve(actual_len);
|
|
for (size_t index = 0; index < actual_len; ++index) {
|
|
name.push_back(static_cast<char>(command[6 + index]));
|
|
}
|
|
if (runtime_.setGatewayName(gateway_id, name)) {
|
|
refreshRuntimeGatewayNames();
|
|
for (const auto& sink : gateway_name_sinks_) {
|
|
sink(gateway_id);
|
|
}
|
|
publishPayload(gateway_id, {0x05, gateway_id, op, 0x01});
|
|
} else {
|
|
publishPayload(gateway_id, {0x05, gateway_id, op, 0x00});
|
|
}
|
|
}
|
|
|
|
void GatewayController::handleGatewayIdentityCommand(uint8_t gateway_id, uint8_t op) {
|
|
std::string value;
|
|
if (op == 0x00) {
|
|
value = gatewayName(gateway_id);
|
|
} else if (op == 0x01) {
|
|
value = runtime_.gatewaySerialHex(gateway_id);
|
|
} else if (op == 0x02) {
|
|
value = runtime_.bleMacHex();
|
|
} else {
|
|
publishPayload(gateway_id, {0x0A, gateway_id, op, 0x00, 0x00});
|
|
return;
|
|
}
|
|
std::vector<uint8_t> payload{0x0A, gateway_id, op,
|
|
static_cast<uint8_t>(std::min(value.size(), kMaxNameBytes))};
|
|
AppendStringBytes(payload, value);
|
|
publishPayload(gateway_id, payload);
|
|
}
|
|
|
|
void GatewayController::handleAllocationCommand(uint8_t gateway_id,
|
|
const std::vector<uint8_t>& command) {
|
|
const uint8_t mode = command[4];
|
|
const uint8_t start_addr = command[5];
|
|
if (mode == 0) {
|
|
dali_domain_.stopAllocAddr(gateway_id);
|
|
} else if (mode == 1) {
|
|
dali_domain_.allocateAllAddr(gateway_id, start_addr);
|
|
} else if (mode == 2) {
|
|
dali_domain_.resetAndAllocAddr(gateway_id);
|
|
} else if (mode == 3) {
|
|
publishPayload(gateway_id, {0x30, gateway_id,
|
|
static_cast<uint8_t>(dali_domain_.isAllocAddr(gateway_id) ? 1 : 0),
|
|
static_cast<uint8_t>(dali_domain_.lastAllocAddr(gateway_id) & 0xff)});
|
|
}
|
|
}
|
|
|
|
void GatewayController::handleInternalSceneCommand(uint8_t gateway_id,
|
|
const std::vector<uint8_t>& command) {
|
|
if (command.size() < 7) {
|
|
publishPayload(gateway_id, {0xA1, gateway_id, 0xff, 0xff, 0x01});
|
|
return;
|
|
}
|
|
const uint8_t op = command[4];
|
|
const uint8_t scene_id = command[5];
|
|
if (scene_id > 15) {
|
|
publishPayload(gateway_id, {0xA1, gateway_id, op, scene_id, 0x01});
|
|
return;
|
|
}
|
|
|
|
switch (op) {
|
|
case 0x00:
|
|
publishPayload(gateway_id, setSceneEnabled(gateway_id, scene_id, true)
|
|
? std::vector<uint8_t>{0xA0, gateway_id, op, scene_id, 0x01}
|
|
: std::vector<uint8_t>{0xA1, gateway_id, op, scene_id, 0x02});
|
|
break;
|
|
case 0x01:
|
|
publishPayload(gateway_id, setSceneEnabled(gateway_id, scene_id, false)
|
|
? std::vector<uint8_t>{0xA0, gateway_id, op, scene_id, 0x01}
|
|
: std::vector<uint8_t>{0xA1, gateway_id, op, scene_id, 0x02});
|
|
break;
|
|
case 0x02:
|
|
publishPayload(gateway_id, {0xA0, gateway_id, op, scene_id,
|
|
static_cast<uint8_t>(cache_.scene(gateway_id, scene_id).enabled ? 1 : 0)});
|
|
break;
|
|
case 0x03: {
|
|
const auto [low, high] = sceneMask(gateway_id);
|
|
publishPayload(gateway_id, {0xA0, gateway_id, op, low, high});
|
|
break;
|
|
}
|
|
case 0x04:
|
|
{
|
|
const auto scene_data = cache_.scene(gateway_id, scene_id);
|
|
publishPayload(gateway_id, {0xA0, gateway_id, op, scene_id, scene_data.brightness,
|
|
scene_data.color_mode, scene_data.data1, scene_data.data2,
|
|
scene_data.data3});
|
|
break;
|
|
}
|
|
case 0x05:
|
|
if (command.size() >= 11 && setSceneDetail(gateway_id, scene_id, command[6], command[7],
|
|
command[8], command[9], command[10])) {
|
|
publishPayload(gateway_id, {0xA0, gateway_id, op, scene_id, 0x01});
|
|
} else {
|
|
publishPayload(gateway_id, {0xA1, gateway_id, op, scene_id, 0x02});
|
|
}
|
|
break;
|
|
case 0x06:
|
|
publishPayload(gateway_id, deleteScene(gateway_id, scene_id)
|
|
? std::vector<uint8_t>{0xA0, gateway_id, op, scene_id, 0x01}
|
|
: std::vector<uint8_t>{0xA1, gateway_id, op, scene_id, 0x02});
|
|
break;
|
|
case 0x07: {
|
|
const auto scene_data = cache_.scene(gateway_id, scene_id);
|
|
std::vector<uint8_t> payload{0xA0, gateway_id, op, scene_id};
|
|
AppendPaddedName(payload, scene_data.name);
|
|
publishPayload(gateway_id, payload);
|
|
break;
|
|
}
|
|
case 0x08: {
|
|
if (command.size() < 8) {
|
|
publishPayload(gateway_id, {0xA1, gateway_id, op, scene_id, 0x02});
|
|
break;
|
|
}
|
|
const size_t payload_end = command.size() - 1;
|
|
const size_t requested_len = std::min<size_t>(command[6], kMaxNameBytes);
|
|
const size_t available = payload_end > 7 ? payload_end - 7 : 0;
|
|
const size_t actual_len = std::min(requested_len, available);
|
|
std::string name;
|
|
for (size_t index = 0; index < actual_len; ++index) {
|
|
name.push_back(static_cast<char>(command[7 + index]));
|
|
}
|
|
publishPayload(gateway_id, setSceneName(gateway_id, scene_id, name)
|
|
? std::vector<uint8_t>{0xA0, gateway_id, op, scene_id, 0x01}
|
|
: std::vector<uint8_t>{0xA1, gateway_id, op, scene_id, 0x02});
|
|
break;
|
|
}
|
|
default:
|
|
publishPayload(gateway_id, {0xA1, gateway_id, op, scene_id, 0x03});
|
|
break;
|
|
}
|
|
}
|
|
|
|
void GatewayController::handleInternalGroupCommand(uint8_t gateway_id,
|
|
const std::vector<uint8_t>& command) {
|
|
if (command.size() < 7) {
|
|
publishPayload(gateway_id, {0xA3, gateway_id, 0xff, 0xff, 0x01});
|
|
return;
|
|
}
|
|
const uint8_t op = command[4];
|
|
const uint8_t group_id = command[5];
|
|
if (group_id > 15) {
|
|
publishPayload(gateway_id, {0xA3, gateway_id, op, group_id, 0x01});
|
|
return;
|
|
}
|
|
|
|
switch (op) {
|
|
case 0x00:
|
|
publishPayload(gateway_id, setGroupEnabled(gateway_id, group_id, true)
|
|
? std::vector<uint8_t>{0xA2, gateway_id, op, group_id, 0x01}
|
|
: std::vector<uint8_t>{0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
case 0x01:
|
|
publishPayload(gateway_id, setGroupEnabled(gateway_id, group_id, false)
|
|
? std::vector<uint8_t>{0xA2, gateway_id, op, group_id, 0x01}
|
|
: std::vector<uint8_t>{0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
case 0x02:
|
|
publishPayload(gateway_id, {0xA2, gateway_id, op, group_id,
|
|
static_cast<uint8_t>(cache_.group(gateway_id, group_id).enabled ? 1 : 0)});
|
|
break;
|
|
case 0x03: {
|
|
const auto [low, high] = groupMask(gateway_id);
|
|
publishPayload(gateway_id, {0xA2, gateway_id, op, low, high});
|
|
break;
|
|
}
|
|
case 0x04:
|
|
{
|
|
const auto group_data = cache_.group(gateway_id, group_id);
|
|
publishPayload(gateway_id, {0xA2, gateway_id, op, group_id,
|
|
normalizeGroupTargetType(group_data.target_type),
|
|
normalizeGroupTargetValue(group_data.target_type,
|
|
group_data.target_value)});
|
|
break;
|
|
}
|
|
case 0x05:
|
|
if (command.size() >= 9 && setGroupDetail(gateway_id, group_id, command[6], command[7])) {
|
|
publishPayload(gateway_id, {0xA2, gateway_id, op, group_id, 0x01});
|
|
} else {
|
|
publishPayload(gateway_id, {0xA3, gateway_id, op, group_id, 0x02});
|
|
}
|
|
break;
|
|
case 0x06:
|
|
publishPayload(gateway_id, deleteGroup(gateway_id, group_id)
|
|
? std::vector<uint8_t>{0xA2, gateway_id, op, group_id, 0x01}
|
|
: std::vector<uint8_t>{0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
case 0x07: {
|
|
const auto group_data = cache_.group(gateway_id, group_id);
|
|
std::vector<uint8_t> payload{0xA2, gateway_id, op, group_id};
|
|
AppendPaddedName(payload, group_data.name);
|
|
publishPayload(gateway_id, payload);
|
|
break;
|
|
}
|
|
case 0x08: {
|
|
if (command.size() < 8) {
|
|
publishPayload(gateway_id, {0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
}
|
|
const size_t payload_end = command.size() - 1;
|
|
const size_t requested_len = std::min<size_t>(command[6], kMaxNameBytes);
|
|
const size_t available = payload_end > 7 ? payload_end - 7 : 0;
|
|
const size_t actual_len = std::min(requested_len, available);
|
|
std::string name;
|
|
for (size_t index = 0; index < actual_len; ++index) {
|
|
name.push_back(static_cast<char>(command[7 + index]));
|
|
}
|
|
publishPayload(gateway_id, setGroupName(gateway_id, group_id, name)
|
|
? std::vector<uint8_t>{0xA2, gateway_id, op, group_id, 0x01}
|
|
: std::vector<uint8_t>{0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
}
|
|
case 0x09:
|
|
publishPayload(gateway_id, executeGroup(gateway_id, group_id)
|
|
? std::vector<uint8_t>{0xA2, gateway_id, op, group_id, 0x01}
|
|
: std::vector<uint8_t>{0xA3, gateway_id, op, group_id, 0x02});
|
|
break;
|
|
default:
|
|
publishPayload(gateway_id, {0xA3, gateway_id, op, group_id, 0x03});
|
|
break;
|
|
}
|
|
}
|
|
|
|
} // namespace gateway
|