Google verwendet KI-Technologie, um Inhalte in Ihre bevorzugte Sprache zu übersetzen. KI-Übersetzungen können Fehler enthalten.

Geräteanleitung für Lampen

Leuchten verwenden standardmäßige Matter-Attribute, um Leuchten zu identifizieren, den Ein-/Aus-Zustand umzuschalten und die Helligkeit anzupassen.

Der einfachste Gerätetyp für Lampen ist OnOffLight, der mit den Attributen OnOff und Identify implementiert wird und optional die Attribute LevelControl und LightEffects unterstützt.

Andere Lampentypen bieten zusätzliche Funktionen und werden mit anderen Attributen implementiert:

Gerätetyp für Home APIs	Merkmale	Kotlin-Beispiel-App	Anwendungsfall
Farbtemperaturlicht `ColorTemperatureLightDevice` `home.matter.0000.types.010c` Ein Beleuchtungsgerät, das ein- oder ausgeschaltet werden kann und dessen Lichtintensität und Farbtemperatur angepasst werden können.	Erforderliche Attribute Matter Identify Matter OnOff Matter LevelControl Matter ColorControl Optionale Eigenschaften google LightEffects google ExtendedColorControl	ein- und ausschalten, Helligkeit	Leicht
Dimmbare Lampe `DimmableLightDevice` `home.matter.0000.types.0101` Ein Beleuchtungsgerät, das ein- oder ausgeschaltet werden kann, dessen Lichtintensität angepasst werden kann und das über einen verknüpften Anwesenheitssensor geschaltet werden kann.	Erforderliche Eigenschaften matter Identify matter OnOff matter LevelControl Optionale Attribute google LightEffects	ein- und ausschalten, Helligkeit	Leicht
Erweiterte Farblichtquelle `ExtendedColorLightDevice` `home.matter.0000.types.010d` Ein Beleuchtungsgerät, das ein- oder ausgeschaltet werden kann, dessen Lichtintensität und Farbtemperatur angepasst werden können und das über einen gebundenen Anwesenheitssensor geschaltet werden kann.	Erforderliche Attribute Matter Identify Matter OnOff Matter LevelControl Matter ColorControl Optionale Eigenschaften google LightEffects google ExtendedColorControl	ein- und ausschalten, Helligkeit	Leicht
Licht ein/aus `OnOffLightDevice` `home.matter.0000.types.0100` Ein Beleuchtungsgerät, das ein- oder ausgeschaltet werden kann.	Erforderliche Attribute matter Identify matter OnOff Optionale Attribute matter LevelControl google LightEffects	ein- und ausschalten, Helligkeit	Leicht

Prüfe immer, ob ein Gerät die Attribute und Befehle unterstützt, bevor du Funktionen verwendest oder versuchst, Attribute zu aktualisieren. Weitere Informationen findest du unter Geräte aufAndroidsteuern.

Vorbereitung

Bevor du mit Beleuchtungsgeräten und Beleuchtungskurven arbeitest, musst du dafür sorgen, dass deine App das Home SDK initialisiert und die erforderlichen Importe enthält:

import com.google.home.HomeDevice
import com.google.home.Structure
import com.google.home.google.DayOfWeek
import com.google.home.google.ExtendedColorControl
import com.google.home.google.ExtendedColorControlTrait
import com.google.home.google.LightingCurve
import com.google.home.google.LightingCurveTrait
import com.google.home.matter.standard.ColorControl
import com.google.home.matter.standard.ColorControlTrait
import com.google.home.matter.standard.ColorTemperatureLightDevice
import com.google.home.matter.standard.DimmableLightDevice
import com.google.home.matter.standard.ExtendedColorLightDevice
import com.google.home.matter.standard.GeneralDiagnostics
import com.google.home.matter.standard.Identify
import com.google.home.matter.standard.IdentifyTrait
import com.google.home.matter.standard.LevelControl
import com.google.home.matter.standard.LevelControlTrait
import com.google.home.matter.standard.OnOff
import com.google.home.matter.standard.OnOffLightDevice
import com.google.home.matter.standard.OnOffTrait
import com.google.home.matter.standard.RootNodeDevice
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.firstOrNull

Leuchten finden

Wenn du Beleuchtungsgeräte in einem Gebäude finden möchtest, filtere die Geräteliste nach Gerätetyp, z. B. OnOffLightDevice und DimmableLightDevice.

// Get all On/Off Light devices in the structure
val onOffLights: List<HomeDevice> =
  home.devices().list().filter { it.has(OnOffLightDevice) }

// Get all Dimmable Light devices in the structure
val dimmableLights: List<HomeDevice> =
  home.devices().list().filter { it.has(DimmableLightDevice) }

// Retrieve a specific device type instance to access its traits
val onOffLightDevice: OnOffLightDevice? =
  onOffLights.firstOrNull()?.type(OnOffLightDevice)?.firstOrNull()

val dimmableLightDevice: DimmableLightDevice? =
  dimmableLights.firstOrNull()?.type(DimmableLightDevice)?.firstOrNull()

Du kannst auch alle Beleuchtungsgeräte über mehrere Beleuchtungsgerätetypen hinweg in einem einzigen Filter abrufen:

// Get a list of devices with similar device types (lights)
val lightDevices =
  home.devices().map { devices ->
    devices.filter {
      it.has(DimmableLightDevice) ||
        it.has(OnOffLightDevice) ||
        it.has(ColorTemperatureLightDevice) ||
        it.has(ExtendedColorLightDevice)
    }
  }

Grundlegende Informationen zu einem Gerät abrufen

In der Beispiel-App für Android implementiert

Das Attribut BasicInformation enthält Informationen wie den Namen des Anbieters, die Anbieter-ID, die Produkt-ID, den Produktnamen (einschließlich Modellinformationen) und die Softwareversion für ein Gerät:

// Get device basic information. All general information traits are on the RootNodeDevice type.
    device.type(RootNodeDevice).first().standardTraits.basicInformation?.let { basicInformation ->
        println("vendorName ${basicInformation.vendorName}")
        println("vendorId ${basicInformation.vendorId}")
        println("productId ${basicInformation.productId}")
        println("productName ${basicInformation.productName}")
        println("softwareVersion ${basicInformation.softwareVersion}")
    }

Beleuchtungsgerät identifizieren

Wenn ein Raum mehrere Lampen enthält, kannst du Nutzern helfen, eine bestimmte physische Leuchte zu finden, indem du einen visuellen Identifikationsstatus auslöst, z. B. indem du die Lampe einige Sekunden lang blinken lässt. Alle vier Gerätetypen für Lampen erfordern das Attribut Identify.

Rufen Sie den Befehl identify mit einer identifyTime-Dauer in Sekunden auf, um den Identifikationsstatus zu starten. Wenn Sie 0 übergeben, wird der Identifikationsstatus sofort beendet. Sie können auch triggerEffect aufrufen, um einen bestimmten visuellen Effekt auszuführen, z. B. Blink oder Breathe.

suspend fun identifyLight(lightDevice: DimmableLightDevice) {
  val identifyTrait = lightDevice.standardTraits.identify ?: return

  // Blink the light for 10 seconds so the user can locate it
  if (identifyTrait.supports(Identify.Command.Identify)) {
    identifyTrait.identify(identifyTime = 10u)
  }

  // Or trigger a specific visual identification effect
  if (identifyTrait.supports(Identify.Command.TriggerEffect)) {
    identifyTrait.triggerEffect(
      effectIdentifier = IdentifyTrait.EffectIdentifierEnum.Blink,
      effectVariant = IdentifyTrait.EffectVariantEnum.Default
    )
  }
}

Verbindung eines Beleuchtungsgeräts prüfen

Die Konnektivität eines Geräts wird auf der Ebene des Gerätetyps geprüft, da einige Geräte mehrere Gerätetypen unterstützen. Der zurückgegebene Status ist eine Kombination der Verbindungsstatus aller Attribute auf diesem Gerät.

let lightConnectivity =
  dimmableLightDeviceType.metadata.sourceConnectivity
  .connectivityState

Der Status partiallyOnline kann bei gemischten Gerätetypen auftreten, wenn keine Internetverbindung besteht. Matter-Standard-Traits sind aufgrund des lokalen Routings möglicherweise noch online, cloudbasierte Traits sind jedoch offline.

IP-Adresse des Geräts abrufen

Verwenden Sie das Attribut networkInterfaces von GeneralDiagnosticsTrait, um die IP-Adresse des Geräts zu ermitteln. Die Adressen werden als Data-Objekte zurückgegeben, die Sie mit dem Network-Framework in IPv4- oder IPv6-Standardstrings formatieren können:

func getIpAddresses(trait: Matter.GeneralDiagnosticsTrait) -> [String] {
  let interfaces = trait.attributes.networkInterfaces ?? []
  var ipAddresses: [String] = []

  for interface in interfaces {
    for data in interface.iPv4Addresses {
      if let ipv4 = IPv4Address(data) {
        ipAddresses.append(String(describing: ipv4))
      }
    }
    for data in interface.iPv6Addresses {
      if let ipv6 = IPv6Address(data) {
        ipAddresses.append(String(describing: ipv6))
      }
    }
  }

  return ipAddresses
}

Beleuchtungsgeräte steuern

Die Gerätetypen OnOffLight und DimmableLight verwenden Standard-Matter-Attribute, um Leuchten zu identifizieren, den Ein-/Aus-Zustand umzuschalten und die Helligkeit anzupassen.

Licht ein- oder ausschalten

Verwende das Attribut OnOff, um den aktuellen Stromstatus einer OnOffLight oder DimmableLight auszulesen und das Licht ein- oder auszuschalten.

Bevor du das Attribut onOff liest, solltest du prüfen, ob es vom Gerät unterstützt wird. Einige Geräte funktionieren als reine Befehlsendpunkte und melden keinen Status.

// Check if the OnOff trait supports the onOff attribute.
if (onOffTrait.supports(OnOff.Attribute.onOff)) {
  println("onOffTrait supports onOff state")
} else {
  println("onOffTrait is for a command only device!")
}

Wenn onOff true ist, ist das Licht an. Wenn onOff false ist, ist das Licht aus.

Wenn du den Betriebszustand der Lampe ändern möchtest, prüfe, ob das Attribut den gewünschten Befehl unterstützt, und rufe dann on(), off() oder toggle() auf.

// Check if the OnOff trait supports the toggle command.
if (onOffTrait.supports(OnOff.Command.Toggle)) {
  println("onOffTrait supports toggle command")
} else {
  println("onOffTrait does not support stateful toggle command")
}

// Calling a command on a trait.
try {
  onOffTrait.toggle()
} catch (e: HomeException) {
  // Code for handling the exception
}

Sie können auch on() und off() direkt aufrufen, um einen expliziten Status festzulegen:

onOffTrait.off()
onOffTrait.on()

Wenn du eine Lampe mit einem allmählichen visuellen Übergang ausschalten möchtest, rufe offWithEffect() auf und gib einen EffectIdentifierEnum-Wert an:

// Turn off the light using the DyingLight effect.
onOffTrait.offWithEffect(
  effectIdentifier = OnOffTrait.EffectIdentifierEnum.DyingLight,
  effectVariant = 0u,
)

Helligkeit anpassen

Für ein DimmableLight ist das Attribut LevelControl erforderlich. Ein OnOffLight kann es optional unterstützen. Mit diesem Attribut kannst du die Helligkeit einer Lampe ablesen und steuern.

Das Attribut currentLevel gibt die aktuelle Helligkeit auf einer Skala von 0 bis 254 an. Du kannst auch minLevel und maxLevel prüfen, um den gültigen Helligkeitsbereich zu ermitteln, der von der Hardware unterstützt wird.

Wenn du die Helligkeit auf einen bestimmten Wert festlegen möchtest, rufe moveToLevel() auf. Beachte, dass moveToLevel() nur die aktuelle Stufe ändert, wenn das Licht bereits eingeschaltet ist, es sei denn, du konfigurierst optionsOverride mit executeIfOff. Wenn du möchtest, dass das Licht automatisch eingeschaltet wird, wenn du eine Helligkeit über null einstellst (oder ausgeschaltet wird, wenn du die Helligkeit auf das Minimum einstellst), verwende moveToLevelWithOnOff().

// Change the brightness of the light to 50%
levelControlTrait.moveToLevel(
  level = 127u.toUByte(),
  transitionTime = null,
  optionsMask = LevelControlTrait.OptionsBitmap(),
  optionsOverride = LevelControlTrait.OptionsBitmap(),
)

Im folgenden Beispiel wird die aktuelle Helligkeit ausgelesen und mit moveToLevelWithOnOff() eine dimmbare Lampe auf 75% Helligkeit (190u) über einen Übergang von 1 Sekunde (10u Zehntelsekunden) eingestellt:

suspend fun setLightBrightness(lightDevice: DimmableLightDevice) {
  val levelControl = lightDevice.standardTraits.levelControl ?: return

  // Read the current brightness level (0 to 254)
  val currentLevel: UByte? = levelControl.currentLevel
  println("Current brightness level: $currentLevel")

  // Move to ~75% brightness (190 out of 254) and turn on the light if it is off
  if (levelControl.supports(LevelControl.Command.MoveToLevelWithOnOff)) {
    levelControl.moveToLevelWithOnOff(
      level = 190u,
      transitionTime = 10u,
      optionsMask = LevelControlTrait.OptionsBitmap(),
      optionsOverride = LevelControlTrait.OptionsBitmap()
    )
  }
}

Du kannst die Helligkeit auch relativ zum aktuellen Wert erhöhen oder verringern, indem du stepWithOnOff() mit StepModeEnum.Up oder StepModeEnum.Down und einem stepSize aufrufst.

Farbe der Steuerelemente

Das Attribut ColorControl ist sowohl für ColorTemperatureLightDevice als auch für ExtendedColorLightDevice verfügbar.

Mit diesem Attribut kannst du die Farbtemperatur in Mikro-Reziprokgrad oder Mired anpassen.

val colorControlTrait =
  colorTempLightDevice.standardTraits.colorControl ?: return
// Read the current color temperature and hardware limits in mireds
// (Mireds = 1,000,000 / Kelvin; e.g., 370 mireds ≈ 2700K warm white, 250 mireds = 4000K cool white)
val currentMireds = colorControlTrait.colorTemperatureMireds
val minMireds = colorControlTrait.colorTempPhysicalMinMireds ?: 153u // ~6500K (coolest)
val maxMireds = colorControlTrait.colorTempPhysicalMaxMireds ?: 500u // 2000K (warmest)
// Clamp target (370 mireds ≈ 2700K) to the device's physical bounds
val targetMireds = 370u.toUShort().coerceIn(minMireds, maxMireds)
if (
  colorControlTrait.supports(
    ColorControl.Command.MoveToColorTemperature
  )
) {
  colorControlTrait.moveToColorTemperature(
    colorTemperatureMireds = targetMireds,
    transitionTime = 20u, // 2.0 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

Du kannst die Farbe auch mit CIE 1931-Farbkoordinaten und 16-Bit-Farbton- und Sättigungswerten festlegen.

val colorControlTrait =
  extendedColorLightDevice.standardTraits.colorControl ?: return
// 1. Move to CIE 1931 xy chromaticity coordinates (scaled 0..65279)
// Example: x = 0.3127 (20493), y = 0.3290 (21561) for D65 white point
if (colorControlTrait.supports(ColorControl.Command.MoveToColor)) {
  colorControlTrait.moveToColor(
    colorX = 20493u,
    colorY = 21561u,
    transitionTime = 10u, // 1.0 second (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
val currentX = colorControlTrait.currentX
val currentY = colorControlTrait.currentY
// 2. Move to 16-bit Enhanced Hue (0..65534) and 8-bit Saturation (0..254)
if (
  colorControlTrait.supports(
    ColorControl.Command.EnhancedMoveToHueAndSaturation
  )
) {
  colorControlTrait.enhancedMoveToHueAndSaturation(
    enhancedHue = 43690u, // ~240° (Blue) on the 0..65534 scale
    saturation = 254u,    // Full saturation
    transitionTime = 15u, // 1.5 seconds (in 0.1s units)
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}
// 3. Start a hardware color loop across the device's hue range
if (colorControlTrait.supports(ColorControl.Command.ColorLoopSet)) {
  colorControlTrait.colorLoopSet(
    updateFlags =
      ColorControlTrait.UpdateFlagsBitmap(
        updateAction = true,
        updateDirection = true,
        updateTime = true,
        updateStartHue = true
      ),
    action =
      ColorControlTrait.ColorLoopActionEnum
        .ActivateFromColorLoopStartEnhancedHue,
    direction = ColorControlTrait.ColorLoopDirectionEnum.Increment,
    time = 30u, // 30 seconds per full cycle
    startHue = 0u,
    optionsMask = ColorControlTrait.OptionsBitmap(),
    optionsOverride = ColorControlTrait.OptionsBitmap()
  )
}

ExtendedColorControl ist ein optionales Google-Attribut für ExtendedColorLightDevice, das die Farbsteuerung vereinfacht, indem es Farbnamen, RGB-Werte oder einheitliche HSV-Gleitkommawerte akzeptiert, die Farbe und Helligkeit in einer einzigen Einheit kombinieren.

val extendedColorControlTrait =
  extendedColorLightDevice.googleTraits.extendedColorControl ?: return
// 1. Set color by name
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorName
  )
) {
  extendedColorControlTrait.moveToColorName(colorName = "Lavender")
}
val currentColorName = extendedColorControlTrait.currentName
// 2. Set color using 8-bit RGB values (0..255 per channel)
// Automatically coordinates brightness (LevelControl) and color (ColorControl)
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorRgb
  )
) {
  extendedColorControlTrait.moveToColorRgb(
    red = 255u,
    green = 128u,
    blue = 0u
  )
}
val currentRed = extendedColorControlTrait.currentRed
val currentGreen = extendedColorControlTrait.currentGreen
val currentBlue = extendedColorControlTrait.currentBlue
// 3. Set color and brightness together using floating-point HSV
// hue: 0.0f..360.0f, saturation: 0.0f..1.0f, value (brightness): 0.0f..1.0f
if (
  extendedColorControlTrait.supports(
    ExtendedColorControl.Command.MoveToColorHsv
  )
) {
  extendedColorControlTrait.moveToColorHsv(
    hue = 210.0f,
    saturation = 0.85f,
    value = 0.75f
  )
}
val currentHue = extendedColorControlTrait.currentHue
val currentSaturation = extendedColorControlTrait.currentSaturation
val currentValue = extendedColorControlTrait.currentValue

Beleuchtungskurven verwalten

Eine Beleuchtungskurve definiert einen automatisierten Zeitplan, der die Helligkeit und optional die Farbtemperatur der Ziellampen im Laufe des Tages fließend anpasst. Mit einer Lichtkurve können Lampen beispielsweise morgens langsam heller und abends auf einen wärmeren Farbton gedimmt werden. Leuchtentypen, die nur die Helligkeit unterstützen, z. B. dimmbare Leuchten, folgen der Helligkeitskurve und ignorieren die Farbtemperatur.

Das Attribut LightingCurve ist ein Google Home platform-Attribut auf Gebäudeebene. Du greifst über eine Structure-Instanz darauf zu, nicht über ein einzelnes Beleuchtungsgerät.

Jedes Programm im Attribut wird durch ein LightingCurveSetting dargestellt, das eine eindeutige settingId mit einem LightingCurveConfig verknüpft. In der folgenden Tabelle werden die Konfigurationsfelder von LightingCurveConfig beschrieben:

Feld	Beschreibung
`curvePointsList`	Eine Abfolge von mindestens zwei `CurvePoint`-Elementen mit unterschiedlichen Zeiten. Jeder Punkt gibt eine `time` (`CurveTimeOfDay` mit `hours` von `0` bis `23` und `minutes` von `0` bis `59`), eine `brightnessPercent` (`0` bis `100`) und eine optionale `colorTemperature` in Kelvin an. Wenn `colorTemperature` für einen Punkt angegeben ist, muss es für alle Punkte ein positiver Wert sein.
`roomId`	Die ID des Zielraums (z. B. `room@{uuid}`). Die Lichtkurve wird auf kompatible dimmbare Lampen und Lampen mit Farbtemperatur in diesem Raum angewendet. Geben Sie entweder `roomId` oder `devices` an.
`devices`	Ein `TargetDevices`-Objekt, das eine Liste von `TargetDevice`-Einträgen enthält, jeweils mit einem `id` und einer `type`-ID (z. B. `home.matter.0000.types.0101` für `DimmableLight` oder `home.matter.0000.types.010c` für `ColorTemperatureLight`). Gib entweder `devices` oder `roomId` an.
`daysOfWeekList`	Die Wochentage, an denen die Beleuchtungskurve ausgeführt wird (`DayOfWeek`). Wenn die Liste leer ist, wird die Beleuchtungskurve täglich ausgeführt.
`adaptive`	Optionaler boolescher Wert, der angibt, ob die Beleuchtungskurve adaptiv ist. Das bedeutet, dass ein Ziellicht die aktive Kurvenstufe wieder aufnimmt, wenn es während des geplanten Zeitfensters eingeschaltet wird. Wenn `false`, wird eine Lampe durch eine manuelle Änderung für den Rest des Tages von der Lichtkurve getrennt. Wenn `true`, wird eine Lampe, die während des Zeitfensters für den Zeitplan aus- und wieder eingeschaltet wird, wieder in die Lichtkurve eingebunden. Sie passt sich dann der aktuellen Helligkeit und Farbtemperatur der Kurve an und folgt ihr von da an.
`enabled`	Optionaler boolescher Wert, der angibt, ob die Einstellung für die Beleuchtungskurve aktiv ist. Der Standardwert beim Erstellen einer neuen Einstellung ist `true`. Wenn `enabled` in einem Aktualisierungsbefehl weggelassen wird, ändert sich der Status von `enabled` nicht.

Einstellungen für die Beleuchtungskurve abrufen

Wenn du die für ein Gebäude konfigurierten Lichtkurven prüfen möchtest, rufe das Attribut LightingCurve aus dem Structure ab und lies das Attribut lightingCurveSettingsList.

suspend fun readLightingCurves(structure: Structure) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  for (setting in lightingCurve.lightingCurveSettingsList) {
    val settingId = setting.settingId
    val config = setting.config
    println("Setting ID: $settingId, enabled: ${config?.enabled}")
    config?.curvePointsList?.forEach { point ->
      println(
        "  Time: ${point.time?.hours}:${point.time?.minutes}, " +
          "Brightness: ${point.brightnessPercent}%, " +
          "ColorTemp: ${point.colorTemperature}K"
      )
    }
  }
}

Einstellung für die Beleuchtungskurve erstellen

Wenn du ein neues Beleuchtungskurvenprogramm für ein Gebäude erstellen möchtest, erstelle ein LightingCurveConfig mit mindestens zwei CurvePoint-Einträgen, den Ziellampen (angegeben durch roomId oder devices) und den aktiven Wochentagen. Übergeben Sie dann die Konfiguration an createLightingCurveSetting(). Der Befehl gibt die eindeutige settingId zurück, die der neuen Einstellung für die Beleuchtungskurve zugewiesen ist.

Im folgenden Beispiel wird eine Beleuchtungskurve für einen Raum an Wochentagen erstellt. Sie wird von 30% Helligkeit bei warmen 2.700 K um 7:00 Uhr auf 80% bei kühleren 4.000 K um 9:00 Uhr erhöht und dann bis 21:00 Uhr auf 20% bei sehr warmen 2.200 K gedimmt:

suspend fun createRoomLightingCurve(
  structure: Structure,
  targetRoomId: String
): String? {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return null

  val curvePoints = listOf(
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 7, minutes = 0),
      brightnessPercent = 30,
      colorTemperature = 2700
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 9, minutes = 0),
      brightnessPercent = 80,
      colorTemperature = 4000
    ),
    LightingCurveTrait.CurvePoint(
      time = LightingCurveTrait.CurveTimeOfDay(hours = 21, minutes = 0),
      brightnessPercent = 20,
      colorTemperature = 2200
    )
  )

  val config = LightingCurveTrait.LightingCurveConfig(
    curvePointsList = curvePoints,
    roomId = targetRoomId,
    daysOfWeekList = listOf(
      DayOfWeek.MONDAY,
      DayOfWeek.TUESDAY,
      DayOfWeek.WEDNESDAY,
      DayOfWeek.THURSDAY,
      DayOfWeek.FRIDAY
    ),
    adaptive = true,
    enabled = true
  )

  // Returns the newly created settingId
  return lightingCurve.createLightingCurveSetting(config = config)
}

Wenn du bestimmte Beleuchtungsgeräte anstelle eines ganzen Raums ansprechen möchtest, gib den Parameter devices mit LightingCurveTrait.TargetDevices an:

val targetDevices = LightingCurveTrait.TargetDevices(
  devicesList = listOf(
    LightingCurveTrait.TargetDevice(
      id = dimmableLight.id.id,
      type = DimmableLightDevice.TYPE_ID
    )
  )
)

val deviceCurveConfig = LightingCurveTrait.LightingCurveConfig(
  curvePointsList = curvePoints,
  devices = targetDevices,
  daysOfWeekList = listOf(DayOfWeek.SATURDAY, DayOfWeek.SUNDAY),
  adaptive = true,
  enabled = true
)

val settingId = lightingCurve.createLightingCurveSetting(
  config = deviceCurveConfig
)

Einstellung für die Beleuchtungskurve aktualisieren

Wenn du eine vorhandene Beleuchtungskurve ändern möchtest, z. B. die Kurvenpunkte ändern, die aktiven Wochentage aktualisieren oder den Zeitplan aktivieren oder deaktivieren, rufe updateLightingCurveSetting() mit dem Ziel settingId und einer aktualisierten LightingCurveConfig auf.

suspend fun updateLightingCurve(
  structure: Structure,
  settingId: String,
  updatedConfig: LightingCurveTrait.LightingCurveConfig
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.updateLightingCurveSetting(
    settingId = settingId,
    config = updatedConfig
  )
}

Einstellung für die Beleuchtungskurve löschen

Wenn du eine Einstellung für die Beleuchtungskurve aus einem Gebäude entfernen möchtest, rufe deleteLightingCurveSetting() mit der settingId der Einstellung auf, die du löschen möchtest.

suspend fun deleteLightingCurve(
  structure: Structure,
  settingId: String
) {
  val lightingCurve = structure.trait(LightingCurve).firstOrNull() ?: return

  lightingCurve.deleteLightingCurveSetting(settingId = settingId)
}