iobroker.lorawan 1.18.62 → 1.19.0

package/README.md

@@ -23,6 +23,13 @@ For now there is documentation in English here: https://wiki.hafenmeister.de
 	Placeholder for the next version (at the beginning of the line):
 	### **WORK IN PROGRESS**
 -->
+### 1.19.0 (2026-01-03)
+* (BenAhrdt) remove Bridgetype Smarthome
+* (BenAhrdt) add firt possibility to generate devices from Bridge to Iob
+
+### 1.18.63 (2026-01-01)
+* (BenAhrdt) return to await calls in checkAll (bridge)
+
 ### 1.18.62 (2026-01-01)
 * (BenAhrdt) Promise the foreign functions in Promise.all
 

package/admin/jsonConfig.json

@@ -751,8 +751,7 @@
 					"tooltip": "BridgeTypeTooltip",
 					"options": [
 						{"label":"BridgeTypeOff","value":"off"},
-						{"label":"BridgeTypeHA","value":"HA"},
-						{"label":"BridgeTypeSH","value":"SH"}
+						{"label":"BridgeTypeHA","value":"HA"}
 					],
 					"default": "off",
 					"xs": 12,

package/io-package.json

@@ -1,8 +1,34 @@
 {
   "common": {
     "name": "lorawan",
-    "version": "1.18.62",
+    "version": "1.19.0",
     "news": {
+      "1.19.0": {
+        "en": "remove Bridgetype Smarthome\nadd firt possibility to generate devices from Bridge to Iob",
+        "de": "bridgetype Smarthome entfernen\nfügen Sie firt Möglichkeit, Geräte von Bridge zu Iob zu generieren",
+        "ru": "скачать Bridgetype Smarthome\nдобавьте возможность создания устройств от Bridge до Iob",
+        "pt": "remover o tipo de ponte Smarthome\nadicionar a possibilidade inicial de gerar dispositivos de Bridge para Iob",
+        "nl": "verwijderen Bridgetype Smarthome\nfirt mogelijkheid toevoegen om apparaten van brug aan Iob te genereren",
+        "fr": "supprimer Bridgetype Smarthome\najouter la possibilité de firt pour générer des appareils de Bridge à Iob",
+        "it": "rimuovere Bridgetype Smarthome\naggiungere firt possibilità di generare dispositivi da Bridge a Iob",
+        "es": "eliminar Bridgetype Smarthome\nañadir firt posibilidad de generar dispositivos desde Bridge a Iob",
+        "pl": "usuń Bridgetype Smarthome\ndodać firt możliwość generowania urządzeń z Bridge do Iob",
+        "uk": "видалити Bridgetype Smarthome\nдо Iob",
+        "zh-cn": "删除桥型 Smarthome\n从 Bridge 添加 firt 生成设备的可能性"
+      },
+      "1.18.63": {
+        "en": "return to await calls in checkAll (bridge)",
+        "de": "zurück zu warten Anrufe im Check Alle (Brücke)",
+        "ru": "возвращение в ожидании звонков в чек Все (мост)",
+        "pt": "retornar para aguardar chamadas em cheque Todos (ponte)",
+        "nl": "terug te keren naar wachten gesprekken in check Alle (brug)",
+        "fr": "retour à attendre les appels en contrôle Tous (pont)",
+        "it": "ritorno in attesa chiamate in controllo Tutti (ponte)",
+        "es": "volver a esperar llamadas en cheque Todo (puente)",
+        "pl": "powrót czekać rozmowy w czeku Wszystkie (most)",
+        "uk": "поверніть на чек дзвінків Всі (місто)",
+        "zh-cn": "返回等待呼叫检查 全部(桥梁)"
+      },
       "1.18.62": {
         "en": "Promise the foreign functions in Promise.all",
         "de": "Versprechen Sie die ausländischen Funktionen in Promise.all",
@@ -67,32 +93,6 @@
         "pl": "serializuj i buforuj wiadomości konfiguracyjne",
         "uk": "послідовність і кешування конфігураційних повідомлень",
         "zh-cn": "序列化和缓存配置信件"
-      },
-      "1.18.57": {
-        "en": "cache Infos in config for more performance",
-        "de": "cache Infos in config für mehr Leistung",
-        "ru": "cache Infos in Config для повышения производительности",
-        "pt": "informações de cache em configuração para mais desempenho",
-        "nl": "cache-informatie in configuratie voor meer prestaties",
-        "fr": "cache Infos en configuration pour plus de performances",
-        "it": "cache Infos in config per maggiori prestazioni",
-        "es": "cache Infos en config para más rendimiento",
-        "pl": "cache Infos w konfiguracji dla większej wydajności",
-        "uk": "cache Infos в конфігурації для більшої продуктивності",
-        "zh-cn": "为更多性能在配置中缓存信息"
-      },
-      "1.18.56": {
-        "en": "remoove namespace twice remooved\nserialize getConfigStates",
-        "de": "remoove namespace zweimal remooved\nserialisieren getConfigStates",
-        "ru": "remoove namespace дважды удаляется\nсерийный GetConfigStates",
-        "pt": "remoove namespace duas vezes remooved\nserialize getConfigStates",
-        "nl": "naamruimte twee keer verplaatsen\nserialiseren getConfigStates",
-        "fr": "remove namespace deux fois removed\nsérialiser getConfigStates",
-        "it": "rimoove namespace due volte rimuovi\nserializzare ottenereConfigStates",
-        "es": "remoove namespace dos remooved\nserialize getConfigStates",
-        "pl": "remoove namespace two remooved\nserialize getConfigurations",
-        "uk": "remoove namespace двічі remooved\nсертифіковано getConfigStates",
-        "zh-cn": "两次重新移动命名空间\n序列化获取配置状态"
       }
     },
     "titleLang": {

package/lib/modules/bridge.js

@@ -1,4 +1,5 @@
 const bridgeMqttClientClass = require('./bridgeMqttclient');
+const bridgeDeviceHandlerClass = require('./bridgeDeviceHandler');
 const schedule = require('node-schedule');
 /* 
     Also er published irgendwie nicht den Mode => und es kommt virtual_Mode nicht subcribed....
@@ -18,6 +19,7 @@ class bridgeClass {
          * ******************************************************************/
 
         this.bridgeMqttClient = new bridgeMqttClientClass(this.adapter, this.adapter.config);
+        this.bridgeDeviceHandler = new bridgeDeviceHandlerClass(this.adapter);
 
         // Structure of actual vaulues in Bridge (till las start of Adapter)
         this.CheckedIds = {};
@@ -29,7 +31,6 @@ class bridgeClass {
         this.Notifications = {};
         this.BridgeDiscoveryPrefix = {
             HA: 'homeassistant/',
-            SH: 'smarthome/',
         };
         this.ForeignBridgeMembers = {};
         this.MinTime = 100; // ms between publish and subscribe same value
@@ -289,6 +290,9 @@ class bridgeClass {
                     // Special DataExchange
                     if (this.SubscribedTopics[topic].dataExchange) {
                         if (typeof message === 'object') {
+                            // Call the BridgeDeviceHandler
+                            await this.bridgeDeviceHandler.generateDeviceStructure(message);
+                            // Stringify for set State
                             message = JSON.stringify(message);
                         }
                         await this.adapter.setState(
@@ -1749,6 +1753,59 @@ class bridgeClass {
      *
      * @param options options to special functions
      */
+    async checkAllStatesForBridgeWork(options) {
+        const activeFunction = 'bridge.js - checkAllStatesForBridgeWork';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            // get old Discovered ids
+            this.OldDiscoveredIds = JSON.parse((await this.adapter.getStateAsync('info.discoveredIds')).val);
+            this.oldDiscoveredDevices = this.generateOldDevices(this.OldDiscoveredIds);
+            // Clear object of all subscribed Ids and published Topics
+            this.SubscribedTopics = {};
+            this.PublishedIds = {};
+            this.Notifications = {};
+
+            //this.adapter.log.error(JSON.stringify(this.oldDiscoveredDevices));
+            await this.discoverGeneralNotification();
+
+            await this.discoverDataExchange();
+
+            // Get all ids in adapterfolder
+            // Generate Infos of all devices and decoded folders
+            const adapterObjects = await this.adapter.getAdapterObjectsAsync();
+            for (const adapterObject of Object.values(adapterObjects)) {
+                if (
+                    adapterObject._id.includes(
+                        `${this.adapter.messagehandler.directoryhandler.reachableSubfolders.uplinkDecoded}.`,
+                    ) ||
+                    adapterObject._id.includes(
+                        `${this.adapter.messagehandler.directoryhandler.reachableSubfolders.downlinkControl}.`,
+                    )
+                ) {
+                    if (adapterObject.type === 'state') {
+                        const localOptions = {
+                            ...(options || {}),
+                            common: adapterObject.common,
+                        };
+
+                        await this.work(adapterObject._id, undefined, localOptions);
+                    }
+                }
+            }
+            await this.discoverClimate();
+            await this.getForeignStatesForStandardEntities();
+            await this.getForeignClimateConfig();
+            await this.getForeignHumidifierConfig();
+            await this.getForeignLightConfig();
+            await this.getForeignCoverConfig();
+            await this.getForeignLockConfig();
+            await this.checkDiscoveries();
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /*
     async checkAllStatesForBridgeWork(options) {
         const activeFunction = 'bridge.js - checkAllStatesForBridgeWork';
         this.adapter.log.debug(`Function ${activeFunction} started.`);
@@ -1819,59 +1876,8 @@ class bridgeClass {
             this.adapter.log.error(`error at ${activeFunction}: ${error}`);
         }
     }
-
-    /* Alte Version
-    async checkAllStatesForBridgeWork(options) {
-        const activeFunction = 'bridge.js - checkAllStatesForBridgeWork';
-        this.adapter.log.debug(`Function ${activeFunction} started.`);
-        try {
-            // get old Discovered ids
-            this.OldDiscoveredIds = JSON.parse((await this.adapter.getStateAsync('info.discoveredIds')).val);
-            this.oldDiscoveredDevices = this.generateOldDevices(this.OldDiscoveredIds);
-            // Clear object of all subscribed Ids and published Topics
-            this.SubscribedTopics = {};
-            this.PublishedIds = {};
-            this.Notifications = {};
-
-            //this.adapter.log.error(JSON.stringify(this.oldDiscoveredDevices));
-            await this.discoverGeneralNotification();
-
-            await this.discoverDataExchange();
-
-            // Get all ids in adapterfolder
-            // Generate Infos of all devices and decoded folders
-            const adapterObjects = await this.adapter.getAdapterObjectsAsync();
-            for (const adapterObject of Object.values(adapterObjects)) {
-                if (
-                    adapterObject._id.includes(
-                        `${this.adapter.messagehandler.directoryhandler.reachableSubfolders.uplinkDecoded}.`,
-                    ) ||
-                    adapterObject._id.includes(
-                        `${this.adapter.messagehandler.directoryhandler.reachableSubfolders.downlinkControl}.`,
-                    )
-                ) {
-                    if (adapterObject.type === 'state') {
-                        if (!options) {
-                            options = {};
-                        }
-                        options.common = adapterObject.common;
-                        await this.work(adapterObject._id, undefined, options);
-                    }
-                }
-            }
-            await this.discoverClimate();
-            await this.getForeignStatesForStandardEntities();
-            await this.getForeignClimateConfig();
-            await this.getForeignHumidifierConfig();
-            await this.getForeignLightConfig();
-            await this.getForeignCoverConfig();
-            await this.getForeignLockConfig();
-            await this.checkDiscoveries();
-        } catch (error) {
-            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
-        }
-    }
     */
+
     /**
      * @param oldDiscoveredIds Ids wiche are discovered last time that Adapter runs
      */

package/lib/modules/bridgeDeviceHandler.js

@@ -0,0 +1,373 @@
+/**
+ * class to handle incomming messages from Bridge
+ */
+class bridgeDeviceHandlerClass {
+    /**
+     * @param adapter data of the adapter (eg. for logging)
+     */
+    constructor(adapter) {
+        this.adapter = adapter;
+        this.basefolder = 'bridge.devices';
+        this.adapter.extendObject(this.basefolder, {
+            type: 'folder',
+            common: { name: 'Devices recieved from Bridge' },
+            native: {},
+        });
+    }
+
+    // Generate Structure of incomming Data
+    /**
+     * @param message message from bridge to generate devices (eg.)
+     */
+    async generateDeviceStructure(message) {
+        const activeFunction = 'bridgeDeviceHandler.js - generateDeviceStructure';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            // Query for Entity
+            if (message.entities) {
+                for (const entity of Object.values(message.entities)) {
+                    const entityInfo = this.generateStructure(entity);
+                    await this.adapter.extendObject(entityInfo?.device.id, {
+                        type: 'device',
+                        common: { name: entity.device.name },
+                        native: entity.device,
+                    });
+                    const channel = entity.entity_id.substring(0, entity.entity_id.indexOf('.'));
+                    await this.adapter.extendObject(entityInfo?.channel.id, {
+                        type: 'channel',
+                        common: { name: 'Channel of Entity' },
+                        native: {},
+                    });
+                    let unique_id = entity.unique_id;
+                    if (entity.unique_id.startsWith(channel)) {
+                        unique_id = unique_id.substring(channel.length + 1, unique_id.length);
+                    }
+                    unique_id.replace('.', '_');
+                    await this.adapter.extendObject(entityInfo?.state.id, {
+                        type: 'state',
+                        common: {
+                            name: entityInfo?.state.name,
+                            type: entityInfo?.state.type,
+                            role: entityInfo?.state.role,
+                            read: entityInfo?.state.read,
+                            write: entityInfo?.state.write,
+                            unit: entityInfo?.state.unit,
+                        },
+                        native: { entity: entity, entityInfo: entityInfo },
+                    });
+                    let state = entity.state;
+                    if (entityInfo?.state.type === 'boolean') {
+                        state = entity.state === 'on';
+                    } else if (entityInfo?.state.type === 'number') {
+                        state = Number(entity.state);
+                    }
+                    await this.adapter.setState(entityInfo?.state.id, state, true);
+                }
+            }
+            // Periodic discovery
+            if (message.discovery) {
+                const id = `${this.basefolder}.discoveredEntities`;
+                await this.adapter.extendObject(id, {
+                    type: 'state',
+                    common: {
+                        name: 'Discovered Entities',
+                        type: 'string',
+                        role: 'json',
+                        read: true,
+                        write: false,
+                        def: '',
+                    },
+                    native: {},
+                });
+
+                // Read current data
+                const discoveredEntities = await this.adapter.getStateAsync(id);
+                const checkDevices = {};
+                if (discoveredEntities.val) {
+                    const entities = JSON.parse(discoveredEntities.val);
+                    for (const entityId of Object.keys(entities)) {
+                        if (!Object.keys(message.entities).includes(entityId)) {
+                            const entityInfo = this.generateStructure(entities[entityId]);
+                            await this.adapter.delObjectAsync(entityInfo?.state.id);
+                            checkDevices[entityInfo?.device.id] = {};
+                            if (entityInfo?.channel.id) {
+                                checkDevices[entityInfo?.device.id][entityInfo?.channel.id] = {};
+                            }
+                        }
+                    }
+
+                    // Check for delete channels and devices
+                    for (const deviceId of Object.keys(checkDevices)) {
+                        let foundStateInAnyChannel = false;
+
+                        // Check channel
+                        for (const channelId of Object.keys(checkDevices[deviceId])) {
+                            const channelParams = {
+                                startkey: `${channelId}.`,
+                                endkey: `${channelId}.\u9999`,
+                            };
+
+                            const channelStates = await this.adapter.getObjectViewAsync(
+                                'system',
+                                'state',
+                                channelParams,
+                            );
+
+                            if (channelStates.rows.length > 0) {
+                                // State found
+                                foundStateInAnyChannel = true;
+                                continue;
+                            }
+
+                            // No state
+                            await this.adapter.delObjectAsync(channelId, { recursive: true });
+                            this.adapter.log.debug(`Deleted empty channel: ${channelId}`);
+                        }
+
+                        // Check device
+                        if (!foundStateInAnyChannel) {
+                            const deviceParams = {
+                                startkey: `${deviceId}.`,
+                                endkey: `${deviceId}.\u9999`,
+                            };
+
+                            const deviceStates = await this.adapter.getObjectViewAsync('system', 'state', deviceParams);
+
+                            if (deviceStates.rows.length === 0) {
+                                await this.adapter.delObjectAsync(deviceId, { recursive: true });
+                                this.adapter.log.debug(`Deleted empty device: ${deviceId}`);
+                            }
+                        }
+                    }
+                }
+                await this.adapter.setState(id, JSON.stringify(message.entities), true);
+            }
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param entity entity wich contains the desired informations
+     */
+    generateStructure(entity) {
+        const activeFunction = 'bridgeDeviceHandler.js - generateStructure';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            if (!entity || !entity.entity_id) {
+                return null;
+            }
+
+            const [domain] = entity.entity_id.split('.');
+
+            const stateId = this.buildSafeStateId(entity);
+            if (!stateId) {
+                return null;
+            }
+            const type = this.detectType(entity);
+            const assign = this.detectAssign(entity);
+
+            const device = {
+                id: `${this.basefolder}.${entity.device?.id ?? 'unknown_device'}`,
+                name: entity.device?.name || 'Unknown Device',
+                manufacturer: entity.device?.manufacturer || '',
+                model: entity.device?.model || '',
+            };
+
+            const channel = {
+                id: `${this.basefolder}.${entity.device?.id}.${domain}`,
+                name: domain,
+            };
+
+            const state = {
+                id: `${this.basefolder}.${entity.device?.id}.${domain}.${stateId}`,
+                name: entity.friendly_name || stateId,
+                type: type,
+                role: this.detectRole(entity, domain, type),
+                unit: entity.unit_of_measurement || undefined,
+                read: true,
+                write: this.isWritable(domain),
+            };
+            if (assign) {
+                state.assign = assign;
+            }
+
+            const meta = {
+                entity_id: entity.entity_id,
+                unique_id: entity.unique_id,
+                device_class: entity.device_class,
+                state_class: entity.state_class,
+            };
+            return {
+                device: device,
+                channel: channel,
+                state: state,
+                meta: meta,
+            };
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param entity entity wich contains the deired informations
+     */
+    detectType(entity) {
+        const activeFunction = 'bridgeDeviceHandler.js - detectType';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            const s = entity.state;
+
+            if (['on', 'off', 'true', 'false'].includes(s)) {
+                return 'boolean';
+            }
+            if (!isNaN(s) && s !== '') {
+                return 'number';
+            }
+            return 'string';
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param entity entity wich contains the deired informations
+     */
+    detectAssign(entity) {
+        const activeFunction = 'bridgeDeviceHandler.js - detectAssign';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            const s = entity.state;
+            if (['on', 'off'].includes(s)) {
+                return { true: 'on', false: 'off' };
+            }
+            if (['true', 'false'].includes(s)) {
+                return { true: 'true', false: 'false' };
+            }
+            return null;
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param domain domain, wich contains the type of entity
+     */
+    isWritable(domain) {
+        const activeFunction = 'bridgeDeviceHandler.js - isWritable';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            return [
+                'switch',
+                'light',
+                'input_boolean',
+                'input_number',
+                'input_select',
+                'climate',
+                'cover',
+                'lock',
+            ].includes(domain);
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param entity entity wich contains the desired informations
+     * @param domain domain wich contains the type of the entity
+     * @param type type wich contains the type of ioBroker state
+     */
+    detectRole(entity, domain, type) {
+        const activeFunction = 'bridgeDeviceHandler.js - detectRole';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            if (domain === 'switch') {
+                return 'switch';
+            }
+            if (domain === 'light') {
+                return 'light';
+            }
+            if (domain === 'binary_sensor') {
+                return 'indicator';
+            }
+
+            if (entity.device_class) {
+                const map = {
+                    temperature: 'value.temperature',
+                    humidity: 'value.humidity',
+                    power: 'value.power',
+                    energy: 'value.energy',
+                    window: 'sensor.window',
+                    door: 'sensor.door',
+                };
+                if (map[entity.device_class]) {
+                    return map[entity.device_class];
+                }
+            }
+
+            if (type === 'number') {
+                return 'value';
+            }
+            if (type === 'boolean') {
+                return 'indicator';
+            }
+            return 'state';
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /**
+     * @param entity entity wich contains the deired informations
+     */
+    buildSafeStateId(entity) {
+        const activeFunction = 'bridgeDeviceHandler.js - buildSafeStateId';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            // 1. Basis: unique_id oder entity_id
+            const baseId = entity.unique_id || entity.entity_id;
+
+            if (!baseId) {
+                return null;
+            }
+
+            // if eg. switch in front => remove
+            const parts = baseId.split('.');
+            const raw =
+                parts.length > 1 && parts[0] === entity.entity_id?.split('.')[0] ? parts.slice(1).join('.') : baseId;
+
+            // 3. remove ".
+            return raw.replace(/\./g, '_');
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+
+    /************************************************************************************
+     *
+     ************************************************************************************/
+
+    /**
+     * @param id id wich is to send
+     * @param state state of the id
+     */
+    async sendData(id, state) {
+        const activeFunction = 'bridgeDeviceHandler.js - sendData';
+        this.adapter.log.debug(`Function ${activeFunction} started.`);
+        try {
+            const idObject = await this.adapter.getObjectAsync(id);
+            const sendInfo = {};
+            if (idObject.native.entityInfo.state.assign) {
+                sendInfo[idObject.native.entity.entity_id] = idObject.native.entityInfo.state.assign[state.val];
+            } else {
+                sendInfo[idObject.native.entity.entity_id] = state.val;
+            }
+            await this.adapter.bridge.publishId(`${this.adapter.namespace}.bridge.dataFromIob`, sendInfo, {});
+            await this.adapter.setState(`${this.adapter.namespace}.bridge.dataFromIob`, JSON.stringify(sendInfo), true);
+        } catch (error) {
+            this.adapter.log.error(`error at ${activeFunction}:  ${error}`);
+        }
+    }
+}
+
+module.exports = bridgeDeviceHandlerClass;

package/main.js

@@ -846,24 +846,6 @@ class Lorawan extends utils.Adapter {
                                         native: {},
                                     });
                                     await this.setState(id, '', true);
-                                } else if (words[1] === 'chunk') {
-                                    this.extendObject('bridge.debug', {
-                                        type: 'folder',
-                                        common: { name: 'Debugfunctions of bridge' },
-                                        native: {},
-                                    });
-                                    this.extendObject('bridge.debug.chunk', {
-                                        type: 'state',
-                                        common: {
-                                            name: 'chunk of parallel works',
-                                            type: 'number',
-                                            read: true,
-                                            write: true,
-                                            def: 32,
-                                        },
-                                        native: {},
-                                    });
-                                    await this.setState(id, '', true);
                                 }
                             } else {
                                 let notificationId = `${this.namespace}.${this.bridge?.Words.notification}${this.bridge?.GeneralId}`;
@@ -894,6 +876,9 @@ class Lorawan extends utils.Adapter {
                                 await this.setState(id, state.val, true);
                                 await this.bridge.publishId(id, state.val, {});
                             }
+                        } else if (id.startsWith(`${this.namespace}.bridge.devices.`)) {
+                            await this.bridge?.bridgeDeviceHandler.sendData(id, state);
+                            await this.setState(id, state.val, true);
                         }
                     } else {
                         // Query for 0_userdata or alias => states also publish with ack = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "iobroker.lorawan",
-  "version": "1.18.62",
+  "version": "1.19.0",
   "description": "converts the desired lora gateway data to a ioBroker structure",
   "author": {
     "name": "BenAhrdt",