YSR-MINI-01_dimmer

[theuselessone]

I have a couple of thees odd devices ZigBee 3.0 LED Light Dimmer Controller
The identify themself as
[YSR-MINI-01_dimmer].
If they are powered off they don't start again if you adjust the brightness level only if you press on or off. I narrowed it down to that the device probably don't handle "move to level with onoff" very well.
I am not a good programmer but i did get the device to work properly when rewriting the light_onoff_brightness for that device. Since this was my first attempt of tinkering with adding a device to zigbee2mqtt i probably did it wrong and it also identifies as a YSR-MINI that might work therefore i dont want to submit a pull request

Anyway i thought id share the code at least so if anyone else experience the same problem they might be helped

const fz = require('zigbee-herdsman-converters/converters/fromZigbee');
const tz = require('zigbee-herdsman-converters/converters/toZigbee');
const constants = require('zigbee-herdsman-converters/lib/constants');
const exposes = require('zigbee-herdsman-converters/lib/exposes');
const reporting = require('zigbee-herdsman-converters/lib/reporting');
const extend = require('zigbee-herdsman-converters/lib/extend');
const e = exposes.presets;
const ea = exposes.access;
const globalStore = require('zigbee-herdsman-converters/lib/store');
const tuya = require('zigbee-herdsman-converters/lib/tuya');
const utils = require('zigbee-herdsman-converters/lib/utils');
const herdsman = require('zigbee-herdsman');
const legacy = require('zigbee-herdsman-converters/lib/legacy');
const light = require('zigbee-herdsman-converters/lib/light');

const libColor = require('zigbee-herdsman-converters/lib/color');


const tzLocal =  {
    light_onoff_brightness: {
    key: ['state', 'brightness', 'brightness_percent', 'on_time'],
    options: [exposes.options.transition()],
    convertSet: async (entity, key, value, meta) => {
        const {message} = meta;
        const transition = utils.getTransition(entity, 'brightness', meta);
        const turnsOffAtBrightness1 = utils.getMetaValue(entity, meta.mapped, 'turnsOffAtBrightness1', 'allEqual', false);
        let state = message.hasOwnProperty('state') ? (message.state === null ? null : message.state.toLowerCase()) : undefined;
        let brightness = undefined;
        if (message.hasOwnProperty('brightness')) {
            brightness = Number(message.brightness);
        } else if (message.hasOwnProperty('brightness_percent')) {
            brightness = utils.mapNumberRange(Number(message.brightness_percent), 0, 100, 0, 255);
        }
        
    

        if (brightness === 255) {
            // Allow 255 for backwards compatibility.
            brightness = 254;
        }

        if (brightness !== undefined && (isNaN(brightness) || brightness < 0 || brightness > 254)) {
            throw new Error(`Brightness value of message: '${JSON.stringify(message)}' invalid, must be a number >= 0 and =< 254`);
        }

        if (state !== undefined && state !== null && ['on', 'off', 'toggle'].includes(state) === false) {
            throw new Error(`State value of message: '${JSON.stringify(message)}' invalid, must be 'ON', 'OFF' or 'TOGGLE'`);
        }

        if ((state === undefined || state === null) && brightness === undefined) {
            throw new Error(`At least one of "brightness" or "state" must have a value: '${JSON.stringify(message)}'`);
        }

        // Infer state from desired brightness if unset. Ideally we'd want to keep it as it is, but this code has always
        // used 'MoveToLevelWithOnOff' so that'd break backwards compatibility. To keep the state, the user
        // has to explicitly set it to null.
        if (state === undefined) {
            // Also write to `meta.message.state` in case we delegate to the `on_off` converter.
            state = meta.message.state = brightness === 0 ? 'off' : 'on';
        }

        let publishBrightness = brightness !== undefined;
        const targetState = state === 'toggle' ? (meta.state.state === 'ON' ? 'off' : 'on') : state;
        if (targetState === 'off') {
            // Simulate 'Off' with transition via 'MoveToLevelWithOnOff', otherwise just use 'Off'.
            // TODO: if this is a group where some members don't support Level Control, turning them off
            //  with transition may have no effect. (Some devices, such as Envilar ZG302-BOX-RELAY, handle
            //  'MoveToLevelWithOnOff' despite not supporting the cluster; others, like the LEDVANCE SMART+
            //  plug, do not.)
            brightness = transition.specified || brightness === 0 ? 0 : undefined;
            if (meta.state.hasOwnProperty('brightness') && meta.state.state === 'ON') {
                // The light's current level gets clobbered in two cases:
                //   1. when 'Off' has a transition, in which case it is really 'MoveToLevelWithOnOff'
                //      https://github.com/Koenkk/zigbee-herdsman-converters/issues/1073
                //   2. when 'OnLevel' is set: "If OnLevel is not defined, set the CurrentLevel to the stored level."
                //      https://github.com/Koenkk/zigbee2mqtt/issues/2850#issuecomment-580365633
                // We need to remember current brightness in case the next 'On' does not provide it. `meta` is not reliable
                // here, as it will get clobbered too if reporting is configured.
                globalStore.putValue(entity, 'brightness', meta.state.brightness);
                globalStore.putValue(entity, 'turnedOffWithTransition', brightness !== undefined);
            }
        } else if (targetState === 'on' && brightness === undefined) {
            // Simulate 'On' with transition via 'MoveToLevelWithOnOff', or restore the level from before
            // it was clobbered by a previous transition to off; otherwise just use 'On'.
            // TODO: same problem as above.
            // TODO: if transition is not specified, should use device default (OnTransitionTime), not 0.
            if (transition.specified || globalStore.getValue(entity, 'turnedOffWithTransition') === true) {
                const current = utils.getObjectProperty(meta.state, 'brightness', 254);
                brightness = globalStore.getValue(entity, 'brightness', current);
                try {
                    const attributeRead = await entity.read('genLevelCtrl', ['onLevel']);
                    // TODO: for groups, `read` does not wait for responses. If it did, we could still issue a single
                    //  command if all values of `OnLevel` are equal, or split into one command per device if not.
                    if (attributeRead !== undefined && attributeRead['onLevel'] != 255) {
                        brightness = attributeRead['onLevel'];
                    }
                } catch (e) {
                    // OnLevel not supported
                }
                // Published state might have gotten clobbered by reporting.
                publishBrightness = true;
            }
        }

        if (brightness === undefined) {
            
          
            const result = await tzLocal.on_off.convertSet(entity, 'state', state, meta);
            result.readAfterWriteTime = 0;
            if (result.state && result.state.state === 'ON' && meta.state.brightness === 0) {
                result.state.brightness = 1;
            }
            return result;
        }

        if (brightness === 0 && (targetState === 'on' || state === null)) {
            brightness = 1;
        }
        if (brightness === 1 && turnsOffAtBrightness1) {
            brightness = 2;
        }

        if (targetState !== 'off') {
            globalStore.putValue(entity, 'brightness', brightness);
            globalStore.clearValue(entity, 'turnedOffWithTransition');
        }
        // state === null ? 'moveToLevel' : 'moveToLevelWithOnOff',
      //  meta.logger.debug('STATE ' + state + ' : BRIGHT' + brightness);
        
       // const onOff = (await target.read('genOnOff', ['onOff'])).onOff;
      
       const target = utils.getEntityOrFirstGroupMember(entity);
       const onOff = (await target.read('genOnOff', ['onOff'])).onOff;
      

       if (onOff === 0) {
                meta.message.state = 'ON';
                const result = await tzLocal.on_off.convertSet(entity, 'state', state, meta);
               // meta.logger.debug('********TURN ON ' + result.state.state + ' : ' + result.state.brightness );
       }
       
       
       //meta.logger.debug('onOff ' + onOff + ' : BRIGHT' + brightness);
        //onOff === 1 ? 'moveToLevel' : 'moveToLevelWithOnOff',
        await entity.command(
            'genLevelCtrl',
            'moveToLevel',
            {level: Number(brightness), transtime: transition.time},
            utils.getOptions(meta.mapped, entity),
        );

        const result = {state: {}, readAfterWriteTime: transition.time * 100};
        if (publishBrightness) {
            result.state.brightness = Number(brightness);
          
        }
        if (state !== null) {
            result.state.state = brightness === 0 ? 'OFF' : 'ON';
        
        }
     
        return result;
    },
    convertGet: async (entity, key, meta) => {
        if (key === 'brightness') {
            await entity.read('genLevelCtrl', ['currentLevel']);
        } else if (key === 'state') {
            await tzLocal.on_off.convertGet(entity, key, meta);
        }
    },
},
on_off: {
    key: ['state', 'on_time', 'off_wait_time'],
    convertSet: async (entity, key, value, meta) => {
       
        const state = meta.message.hasOwnProperty('state') ? meta.message.state.toLowerCase() : null;
       
        utils.validateValue(state, ['toggle', 'off', 'on']);

        
        if (state === 'on' && (meta.message.hasOwnProperty('on_time') || meta.message.hasOwnProperty('off_wait_time'))) {
            const onTime = meta.message.hasOwnProperty('on_time') ? meta.message.on_time : 0;
            const offWaitTime = meta.message.hasOwnProperty('off_wait_time') ? meta.message.off_wait_time : 0;

            if (typeof onTime !== 'number') {
                throw Error('The on_time value must be a number!');
            }
            if (typeof offWaitTime !== 'number') {
                throw Error('The off_wait_time value must be a number!');
            }

            const payload = {ctrlbits: 0, ontime: Math.round(onTime * 10), offwaittime: Math.round(offWaitTime * 10)};
            await entity.command('genOnOff', 'onWithTimedOff', payload, utils.getOptions(meta.mapped, entity));
        } else {
            await entity.command('genOnOff', state, {}, utils.getOptions(meta.mapped, entity));
            if (state === 'toggle') {
                const currentState = meta.state[`state${meta.endpoint_name ? `_${meta.endpoint_name}` : ''}`];
                return currentState ? {state: {state: currentState === 'OFF' ? 'ON' : 'OFF'}} : {};
            } else {
                return {state: {state: state.toUpperCase()}};
            }
        }
    },
    convertGet: async (entity, key, meta) => {
        await entity.read('genOnOff', ['onOff']);
    },
}
}

//bit 0 contact: !((zoneStatus & 1) > 0),
//bit 1 vibration: (zoneStatus & 1<<1) > 0,
//bit 2 tamper: (zoneStatus & 1<<2) > 0,
//battery_low: (zoneStatus & 1<<3) > 0,
// fromZigbee: [fzLocal.LDSENK08,fz.battery,fz.illuminance], // We will add this later

module.exports = [
    {
    zigbeeModel: ['ZB-DL01'], // The model ID from: Device with modelID 
    model: 'LEDEAST_S10', // Vendor model number, look on the device for a model number
    vendor: 'eWeLight', // Vendor of the device (only used for documentation and startup logging)
    description: 'Remote Control Zigbee 0/1-10V LED Dimmer', // Description of the device, copy from vendor site. (only used for documentation and startup logging)
    fromZigbee: [fz.on_off, fz.brightness, fz.level_config, fz.ignore_basic_report], // We will add this later
    toZigbee: [tzLocal.light_onoff_brightness, tz.ignore_transition, tz.ignore_rate, tz.light_brightness_move,
        tz.light_brightness_step, tz.level_config,tz.effect], // Should be empty, unless device can be controlled (e.g. lights, switches).
    exposes: [ e.light_brightness(),e.effect()], // Defines what this device exposes, used for e.g. Home Assistant discovery and in the frontend
    whiteLabel: [{vendor: 'TuYa', model: 'iHSW02'}],
    configure: async (device, coordinatorEndpoint, logger) => {
        await light.configure(device, coordinatorEndpoint, logger, true);
    },
},
];

[myreczek]

I'm experiencing the same problems with this device. How am I supposed use this code? As external converter?

[theuselessone]

Yes exactly it is an external converter! You put the code into a file in my case i named it eWeLight.js and then put into the zigbee2mqtt folder. Then you add the file name to the zigbee2mqtt/configuration.yaml file in the external_converters: section and restart z2m and add the device.

[myreczek]

Unfortunately it did not help. I can see the external converter as effective on the device page but it keeps behaving weird.

[theuselessone]

Ok! Weird is a bit wage. I think the problem might be that different devices identify themself as the same device although they are different and have different FW. Thats also why i did not push this change in the driver. My problem was that my device did not handle turn on light with value so good so i divided that functionality and i have not had any problems since then. This is what my device looked like.

[myreczek]

I have this device from Amazon: https://www.amazon.de/dp/B0C7K5WP1C
It reports itself as YSR-MINI-01_dimmer in z2m. Transitions do not work as documented. It is different device than yours.