Zemismart ZMP1 Roller Shade Driver: Adding Z2M and ZHA Support

const exposes = require('zigbee-herdsman-converters/lib/exposes');
const tuya = require('zigbee-herdsman-converters/lib/tuya');
const e = exposes.presets;
const ea = exposes.access;

const definition = {
    fingerprint: tuya.fingerprint('TS0601', ['_TZE284_6hrnp30w']),
    model: 'ZMP1',
    vendor: 'Zemismart',
    description: 'Roller shade driver',
    fromZigbee: [tuya.fz.datapoints],
    toZigbee: [tuya.tz.datapoints],
    onEvent: tuya.onEventSetTime,
    configure: async (device, coordinatorEndpoint) => {
        await tuya.configureMagicPacket(device, coordinatorEndpoint);
    },
    exposes: [
        // Core cover
        e.cover_position().setAccess('position', ea.STATE_SET),

        // Manual nudge
        e.enum('click_control', ea.SET, ['up', 'down'])
            .withDescription('Nudge the shade up or down by one step'),

        // Motor direction
        e.enum('motor_direction', ea.STATE_SET, ['forward', 'back'])
            .withDescription('Reverse motor direction if open/close are inverted'),

        // Mode
        e.enum('mode', ea.STATE_SET, ['morning', 'night'])
            .withDescription('Morning or night mode'),

        // Live motion state (read only, event-driven)
        e.enum('work_state', ea.STATE, ['opening', 'closing'])
            .withDescription('Current motor motion state'),

        // Calibrated full travel time (read only, set during limit calibration)
        e.numeric('time_total', ea.STATE)
            .withUnit('ms')
            .withValueMin(0)
            .withValueMax(120000)
            .withDescription(
                'Total calibrated travel time in milliseconds. ' +
                'Measured by the motor when upper and lower limits are set.'
            ),

        // Limit hit event (read only, fires when shade reaches a limit)
        e.enum('situation_set', ea.STATE, ['fully_open', 'fully_close'])
            .withDescription('Reports when the shade physically reaches a set limit'),

        // Motor fault (read only, fires on fault condition)
        e.binary('motor_fault', ea.STATE, true, false)
            .withDescription('Motor fault detected'),

        // Battery
        e.battery(),

        // Set travel limits
        e.enum('set_limit', ea.SET, ['Set upper limit', 'Set lower limit'])
            .withDescription(
                'Save the current motor position as a travel limit. ' +
                'Move the motor to the desired position first, then select and apply.'
            ),

        // Remove travel limits
        e.enum('remove_limit', ea.SET, ['Remove upper limit', 'Remove lower limit', 'Clear both limits'])
            .withDescription(
                'Remove one or both travel limits. ' +
                '"Clear both limits" resets the motor fully — use before recalibrating from scratch.'
            ),

    ],
    meta: {
        tuyaDatapoints: [
            // DP1 — primary open/stop/close command
            [1, 'state', tuya.valueConverterBasic.lookup({
                OPEN:  tuya.enum(0),
                STOP:  tuya.enum(1),
                CLOSE: tuya.enum(2),
            })],

            // DP2 — position setpoint (write only)
            [2, 'position', {
                from: null,
                to: (value) => value,
            }],

            // DP3 — actual position state (read only)
            [3, 'position', {
                from: (value) => value,
                to: null,
            }],

            // DP4 — mode
            [4, 'mode', tuya.valueConverterBasic.lookup({
                morning: tuya.enum(0),
                night:   tuya.enum(1),
            })],

            // DP5 — motor direction
            [5, 'motor_direction', tuya.valueConverterBasic.lookup({
                forward: tuya.enum(0),
                back:    tuya.enum(1),
            })],

            // DP7 — work state
            [7, 'work_state', tuya.valueConverterBasic.lookup({
                opening: tuya.enum(0),
                closing: tuya.enum(1),
            })],

            // DP10 — total calibrated travel time
            [10, 'time_total', tuya.valueConverter.raw],

            // DP11 — situation set (limit reached event)
            [11, 'situation_set', tuya.valueConverterBasic.lookup({
                fully_open:  tuya.enum(0),
                fully_close: tuya.enum(1),
            })],

            // DP12 — fault bitmap
            [12, 'motor_fault', {
                from: (value) => value !== 0,
                to: null,
            }],

            // DP13 — battery percentage
            [13, 'battery', tuya.valueConverter.raw],

            // DP16 — travel limit calibration (write only, from: null suppresses echo-back parse errors)
            [16, 'set_limit', {
                from: null,
                to: (value) => {
                    const map = {
                        'Set upper limit': tuya.enum(0),
                        'Set lower limit': tuya.enum(1),
                    };
                    return map[value];
                },
            }],
            [16, 'remove_limit', {
                from: null,
                to: (value) => {
                    const map = {
                        'Remove upper limit': tuya.enum(2),
                        'Remove lower limit': tuya.enum(3),
                        'Clear both limits':  tuya.enum(4),
                    };
                    return map[value];
                },
            }],

            // DP19 — position_best exists on device but has no recall DP,
            // so it is intentionally not exposed to avoid a useless slider.

            // DP20 — click control (nudge)
            [20, 'click_control', tuya.valueConverterBasic.lookup({
                up:   tuya.enum(0),
                down: tuya.enum(1),
            })],
        ],
    },
};

module.exports = definition;