FIBARO Walli Dimmer – inteligentny ściemniacz ścienny

Sterowanie kontaktami ściennymi to preludium do sterowania całym oświetleniem w domu. Może się ono odbywać za pomocą całych inteligentnych kontaktów bądź za pomocą dodatkowych modułów montowanych za starym włącznikiem ściennym.

Inteligentne ściemniacze ścienne w prosty sposób zmieniają nam zwykły np. żyrandol w jego inteligenty odpowiednik gdzie możemy sterować oświetleniem, zachowując tym samym zwykłe żarówki (muszą posiadać opcję ściemniania).

Pamiętaj: Przed zakupem zaznajom się z instalacją elektryczną w swoim domu, posiadanymi żarówkami oraz instrukcją instalacji i dodania do ekosystemu SmartThings. Niestety do najłatwiejszych to nie należy, całość znajdziesz tutaj oraz w tym poście poniżej.

Z powodu braku kabla naturalnego w puszce ściennej, byłem zmuszony skorzystać nie ze zwykłego przełącznika np. FIBARO Walli Switch, lecz ze ściemniacza polskiej firmy FIBAROWalli Dimmer.

Opis

Inteligentny ściemniacz ścienny Walli Dimmer (FGWDEU-111) posiada unikalny design, wyposażony jest w dwa przyciski oraz pierścień LED włoku grzybka. Wyświetlana kolory pierścienia może się różnić w zależności czy ściemniacz jest włączony czy wyłączony, można wybierać z siedmiu dostępnych jak i całkowicie wyłączyć pierścień. Mierzy moc czynną i energię zużywaną przez kontrolowane obciążenie. Komunikacja odbywa się po protokole Z-Wave. Ściemniacz posiada wymiary 8,6 cm x 8,6 cm oraz głębokość 5,1 cm. Mieści się do puszki o średnicy 6,0 cm i głębokość minimum 4,0 cm. Zasilanie 110-230V~50/60 Hz. Temperatura pracy 0-35 °C, nie można stosować na zewnątrz. Dostępny tylko w kolorze białym, możesz zamontować go z załączoną ramką i przyciskiem przełączającym lub z innym kompatybilnym zestawem np. ramką GIRA, Legrand czy Schneider.

Ściemniacz włączamy i wyłączamy przyciskając raz dolny i górny przycisk, po włączeniu wraca do ostatniego stanu jasności. W ustawieniach mamy możliwość wybrania określonej jasności dla podwójnego kliknięcia. Przy trzykrotnym naciśnięciu pasek LED miga na żółto co wskazuje na uruchomienie procesu parowania z inną centralą, wystarczy odczekać a ściemniacz wróci do normalnej pracy.

Wymiary urządzenia
  • Plusy
    • unikalny design 
    • możliwość wyboru innych ramek
  • Minusy
    • zmniejszona liczba funkcji w stosunku do implementacji w systemie FIBARO
    • przetwarzanie w chmurze

Współpraca z SmartThings

W głównym panelu aplikacji mamy prostą możliwość włączenia i wyłączenia gniazdka oraz możliwość uruchomienia szybkich automatyzacji np. minutnika. Poniżej informację o dotychczasowym zużyciu i pobieranej aktualnie energii elektrycznej. Na koniec jest możliwość ściemniania od 0% do 100%. Panel „Historii” nie różni się znacznie od innych urządzeń, mamy dostęp do sortowania i przestudiowania historii działań kontaktu. W ustawieniach „Edytuj” mamy standardową możliwość zmiany nazwy, lokalizacji oraz pokoju. Posiadamy również opcję ustawień, gdzie możemy wybrać kolory kiedy ściemniacz jest włączony, kiedy wyłączony. Jak i wiele innych opcji, szczegóły w screenach powyżej.

Urządzenia w ekosystemie SmartThings wykonuje przetwarzanie poleceń w chmurze, z tego też tytułu przy utracie połączenia z Internetem, nie jest możliwe wykonywanie poleceń, aktualizowanie stanów urządzeń, jak i zaprogramowanych zadań np. automatyzacji.

Tworzenie automatyzacji „Jeśli … to Wtedy” musimy podzielić na dwa etapy, ponieważ znacznie różnią się dostępne opcje jeśli inicjujemy warunek „Jeśli”. W pierwszej możliwości „Jeśli” urządzenie pozwala na wybranie opcji „Włączono lub wyłączono” czyli zmiana stanu, oraz „On” (Włączone) i „Off” (Wyłączone). Ustawienie zużycia energii, poboru mocy. Jak i wartość ściemniacza od 0 do 100%.

W drugiej możliwości „Wtedy”, ściemniacz pozwala na troszkę mniej opcji, mamy ponownie opcje „Włączono lub wyłączono” czyli zmiana stanu, oraz „Włączone” i „Wyłączone”. Ustawienie jasności oświetlenia. Możemy opóźnić akcję lub wyłączyć automatycznie po określonym czasie.

Instalacja

Dodanie do ekosystemu do najprostszych nie należy, musimy znać się na elektryce oraz skorzystać z niestandardowej obsługi urządzeń, ponieważ producent nie wspiera obecnie automatycznego dodania do ekosystemu.

Pamiętaj: Przed zakupem zaznajom się z instalacją elektryczną w swoim domu. Całość znajdziesz tutaj. Przyjrzyjmy się teraz przykładowi instalacji w bloku mieszkalnym. W puszcze ściennej posiadam kolory kabli żółty, czarny i niebieski. Oznakowanie niestety nie potwierdziło rzeczywistej funkcji kabli. Przewód fazowy (L) to żyła niebieska pod napięciem 230V. Zaś żyły o kolorach żółtym i czarnym prowadzą do żyrandola. Podłączenie wygląda następująco:

Następnie musimy dodać kod obsługi urządzenia do SmartThings IDE. Całość została opisana tutaj, poniżej zamieszczam szybką instrukcję.

  1. Zacznijmy po kolei wejdź na stronę SmartThings – IDE i zaloguj się (Log in).
  2. Przejdź do Moich urządzeń obsługi urządzeń (My Device Handlers).
  3. Kliknij Utwórz nowy moduł obsługi urządzeń (Create New Device Handler).
  4. Skopiuj poniższy kod w całości. Wróć do WEB ST IDE, wybierz Z kodu (From Code) i wklej kod w formularzu. Kliknij Utwórz (Create).
  5. Kliknij Publikuj – dla mnie, aby zakończyć proces.
/**
 * 	Copyright 2020 SmartThings
 *
 *  Fibaro Walli Dimmer Switch
 *
 *	Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
 *	in compliance with the License. You may obtain a copy of the License at:
 *
 *		http://www.apache.org/licenses/LICENSE-2.0
 *
 *	Unless required by applicable law or agreed to in writing, software distributed under the License is distributed
 *	on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
 *	for the specific language governing permissions and limitations under the License.
 *
 */
metadata {
	definition (name: "Fibaro Walli Dimmer Switch", namespace: "fibargroup", author: "SmartThings", ocfDeviceType: "oic.d.switch", runLocally: false, minHubCoreVersion: '000.017.0012', executeCommandsLocally: false, genericHandler: "Z-Wave") {
		capability "Actuator"
		capability "Configuration"
		capability "Energy Meter"
		capability "Health Check"
		capability "Power Meter"
		capability "Refresh"
		capability "Sensor"
		capability "Switch"
		capability "Switch Level"
		command "reset"
		// Fibaro Walli Dimmer FGWDEU-111,
		// Raw Description: zw:Ls type:1101 mfr:010F prod:1C01 model:1000 ver:5.01 zwv:6.02 lib:03 cc:5E,55,98,56,6C,22 sec:26,85,8E,59,86,72,5A,73,32,70,71,75,5B,7A role:05 ff:9C00 ui:9C00
		fingerprint mfr: "010F", prod: "1C01", model: "1000", deviceJoinName: "Fibaro Dimmer Switch"
	}
	tiles(scale: 2) {
		multiAttributeTile(name:"switch", type: "lighting", width: 6, height: 4, canChangeIcon: true){
			tileAttribute ("device.switch", key: "PRIMARY_CONTROL") {
				attributeState "on", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
				attributeState "off", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
				attributeState "turningOn", label:'${name}', action:"switch.off", icon:"st.switches.switch.on", backgroundColor:"#00a0dc", nextState:"turningOff"
				attributeState "turningOff", label:'${name}', action:"switch.on", icon:"st.switches.switch.off", backgroundColor:"#ffffff", nextState:"turningOn"
			}
			tileAttribute ("device.level", key: "SLIDER_CONTROL") {
				attributeState "level", action:"switch level.setLevel"
			}
		}
		valueTile("power", "device.power", width: 2, height: 2) {
			state "default", label:'${currentValue} W'
		}
		valueTile("energy", "device.energy", width: 2, height: 2) {
			state "default", label:'${currentValue} kWh'
		}
		standardTile("reset", "device.energy", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
			state "default", label:'reset kWh', action:"reset"
		}
		standardTile("refresh", "device.switch", inactiveLabel: false, decoration: "flat", width: 2, height: 2) {
			state "default", label:"", action:"refresh.refresh", icon:"st.secondary.refresh"
		}
	}
	preferences {
		// Preferences template begin
		parameterMap.each {
			input (
					title: it.name,
					description: it.description,
					type: "paragraph",
					element: "paragraph"
			)
			switch(it.type) {
				case "boolRange":
					input(
							name: it.key + "Boolean",
							type: "bool",
							title: "Włączyć",
							description: "If you disable this option, it will overwrite setting below.",
							defaultValue: it.defaultValue != it.disableValue,
							required: false
					)
					input(
							name: it.key,
							type: "number",
							title: "Ustaw wartość (zakres ${it.range})",
							defaultValue: it.defaultValue,
							range: it.range,
							required: false
					)
					break
				case "boolean":
					input(
							type: "paragraph",
							element: "paragraph",
							description: "Option enabled: ${it.activeDescription}\n" +
									"Option disabled: ${it.inactiveDescription}"
					)
					input(
							name: it.key,
							type: "boolean",
							title: "Włączyć",
							defaultValue: it.defaultValue == it.activeOption,
							required: false
					)
					break
				case "enum":
					input(
							name: it.key,
							title: "Wybierz",
							type: "enum",
							options: it.values,
							defaultValue: it.defaultValue,
							required: false
					)
					break
				case "range":
					input(
							name: it.key,
							type: "number",
							title: "Ustaw wartość (zakres ${it.range})",
							defaultValue: it.defaultValue,
							range: it.range,
							required: false
					)
					break
			}
		}
		// Preferences template end
	}
	main(["switch","power","energy"])
	details(["switch", "power", "energy", "refresh", "reset"])
}
def getCommandClassVersions() {
	[
			// cc:
			0x22: 1, // Application Status
			0x55: 1, // Transport Service
			0x56: 1, // Crc16 Encap
			0x5E: 1, //
			0x6C: 1, //
			0x98: 1, // Security
			// sec:
			0x26: 3, // Switch Multilevel
			0x32: 3, // Meter
			0x59: 1, // Association Grp Info
			0x5A: 1, // Device Reset Locally
			0x5B: 2, // Central Scene
			0x70: 2, // Configuration
			0x71: 2, // Notification
			0x72: 2, // Manufacturer Specific
			0x73: 1, // Power Level
			0x75: 2, // Protection
			0x7A: 2, // Firmware Update Md
			0x85: 2, // Association
			0x86: 1, // Version
			0x8E: 2  // Multi Channel Association
	]
}
def installed() {
	// Device-Watch simply pings if no device events received for 32min(checkInterval)
	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
	// Rozpocznie się szablon preferencji
	state.currentPreferencesState = [:]
	parameterMap.each {
		state.currentPreferencesState."$it.key" = [:]
		state.currentPreferencesState."$it.key".value = getPreferenceValue(it)
		if (it.type == "boolRange" && getPreferenceValue(it) == it.disableValue) {
			state.currentPreferencesState."$it.key".status = "disablePending"
		} else {
			state.currentPreferencesState."$it.key".status = "synced"
		}
	}
	// Koniec szablonu preferencji
}
def updated() {
	// Device-Watch simply pings if no device events received for 32min(checkInterval)
	sendEvent(name: "checkInterval", value: 2 * 15 * 60 + 2 * 60, displayed: false, data: [protocol: "zwave", hubHardwareId: device.hub.hardwareID])
	// Rozpocznie się szablon preferencji
	parameterMap.each {
		if (isPreferenceChanged(it)) {
			log.debug "Preference ${it.key} has been updated from value: ${state.currentPreferencesState."$it.key".value} to ${settings."$it.key"}"
			state.currentPreferencesState."$it.key".status = "syncPending"
			if (it.type == "boolRange") {
				def preferenceName = it.key + "Boolean"
				if (notNullCheck(settings."$preferenceName")) {
					if (!settings."$preferenceName") {
						state.currentPreferencesState."$it.key".status = "disablePending"
					} else if (state.currentPreferencesState."$it.key".status == "disabled") {
						state.currentPreferencesState."$it.key".status = "syncPending"
					}
				} else {
					state.currentPreferencesState."$it.key".status = "syncPending"
				}
			}
		} else if (!state.currentPreferencesState."$it.key".value) {
			log.warn "Preference ${it.key} no. ${it.parameterNumber} has no value. Please check preference declaration for errors."
		}
	}
	syncConfiguration()
	// Koniec szablonu ustawień 
	response(refresh())
}
private syncConfiguration() {
	def commands = []
	parameterMap.each {
		if (state.currentPreferencesState."$it.key".status == "syncPending") {
			commands += encap(zwave.configurationV2.configurationSet(scaledConfigurationValue: getCommandValue(it), parameterNumber: it.parameterNumber, size: it.size))
			commands += encap(zwave.configurationV2.configurationGet(parameterNumber: it.parameterNumber))
		} else if (state.currentPreferencesState."$it.key".status == "disablePending") {
			commands += encap(zwave.configurationV2.configurationSet(scaledConfigurationValue: it.disableValue, parameterNumber: it.parameterNumber, size: it.size))
			commands += encap(zwave.configurationV2.configurationGet(parameterNumber: it.parameterNumber))
		}
	}
	sendHubCommand(commands)
}
def zwaveEvent(physicalgraph.zwave.commands.configurationv2.ConfigurationReport cmd) {
	// Rozpocznie się szablon ustawień
	log.debug "Configuration report: ${cmd}"
	def preference = parameterMap.find( {it.parameterNumber == cmd.parameterNumber} )
	def key = preference.key
	def preferenceValue = getPreferenceValue(preference, cmd.scaledConfigurationValue)
	if (settings."$key" == preferenceValue) {
		state.currentPreferencesState."$key".value = settings."$key"
		state.currentPreferencesState."$key".status = "synced"
	} else if (preference.type == "boolRange") {
		if (state.currentPreferencesState."$key".status == "disablePending" && preferenceValue == preference.disableValue) {
			state.currentPreferencesState."$key".status = "disabled"
		} else {
			runIn(5, "syncConfiguration", [overwrite: true])
		}
	} else {
		state.currentPreferencesState."$key"?.status = "syncPending"
		runIn(5, "syncConfiguration", [overwrite: true])
	}
	// Preferences template end
}
private getPreferenceValue(preference, value = "default") {
	def integerValue = (value == "default" ? preference.defaultValue : value.intValue())
	switch (preference.type) {
		case "enum":
			return String.valueOf(integerValue)
		case "boolean":
			return String.valueOf(preference.optionActive == integerValue)
		default:
			return integerValue
	}
}
private getCommandValue(preference) {
	def parameterKey = preference.key
	switch (preference.type) {
		case "boolean":
			return settings."$parameterKey" ? preference.optionActive : preference.optionInactive
		case "boolRange":
			def parameterKeyBoolean = parameterKey + "Boolean"
			return !notNullCheck(settings."$parameterKeyBoolean") || settings."$parameterKeyBoolean" ? settings."$parameterKey" : preference.disableValue
		case "range":
			return settings."$parameterKey"
		default:
			return Integer.parseInt(settings."$parameterKey")
	}
}
private isPreferenceChanged(preference) {
	if (notNullCheck(settings."$preference.key")) {
		if (preference.type == "boolRange") {
			def boolName = preference.key + "Boolean"
			if (state.currentPreferencesState."$preference.key".status == "disabled") {
				return settings."$boolName"
			} else {
				return state.currentPreferencesState."$preference.key".value != settings."$preference.key" || !settings."$boolName"
			}
		} else {
			return state.currentPreferencesState."$preference.key".value != settings."$preference.key"
		}
	} else {
		return false
	}
}
private notNullCheck(value) {
	return value != null
}
// parse events into attributes
def parse(String description) {
	//log.debug "description: ${description}"
	def result = null
	if (description != "updated") {
		def cmd = zwave.parse(description, commandClassVersions)
		//log.debug "cmd: ${cmd}"
		if (cmd) {
			result = zwaveEvent(cmd)
			//log.debug("'$description' parsed to $result")
		} else {
			log.debug("Couldn't zwave.parse '$description'")
		}
	}
	result
}
/*
 * Security encapsulation support:
 */
def zwaveEvent(physicalgraph.zwave.commands.securityv1.SecurityMessageEncapsulation cmd) {
	def encapsulatedCommand = cmd.encapsulatedCommand(commandClassVersions)
	if (encapsulatedCommand) {
		log.debug "Parsed SecurityMessageEncapsulation into: ${encapsulatedCommand}"
		zwaveEvent(encapsulatedCommand)
	} else {
		log.warn "Unable to extract Secure command from $cmd"
	}
}
def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicReport cmd) {
	dimmerEvents(cmd)
}
def zwaveEvent(physicalgraph.zwave.commands.basicv1.BasicSet cmd) {
	dimmerEvents(cmd)
}
def zwaveEvent(physicalgraph.zwave.commands.switchmultilevelv3.SwitchMultilevelReport cmd) {
	dimmerEvents(cmd)
}
def zwaveEvent(physicalgraph.zwave.Command cmd) {
	log.debug "Unhandled command: ${cmd}"
	[:]
}
def dimmerEvents(physicalgraph.zwave.Command cmd) {
	def result = []
	def value = (cmd.value ? "on" : "off")
	def switchEvent = createEvent(name: "switch", value: value, descriptionText: "$device.displayName was turned $value")
	result << switchEvent
	if (cmd.value) {
		result << createEvent(name: "level", value: cmd.value == 99 ? 100 : cmd.value , unit: "%")
	}
	if (switchEvent.isStateChange) {
		result << response(["delay 3000", meterGet(scale: 2).format()])
	}
	return result
}
def zwaveEvent(physicalgraph.zwave.commands.meterv3.MeterReport cmd) {
	log.debug "v3 Meter report: "+cmd
	handleMeterReport(cmd)
}
def handleMeterReport(cmd) {
	if (cmd.meterType == 1) {
		if (cmd.scale == 0) {
			createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kWh")
		} else if (cmd.scale == 1) {
			createEvent(name: "energy", value: cmd.scaledMeterValue, unit: "kVAh")
		} else if (cmd.scale == 2) {
			createEvent(name: "power", value: Math.round(cmd.scaledMeterValue), unit: "W")
		}
	}
}
def configure() {
	log.debug "configure()"
	def result = []
	result << response(encap(meterGet(scale: 0)))
	result << response(encap(meterGet(scale: 2)))
}
def on() {
	encapSequence([
			zwave.basicV1.basicSet(value: 0xFF),
			zwave.switchMultilevelV1.switchMultilevelGet(),
	], 1000)
}
def off() {
	encapSequence([
			zwave.basicV1.basicSet(value: 0x00),
			zwave.switchMultilevelV1.switchMultilevelGet(),
	], 1000)
}
def setLevel(level, rate = null) {
	if(level > 99) level = 99
	encapSequence([
			zwave.basicV1.basicSet(value: level),
			zwave.switchMultilevelV1.switchMultilevelGet()
	], 1000)
}
/**
 * PING is used by Device-Watch in attempt to reach the Device
 * */
def ping() {
	log.debug "ping() called"
	refresh()
}
def refresh() {
	log.debug "refresh()"
	encapSequence([
			zwave.switchMultilevelV1.switchMultilevelGet(),
			meterGet(scale: 0),
			meterGet(scale: 2),
	], 1000)
}
def reset() {
	encapSequence([
			meterReset(),
			meterGet(scale: 0)
	])
}
def meterGet(scale) {
	zwave.meterV2.meterGet(scale)
}
def meterReset() {
	zwave.meterV2.meterReset()
}
private encapSequence(cmds, Integer delay=250) {
	delayBetween(cmds.collect{ encap(it) }, delay)
}
private encap(physicalgraph.zwave.Command cmd) {
	if (zwaveInfo?.zw?.contains("s")) {
		secEncap(cmd)
	} else {
		log.debug "no encapsulation supported for command: $cmd"
		cmd.format()
	}
}
private secEncap(physicalgraph.zwave.Command cmd) {
	log.debug "encapsulating command using Secure Encapsulation, command: $cmd"
	zwave.securityV1.securityMessageEncapsulation().encapsulate(cmd).format()
}
private getParameterMap() {[
	[
		name: "Ramka LED - kolor, gdy jest włączony", key: "ledFrame–ColourWhenOn", type: "enum",
		parameterNumber: 11, size: 1, defaultValue: 1,
		values: [
			0: "LED wyłączony",
			1: "Biały",
			2: "Czerwony",
			3: "Zielony",
			4: "Niebieski",
			5: "Żółty",
			6: "Cyjan",
			7: "Magenta",
			8: "kolor zmienia się płynnie w zależności od mierzonej mocy",
			9: "zmiana koloru w krokach w zależności od zmierzonej mocy"
		],
		description: "Kolor diody LED, gdy urządzenie jest włączone. Po ustawieniu na 8 lub 9, kolor ramki LED zmieni się w zależności od zmierzonej mocy i parametru 10. Inne kolory są ustawione na stałe i nie zależą od zużycia energii."
	],
	[
		name: "Ramka LED - kolor, gdy jest wyłączony", key: "ledFrame–ColourWhenOff", type: "enum",
		parameterNumber: 12, size: 1, defaultValue: 0,
		values: [
			0: "LED wyłączony",
			1: "Biały",
			2: "Czerwony",
			3: "Zielony",
			4: "Niebieski",
			5: "Żółty",
			6: "Cyjan",
			7: "Magenta"
		],
		description: "Kolor diody LED, gdy urządzenie jest wyłączone."
	],
	[
		name: "Ramka LED - jasność", key: "ledFrame–Brightness", type: "range",
		parameterNumber: 13, size: 1, defaultValue: 100,
		range: "0..102",
		description: "Dostosuj jasność ramki LED. " +
				"101 - jasność wprost proporcjonalna do ustawionego poziomu, " +
				"102 - jasność odwrotnie proporcjonalna do ustawionego poziomu"
	],
	[
		name: "Sterowanie ręczne - wielkość kroku ściemniania", key: "manualControl–DimmingStepSize", type: "range",
		parameterNumber: 156, size: 1, defaultValue: 1,
		range: "1..99",
		description: "Percentage value of the dimming step during the manual control. " +
				"1 - [MSB] – Typ powiadomienia (domyślnie)\n" +
				"2 - Wartość powiadomienia\n" +
				"3 - Parametr zdarzenia/stanu\n" +
				"4 - [LSB] – akcja\n" +
				"1 do 99 - (1-99%, 1% krok) – krok ściemniania"
	],
	[
		name: "Sterowanie ręczne - czas kroku ściemniania", key: "manualControl–TimeOfDimmingStep", type: "range",
		parameterNumber: 157, size: 2, defaultValue: 5,
		range: "0..255",
		description: "Czas wykonania pojedynczego kroku ściemniania ustawionego w parametrze 156 podczas sterowania ręcznego."
	],
	[
		name: "Podwójne kliknięcie - ustaw poziom", key: "doubleClick–SetLevel", type: "range",
		parameterNumber: 165, size: 1, defaultValue: 99,
		range: "0..99",
		description: "Poziom jasności ustawiony po dwukrotnym kliknięciu dowolnego przycisku."
	],
	[
		name: "Orientacja przycisków", key: "buttonsOrientation", type: "boolean",
		parameterNumber: 24, size: 1, defaultValue: 0,
		optionInactive: 0, inactiveDescription: "domyślnie (pierwszy przycisk rozjaśnia się, drugi przyciemnia)",
		optionActive: 1, activeDescription: "odwrócone (pierwszy przycisk przyciemnia, drugi przycisk rozjaśnia się)",
		description: "Odwrócenie działania przycisków."
	]
]}

Powyżej znajduje się kod, część komunikatów jak i menu zostało spolszczone. Oryginał znajdziesz na GitHub tutaj.

Po dodaniu kodu niestandardowej obsługi, możemy przejść do dodania łączenia ściemniacza z centralą. Dodanie do ekosystemu już przebiega standardowo, należy postępować zgodnie z instrukcją w aplikacji. Klikamy w aplikacji „Dodaj urządzenie”, wybieramy markę FIBARO >> Przełącznik/ściemniacz. Wybieramy „Obsługiwane urządzenia” i Walli Dimmer. Kontynuujemy pierwsze kroki, wybieramy koncentrator i pomieszczenie dla urządzenia. Następnie naciskamy 3 razy przycisk (górny bądź dolny) ściemniacza. Poczekać na wykrycie urządzenia i pozostaje nadać nazwę.

Gdzie zakupić ?

Zawartość pudełka to ściemniacz i kilka instrukcji obsługi w różnych językach.

Produkt jest szeroko dostępny na rynku. Cena to ok. 250 zł.

Instrukcja

Dodatkowe informacje na temat podłączenia i specyfikacji można znaleźć tutaj.

Wnętrze sensoru

Skomentuj

Wprowadź swoje dane lub kliknij jedną z tych ikon, aby się zalogować:

Logo WordPress.com

Komentujesz korzystając z konta WordPress.com. Wyloguj /  Zmień )

Zdjęcie na Google

Komentujesz korzystając z konta Google. Wyloguj /  Zmień )

Zdjęcie z Twittera

Komentujesz korzystając z konta Twitter. Wyloguj /  Zmień )

Zdjęcie na Facebooku

Komentujesz korzystając z konta Facebook. Wyloguj /  Zmień )

Połączenie z %s