Zemismart ZMP1 Z2M ZHA

Zemismart ZMP1: Integración Avanzada con Zigbee2MQTT y ZHA

Descifrando el Controlador de Persianas Zemismart ZMP1 para Zigbee2MQTT y ZHA

La domótica avanza a pasos agigantados, y dispositivos como el Zemismart ZMP1 se posicionan como piezas clave para la automatización de nuestros hogares. Este controlador de persianas, compatible con protocolos como Zigbee, abre un abanico de posibilidades para quienes buscan un control granular y eficiente de sus sistemas de sombreado.

Zemismart ZMP1: El Corazón de tu Automatización de Persianas

El Zemismart ZMP1 no es un simple interruptor. Es un controlador inteligente diseñado para gestionar el movimiento de persianas motorizadas. Su integración con plataformas como Zigbee2MQTT y ZHA permite una interoperabilidad sin precedentes, fusionando la comodidad de la automatización con la robustez de una red inalámbrica eficiente.

Configuración Detallada con Zigbee2MQTT: El Poder del External Converter

La verdadera potencia del Zemismart ZMP1 se desvela al utilizarlo con Zigbee2MQTT, especialmente a través de su “External Converter”. Este método permite una personalización profunda y la exposición de todas las funcionalidades del dispositivo, algo que no siempre se logra con la configuración predeterminada.

Análisis del Código del External Converter para Zemismart ZMP1

El código proporcionado es un ejemplo de cómo un desarrollador ha mapeado las capacidades del Zemismart ZMP1 para Zigbee2MQTT. Vamos a desglosar cada sección para entender su propósito:

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;

Componentes Clave del `definition`
`fingerprint`: Identifica de manera única el dispositivo dentro del ecosistema Zigbee. En este caso, se basa en el identificador de Tuya (`TS0601`) y un modelo específico (`_TZE284_6hrnp30w`).
`model` y `vendor`: Detallan el modelo (`ZMP1`) y el fabricante (`Zemismart`), cruciales para la correcta identificación.
`description`: Una breve descripción funcional del dispositivo: “Roller shade driver” (controlador de persianas).
`fromZigbee` y `toZigbee`: Definen cómo el dispositivo se comunica con Zigbee2MQTT. Aquí se utilizan las funciones genéricas de Tuya para el manejo de datapoints.
`onEvent` y `configure`: Métodos para gestionar eventos y la configuración inicial del dispositivo, respectivamente. La llamada a `tuya.configureMagicPacket` es fundamental para la comunicación con dispositivos Tuya.
Exposición de Funcionalidades (`exposes`)
La sección `exposes` es la que determina qué características del Zemismart ZMP1 estarán disponibles para su control y monitorización en plataformas como Home Assistant:
📣
¿Te interesan estas ofertas? Las publicamos primero en nuestro canal de Telegram — 10.247 miembros.
`cover_position`: Permite el control y la lectura de la posición de la persiana (porcentaje de apertura/cierre).
`click_control`: Ofrece la posibilidad de enviar comandos de “empuje” (nudge) hacia arriba o abajo, útil para ajustes finos.
`motor_direction`: Permite invertir la dirección del motor si la configuración de apertura y cierre está invertida de fábrica.
`mode`: Soporta diferentes modos de operación, como “morning” (mañana) y “night” (noche), lo que sugiere funcionalidades preprogramadas.
`work_state`: Proporciona información en tiempo real sobre el estado de movimiento del motor: “opening” (abriendo) o “closing” (cerrando).
`time_total`: Muestra el tiempo total calibrado que tarda el motor en completar un recorrido completo. Este valor se establece durante la calibración de los límites.
`situation_set`: Un indicador de eventos que reporta cuándo la persiana ha alcanzado físicamente los límites superior o inferior.
`motor_fault`: Una señal binaria que alerta sobre posibles fallos en el motor.
`battery`: Muestra el nivel de carga de la batería, esencial para dispositivos inalámbricos.
`set_limit`: Permite guardar la posición actual del motor como límite superior o inferior, facilitando la calibración.
`remove_limit`: Ofrece la opción de eliminar los límites de recorrido configurados, individualmente o ambos a la vez, para una recalibración completa.
Mapeo de Data Points (`meta.tuyaDatapoints`)
Esta subsección es la más técnica y crucial, ya que define la correspondencia entre los comandos y estados del dispositivo y los “datapoints” (DPs) específicos del protocolo Tuya:
DP1 (`state`): Mapea los comandos `OPEN`, `STOP`, `CLOSE` a valores numéricos específicos para el control principal del movimiento.
DP2 (`position`): Utilizado para enviar el valor de posición deseado al dispositivo (solo escritura).
DP3 (`position`): Utilizado para recibir la posición actual del dispositivo (solo lectura).
DP4 (`mode`): Convierte entre los modos `morning`/`night` y sus correspondientes valores numéricos.
DP5 (`motor_direction`): Mapea la dirección del motor (`forward`/`back`) a valores numéricos.
DP7 (`work_state`): Traduce los estados de movimiento (`opening`/`closing`) a valores numéricos.
DP10 (`time_total`): Permite leer el tiempo total de recorrido calibrado.
DP11 (`situation_set`): Indica cuándo se alcanzan los límites (`fully_open`/`fully_close`).
DP12 (`motor_fault`): Convierte un valor numérico de un “bitmap de fallos” a un estado booleano (`true`/`false`).
DP13 (`battery`): Lee directamente el porcentaje de batería.
DP16 (`set_limit`, `remove_limit`): Estos son comandos complejos para la calibración de límites. El código maneja tanto el establecimiento como la eliminación de los límites superior e inferior, e incluye una opción para “limpiar ambos límites”.
DP20 (`click_control`): Mapea los comandos de “nudge” (`up`/`down`) para el control manual.
Zemismart ZMP1 y ZHA: Una Alternativa de Integración
Aunque el código proporcionado se centra en Zigbee2MQTT, el Zemismart ZMP1 también es compatible con la integración a través de ZHA (Zigbee Home Automation) en Home Assistant. La compatibilidad con ZHA generalmente se logra si el dispositivo sigue los estándares Zigbee y expone sus funcionalidades de manera correcta. En muchos casos, la configuración automática de ZHA puede reconocer el dispositivo y exponer sus características básicas, como el control de posición y el estado de la batería.
Ventajas de la Integración con ZHA
La principal ventaja de usar ZHA es su integración nativa dentro de Home Assistant, lo que puede simplificar la configuración para muchos usuarios. Sin embargo, es posible que la granularidad y el control fino que ofrece un “external converter” de Zigbee2MQTT no siempre estén disponibles de forma predeterminada en ZHA, requiriendo a veces definiciones personalizadas si el dispositivo no es reconocido completamente.
Consideraciones Finales para el Zemismart ZMP1
El Zemismart ZMP1 se presenta como una solución robusta y versátil para la automatización de persianas. La clave para desbloquear todo su potencial reside en la correcta configuración y la elección de la plataforma de integración adecuada. Para usuarios avanzados que buscan el máximo control y personalización, la implementación de un “external converter” en Zigbee2MQTT es el camino a seguir, permitiendo ajustar cada parámetro y recibir toda la información del dispositivo.
La inversión en un dispositivo como el Zemismart ZMP1, junto con una plataforma de domótica como Home Assistant y un protocolo eficiente como Zigbee, sienta las bases para un hogar verdaderamente inteligente y automatizado, donde el confort y la eficiencia energética van de la mano.