Add support for DT4, DT5, and DT6 devices

- Updated CMakeLists.txt to include new source files for DT4, DT5, and DT6. - Modified dali.hpp to include headers for DT4, DT5, and DT6. - Added command definitions for DT4, DT5, and DT6 in dali_define.hpp. - Enhanced DaliDeviceCapabilities to support DT4, DT5, and DT6 detection. - Implemented DT4 and DT5 classes with methods for device control and status querying. - Created DT6 class with methods for device control and status querying. - Updated decode.cpp to include new device types in the deviceTypeName mapping. - Enhanced device.cpp to handle new device capabilities.
2026-04-24 13:36:08 +08:00
parent 21afc6b942
commit bbcfcd11f6
12 changed files with 798 additions and 1 deletions
@@ -383,7 +383,10 @@ std::string DaliDecode::whoLabel(int addr, bool even) {
 std::string DaliDecode::deviceTypeName(int v) {
  static const std::map<int, std::string> map = {{0x00, "general control gear"},
                                                  {0x01, "self-contained emergency"},
+                                                  {0x04, "incandescent/halogen"},
+                                                  {0x05, "converter (0/1-10 V)"},
                                                  {0x06, "LED control gear"},
+                                                  {0x07, "switching / OLED control gear"},
                                                  {0x08, "colour control (DT8)"}};
  const auto it = map.find(v);
  return it == map.end() ? "" : it->second;
@@ -49,6 +49,9 @@ DaliDeviceCapabilities DaliDeviceCapabilities::fromJson(const DaliValue::Object*
  DaliDeviceCapabilities c;
  if (!json) return c;
  c.supportsDt1 = getObjectBool(*json, "dt1");
+  c.supportsDt4 = getObjectBool(*json, "dt4");
+  c.supportsDt5 = getObjectBool(*json, "dt5");
+  c.supportsDt6 = getObjectBool(*json, "dt6");
  c.supportsDt8 = getObjectBool(*json, "dt8");
  return c;
 }
@@ -56,12 +59,18 @@ DaliDeviceCapabilities DaliDeviceCapabilities::fromJson(const DaliValue::Object*
 DaliValue::Object DaliDeviceCapabilities::toJson() const {
  DaliValue::Object out;
  if (supportsDt1.has_value()) out["dt1"] = supportsDt1.value();
+  if (supportsDt4.has_value()) out["dt4"] = supportsDt4.value();
+  if (supportsDt5.has_value()) out["dt5"] = supportsDt5.value();
+  if (supportsDt6.has_value()) out["dt6"] = supportsDt6.value();
  if (supportsDt8.has_value()) out["dt8"] = supportsDt8.value();
  return out;
 }

 void DaliDeviceCapabilities::merge(const DaliDeviceCapabilities& other) {
  if (!supportsDt1.has_value()) supportsDt1 = other.supportsDt1;
+  if (!supportsDt4.has_value()) supportsDt4 = other.supportsDt4;
+  if (!supportsDt5.has_value()) supportsDt5 = other.supportsDt5;
+  if (!supportsDt6.has_value()) supportsDt6 = other.supportsDt6;
  if (!supportsDt8.has_value()) supportsDt8 = other.supportsDt8;
 }

@@ -0,0 +1,147 @@
+#include "dt4.hpp"
+
+#include "dali_define.hpp"
+
+#include <algorithm>
+
+DaliDT4::DaliDT4(DaliBase& base) : base_(base) {}
+
+bool DaliDT4::enable() { return base_.dtSelect(4); }
+
+int DaliDT4::addrOf(int a) { return a * 2 + 1; }
+
+std::optional<int> DaliDT4::query(int a, int code) {
+  if (!enable()) return std::nullopt;
+  return base_.queryCmd(static_cast<uint8_t>(addrOf(a)), static_cast<uint8_t>(code));
+}
+
+std::optional<bool> DaliDT4::queryYesNo(int a, int code) {
+  const auto value = query(a, code);
+  if (!value.has_value()) return std::nullopt;
+  return value.value() != 0;
+}
+
+bool DaliDT4::enableDT4() { return enable(); }
+
+bool DaliDT4::referenceSystemPower(int a) {
+  return enable() && base_.sendExtCmd(addrOf(a), DALI_CMD_DT4_REFERENCE_SYSTEM_POWER) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT4_REFERENCE_SYSTEM_POWER);
+}
+
+bool DaliDT4::selectDimmingCurve(int a, int curve) {
+  const int value = std::clamp(curve, 0, 255);
+  return enable() && base_.setDTR(value) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT4_SELECT_DIMMING_CURVE) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT4_SELECT_DIMMING_CURVE);
+}
+
+std::optional<int> DaliDT4::getDimmingCurve(int a) { return query(a, DALI_CMD_DT4_QUERY_DIMMING_CURVE); }
+
+std::optional<DaliDT4DimmerStatus> DaliDT4::getDimmerStatus(int a) {
+  const auto raw = query(a, DALI_CMD_DT4_QUERY_DIMMER_STATUS);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT4DimmerStatus(raw.value());
+}
+
+std::optional<DaliDT4Features> DaliDT4::getFeatures(int a) {
+  const auto raw1 = query(a, DALI_CMD_DT4_QUERY_FEATURES);
+  if (!raw1.has_value()) return std::nullopt;
+  const auto raw2 = base_.getDTR(a);
+  const auto raw3 = base_.getDTR1(a);
+  if (!raw2.has_value() || !raw3.has_value()) return std::nullopt;
+  return DaliDT4Features(raw1.value(), raw2.value(), raw3.value());
+}
+
+std::optional<DaliDT4FailureStatus> DaliDT4::getFailureStatus(int a) {
+  const auto raw1 = query(a, DALI_CMD_DT4_QUERY_FAILURE_STATUS);
+  if (!raw1.has_value()) return std::nullopt;
+  const auto raw2 = base_.getDTR1(a);
+  if (!raw2.has_value()) return std::nullopt;
+  return DaliDT4FailureStatus(raw1.value(), raw2.value());
+}
+
+std::optional<int> DaliDT4::getDimmerTemperatureRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_DIMMER_TEMPERATURE);
+}
+
+std::optional<int> DaliDT4::getDimmerTemperatureCelsius(int a) {
+  const auto raw = getDimmerTemperatureRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() - 40;
+}
+
+std::optional<int> DaliDT4::getRmsSupplyVoltageRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_RMS_SUPPLY_VOLTAGE);
+}
+
+std::optional<double> DaliDT4::getRmsSupplyVoltageVolts(int a) {
+  const auto raw = getRmsSupplyVoltageRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 2.0;
+}
+
+std::optional<int> DaliDT4::getSupplyFrequencyRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_SUPPLY_FREQUENCY);
+}
+
+std::optional<double> DaliDT4::getSupplyFrequencyHertz(int a) {
+  const auto raw = getSupplyFrequencyRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 0.5;
+}
+
+std::optional<int> DaliDT4::getRmsLoadVoltageRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_RMS_LOAD_VOLTAGE);
+}
+
+std::optional<double> DaliDT4::getRmsLoadVoltageVolts(int a) {
+  const auto raw = getRmsLoadVoltageRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 2.0;
+}
+
+std::optional<int> DaliDT4::getRmsLoadCurrentRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_RMS_LOAD_CURRENT);
+}
+
+std::optional<double> DaliDT4::getRmsLoadCurrentPercent(int a) {
+  const auto raw = getRmsLoadCurrentRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 0.5;
+}
+
+std::optional<int> DaliDT4::getRealLoadPowerRaw(int a) {
+  const auto high = query(a, DALI_CMD_DT4_QUERY_REAL_LOAD_POWER);
+  if (!high.has_value()) return std::nullopt;
+  const auto low = base_.getDTR(a);
+  if (!low.has_value()) return std::nullopt;
+  return ((high.value() & 0xFF) << 8) | (low.value() & 0xFF);
+}
+
+std::optional<double> DaliDT4::getRealLoadPowerWatts(int a) {
+  const auto raw = getRealLoadPowerRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFFFF) return std::nullopt;
+  return raw.value() * 0.25;
+}
+
+std::optional<int> DaliDT4::getLoadRatingRaw(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_LOAD_RATING);
+}
+
+std::optional<double> DaliDT4::getLoadRatingAmps(int a) {
+  const auto raw = getLoadRatingRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 0.15;
+}
+
+std::optional<bool> DaliDT4::isReferenceRunning(int a) {
+  return queryYesNo(a, DALI_CMD_DT4_QUERY_REFERENCE_RUNNING);
+}
+
+std::optional<bool> DaliDT4::isReferenceMeasurementFailed(int a) {
+  return queryYesNo(a, DALI_CMD_DT4_QUERY_REFERENCE_MEASUREMENT_FAILED);
+}
+
+std::optional<int> DaliDT4::getExtendedVersion(int a) {
+  return query(a, DALI_CMD_DT4_QUERY_EXTENDED_VERSION);
+}
@@ -0,0 +1,93 @@
+#include "dt5.hpp"
+
+#include "dali_define.hpp"
+
+#include <algorithm>
+
+DaliDT5::DaliDT5(DaliBase& base) : base_(base) {}
+
+bool DaliDT5::enable() { return base_.dtSelect(5); }
+
+int DaliDT5::addrOf(int a) { return a * 2 + 1; }
+
+bool DaliDT5::send(int a, int code, bool twice) {
+  if (!enable()) return false;
+  if (!base_.sendExtCmd(addrOf(a), code)) return false;
+  if (twice && !base_.sendExtCmd(addrOf(a), code)) return false;
+  return true;
+}
+
+std::optional<int> DaliDT5::query(int a, int code) {
+  if (!enable()) return std::nullopt;
+  return base_.queryCmd(static_cast<uint8_t>(addrOf(a)), static_cast<uint8_t>(code));
+}
+
+bool DaliDT5::enableDT5() { return enable(); }
+
+bool DaliDT5::setOutputRange1To10V(int a) {
+  return send(a, DALI_CMD_DT5_SET_OUTPUT_RANGE_1_TO_10V, true);
+}
+
+bool DaliDT5::setOutputRange0To10V(int a) {
+  return send(a, DALI_CMD_DT5_SET_OUTPUT_RANGE_0_TO_10V, true);
+}
+
+bool DaliDT5::switchOnInternalPullUp(int a) {
+  return send(a, DALI_CMD_DT5_SWITCH_ON_INTERNAL_PULL_UP, true);
+}
+
+bool DaliDT5::switchOffInternalPullUp(int a) {
+  return send(a, DALI_CMD_DT5_SWITCH_OFF_INTERNAL_PULL_UP, true);
+}
+
+bool DaliDT5::storePhysicalMinimum(int a, int level) {
+  const int value = std::clamp(level, 0, 254);
+  return enable() && base_.setDTR(value) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT5_STORE_DTR_AS_PHYSICAL_MINIMUM) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT5_STORE_DTR_AS_PHYSICAL_MINIMUM);
+}
+
+bool DaliDT5::selectDimmingCurve(int a, int curve) {
+  const int value = std::clamp(curve, 0, 255);
+  return enable() && base_.setDTR(value) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT5_SELECT_DIMMING_CURVE) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT5_SELECT_DIMMING_CURVE);
+}
+
+bool DaliDT5::resetConverterSettings(int a) {
+  return send(a, DALI_CMD_DT5_RESET_CONVERTER_SETTINGS, true);
+}
+
+std::optional<int> DaliDT5::getDimmingCurve(int a) { return query(a, DALI_CMD_DT5_QUERY_DIMMING_CURVE); }
+
+std::optional<int> DaliDT5::getOutputLevelRaw(int a) {
+  return query(a, DALI_CMD_DT5_QUERY_OUTPUT_LEVEL);
+}
+
+std::optional<double> DaliDT5::getOutputLevelVolts(int a) {
+  const auto raw = getOutputLevelRaw(a);
+  if (!raw.has_value() || raw.value() == 0xFF) return std::nullopt;
+  return raw.value() * 0.04;
+}
+
+std::optional<DaliDT5ConverterFeatures> DaliDT5::getConverterFeatures(int a) {
+  const auto raw = query(a, DALI_CMD_DT5_QUERY_CONVERTER_FEATURES);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT5ConverterFeatures(raw.value());
+}
+
+std::optional<DaliDT5FailureStatus> DaliDT5::getFailureStatus(int a) {
+  const auto raw = query(a, DALI_CMD_DT5_QUERY_FAILURE_STATUS);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT5FailureStatus(raw.value());
+}
+
+std::optional<DaliDT5ConverterStatus> DaliDT5::getConverterStatus(int a) {
+  const auto raw = query(a, DALI_CMD_DT5_QUERY_CONVERTER_STATUS);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT5ConverterStatus(raw.value());
+}
+
+std::optional<int> DaliDT5::getExtendedVersion(int a) {
+  return query(a, DALI_CMD_DT5_QUERY_EXTENDED_VERSION);
+}
@@ -0,0 +1,139 @@
+#include "dt6.hpp"
+
+#include "dali_define.hpp"
+
+#include <algorithm>
+
+DaliDT6::DaliDT6(DaliBase& base) : base_(base) {}
+
+bool DaliDT6::enable() { return base_.dtSelect(6); }
+
+int DaliDT6::addrOf(int a) { return a * 2 + 1; }
+
+bool DaliDT6::send(int a, int code, bool twice) {
+  if (!enable()) return false;
+  if (!base_.sendExtCmd(addrOf(a), code)) return false;
+  if (twice && !base_.sendExtCmd(addrOf(a), code)) return false;
+  return true;
+}
+
+std::optional<int> DaliDT6::query(int a, int code) {
+  if (!enable()) return std::nullopt;
+  return base_.queryCmd(static_cast<uint8_t>(addrOf(a)), static_cast<uint8_t>(code));
+}
+
+std::optional<bool> DaliDT6::queryYesNo(int a, int code) {
+  const auto value = query(a, code);
+  if (!value.has_value()) return std::nullopt;
+  return value.value() != 0;
+}
+
+bool DaliDT6::enableDT6() { return enable(); }
+
+bool DaliDT6::referenceSystemPower(int a) {
+  return send(a, DALI_CMD_DT6_REFERENCE_SYSTEM_POWER, true);
+}
+
+bool DaliDT6::enableCurrentProtector(int a) {
+  return send(a, DALI_CMD_DT6_ENABLE_CURRENT_PROTECTOR, true);
+}
+
+bool DaliDT6::disableCurrentProtector(int a) {
+  return send(a, DALI_CMD_DT6_DISABLE_CURRENT_PROTECTOR, true);
+}
+
+bool DaliDT6::selectDimmingCurve(int a, int curve) {
+  const int value = std::clamp(curve, 0, 255);
+  return enable() && base_.setDTR(value) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT6_SELECT_DIMMING_CURVE) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT6_SELECT_DIMMING_CURVE);
+}
+
+bool DaliDT6::storeFastFadeTime(int a, int value) {
+  const int clamped = std::clamp(value, 0, 27);
+  return enable() && base_.setDTR(clamped) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT6_STORE_DTR_AS_FAST_FADE_TIME) &&
+         base_.sendExtCmd(addrOf(a), DALI_CMD_DT6_STORE_DTR_AS_FAST_FADE_TIME);
+}
+
+std::optional<DaliDT6GearType> DaliDT6::getGearType(int a) {
+  const auto raw = query(a, DALI_CMD_DT6_QUERY_GEAR_TYPE);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT6GearType(raw.value());
+}
+
+std::optional<int> DaliDT6::getDimmingCurve(int a) { return query(a, DALI_CMD_DT6_QUERY_DIMMING_CURVE); }
+
+std::optional<DaliDT6OperatingModes> DaliDT6::getPossibleOperatingModes(int a) {
+  const auto raw = query(a, DALI_CMD_DT6_QUERY_POSSIBLE_OPERATING_MODES);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT6OperatingModes(raw.value());
+}
+
+std::optional<DaliDT6Features> DaliDT6::getFeatures(int a) {
+  const auto raw = query(a, DALI_CMD_DT6_QUERY_FEATURES);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT6Features(raw.value());
+}
+
+std::optional<DaliDT6FailureStatus> DaliDT6::getFailureStatus(int a) {
+  const auto raw = query(a, DALI_CMD_DT6_QUERY_FAILURE_STATUS);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT6FailureStatus(raw.value());
+}
+
+std::optional<bool> DaliDT6::hasShortCircuit(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_SHORT_CIRCUIT);
+}
+
+std::optional<bool> DaliDT6::hasOpenCircuit(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_OPEN_CIRCUIT);
+}
+
+std::optional<bool> DaliDT6::hasLoadDecrease(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_LOAD_DECREASE);
+}
+
+std::optional<bool> DaliDT6::hasLoadIncrease(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_LOAD_INCREASE);
+}
+
+std::optional<bool> DaliDT6::isCurrentProtectorActive(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_CURRENT_PROTECTOR_ACTIVE);
+}
+
+std::optional<bool> DaliDT6::hasThermalShutDown(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_THERMAL_SHUTDOWN);
+}
+
+std::optional<bool> DaliDT6::hasThermalOverload(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_THERMAL_OVERLOAD);
+}
+
+std::optional<bool> DaliDT6::isReferenceRunning(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_REFERENCE_RUNNING);
+}
+
+std::optional<bool> DaliDT6::isReferenceMeasurementFailed(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_REFERENCE_MEASUREMENT_FAILED);
+}
+
+std::optional<bool> DaliDT6::isCurrentProtectorEnabled(int a) {
+  return queryYesNo(a, DALI_CMD_DT6_QUERY_CURRENT_PROTECTOR_ENABLED);
+}
+
+std::optional<DaliDT6OperatingMode> DaliDT6::getOperatingMode(int a) {
+  const auto raw = query(a, DALI_CMD_DT6_QUERY_OPERATING_MODE);
+  if (!raw.has_value()) return std::nullopt;
+  return DaliDT6OperatingMode(raw.value());
+}
+
+std::optional<int> DaliDT6::getFastFadeTime(int a) { return query(a, DALI_CMD_DT6_QUERY_FAST_FADE_TIME); }
+
+std::optional<int> DaliDT6::getMinFastFadeTime(int a) {
+  return query(a, DALI_CMD_DT6_QUERY_MIN_FAST_FADE_TIME);
+}
+
+std::optional<int> DaliDT6::getExtendedVersion(int a) {
+  return query(a, DALI_CMD_DT6_QUERY_EXTENDED_VERSION);
+}