Fil pilote Xanlite et fichier converters incomplet

[chrisgen]

Bonsoir
On m' a donné un appareil fil pilote Xanlite home Zigbee 3 . Sous Zigbee2Mqtt , il n' est pas reconnu , mais avec un fichier placé dans le répertoire pour converters , après avoir un peu (beaucoup) galéré j' ai réussi à récupérer un fonctionnement à peu près correct ( les 6 modes , la température courante ,l' étalonnage de la temp courante ) . Plutôt que de réinventer la roue , y a t-il quelqu'un qui aurait trouvé le fonctionnement complet ? Il me manque la température des bornes (eco température , température confort , target ,etc) Cela fonctionne sans mais j' aimerais finaliser ..Sinon quelqu'un connaît -il les adresses des datapoints que je pourrais éventuellement tester ? Merci
Bonne soirée

[chrisgen]

Bonsoir
voila mon fichier converters qui fonctionne mais qui est (très) incomplet :

Code : Tout sélectionner

// 13/09   22_30   version simplifiée: 6 modes ; current temperature; etalonnage temperature ; child_lock
//  chrisgen   inspiré par Zelox69 T  (https://github.com/Koenkk/zigbee2mqtt/discussions/25687) 
//et aldoushx (https://github.com/Koenkk/zigbee2mqtt/discussions/26256)

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 e = exposes.presets;
const ea = exposes.access;
const tuya = require('zigbee-herdsman-converters/lib/tuya');

const CHILD_LOCK_DP = 39;     // child_lock DP confirmé
const  HUMIDITY_DP = 8;  //  // ne fonctionne pas idem pour 9 10,11.. semble fonctionner pour 8


const definition = {
    fingerprint: [{ modelID: 'TS0601', manufacturerName: '_TZE204_3q3maeoo' }],
    model: 'TS0601_3q3maeoo',
    vendor: 'Tuya',
    description: 'Gestion de chauffage par fil pilote (version simplifiée)',

    fromZigbee: [
        tuya.fz.datapoints,
        {
            cluster: 'manuSpecificTuya',
            type: ['attributeReport', 'readResponse'],
            convert: (model, msg, publish, options, meta) => {
                const dp = msg.data.dp;
                const value = msg.data.value;

                switch (dp) {
                    case HUMIDITY_DP: // humidity   
					       return { humidity: value  };
                   

                    case 127: // Mode
                        const modes = {
                            2: 'comfort_minus_2',
                            1: 'comfort_minus_1',
                            0: 'comfort',
                            3: 'eco',
                            4: 'anti_frost',
                            5: 'off',
                            6: 'program',
                        };
                        return { mode: modes[value] || `unknown_${value}` };

			             case 16: // Température actuelle
                        return { current_temperature: value / 10 };

                    case 101: // Etalonnage température
                        {
                            const signed = value > 32767 ? value - 65536 : value;
                            return { etalonnage_temp: signed / 10 };
                        }

                   case CHILD_LOCK_DP: // Child lock
                        return { child_lock: (value === 1 || value === true) ? 'LOCK' : 'UNLOCK' };

                    default:
                        meta.logger.warn(`Datapoint non géré : ${dp}, valeur : ${value}`);
                        return null;
                }
            },
        },
    ],

    toZigbee: [
        

        {
            key: ['mode'],
            convertSet: async (entity, key, value, meta) => {
                try {
                    const modes = {
                        'comfort_minus_2': 2,
                        'comfort_minus_1': 1,
                        'comfort': 0,
                        'eco': 3,
                        'anti_frost': 4,
                        'off': 5,
                        'program': 6,
                    };
                    const dpValue = modes[value];
                    if (dpValue === undefined) throw new Error(`Mode invalide : ${value}`);
                    await tuya.sendDataPointEnum(entity, 127, dpValue);
                    return { mode: value };
                } catch (error) {
                    meta.logger.error(`Erreur en envoyant mode: ${error?.message || error}`);
                }
            },
        },

        {
            key: ['etalonnage_temp'],
            convertSet: async (entity, key, value, meta) => {
                try {
                    const raw = Math.round(value * 10);
                    const tempValue = raw < 0 ? 65536 + raw : raw; // signed 16 bits
                    await tuya.sendDataPointValue(entity, 101, tempValue);
                } catch (error) {
                    meta.logger.error(`Erreur etalonnage_temp: ${error?.message || error}`);
                }
            },
        },

       
        // child_lock DP39 (LOCK/UNLOCK)
        {
            key: ['child_lock'],
            convertSet: async (entity, key, value, meta) => {
                try {
                    const v = (typeof value === 'string') ? value.toUpperCase() : value;
                    const mapping = {
                        'LOCK': 1, 'UNLOCK': 0,
                        'ON': 1,   'OFF': 0,
                        true: 1,   false: 0,
                        1: 1,      0: 0
                    };
                    const dpVal = mapping[v];
                    if (dpVal === undefined) throw new Error(`Valeur child_lock invalide : ${value}`);
                    await tuya.sendDataPointEnum(entity, CHILD_LOCK_DP, dpVal);
                    return { child_lock: dpVal === 1 ? 'LOCK' : 'UNLOCK' };
                } catch (error) {
                    meta.logger.error(`Erreur child_lock convertSet: ${error?.message || error}`);
                }
            },
        },
    ],

    exposes: [
       // e.switch().withDescription('Contrôle ON/OFF de l\'appareil'),
        e.enum('mode', ea.SET, [
            'comfort_minus_2', 'comfort_minus_1', 'comfort', 'eco', 'anti_frost', 'off', 'program'
        ]).withDescription('Mode de fonctionnement'),
        e.numeric('current_temperature', ea.STATE).withUnit('C').withDescription('Temperature actuelle mesurée'),
		   e.numeric('humidity', ea.STATE).withUnit('%').withDescription('humidite mesuree'),
		   e.numeric('etalonnage_temp', ea.SET).withUnit('C').withDescription('Réglage température courante').withValueMin(-6).withValueMax(6).withValueStep(0.1),
        e.enum('child_lock', ea.SET, ['LOCK','UNLOCK']).withDescription('Verrouillage enfant (LOCK/UNLOCK)'),
       
    ],

    meta: {
        tuyaDatapoints: [
           
            [127, 'mode', {
                from: (value) => {
                    const modes = { 2:'comfort_minus_2',1:'comfort_minus_1',0:'comfort',3:'eco',4:'anti_frost',5:'off',6:'program' };
                    return modes[value] || `unknown_${value}`;
                },
                to: (value) => {
                    const modes = { 'comfort_minus_2':2,'comfort_minus_1':1,'comfort':0,'eco':3,'anti_frost':4,'off':5,'program':6 };
                    return modes[value];
                }
            }],

			     [16, 'current_temperature', { from: (value) => value / 10 }],
					
					
				  [HUMIDITY_DP, 'humidity', { from: (value) => value  }],
					

            [101, 'etalonnage_temp', {
                from: (value) => {
                    const signed = value > 32767 ? value - 65536 : value;
                    return signed / 10;
                },
                to: (value) => {
                    const raw = Math.round(value * 10);
                    return raw < 0 ? 65536 + raw : raw;
                },
            }],
            
            [CHILD_LOCK_DP, 'child_lock', {
                from: (v) => (v === 1 || v === true) ? 'LOCK' : 'UNLOCK',
                to: (val) => {
                    const vv = (typeof val === 'string') ? val.toUpperCase() : val;
                    return (vv === 'LOCK' || vv === 'ON' || vv === true || vv === 1) ? 1 : 0;
                }
            }],
        ],
    },
};

module.exports = definition;

il est fonctionnel. J' utilise MqttMapper (pour le relier à Domoticz), le bien nommé et fort apprécié programme de Flying Domotic mais j' aimerais encore l' améliorer si possible .. Le boitier fonctionne bien (pour les modes , la température , child_lock) et me remplacera avantageusement un vieux qbino zwave qui devient introuvable . Si vous avez quelques idées
Merci

[lost]

Les Qubino, tout mon chauffage est piloté via ces modules, avaient en effet été définitivement arrêtés par le fabricant: Cela m'avait été confirmé par le support Domotique-Store avant que le site périclite...

Ce module avait été fait sur la base technique d'un module existant sans changement autre que son firmware et à l'arrêt de ce module donneur, plus moyen de faire de même avec le remplacant et ce mode de pilotage de radiateurs franco-français n'avait pas un marché suffisant pour justifier un développement complet.
J'en avait acheté 1 de rab en cas de panne, j'espère qu'ils dureront: C'est l'existence de ce module, alors unique, qui m'avait fait partir sur le zwave quand j'avais démarré la domotique il y a 10 ans (en commençant par la gestion du chauffage).

Sinon en zigbee Nodon semble faire un tel module avec visiblement un clone commercialisé par Leroy-Merlin sous sa marque Equation. Aucune idée du support Z2M ou Z4D par contre.

[Keros]

Lost, les modules Nodon avec fil pilote et mesure de conso électrique sont fonctionnels dans le plugin Z4D.

[chrisgen]

Bonsoir
Suite au chute de température , j' ai pu tester avec le converters ci-dessus, l'utilisation de cet appareil dans des conditions réelles .
Les moins par rapport à Qbino :
- ce n' est pas un module donc pas possible de le mettre derrière le radiateur ..
- le fil peut paraître un peu court pour le décaler du radiateur (mais on peut facilement le rallonger)
- pas de mesure directe de la consommation (comme le qbino d' ailleurs )mais Nodon semble le faire (branchements du radiateur sur le module )
les plus :
- le prix (on me l'a offert , mais on peut le trouver pour environ 30€)
- les 6 modes (idem qbino)
- la mesure de la température ( cela me permet d'utiliser au mieux le script TPI de Neutrino par rapport à une sonde déportée)
- le Zigbee (qui prend de plus en plus de place dans mes "devices" )
- la modernisation de mon vieux grill-pain atlantic à boutons rotatifs et selecteur de mode ..
- la touche child_lock pour bloquer les réglages à mes petits enfants ..
Bref , pas mécontent de cet engin . Je pense en utiliser d' autres . A voir dans la durée

[lost]

- les 6 modes (idem qbino)
(...)
- la modernisation de mon vieux grill-pain atlantic à boutons rotatifs et selecteur de mode ..

Attention car sur un vieux radiateur il est possible que seuls 4 ordres soient supportés (off/hors-gel/éco/confort, sans les deux confort -1 et -2°C)... avec un comportement pas forcément prévisible si on sélectionne les 2 modes non supportés.

J'ai un sèche serviette radiant dans ma SdB un peu ancien qui est dans ce cas... et difficile de le changer, car on ne trouve plus de tels appareils en radiant alors que s'il y a une pièce ou le radiant a un sens, c'est bien la SdB car il vous chauffe à travers la paroi de douche. On ne trouve pour ce type de chauffage hélas plus que de l'inertie, éventuellement avec un ventilo (qui s'use et fait du bruit pour espérer mieux diffuser la chaleur... mais toujours plus mal qu'un radiant si paroi verre haute)...

Tandis qu'on trouve des tas de radiants à installer dans son salon... idéalement avec une porte fenêtre dans l'axe.... pour irradier sa chaleur en partie dehors! Allez comprendre...