bt-sensors-plugin-sk 1.0.2 → 1.1.0-beta.1

package/sensor_classes/VictronSmartBatteryProtect.js

@@ -0,0 +1,49 @@
+/*
+Smart Battery Protect
+Start
+bit
+Nr of
+bits Meaning Units Range NA
+value Remark
+8 8 Device state 0 .. 0xFE 0xFF VE_REG_DEVICE_STATE
+16 8 Output state 0 .. 0xFE 0xFF VE_REG_DC_OUTPUT_STATUS
+24 8 Error code 0 .. 0xFE 0xFF VE_REG_CHR_ERROR_CODE
+32 16 Alarm reason 0 .. 0xFFFF - VE_REG_ALARM_REASON
+48 16 Warning reason 0 .. 0xFFFF - VE_REG_WARNING_REASON
+64 16 Input voltage 0.01 V 327.68 .. 327.66 V 0x7FFF VE_REG_DC_CHANNEL1_VOLTAGE
+80 16 Output voltage 0.01 V 0 .. 655.34 V 0xFFFF VE_REG_DC_OUTPUT_VOLTAGE
+96 32 Off reason 0 .. 0xFFFFFFFF - VE_REG_DEVICE_OFF_REASON_2
+*/
+
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+class VictronSmartBatteryProtect extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x09)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('deviceState','', 'device state', 
+                        (buff)=>{return VC.OperationMode.get(buff.readUInt8(1))})
+        this.addMetadatum('outputStatus','', 'output status', //TODO
+            (buff)=>{return (buff.readUInt8(2))})
+
+        this.addMetadatum('chargerError','', 'charger error',
+            (buff)=>{return VC.ChargerError.get(buff.readUInt8(3))})
+        this.addMetadatum('alarmReason','', 'alarm reason', 
+            (buff)=>{return VC.AlarmReason.get(buff.readUInt16LE(4))})
+        this.addMetadatum('warningReason','', 'warning reason', //TODO
+            (buff)=>{return (buff.readUInt16LE(5))})
+        this.addMetadatum('channel1Voltage','V', 'channel one voltage', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(7),0x7FFF)/100})
+        this.addMetadatum('outputVoltage','V', 'output voltage', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(9),0xFFFF)/100})
+        this.addMetadatum('offReason','', 'off reason', 
+            (buff)=>{return VC.OffReasons.get(buff.readUInt16LE(11))}) //TODO
+        }
+
+}
+module.exports=VictronSmartBatteryProtect 

package/sensor_classes/VictronSmartLithium.js

@@ -0,0 +1,66 @@
+/*
+SmartLithium (0x05)
+Start Bit	Nr of Bits	Meaning	Units	Range	NA Value	Remark
+32	32	BMS flags		0..0xFFFFFFFF		VE_REG_BMS_FLAGs
+64	16	SmartLithium error		0..0xFFFF		VE_REG_SMART_LITHIUM_ERROR_FLAGS
+80	7	Cell 1	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+87	7	Cell 2	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+94	7	Cell 3	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+101	7	Cell 4	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+108	7	Cell 5	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+115	7	Cell 6	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+122	7	Cell 7	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+129	7	Cell 8	0.01V	2.60..3.86 V	0x7F	VE_REG_BATTERY_CELL_VOLTAGE*
+136	12	Battery voltage	0.01V	0..40.94 V	0x0FFF	VE_REG_DC_CHANNEL1_VOLTAGE
+148	4	Balancer status		0..15	0x0F	VE_REG_BALANCER_STATUS
+152	7	Battery temperature	1°C	-40..86 °C	0x7F	VE_REG_BAT_TEMPERATURE Temperature = Record value - 40
+159	1	Unused				
+VE_REG_BATTERY_CELL_VOLTAGE 0x00 ( 0) when cell voltage < 2.61V 0x01 ( 1) when cell voltage == 2.61V 0x7D (125) when cell voltage == 3.85V 0x7E (126) when cell voltage > 3.85 0x7F (127) when cell voltage is not available / unknown
+*/const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+
+class VictronSmartLithium extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x05)
+    }   
+
+    static {
+
+        function _toCellVoltage(val){    
+            return val==0x7F?NaN:2.6+(val/100)
+        }
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('bmsFlags','', 'BMS Flags', 
+                        (buff)=>{return buff.readUInt32BE(0)})
+/
+        this.addMetadatum('smartLithiumErrors','', 'Smart Lithium Errors Flags',
+            (buff)=>{return buff.readUInt16BE(3)})
+        this.addMetadatum('cell1Voltage','V', 'cell #1 voltage', 
+            (buff)=>{return _toCellVoltage((buff.readUInt8(5))>>1)})
+        this.addMetadatum('cell2Voltage','V', 'cell #2 voltage', 
+            (buff)=>{return _toCellVoltage((buff.subarray(5,7).readUInt16BE())&0x01fe>>2)})
+        this.addMetadatum('cell3Voltage','V', 'cell #3 voltage', 
+            (buff)=>{return _toCellVoltage(((buff.subarray(6,8).readUInt16BE())&0x03fe)>>3)})
+        this.addMetadatum('cell4Voltage','V', 'cell #4 voltage', 
+            (buff)=>{return _toCellVoltage(((buff.subarray(7,9).readUInt16BE())&0x07fe)>>4)})
+        this.addMetadatum('cell5Voltage','V', 'cell #5 voltage', 
+            (buff)=>{return _toCellVoltage(((buff.subarray(8,10).readUInt16BE())&0x0ffe)>>5)})
+        this.addMetadatum('cell6Voltage','V', 'cell #6 voltage', 
+            (buff)=>{return _toCellVoltage(((buff.subarray(9,11).readUInt16BE())&0x1ffe)>>6)})
+        this.addMetadatum('cell7Voltage','V', 'cell #7 voltage', 
+            (buff)=>{return _toCellVoltage(((buff.subarray(10,12).readUInt16BE())&0x3ffe)>>7)})
+        this.addMetadatum('cell8Voltage','V', 'cell #8 voltage', 
+            (buff)=>{return _toCellVoltage((buff.readUInt8(11))&0x7f)})
+        this.addMetadatum('batteryVoltage','V', 'battery voltage', 
+            (buff)=>{return this.NaNif((buff.readUInt16BE(14)>>4),0xFFF)/100})
+        this.addMetadatum('balancerStatus','', 'balancer status', //TODO
+            (buff)=>{return this.NaNif((buff.readUInt16BE(14)&0xf),0xF)})
+        this.addMetadatum('batteryTemp','K', 'battery temperature', 
+            (buff)=>{return this.NaNif((buff.readInt8(15)>>1),0x7F)+233.15})
+    
+                
+    }
+}
+module.exports=VictronSmartLithium

package/sensor_classes/VictronSolarCharger.js

@@ -0,0 +1,29 @@
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+class VictronSolarCharger extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x01)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('chargeState','', 'charge state', 
+            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+        this.addMetadatum('chargerError','', 'charger error',
+            (buff)=>{return VC.ChargerError.get(buff.readUInt8(1))})
+        this.addMetadatum('voltage','V', 'charger battery voltage', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FFF)/100})
+        this.addMetadatum('current','A','charger battery current', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(4),0x7FFF)/10})
+        this.addMetadatum('yield','Wh', 'yield today in Watt-hours', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(6),0xFFFF)*10})
+        this.addMetadatum('solarPower','W', 'solar power', 
+            (buff)=>{return this.NaNif(buff.readUInt16LE(8),0xFFFF)})    
+        this.addMetadatum('externalDeviceLoad','A', 'external device load', 
+            (buff)=>{return this.NaNif(buff.readUInt16BE(10)>>7,0x1FF)})    
+        }
+
+}
+module.exports=VictronSolarCharger 

package/sensor_classes/VictronVEBus.js

@@ -0,0 +1,47 @@
+const VictronSensor = require ("./Victron/VictronSensor.js") 
+const VC = require("./Victron/VictronConstants.js")
+const int24 = require('int24')
+AC_IN_STATE=["AC in 1","AC in 2","NOT CONNECTED", "NA"]
+ALARM_STATE=["None","warning", "alarm","NA"]
+class VictronVEBus extends VictronSensor{
+
+    static async identify(device){
+        return await this.identifyMode(device, 0x0C)
+    }   
+
+    static {
+        this.metadata = new Map(super.getMetadata())
+
+        this.addMetadatum('chargeState','', 'charge state', 
+            (buff)=>{return VC.OperationMode.get(buff.readUInt8(0))})
+            
+        this.addMetadatum('veBusError','', 'VE bus error',
+            (buff)=>{return buff.readUInt8(1)}) //TODO
+        
+        this.addMetadatum('current','A','charger battery current', 
+            (buff)=>{return this.NaNif(buff.readInt16LE(2),0x7FFF)/10})
+        
+        this.addMetadatum('voltage','V', 'charger battery voltage',
+            (buff)=>{return this.NaNif(buff.readUInt16LE(4) & 0x3FFF,0x3FFF)/100})
+         
+        this.addMetadatum('acInState','', 'AC in state', 
+            (buff)=>{return AC_IN_STATE[readUInt8(5)>>6]})
+        
+        this.addMetadatum('acInPower','W','AC power IN in watts',  
+            (buff)=>{return this.NaNif(int24.readInt24LE(buff,6)>>5,0x3FFFF)*(raw & 0x40000)?-1:1})
+        
+        this.addMetadatum('acOutPower','W','AC power OUT in watts',  
+            (buff)=>{return this.NaNif((int24.readInt24LE(buff,8) & 0x1FFFF) >> 2,0x3FFFF) * (raw & 0b1)?-1:1})
+        
+        this.addMetadatum('alarm','','alarm state 0=no alarm, 1=warning, 2=alarm',  
+            (buff)=>{return ALARM_STATE[buff.readUInt8(10)&0x3] })
+        
+        this.addMetadatum('batteryTemperature','K', 'battery temperature', 
+            (buff)=>{return this.NaNif((buff.readInt8(10)&0x1FF)>>1,0x7F) +233.15})    
+
+        this.addMetadatum('soc', 'ratio', 'state of charge',
+            (buff)=>{return this.NaNif((buff.readInt16BE(10)&0x1FF)>>2,0x7F)/100})    
+            
+    }
+}
+module.exports=VictronVEBus

package/sensor_classes/XiaomiMiBeacon.js

@@ -0,0 +1,232 @@
+const { throws } = require("assert");
+const BTSensor = require("../BTSensor");
+
+const crypto = require('crypto');
+const { isGeneratorFunction } = require("util/types");
+
+const DEVICE_TYPES = new Map([
+    [0x0C3C, { name: "Alarm Clock", model: "CGC1" }],
+    [0x0576, { name: "3-in-1 Alarm Clock", model: "CGD1" }],
+    [0x066F, { name: "Temperature/Humidity Sensor", model: "CGDK2" }],
+    [0x0347, { name: "Temperature/Humidity Sensor", model: "CGG1" }],
+    [0x0B48, { name: "Temperature/Humidity Sensor", model: "CGG1-ENCRYPTED" }],
+    [0x03D6, { name: "Door/Window Sensor", model: "CGH1" }],
+    [0x0A83, { name: "Motion/Light Sensor", model: "CGPR1" }],
+    [0x03BC, { name: "Grow Care Garden", model: "GCLS002" }],
+    [0x0098, { name: "Plant Sensor", model: "HHCCJCY01" }],
+    [0x015D, { name: "Smart Flower Pot", model: "HHCCPOT002" }],
+    [0x02DF, { name: "Formaldehyde Sensor", model: "JQJCY01YM" }],
+    [0x0997, { name: "Smoke Detector", model: "JTYJGD03MI" }],
+    [0x1568, { name: "Switch (single button)", model: "K9B-1BTN" }],
+    [0x1569, { name: "Switch (double button)", model: "K9B-2BTN" }],
+    [0x0DFD, { name: "Switch (triple button)", model: "K9B-3BTN" }],
+    [0x1C10, { name: "Switch (single button)", model: "K9BB-1BTN" }],
+    [0x1889, { name: "Door/Window Sensor", model: "MS1BB(MI)" }],
+    [0x2AEB, { name: "Motion Sensor", model: "HS1BB(MI)" }],
+    [0x3F0F, { name: "Flood and Rain Sensor", model: "RS1BB(MI)" }],
+    [0x01AA, { name: "Temperature/Humidity Sensor", model: "LYWSDCGQ" }],
+    [0x045B, { name: "Temperature/Humidity Sensor", model: "LYWSD02" }],
+    [0x16E4, { name: "Temperature/Humidity Sensor", model: "LYWSD02MMC" }],
+    [0x2542, { name: "Temperature/Humidity Sensor", model: "LYWSD02MMC" }],
+    [0x055B, { name: "Temperature/Humidity Sensor", model: "LYWSD03MMC" }],
+    [0x2832, { name: "Temperature/Humidity Sensor", model: "MJWSD05MMC" }],
+    [0x098B, { name: "Door/Window Sensor", model: "MCCGQ02HL" }],
+    [0x06D3, { name: "Alarm Clock", model: "MHO-C303" }],
+    [0x0387, { name: "Temperature/Humidity Sensor", model: "MHO-C401" }],
+    [0x07F6, { name: "Nightlight", model: "MJYD02YL" }],
+    [0x04E9, { name: "Door Lock", model: "MJZNMSQ01YD" }],
+    [0x00DB, { name: "Baby Thermometer", model: "MMC-T201-1" }],
+    [0x0391, { name: "Body Thermometer", model: "MMC-W505" }],
+    [0x03DD, { name: "Nightlight", model: "MUE4094RT" }],
+    [0x0489, { name: "Smart Toothbrush", model: "M1S-T500" }],
+    [0x0806, { name: "Smart Toothbrush", model: "T700" }],
+    [0x1790, { name: "Smart Toothbrush", model: "T700" }],
+    [0x0A8D, { name: "Motion Sensor", model: "RTCGQ02LM" }],
+    [0x3531, { name: "Motion Sensor", model: "XMPIRO2SXS" }],
+    [0x4C60, { name: "Motion Sensor", model: "XMPIRO2GSXS" }],
+    [0x4683, { name: "Occupancy Sensor", model: "XMOSB01XS" }],
+    [0x0863, { name: "Flood Detector", model: "SJWS01LM" }],
+    [0x045C, { name: "Smart Kettle", model: "V-SK152" }],
+    [0x040A, { name: "Mosquito Repellent", model: "WX08ZM" }],
+    [0x04E1, { name: "Magic Cube", model: "XMMF01JQD" }],
+    [0x1203, { name: "Thermometer", model: "XMWSDJ04MMC" }],
+    [0x1949, { name: "Switch (double button)", model: "XMWXKG01YL" }],
+    [0x2387, { name: "Button", model: "XMWXKG01LM" }],
+    [0x098C, { name: "Door Lock", model: "XMZNMST02YD" }],
+    [0x0784, { name: "Door Lock", model: "XMZNMS04LM" }],
+    [0x0E39, { name: "Door Lock", model: "XMZNMS08LM" }],
+    [0x07BF, { name: "Wireless Switch", model: "YLAI003" }],
+    [0x38BB, { name: "Wireless Switch", model: "PTX_YK1_QMIMB" }],
+    [0x0153, { name: "Remote Control", model: "YLYK01YL" }],
+    [0x068E, { name: "Fan Remote Control", model: "YLYK01YL-FANCL" }],
+    [0x04E6, { name: "Ventilator Fan Remote Control", model: "YLYK01YL-VENFAN" }],
+    [0x03BF, { name: "Bathroom Heater Remote", model: "YLYB01YL-BHFRC" }],
+    [0x03B6, { name: "Dimmer Switch", model: "YLKG07YL/YLKG08YL" }],
+    [0x0083, { name: "Smart Kettle", model: "YM-K1501" }],
+    [0x0113, { name: "Smart Kettle", model: "YM-K1501EU" }],
+    [0x069E, { name: "Door Lock", model: "ZNMS16LM" }],
+    [0x069F, { name: "Door Lock", model: "ZNMS17LM" }],
+    [0x0380, { name: "Door Lock", model: "DSL-C08" }],
+    [0x11C2, { name: "Door Lock", model: "Lockin-SV40" }],
+    [0x0DE7, { name: "Odor Eliminator", model: "SU001-T" }]
+  ]);
+
+class XiaomiMiBeacon extends BTSensor{
+
+    constructor(device, config, gattConfig){
+        super(device, config, gattConfig)
+        this.encryptionKey = config?.encryptionKey
+     }
+    static SERVICE_MIBEACON = "0000fe95-0000-1000-8000-00805f9b34fb"
+
+    static async identify(device){
+        try{
+            const sd = await this.getDeviceProp(device, 'ServiceData')
+            if (sd == null || sd.length==0) return null
+            const keys = Object.keys(sd)
+            if (keys[0]==this.SERVICE_MIBEACON) return this
+        } catch (e){
+            console.log(e)
+            return null
+        }
+        return null
+    }
+    static {
+        this.metadata = new Map(super.getMetadata())
+           //3985f4ebc032f276cc316f1f6ecea085
+        //8a1dadfa832fef54e9c1d190
+
+        const md = this.addMetadatum("encryptionKey", "", "encryptionKey (AKA bindKey) for decryption")
+        md.isParam=true
+        this.addMetadatum('temp','K', 'temperature',
+            (buff,offset)=>{return ((buff.readInt16LE(offset))/100) + 273.1})
+        this.addMetadatum('humidity','ratio', 'humidity',
+            (buff,offset)=>{return ((buff.readUInt8(offset))/100)})
+        this.addMetadatum('voltage', 'V',  'sensor battery voltage',
+            (buff,offset)=>{return ((buff.readUInt16LE(offset))/1000)})
+       
+    }
+    GATTwarning = "WARNING: Xiaomi GATT connections are known to be unreliable on Debian distributions with Bluez 5.55 and up (earlier BlueZ versions are untested). Using GATT on the Xiaomi may put the system Bluetooth stack into an inconsistent state disrupting and disabling other plugin Bluetooth connections. If by some chance you're successful using GATT with the Xiaomi, let the plugin developer know your configuration. Refer to the plugin documentation for getting the Xiamoi bindKey for non-GATT connections and more information on Xiaomi GATT issues."
+    
+    emitValues(buffer){
+        this.emitData("temp", buffer, 0)
+        this.emitData("humidity", buffer,2)
+        this.emitData("voltage",buffer,3);
+    }
+    getManufacturer(){
+        return "Xiaomi Inc."
+    }
+    getGATTDescription() {
+        return this.GATTwarning
+    }
+    initGATT(){
+        this.debug(this.GATTwarning.toUpperCase())
+        return new Promise((resolve,reject )=>{
+            this.device.connect().then(async ()=>{
+                if (!this.gattServer) {
+                    this.gattServer = await this.device.gatt()
+                    this.gattService = await this.gattServer.getPrimaryService("ebe0ccb0-7a0a-4b0c-8a1a-6ff2997da3a6")
+                    this.gattCharacteristic = await this.gattService.getCharacteristic("ebe0ccc1-7a0a-4b0c-8a1a-6ff2997da3a6")
+                }
+                resolve(this)
+            })
+            .catch((e)=>{
+                reject(e.message)
+            })
+        })
+    }
+
+    emitGATT(){
+        this.gattCharacteristic.readValue()
+            .then((buffer)=>this.emitValues(buffer))
+    }
+
+    async initGATTNotifications() { 
+        Promise.resolve(this.gattCharacteristic.startNotifications().then(()=>{    
+            this.gattCharacteristic.on('valuechanged', buffer => {
+                this.emitValues(buffer)
+            })
+        }))
+    }
+
+    decryptV2and3(data){
+        const encryptedPayload = data.subarray(-4);
+        const xiaomi_mac = data.subarray(5,11)
+        const nonce = Buffer.concat([data.subarray(0, 5), data.subarray(-4,-1), xiaomi_mac.subarray(-1)]);
+        const cipher = crypto.createDecipheriv('aes-128-ccm', Buffer.from(this.encryptionKey,"hex"), nonce, { authTagLength: 4});
+        cipher.setAAD(Buffer.from('11', 'hex'), { plaintextLength: encryptedPayload.length });
+        
+        return cipher.update(encryptedPayload)
+    }
+    decryptV4and5(data){
+        const encryptedPayload = data.subarray(11,-7);
+        const xiaomi_mac = data.subarray(5,11)
+        const nonce = Buffer.concat([xiaomi_mac, data.subarray(2, 5), data.subarray(-7,-4)]);
+        const cipher = crypto.createDecipheriv('aes-128-ccm', Buffer.from(this.encryptionKey,"hex"), nonce, { authTagLength: 4});
+        cipher.setAAD(Buffer.from('11', 'hex'), { plaintextLength: encryptedPayload.length });
+        cipher.setAuthTag(data.subarray(-4))    
+        return cipher.update(encryptedPayload)
+    }
+
+    canUseGATT(){
+        return true
+    }
+
+    propertiesChanged(props){
+        super.propertiesChanged(props)
+        if (this.usingGATT()) return
+        const data = this.getServiceData(this.constructor.SERVICE_MIBEACON)
+        var dec
+        if (this.encryptionVersion >= 4) {
+            dec = this.decryptV4and5(data)
+        } else {
+            if(this.encryptionVersion>=2){
+                dec=this.decryptV2and3(data)
+            }
+        }
+        if (dec.length==0)
+            throw new Error(`${this.getNameAndAddress()} received empty decrypted packet. Check that the bind/encryption key in config is correct.`)
+
+        switch(dec[0]){
+        case 0x04:    
+            this.emit("temp",(dec.readInt16LE(3)/10)+273.15)  
+            break        
+        case 0x06:
+            this.emit("humidity",(dec.readInt16LE(3)/10))          
+            break
+        default:
+            throw new Error(`${this.getNameAndAddress()} unable to parse decrypted service data (${dec})`)
+            
+        }
+    }
+    
+    async init(){
+        await super.init()
+        const data = this.getServiceData(this.constructor.SERVICE_MIBEACON)
+        const frameControl = data[0] + (data[1] << 8)
+        this.deviceID = data[2] + (data[3] << 8)
+        this.isEncrypted = (frameControl >> 3) & 1
+        this.encryptionVersion = frameControl >> 12 
+    }   
+
+    getName(){
+        const dt = DEVICE_TYPES.get(this.deviceID)
+        return this?.name??`${dt.name} ${dt.model}`
+    }
+
+    async disconnectGattCharacteristic(){
+        if (this.gattCharacteristic  && await this.gattCharacteristic.isNotifying()) {
+            await this.gattCharacteristic.stopNotifications()
+            this.gattCharacteristic=null
+        }
+    }
+    async disconnect(){
+        super.disconnect()
+        await this.disconnectGattCharacteristic()
+       
+        if (await this.device.isConnected()){
+               await this.device.disconnect()
+        }
+    }
+}
+module.exports=XiaomiMiBeacon

package/test.js

@@ -0,0 +1,32 @@
+const {createBluetooth} = require('node-ble')
+const {bluetooth, destroy} = createBluetooth()
+const { argv } = require('node:process');
+
+
+async function main(){
+
+  const adapter = await bluetooth.defaultAdapter()
+  
+  try{await adapter.startDiscovery()} catch{}
+  const device = await adapter.waitDevice(argv[2])
+  var trials=0
+  await device.connect()
+  const gatt = await device.gatt()
+  await device.disconnect()
+
+  async function search(){
+      await device.connect()
+
+      console.log(`GATT trial #${++trials}...`)
+      const s = await gatt.getPrimaryService("65970000-4bda-4c1e-af4b-551c4cf74769")
+      const c = await s.getCharacteristic('6597ffff-4bda-4c1e-af4b-551c4cf74769')
+      await c.readValue()
+      await device.disconnect()
+ }
+
+setInterval(() => {
+  search()
+},argv[3]);
+search()
+}
+main()

package/sensor_classes/LYWSD03MMC.js

@@ -1,39 +0,0 @@
-const BTSensor = require("../BTSensor");
-
-class LYWSD03MMC extends BTSensor{
-
-    static needsScannerOn(){
-        return false
-    }
-    static metadata = new Map()
-                    .set('temp',{unit:'K', description: 'temperature'})
-                    .set('humidity',{unit:'ratio', description: 'humidity'})
-                    .set('voltage',{unit:'V', description: 'sensor battery voltage'})
-
-    constructor(device){
-        super(device)
-    }
-
-    emitValues(buffer){
-        this.emit("temp",((buffer.readInt16LE(0))/100) + 273.1);
-        this.emit("humidity",buffer.readUInt8(2)/100);
-        this.emit("voltage",buffer.readUInt16LE(3)/1000);
-    }
-
-    async connect() {
-        await this.device.connect()
-        var gattServer = await this.device.gatt()
-        var gattService = await gattServer.getPrimaryService("ebe0ccb0-7a0a-4b0c-8a1a-6ff2997da3a6")
-        var gattCharacteristic = await gattService.getCharacteristic("ebe0ccc1-7a0a-4b0c-8a1a-6ff2997da3a6")
-        this.emitValues(await gattCharacteristic.readValue())
-        await gattCharacteristic.startNotifications();	
-        gattCharacteristic.on('valuechanged', buffer => {
-            this.emitValues(buffer)
-        })
-    }
-    async disconnect(){
-        super.disconnect()
-        await this.device.disconnect()
-    }
-}
-module.exports=LYWSD03MMC