Creating automation with Z-Wave.Me ZME_WALLC-S Secure Wall Controller

Hi!

I have added av Z-wave.me four way button to home assistant. It still shows up as Initializing(CacheLoad), but as I have understood that should not matter.

I have tested the ability of the buttons to communicate with HA and when I press the buttons this gets shown in the OZW_log:
2018-12-22 19:40:58.823 Info, Node002, Received Central Scene set from node 2: scene id=1 in 0
seconds. Sending event notification.
2018-12-22 19:40:58.823 Warning, Node002, No ValueID created for Scene 1
2018-12-22 19:50:51.064 Detail, Node002, Received: 0x01, 0x0d, 0x00, 0x04, 0x00, 0x02, 0x05, 0x5b,
0x03, 0x51, 0x00, 0x02, 0xb1, 0x00, 0x4b
2018-12-22 19:50:51.064 Detail,
2018-12-22 19:50:51.064 Info, Node002, Received Central Scene set from node 2: scene id=2 in 0
seconds. Sending event notification.
2018-12-22 19:50:51.064 Warning, Node002, No ValueID created for Scene 2
2018-12-22 19:58:05.394 Detail, Node002, Received: 0x01, 0x0d, 0x00, 0x04, 0x00, 0x02, 0x05, 0x5b,
0x03, 0x52, 0x00, 0x01, 0xb3, 0x00, 0x49

I have created an automation that uses this and tested that the automation itself works, but I canā€™t get it to trigger on detecting the scene. It is worth mentioning that I donā€™t see any events callled zwave.scene_activated at all and that doesnā€™t look right.

Automation:

automation old:
- alias: Test av knapp
  trigger:
    platform: event
    event_type: zwave.scene_activated
    event_data:
        entity_id: zwave.zwaveme_zme_wallcs_secure_wall_controller
        scene_id: 1
  action:  
    service: light.turn_off
    data:
        entity_id:
            - light.kjkken

After running this, nothing shows up in the HA log at all and the event id shows up in the z-wave log, but I canā€™t seem to connect the twoā€¦ Any help would be appreciated.

Update:

Turns out that the z-wave device was not installed completely and by holding all four buttons in for 5 seconds and then pressing the number 2 button I could wake the device up enough times for the installation procedure to finish.

I also had a problem with the COMMAND_CLASS_CENTRAL_SCENE in the zwcfg configuration file as it kept resetting what I had written there. Turns out you have to turn off home assistant, update the file with the config for the Aeotec wallmote located here https://www.home-assistant.io/docs/z-wave/device-specific/#aeotec-wallmote

Now the logs from OZW_log.txt shows this instead:
2018-12-24 13:42:23.612 Info, Node002, Received Central Scene set from node 2: scene id=1 in 0 seconds. Sending event notification.
2018-12-24 13:42:23.612 Detail, Node002, Refreshed Value: old value=0, new value=0, type=int
2018-12-24 13:42:23.613 Detail, Node002, Changes to this value are not verified
2018-12-24 13:42:23.613 Detail, Node002, Notification: ValueChanged
2018-12-24 13:42:24.936 Detail, Node002, Received: 0x01, 0x0d, 0x00, 0x04, 0x00, 0x02, 0x05, 0x5b, 0x03, 0x7c, 0x00, 0x01, 0xc6, 0x00, 0x12
2018-12-24 13:42:24.937 Detail,

Buuuut, the automation I have created above does not fire at all, so still as far when it comes to getting the automation to run, nothing in the logs on it either.

1 Like

Hello,
I have set up my wallc-s to send scenes, and configured zwcfg according to https://www.home-assistant.io/docs/z-wave/device-specific/#aeotec-wallmote. I also have included a network key in configuration.yaml.

In the logger, when pushing a button on the remote I get this message:
2019-01-01 20:54:23.399 Warning, Node008, Received a Clear Text Message for the CommandClass COMMAND_CLASS_SCENE_ACTIVATION which is Secured
2019-01-01 20:54:23.399 Warning, Node008, Dropping Message
2019-01-01 20:54:24.331 Detail, Node008, Received: 0x01, 0x0a, 0x00, 0x04, 0x00, 0x08, 0x04, 0x2b, 0x01, 0x0b, 0xff, 0x23

From what I can see, the remote does not send any scene id?
Any guess to what could be wrong?

Seems like you have included the device in a non-secure manner. Try including it securely by using the include secure option when including it, that should solve it.

I finally got it to work, although with delays and missed inputs. I removed and reincluded the wallc-s secured and got it to send scene id. I even got the automation to work here is my configuration.yaml code:

  - alias: 'Kitchen light 50 on'
    trigger:
      - platform: event
        event_type: zwave.scene_activated
        event_data:
          entity_id: zwave.popp_009303_battery_wall_controller_2
          scene_id: 1
    action:
      - service: scene.turn_on
        data:
          entity_id: scene.Kitchen50

  - alias: 'Kitchen light 50 off'
    trigger:
      - platform: event
        event_type: zwave.scene_activated
        event_data:
          entity_id: zwave.popp_009303_battery_wall_controller_2
          scene_id: 3
    action:
      - service: light.turn_off
        data:
          entity_id: light.alla

scene:
  - name: Kitchen50
    entities:
      light.golv:
        state: on
        brightness: 50
      light.diskbank:
        state: on
        brightness: 128
      light.spis:
        state: on
        brightness: 128
      light.spotlight:
        state: on
        brightness: 50

light:
  - platform: group
    name: Alla
    entities:
      - light.golv
      - light.diskbank
      - light.spis
      - light.spotlight
2 Likes

Iā€™m using a few a few of these switches, im using the following custom component to allow dimming.

import voluptuous as vol
import asyncio
import logging
import homeassistant.helpers.config_validation as cv
from homeassistant.core import callback
from homeassistant.loader import bind_hass
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.event import async_track_state_change
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (CONF_ENTITY_ID, ATTR_ENTITY_ID,
                                 EVENT_STATE_CHANGED, SERVICE_TURN_ON,
                                 SERVICE_TURN_OFF)
from homeassistant.components.zwave.const import (EVENT_SCENE_ACTIVATED,
                                                  ATTR_SCENE_ID)
from homeassistant.components.light import (is_on, ATTR_BRIGHTNESS,
                                            ATTR_TRANSITION, DOMAIN)


STATE_OFF = 0

_LOGGER = logging.getLogger(__name__)
ICON = "mdi:debug-step-over"
# add ƶpggomg all around this place!
# change log level for my component!
CONF_DIMMERS = "dimmers"
CONF_START = "start"
CONF_NAME = "name"
CONF_STOP = "stop"
CONF_SCENE_ID = ATTR_SCENE_ID
CONF_DELAY = "delay"
CONF_STEP = "step"
CONF_LIGHTS = "lights"
CONF_ON = "on"
CONF_OFF = "off"
CONF_DEFAULT_BRIGHTNESS = "default_brightness"

CONF_BRIGHTEN = "brighten"
CONF_DARKEN = "darken"
# Tradfri has a max of 254 for some reason.
MAX_BRIGHTNESS = 254

PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend({
    vol.Required(CONF_DIMMERS): [{
        vol.Required(CONF_NAME): cv.string,
        vol.Required(CONF_ENTITY_ID): cv.entity_id,
        vol.Required(CONF_BRIGHTEN): {
            vol.Required(CONF_START): {
                vol.Required(CONF_SCENE_ID): cv.byte},
            vol.Required(CONF_STOP): {
                vol.Required(CONF_SCENE_ID): cv.byte}
        },
        vol.Required(CONF_DARKEN): {
            vol.Required(CONF_START): {
                vol.Required(CONF_SCENE_ID): cv.byte},
            vol.Required(CONF_STOP): {
                vol.Required(CONF_SCENE_ID): cv.byte}
        },
        vol.Required(CONF_ON): {
            vol.Required(CONF_SCENE_ID): cv.byte},
        vol.Required(CONF_OFF): {
            vol.Required(CONF_SCENE_ID): cv.byte},
        vol.Required(CONF_DEFAULT_BRIGHTNESS): cv.byte,
        vol.Required(CONF_DELAY): cv.time_period,
        vol.Required(CONF_STEP): cv.byte,
        vol.Required(CONF_LIGHTS): cv.entity_ids
    }]
})

@callback
@bind_hass
def async_turn_on(hass, entity_id=None, transition=None, brightness=None):
    """Turn all or specified light on."""
    data = {
        key: value for key, value in [
            (ATTR_ENTITY_ID, entity_id),
            (ATTR_TRANSITION, transition),
            (ATTR_BRIGHTNESS, brightness),
        ] if value is not None
    }
    hass.async_add_job(hass.services.async_call(DOMAIN, SERVICE_TURN_ON, data))

@callback
@bind_hass
def async_turn_off(hass, entity_id=None, transition=None):
    """Turn all or specified light off."""
    data = {
        key: value for key, value in [
            (ATTR_ENTITY_ID, entity_id),
            (ATTR_TRANSITION, transition),
        ] if value is not None
    }
    hass.async_add_job(hass.services.async_call(
        DOMAIN, SERVICE_TURN_OFF, data))

@asyncio.coroutine
def async_setup_platform(hass, config, async_add_devices, discovery_info=None):
    """Setup the dimmer"""
    _LOGGER.info("start async_setup_platform")
    sensors = []
    for dimmer in config.get(CONF_DIMMERS):
        name = dimmer.get(CONF_NAME)
        entity_id = dimmer.get(CONF_ENTITY_ID)
        brighten = dimmer.get(CONF_BRIGHTEN)
        start_brighten_scene_id = brighten.get(CONF_START).get(CONF_SCENE_ID)
        stop_brighten_scene_id = brighten.get(CONF_STOP).get(CONF_SCENE_ID)
        darken = dimmer.get(CONF_DARKEN)
        start_darken_scene_id = darken.get(CONF_START).get(CONF_SCENE_ID)
        stop_darken_scene_id = darken.get(CONF_STOP).get(CONF_SCENE_ID)

        on_scene_id = dimmer.get(CONF_ON).get(CONF_SCENE_ID)
        off_scene_id = dimmer.get(CONF_OFF).get(CONF_SCENE_ID)
        default_brightness = dimmer.get(CONF_DEFAULT_BRIGHTNESS)

        delay = dimmer.get(CONF_DELAY)
        step = dimmer.get(CONF_STEP)
        light_entity_ids = dimmer.get(CONF_LIGHTS)

        sensor = Dimmer(hass, name, entity_id,
                        start_brighten_scene_id, stop_brighten_scene_id,
                        start_darken_scene_id, stop_darken_scene_id,
                        on_scene_id, off_scene_id, default_brightness,
                        delay, step, light_entity_ids)
        sensors.append(sensor)


#   For some reason the function below is never called with `yield from` in
#   the code base?
    async_add_devices(sensors)


class Dimmer(Entity):

    def __init__(self, hass, name, entity_id,
                 start_brighten_scene_id, stop_brighten_scene_id,
                 start_darken_scene_id, stop_darken_scene_id,
                 on_scene_id, off_scene_id, default_brightness,
                 delay, step, light_entity_ids):
        _LOGGER.info("creating dimmer")
        self._hass = hass
        self._name = name
        self._entity_id = entity_id
        self._brighten_loop_running = False
        self._brighten_loop_task = None
        self._start_brighten_scene_id = start_brighten_scene_id
        self._stop_brighten_scene_id = stop_brighten_scene_id
        self._darken_loop_running = False
        self._darken_loop_task = None
        self._start_darken_scene_id = start_darken_scene_id
        self._stop_darken_scene_id = stop_darken_scene_id
        self._on_scene_id = on_scene_id
        self._off_scene_id = off_scene_id
        self._default_brightness = default_brightness
        self._delay = delay
        self._step = step
        self._light_entity_ids = light_entity_ids
#       contains true or false when all are true trigger the next stage!
        self._light_states = {}
        _LOGGER.info("dimmer created")

    def get_current_brightness(self):
        _LOGGER.info("get_current_brightness")
        total_brightness = 0
        count = 0
        for light_entity_id in self._light_entity_ids:
            light_state = self._hass.states.get(light_entity_id)
            if light_state.state != 'off':
                brightness = light_state.attributes.get('brightness')
                total_brightness += brightness
                count += 1
        if (count == 0):
            return None
        return total_brightness / count

    def is_light_off(self):
        for light_entity_id in self._light_entity_ids:
            light_state = self._hass.states.get(light_entity_id)
            if light_state.state != 'off':
                return False
        return True

    @asyncio.coroutine
    def async_added_to_hass(self):
        _LOGGER.info("start listen")
        self._hass.bus.async_listen(EVENT_SCENE_ACTIVATED, self.async_scene_activated)
        async_track_state_change(self._hass, self._light_entity_ids,
                                 self.async_light_state_changed_listener)
        _LOGGER.info("listen setup")

    @callback
    def async_light_state_changed_listener(self, entity, old_state, new_state):
        _LOGGER.info("async_light_state_changed_listener")
        if not self.is_brighten_task_running() and not self.is_darken_task_running():
            return
        entity_id = new_state.domain + '.' + new_state.object_id
        _LOGGER.info("light state changed")
        self._light_states[entity_id] = True

        for light_entity_id in self._light_entity_ids:
            if not self._light_states[light_entity_id]:
                _LOGGER.info(light_entity_id + " has not changed state yet!")
                return
        if self.is_brighten_task_running():
            self.brighten_step()
        elif self.is_darken_task_running():
            self.darken_step()

    @callback
    def async_scene_activated(self, event):
        _LOGGER.info("scene_activated")
        scene_id = event.data.get(ATTR_SCENE_ID)
        entity_id = event.data.get(ATTR_ENTITY_ID)

#        _LOGGER.error("scene scene_id = " + str(scene_id) + ", entity_id: " + str(entity_id))
#        _LOGGER.error("expected entity_id = " + self._entity_id)

#        _LOGGER.info("expected start_brighten_scene_id = " + str(self._start_brighten_scene_id))
#        _LOGGER.info("expected stop_brighten_scene_id = " + str(self._stop_brighten_scene_id))
#        _LOGGER.info("expected start_darken_scene_id = " + str(self._start_darken_scene_id))
#        _LOGGER.info("expected stop_darken_scene_id = " + str(self._stop_darken_scene_id))

        is_start_brighten = (scene_id == self._start_brighten_scene_id and
                             entity_id == self._entity_id)
        is_stop_brighten = (scene_id == self._stop_brighten_scene_id and
                            entity_id == self._entity_id)
        is_start_darken = (scene_id == self._start_darken_scene_id and
                           entity_id == self._entity_id)
        is_stop_darken = (scene_id == self._stop_darken_scene_id and
                          entity_id == self._entity_id)
        is_on = (scene_id == self._on_scene_id and
                 entity_id == self._entity_id)
        is_off = (scene_id == self._off_scene_id and
                  entity_id == self._entity_id)
#       sanity check
        if is_start_brighten and self.is_brighten_task_running():
            raise Exception("Can't start brighten when its already running")
        elif is_start_brighten and self.is_darken_task_running():
            raise Exception("Can't start brighten when darken already is running")
        elif is_start_darken and self.is_brighten_task_running():
            raise Exception("Can't start darken when brighten already is running")
        elif is_start_darken and self.is_darken_task_running():
            raise Exception("Can't start darken when its already running")

#        _LOGGER.info("is_start_brighten: " + str(is_start_brighten))
#        _LOGGER.info("is_stop_brighten: " + str(is_stop_brighten))
#        _LOGGER.info("is_start_darken: " + str(is_start_darken))
#        _LOGGER.info("is_stop_darken: " + str(is_stop_darken))
#        _LOGGER.info("is_on: " + str(is_on))
#        _LOGGER.info("is_off: " + str(is_off))

        if is_start_brighten and not self.is_brighten_task_running():
            self.start_brighten_loop()
        elif is_stop_brighten and self.is_brighten_task_running():
            self.stop_brighten_loop()
        elif is_start_darken and not self.is_darken_task_running():
            self.start_darken_loop()
        elif is_stop_darken and self.is_darken_task_running():
            self.stop_darken_loop()
        elif is_on and not self.is_brighten_task_running() and not self.is_darken_task_running():
            if self.is_light_off():
                self.turn_on(self._default_brightness)
            else:
                self.turn_on(MAX_BRIGHTNESS)
        elif is_off and not self.is_brighten_task_running() and not self.is_darken_task_running():
            self.turn_off()

    def is_brighten_task_running(self):
        return self._brighten_loop_running

    def is_darken_task_running(self):
        return self._darken_loop_running

    def start_brighten_loop(self):
        _LOGGER.info("start_brighten_loop")
        self._brighten_loop_running = True
        self.brighten_step()

    def stop_brighten_loop(self):
        _LOGGER.info("stop_brighten_loop")
        self._brighten_loop_running = False

    def brighten_step(self):
        _LOGGER.info("brighten_step")
        current_brightness = self.get_current_brightness()
        if current_brightness is None:
            current_brightness = 128
#       check if any lights are off
        all_on = True
        for light_entity_id in self._light_entity_ids:
            if is_on(self._hass, light_entity_id):
                self._light_states[light_entity_id] = True
            else:
                self._light_states[light_entity_id] = False
                all_on = False

        if not all_on:
            for light_entity_id in self._light_entity_ids:
                if not self._light_states[light_entity_id]:
                    async_turn_on(self._hass, light_entity_id,
                                  brightness=current_brightness)
        elif current_brightness == MAX_BRIGHTNESS:
            self.stop_brighten_loop()
        else:
            new_brightness = min(current_brightness + self._step, MAX_BRIGHTNESS)
            for light_entity_id in self._light_entity_ids:
                self._light_states[light_entity_id] = False
                async_turn_on(self._hass, light_entity_id,
                              brightness=new_brightness,
                              transition=self._delay.total_seconds())

    def turn_on(self, brightness):
        _LOGGER.info("turn_on")
        new_brightness = min(brightness, MAX_BRIGHTNESS)
        for light_entity_id in self._light_entity_ids:
            async_turn_on(self._hass, light_entity_id,
                          brightness=new_brightness,
                          transition=1)

    def turn_off(self):
        _LOGGER.info("turn_off")
        for light_entity_id in self._light_entity_ids:
            async_turn_off(self._hass, light_entity_id)

    def start_darken_loop(self):
        _LOGGER.info("start_darken_loop")
        self._darken_loop_running = True
        self.darken_step()

    def stop_darken_loop(self):
        _LOGGER.info("stop_darken_loop")
        self._darken_loop_running = False

    def darken_step(self):
        _LOGGER.info("darken_step")
        current_brightness = self.get_current_brightness()
        if current_brightness is None:
            _LOGGER.info("lights are already off")
            return

        new_brightness = max(current_brightness - self._step, 0)
        all_on = True
        for light_entity_id in self._light_entity_ids:
            if is_on(self._hass, light_entity_id):
                self._light_states[light_entity_id] = True
            else:
                self._light_states[light_entity_id] = False
                all_on = False

        if not all_on:
            _LOGGER.info("not all lights are on turning the rest on")
            for light_entity_id in self._light_entity_ids:
                if not self._light_states[light_entity_id]:
                    async_turn_on(self._hass, light_entity_id,
                                  brightness=current_brightness)
        elif new_brightness == 0:
            _LOGGER.info("target brightness is 0 turning all lights off")
            self.stop_brighten_loop()
            for light_entity_id in self._light_entity_ids:
                self._light_states[light_entity_id] = False
                async_turn_off(self._hass, light_entity_id)
        else:
            _LOGGER.info("lowering brightness from " + str(current_brightness) + " to " + str(new_brightness))
            for light_entity_id in self._light_entity_ids:
                self._light_states[light_entity_id] = False
                async_turn_on(self._hass, light_entity_id,
                              brightness=new_brightness,
                              transition=self._delay.total_seconds())

    @property
    def name(self):
        """Return the name of the sensor."""
        return self._name

    @property
    def icon(self):
        """Return the icon for the frontend."""
        return ICON

    @property
    def state(self):
        if self.is_brighten_task_running():
            return "Brightening"
        elif self.is_darken_task_running():
            return "Darkening"
        else:
            return "Off"

    @asyncio.coroutine
    def shutdown(self):
        _LOGGER.info("shutdown")
        if self.is_brighten_task_running():
            self.stop_darken_loop()
            self._brighten_loop_task.cancel()

        if self.is_darken_task_running():
            self.stop_darken_loop()
            self._darken_loop_task.cancel()

on tap to turn on the light half way, one more tap to go all the way.
keeping the button down to dim up or down.

Iā€™m not that good with python so there might be some issues in the component but it seems to work!

Iā€™m using it with tradfri bulbs.

with the following configuration.

- platform: dimmer
  dimmers:
  - name: living_room_wallswitch_1_left_switch
    entity_id: zwave.living_room_wallswitch_1
    brighten:
      start:
        scene_id: 13
      stop:
        scene_id: 15
    darken:
      start:
        scene_id: 14
      stop:
        scene_id: 16
    'on':
      scene_id: 11
    'off':
      scene_id: 12
    default_brightness: 128
    delay:
      milliseconds: 100
    step: 10
    lights:
      - light.living_room_ceiling_1_left
      - light.living_room_ceiling_1_middle
      - light.living_room_ceiling_1_right
  - name: living_room_wallswitch_1_right_switch
    entity_id: zwave.living_room_wallswitch_1
    brighten:
      start:
        scene_id: 23
      stop:
        scene_id: 25
    darken:
      start:
        scene_id: 24
      stop:
        scene_id: 26
    'on':
      scene_id: 21
    'off':
      scene_id: 22
    default_brightness: 128
    delay:
      milliseconds: 100
    step: 10
    lights:
      - light.living_room_ceiling_2_left
      - light.living_room_ceiling_2_middle
      - light.living_room_ceiling_2_right
1 Like

Great, thanks, that is next project, to get dimmers to work so your post will be useful. I also have to investigate why network is slow turning on and off. I only have the Fibaro dimmer 2 and Qubino flush dimmer with the wallc-s and raspberry pi that is all network, but it seems that the Fibaro is sending a lot of activity in the ozw-log.

I got everything to work a lot because of this thread. Thanks!

This is a complete step by step for anyone wanting to add it:
NB! Make sure you have the device in factory default mode. If not remove the device and factory reset it.

  • click ā€œadd node secureā€ and press any button on the ZME controller for >1 sec until it starts blinking
  • wait until the logs (tail -f /config/OZW_Log.txt) stops printing information about your node
  • look in zwcfg_xxx.xml to see that your node is there ā€œZME-WALLC-Sā€. If not restart hassio and it should show up

// the following 2 should be preceeded by pressing all 4 buttons until blinking and then push button 2. blinking rapidly

  • set association to the z-wave controller in the HA zwave config menu

  • Click refresh node. This will put the device in probe state // maybe not needed but I had to

  • Stop HA by ssh into HA and run hassio homeassistant stop

  • edit /config/owxfg_.xml and look for ZME_WALLC-S Secure Wall Controller.
    In this Node you replace CommandClass id=ā€œ91ā€ with this:

<CommandClass id="91" name="COMMAND_CLASS_CENTRAL_SCENE" version="1" request_flags="5" innif="true" scenecount="0">
<Instance index="1" />
	<Value type="int" genre="system" instance="1" index="0" label="Scene Count" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
	<Value type="int" genre="system" instance="1" index="1" label="Button One" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
	<Value type="int" genre="system" instance="1" index="2" label="Button Two" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
	<Value type="int" genre="system" instance="1" index="3" label="Button Three" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
	<Value type="int" genre="system" instance="1" index="4" label="Button Four" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
	<Value type="int" genre="system" instance="1" index="5" label="Other" units="" read_only="true" write_only="false" verify_changes="false" poll_intensity="0" min="-2147483648" max="2147483647" value="0" />
</CommandClass>
  • Start HA by ssh into HA and run hassio homeassistant start
  • do tail -f /config/OZW_Log.txt and then press a button on your WALL-C controller and see that it should have output like this:
2019-02-17 12:08:39.667 Detail, Node010,   Received: 0x01, 0x0b, 0x00, 0x04, 0x00, 0x0a, 0x05, 0x5b, 0x03, 0xd8, 0x00, 0x01, 0x7e
2019-02-17 12:08:39.667 Detail,
2019-02-17 12:08:39.667 Info, Node010, Received Central Scene set from node 10: scene id=1 in 0 seconds. Sending event notification.
2019-02-17 12:08:39.667 Detail, Node010, Refreshed Value: old value=0, new value=0, type=int
2019-02-17 12:08:39.667 Detail, Node010, Changes to this value are not verified
2019-02-17 12:08:39.667 Detail, Node010, Notification: ValueChange
  • Note the scene id=<number which should be 1 if the top left button was pressed

  • Add automation to test it

alias: Test zwave event
trigger:
  platform: event
  event_type: zwave.scene_activated
  event_data:
    entity_id: zwave.z_wave_me_zme_wallc_s_secure_wall_controller_2
    scene_id: 1
action:
  - service: notify.notify
    data_template:
      message: >
        Got event for scene id 1 from the controller

Every time time I try it again to get the WALLC-S working in home assistant, but only the single click option is working.

I have configured the CommandClass 91 as mentioned above.
My WALLC-S is set to button 1-3 in pair with double click and 2-4 also in pair with double click
Group A and C are configured configure to ā€˜Central Scan to Gateway (default)ā€™

Single click buttons are working fine, but all double click buttons i receive the message in OZW_Log.txt:

No ValueID created for Scene 4

What have i forgotten or missed?

Are you sure you have followed it to the dot?
Two things I can think of:

  • stopp HA by ssh into HA and run hassio homeassistant stop THEN edit the owcfg_xxx.xml followed by restart
  • If that fails you should remove/exclude it from HASS, factory reset it and redo the above steps (I needed to do this one time)

Hello. I used in my automation the following trigger:
trigger:

  • event_data:
    entity_id: zwave.z_wave_me_zme_wallc_s_secure_wall_controller
    node_id: 9
    scene_data: 0
    scene_id: 3
    event_type: zwave.scene_activated
    platform: event

I scanned the trigger with the development tools page and then events and in the bottom listening. You can paste this zwave.scene_activated.
I set the zwaveme wallswitch button control to separate and then the sceneidā€™s are 1 for button 1 and so one. Dubblepress is sceneid: 5 and so one.

Hope it wil help you.

Greetings Thijs Jansen The Netherlands

Hi Peter,

just came across your dimming component, looks great, exactly what I would like to have for my Wall C Wall Controller. Just a stupid question, where do I put this component? In my config folder as a python script?

Thanks!
drwenkman

Hello drwenkman,

got a question about this.
Did you allready got this working?

kind regards,
Norman

Hi All, would really appreciate some help with my wall-c device. I am new to hass and zwave and I think this was information about the previous zwave setup (configuration.yaml). My question is about openzwave (i asked it here: OpenZWave Beta Aeotec WallMote Duo Scene Activation)