How to set up device specific setting from external converter

[akira215]

Following the development of a specific setting (option) of a homemade device (refer to https://github.com/Koenkk/zigbee2mqtt/discussions/24497 ), I manage to set the option in the device state.

But I need to set up the specific settings on the device (an on the frontend display), at startup, from my external converter:

I struggled a lot without success and I don't have any clue on how to do it.
How could this be achieve ?
Thanks ahead

[akira215]

Basically, I need to call settings.changeEntityOptions(device, { tic_mode: ticMode }); as the commented line 2277 in the file
https://github.com/Koenkk/zigbee-herdsman-converters/blob/ba97340d2416dfde77794d780fec9c44d403fa90/src/devices/gmmts.ts#L2277

But how to properly import settings form zigbee2mqtt within the external converter ?

[akira215]

I solved my issue by struggling in the zigbee2mqtt hassio install script. I finally did something a little bit weird but seems to do the job. I post my case in case anyone else is looking for something similar. Any comments are welcome, I'm not familiar with a lot of things in zigbee2mqtt (containers, hassio, ....).

Anyway once the project will be finalize I will commit on my github repo and may be add a pull request here.

const fz = require('zigbee-herdsman-converters/converters/fromZigbee');
const tz = require('zigbee-herdsman-converters/converters/toZigbee');
const exposes = require('zigbee-herdsman-converters/lib/exposes');
const reporting = require('zigbee-herdsman-converters/lib/reporting');
const utils = require('zigbee-herdsman-converters/lib/utils');
const globalStore = require('zigbee-herdsman-converters/lib/store');

// settings from zigbee2mqtt to access changeEntityOptions
const settings = require('/app/dist/util/settings');

const e = exposes.presets;
const ea = exposes.access;

function genCurrentSum() {
    // The name shall not contain space otherwise it is not reported to HA
    return exposes.numeric('water_consumed', ea.STATE_GET)
            .withDescription('Water meter record')
            .withUnit('m³');
};


// Options for the k factor of the water meter (L/pule)
function genWaterMeterOptions() {
    return exposes.numeric('k_factor', ea.ALL)
            .withValueMin(0)
            .withDescription('Water meter kFactor')
            .withUnit('L/pulse')
};

const toZigbee_Metering = {
    //key: ['Water Consumption', 'switch_actions', 'relay_mode', 'max_pause', 'min_long_press'],
    key: ['water_consumed'],
    convertSet: async (entity, key, value, meta) => {
        // just for debug, to see any incoming request
        meta.logger.info(` convertSet key=[${key}]`);
    },
    // convertGet will be call to read value on the device
    convertGet: async (entity, key, meta) => {
        const endpoint = meta.device.getEndpoint(1);
        // If Water Consumption actualization button has been pressed
        if(key == 'water_consumed') {
            await endpoint.read('seMetering', ['currentSummDelivered'/*,'unitOfMeasure','multiplier','divisor','summaFormatting'*/]);
        }
    },

};

const fromZigbee_Metering = {
    
    cluster: 'seMetering',
    type: ['attributeReport', 'readResponse'],
    options: [genWaterMeterOptions()],
    convert: (model, msg, publish, options, meta) => {
        const result = {};
        meta.logger.info(`convert options =${JSON.stringify(options)}`);
        //meta.logger.info(`convert publish =${JSON.stringify(publish)}`);
        //meta.logger.info(`convert model =${JSON.stringify(model)}`);
        //meta.logger.info(`convert msg =${JSON.stringify(msg)}`);

        //Multiplier is read only on configure device, we use this to set up the optional setting from the state
        if (msg.data.hasOwnProperty('multiplier')) {
            //deviceAddr is also available with options.ID or options.friendly_name
            let newK = 1;
            if (options.hasOwnProperty('k_factor'))
                newK = options.k_factor;
            else
                newK =msg.data['multiplier'];
        
            const endpointWaterMeter = msg.device.getEndpoint(1);
            //meta.logger.info(`Reading Multiplier k_factor=${JSON.stringify(options.k_factor)}`);
            settings.changeEntityOptions(endpointWaterMeter.deviceIeeeAddress, { k_factor: newK });
        }

        if (msg.data.hasOwnProperty('currentSummDelivered')) {
            const multiplier = options.k_factor;
            const divisor = meta.device.getEndpoint(1).getClusterAttributeValue('seMetering', 'divisor');
            //meta.logger.info(`+_+_+_ #2 Multiplier=${multiplier}`);
            meta.logger.info(`+_+_+_ #3 options=${JSON.stringify(options)}`);
            const data = msg.data['currentSummDelivered'];
            //Needed BigInt as << 32 overpass the Number JS type
            const currentSummDelivered = (BigInt(parseInt(data[0])) << BigInt(32)) + BigInt(parseInt(data[1]));
            //Multiply by the divisor and divide again to avoid BigInt rounding to 0
            const currentSummDisplayed = (Number(currentSummDelivered) * multiplier /
                                        ( divisor ? divisor: 1));
            
            result[`water_consumed`] = currentSummDisplayed;
        }

        return result;
    },
}
async function onEventCallback(type, data, device, settings, state) {
    //console.info(`onEventCallback type = ${type}`);
    //if(type == 'message'){
    //    console.info(`onEventCallback Message = ${JSON.stringify(data)}`);
    //}

    // Catch deviceOptionsChanged event, triggered by user changing device specific settings
    if(type == 'deviceOptionsChanged'){

        // Warning this event is trigger twice, the 2nd with from field = to field
        // Return if there is no from or no to field
        if ((!data.hasOwnProperty('from'))||(!data.hasOwnProperty('to')))
            return; 

        if (data.to.hasOwnProperty('k_factor'))
        {
            const newK = data.to['k_factor'];

            if(state.hasOwnProperty('options'))
                state.options['k_factor'] = newK;
            else
                state.options = {k_factor: newK}; 
        }

    }  //deviceOptionsChanged
}


const definition = {
    zigbeeModel: ['WaterTankMonitor'],
    model: 'WaterTankMonitor',
    vendor: 'AkiraCorp',
    description: 'Water Tank Monitor Device https://github.com/akira215/zTank',
    fromZigbee: [fz.on_off, fromZigbee_Metering ],
    toZigbee: [tz.on_off, toZigbee_Metering],
    exposes: [ e.switch(), genCurrentSum(), e.temperature()],
    options:[genWaterMeterOptions()],
    configure: async (device, coordinatorEndpoint, logger) => {
        const endpointWaterMeter = device.getEndpoint(1);
        // Bind cluster
        await endpointWaterMeter.bind(['seMetering'], coordinatorEndpoint);
        // trigger a read multiplier to update the k_factor from the saved state
        await reporting.readMeteringMultiplierDivisor(endpointWaterMeter);

        // read value on start up
        await endpointWaterMeter.read('seMetering', ['currentSummDelivered']);

        device.powerSource = 'Mains (single phase)';
        device.save();
    },
    onEvent: onEventCallback
    //ota: ota.zigbeeOTA
};

module.exports = definition;