node-red-contrib-uos-nats 0.1.65 → 0.1.67

package/README.md

@@ -2,20 +2,21 @@
 
 **Unofficial Node-RED Package for u-OS Data Hub**
 
-Built and maintained by [IoTUeli](https://www.linkedin.com/in/iotueli/). This is **not** an official Weidmüller product.  
+Built and maintained by [IoTUeli](https://iotueli.ch). This is **not** an official Weidmüller product.  
 Repository: <https://github.com/uiff/nats-NodeRed-Node-uc20>
 
 ---
 
 ## What is this?
 
-Node-RED nodes to **read** and **write** variables from the **u-OS Data Hub** via NATS protocol.
+Node-RED nodes to **read**, **write**, and **provide** variables for the **Weidmüller u-OS Data Hub** via NATS protocol.
 
-### The Three Nodes:
+### The Four Nodes
 
 1. **u-OS Config** – Connection settings (Host, OAuth credentials, NATS connection)
-2. **DataHub - IN** – Read variables from Data Hub providers
-3. **DataHub - OUT** – Write variables to the Data Hub (creates your own provider)
+2. **DataHub - Read** – Read variables from Data Hub providers
+3. **DataHub - Provider** – Create your own provider (publish variables)
+4. **DataHub - Write** – Send write commands to other providers
 
 ---
 
@@ -71,14 +72,14 @@ Process & forward to other systems
 - Delayed reactions
 - Higher CPU usage
 
-### Use NATS when:
+### Use NATS when
 
 ✅ You need **real-time reactions** to value changes  
 ✅ You want to **create providers** (publish data to Data Hub)  
 ✅ You need **event subscriptions** (get notified on changes)  
 ✅ You're building **scalable industrial workflows**  
 
-### Use REST API when:
+### Use REST API when
 
 ⚠️ You only need **occasional manual reads**  
 ⚠️ You're debugging or doing one-time queries  
@@ -86,164 +87,174 @@ Process & forward to other systems
 
 ---
 
-## 1. u-OS Config Node
+## Quick Start Guide
 
-### Purpose
-Stores connection details and OAuth credentials. All DataHub nodes share this configuration.
+### Step 1: Create OAuth Client in u-OS
+
+Before configuring Node-RED, create an OAuth client on your u-OS device:
 
-### Setup Steps
+1. Open the **u-OS Web Interface** (e.g., `http://192.168.10.100`)
+2. Go to **System** → **Access Control** → **OAuth Clients**
+3. Click **"Add Client"**
+4. Enter:
+   - **Name:** `nodered`
+   - **Scopes:** Select **all** `hub.variables.*` scopes:
+     - `hub.variables.provide` (for creating providers)
+     - `hub.variables.readonly` (for reading)
+     - `hub.variables.readwrite` (for writing)
+5. **Save** and copy the **Client ID** and **Client Secret**
 
-1. **Add a Config Node:**
-   - Open any DataHub node (IN or OUT)
-   - Click the pencil icon next to "Config"
-   - Click "Add new uos-config..."
+### Step 2: Configure u-OS Config Node in Node-RED
 
-2. **Fill in the Fields:**
+1. Drag any **DataHub - IN** or **DataHub - OUT** node onto the canvas
+2. Double-click it to open settings
+3. Click the **pencil icon** next to "Config"
+4. Select **"Add new uos-config..."**
+5. Fill in:
 
 | Field | Example | Description |
 |-------|---------|-------------|
-| **Host** | `192.168.10.100` | IP address of your u-Control device |
-| **Port** | `49360` | NATS port (default: 49360) |
-| **Client Name** | `nodered` | Unique name for this Node-RED instance |
-| **Client ID** | `my-oauth-client` | OAuth2 Client ID (from Control Center) |
-| **Client Secret** | `****************` | OAuth2 Client Secret (from Control Center) |
-| **Scopes** | `hub.variables.*` | Leave default or customize (see below) |
-
-3. **Create OAuth Client in Control Center:**
-   - Open the u-Control Web Interface
-   - Go to **System** → **Access Control** → **OAuth Clients**
-   - Click **"Add Client"**
-   - **Name:** `nodered`
-   - **Scopes:** Select all `hub.variables.*` (provide, readonly, readwrite)
-   - **Copy the Client ID and Secret** into Node-RED
+| **Host** | `192.168.10.100` | IP of your u-OS device |
+| **Port** | `49360` | NATS port (default) |
+| **Client Name** | `nodered` | Unique name for this instance |
+| **Client ID** | `my-oauth-client` | From Step 1 |
+| **Client Secret** | `****************` | From Step 1 |
 
-4. **Test Connection:**
-   - Click **"Test Connection"** button
-   - ✅ Success: Shows "Connected" + granted scopes
-   - ❌ Error: Check Host/Port/Credentials
+6. Click **"Test Connection"** to verify
+7. On success, click **"Add"** then **"Done"**
 
----
+### Step 3: Deploy Your First Flow
 
-## 2. DataHub - IN Node (Read Variables)
+Import this example flow to test both reading and writing:
 
-### Purpose
-Subscribe to variables from a Data Hub provider and output their values as JSON messages.
+```json
+[{"id":"cdad2fa96dc6eeec","type":"datahub-input","z":"c221537c994b056a","name":"","connection":"a0ba0e15c8dad779","providerId":"u_os_adm","manualVariables":"digital_nameplate.address_information.zipcode:2","triggerMode":"poll","pollingInterval":"100","x":110,"y":40,"wires":[["315d179d66bf9b93"]]},{"id":"315d179d66bf9b93","type":"debug","z":"c221537c994b056a","name":"debug 7","active":false,"tosidebar":true,"console":false,"tostatus":false,"complete":"false","statusVal":"","statusType":"auto","x":740,"y":40,"wires":[]},{"id":"09f29f6bfc4e1be2","type":"inject","z":"c221537c994b056a","name":"","props":[{"p":"payload"},{"p":"topic","vt":"str"}],"repeat":"","crontab":"","once":false,"onceDelay":0.1,"topic":"","payload":"","payloadType":"date","x":120,"y":140,"wires":[["43b2fcf73c370f7c"]]},{"id":"43b2fcf73c370f7c","type":"function","z":"c221537c994b056a","name":"Random Data","func":"function randomBetween(min, max) {\n    return Math.random() * (max - min) + min;\n}\n\nmsg.payload = {\n    machine: {\n        status: \"running\",\n        details: {\n            temp: randomBetween(30, 80)\n        }\n    }\n};\n\nreturn msg;","outputs":1,"timeout":0,"noerr":0,"initialize":"","finalize":"","libs":[],"x":300,"y":140,"wires":[["a90304487fe19b3a"]]},{"id":"a90304487fe19b3a","type":"datahub-output","z":"c221537c994b056a","name":"","connection":"a0ba0e15c8dad779","providerId":"","x":500,"y":140,"wires":[["e53fa58e4c1987ba"]]},{"id":"e53fa58e4c1987ba","type":"debug","z":"c221537c994b056a","name":"debug 6","active":false,"tosidebar":true,"console":false,"tostatus":false,"complete":"payload","targetType":"msg","statusVal":"","statusType":"auto","x":740,"y":140,"wires":[]},{"id":"a0ba0e15c8dad779","type":"uos-config","host":"127.0.0.1","port":49360,"clientName":"hub","scope":"hub.variables.provide hub.variables.readwrite hub.variables.readonly"}]
+```
 
-### Setup Steps
+**What this flow does:**
 
-#### Step 1: Select Config
-- Choose your **u-OS Config** node
+**Top Row** (Reading):
+- **DataHub - IN** reads `zipcode` variable from provider `u_os_adm`
+- Polls every 100ms
+- Outputs to Debug node
 
-#### Step 2: Enter Provider ID
-- **What is it?** The name of the data source (e.g., `u_os_sbm`, `hub`, `custom-provider`)
-- **Where to find it?**
-  - u-Control Web Interface → **Data Hub** → **Providers**
-  - Or use the Python sample's `PROVIDER_ID`
+**Bottom Row** (Writing):
+- **Inject** node triggers data generation
+- **Function** node creates random temperature data
+- **DataHub - OUT** publishes to Data Hub as provider `hub`
+- Creates variables: `machine.status` and `machine.details.temp`
 
-**Example:** `u_os_sbm`
+**To customize:**
+1. Edit the **DataHub - IN** node:
+   - Change `Provider ID` to match your system
+   - Update variable mappings in the table
+2. Edit the **Function** node to generate your data structure
+3. Click **Deploy**
 
-#### Step 3: Add Variables (Manual Table)
-Since auto-discovery often fails due to permissions, you **manually map** variable names to their IDs.
+---
 
-**How to find Variable IDs:**
+## Finding Variable IDs
 
-**Option A: From Python Config**
-```python
-# Your working Python config.py
-VARIABLE_DEFINITIONS = [
-    {"id": 0, "key": "manufacturer_name", ...},
-    {"id": 2, "key": "machine.details.temp", ...}
-]
-```
-→ Use these IDs!
+The **DataHub - IN** node requires variable IDs (numbers). Here's how to find them:
+
+### Option 1: u-OS Web Interface
+
+1. Open **Data Hub** → **Providers**
+2. Click on your target provider (e.g., `u_os_adm`)
+3. Click **Variables** tab
+4. Note the **ID** column (e.g., `0`, `1`, `2`)
 
-**Option B: From u-Control Web UI**
-1. Open **Data Hub** → **Providers** → Select your provider
-2. Click on **Variables**
-3. Note the **ID** column (usually 0, 1, 2, ...)
+### Option 2: REST API Query
 
-**Option C: From REST API**
 ```bash
 curl -H "Authorization: Bearer $TOKEN" \
-  http://192.168.10.100/datahub/v1/providers/u_os_sbm/variables
+  http://192.168.10.100/datahub/v1/providers/u_os_adm/variables
+```
+
+Response shows variable definitions with IDs:
+```json
+{
+  "variables": [
+    {"id": 0, "key": "manufacturer_name", ...},
+    {"id": 2, "key": "digital_nameplate.address_information.zipcode", ...}
+  ]
+}
 ```
 
-**Fill the Table:**
+### Option 3: Check Other Apps
+
+If you have other Data Hub clients (apps, PLCs), check their variable definitions to find the IDs.
+
+---
+
+## DataHub - Read Node
+
+### Purpose
+Subscribe to variables from a Data Hub provider and output their values as JSON messages.
+
+### Configuration
+
+1. **Config Node:** Select your u-OS connection
+2. **Provider ID:** Enter the provider name (e.g., `u_os_adm`, `hub`, `u_os_sbm`)
+3. **Variables Table:** Manually map variable names to IDs
 
 | Variable Name | ID |
 |--------------|-----|
 | `manufacturer_name` | `0` |
-| `machine.details.temp` | `2` |
+| `zipcode` | `2` |
 
 Click **"Add Variable"** for each entry.
 
-#### Step 4: Choose Trigger Mode
-
-| Mode | When to Use |
-|------|-------------|
-| **Event (on change)** | Default. Efficient. Outputs only when values change. |
-| **Poll (interval)** | Forces periodic reads (e.g., every 1000ms). Less efficient. |
-
-#### Step 5: Deploy & Test
-1. Click **Deploy**
-2. Connect a **Debug** node to the output
-3. Send a message to the **Input Port** (using an **Inject** node) to trigger a read
-4. Check the Debug panel for output:
-   ```json
-   {
-     "type": "snapshot",
-     "variables": [
-       {"providerId": "u_os_sbm", "id": 0, "key": "manufacturer_name", "value": "Weidmüller", ...}
-     ]
-   }
-   ```
-
-### Troubleshooting
-
-| Problem | Solution |
-|---------|----------|
-| No output | Check: (1) Config deployed? (2) Provider ID correct? (3) Variable IDs correct? (4) Inject signal sent? |
-| "Variable not found" | Double-check IDs in the table. Use Python config or Web UI to verify. |
-| Permission errors | This is expected! That's why we use the manual table. |
+4. **Trigger Mode:**
+   - **Event (on change):** Efficient. Outputs only when values change.
+   - **Poll (interval):** Forces periodic reads (e.g., every 100ms).
+
+### Output Format
+
+```json
+{
+  "type": "snapshot",
+  "variables": [
+    {
+      "providerId": "u_os_adm",
+      "id": 2,
+      "key": "zipcode",
+      "value": "12345",
+      "quality": "GOOD",
+      "timestampNs": 1234567890000000000
+    }
+  ]
+}
+```
+
+### Triggering Reads
+
+Connect an **Inject** node to the input port to trigger manual reads.
 
 ---
 
-## 3. DataHub - OUT Node (Write Variables)
+## DataHub - Provider Node
 
 ### Purpose
-**Creates a real Data Hub provider** that publishes variables to the u-OS Data Hub. Other applications, devices, or even other Node-RED instances can **subscribe to your data in real-time**.
+Creates a real Data Hub provider that publishes variables. Other applications can subscribe to your data in real-time.
 
 ### How It Works
 
 The OUT node:
-1. **Registers as a Provider** on the Data Hub (e.g., provider ID: `nodered`)
+1. **Registers as a Provider** on the Data Hub (uses `Client Name` from Config)
 2. **Publishes variable definitions** automatically when new variables are sent
 3. **Sends value updates** via NATS when you send JSON messages
-4. **Answers read requests** from other consumers (apps can query your latest values)
-5. **Supports event-driven subscriptions** - other apps get updates **instantly** when values change
-
-**Important:** This provider only exists **while Node-RED is running**. When you restart Node-RED, the provider re-registers automatically.
-
-### Real-World Use Cases
-
-✅ **IoT Data Collection:** Node-RED reads sensor data (Modbus, MQTT, etc.) and publishes it to the Data Hub  
-✅ **Edge Processing:** Process data locally in Node-RED, then share results with other apps  
-✅ **System Integration:** Bridge between different protocols (e.g., OPC UA → Data Hub)  
-✅ **Custom Dashboards:** Other apps can subscribe to Node-RED's variables for visualization  
-
-### Setup Steps
+4. **Answers read requests** from other consumers
+5. **Supports event-driven subscriptions** - other apps get updates **instantly**
 
-#### Step 1: Select Config
-- Choose your **u-OS Config** node
+### Configuration
 
-#### Step 2: Provider ID (Optional)
-- **Leave EMPTY** to use the `Client Name` from your Config (recommended)
-- Or enter a custom provider ID (e.g., `my-machine-data`)
+1. **Config Node:** Select your u-OS connection
+2. **Provider ID:** Leave **empty** to use `Client Name` (recommended)
 
-**Example:** If your Config's Client Name is `nodered`, the provider will be `nodered`
+### Send Data
 
-#### Step 3: Send JSON Messages
-Send a JSON object with your data:
+Send JSON to the input:
 
 ```json
 {
@@ -255,91 +266,167 @@ Send a JSON object with your data:
 }
 ```
 
-This creates variables:
-- `temperature` → ID 0
-- `machine.status` → ID 1
-- `machine.speed` → ID 2
+This creates:
+- `temperature` → Variable ID 0
+- `machine.status` → Variable ID 1
+- `machine.speed` → Variable ID 2
 
-**The variables are INSTANTLY available to other apps via:**
-- **Event subscriptions** (other apps get updates when values change)
-- **Read queries** (other apps can request current values)
-- **u-Control Web UI** (visible in Data Hub → Providers → `nodered`)
+**Other apps can now:**
+- Subscribe to value changes (event-driven, instant updates)
+- Query current values (on-demand reads)
+- View in u-OS Web UI (**Data Hub** → **Providers** → `nodered`)
 
 ### Event-Driven Communication
 
-When you send a message to the OUT node:
-
 ```
-[Function: {"temp": 22.5}] → [DataHub - OUT] 
-                                    ↓
-                    ┌───────────────────────────────┐
-                    │   u-OS Data Hub (NATS)        │
-                    └───────────────────────────────┘
-                     ↓           ↓            ↓
-              [Python App]  [Dashboard]  [Other Node-RED]
-              (subscribes)  (subscribes)  (subscribes)
+[Node-RED: DataHub - OUT] → [u-OS Data Hub (NATS)]
+                                      ↓
+                        ┌─────────────┼─────────────┐
+                        ↓             ↓             ↓
+                  [Other Apps]  [Dashboards]  [PLCs]
+                  (subscribe)   (subscribe)   (subscribe)
 ```
 
-**All subscribers receive the update IMMEDIATELY** - no polling needed!
-
-#### Step 4: Deploy & Test
-1. Connect a **Function** or **Inject** node
-2. Click **Deploy**
-3. Check the u-Control Web Interface → **Data Hub** → Your Provider
+**All subscribers receive updates IMMEDIATELY** - no polling needed!
 
 ---
 
-## Example Flow
+## DataHub - Write Node
+
+### Purpose
+Send **write commands** to **external Data Hub providers** to change variable values. This is different from the Provider node - you're controlling **other** systems, not creating your own provider.
+
+### Use Cases
+
+✅ **Control external devices** - Toggle flags, update setpoints  
+✅ **Machine control** - Start/stop operations via Data Hub  
+✅ **Configuration updates** - Change parameters in other apps  
+✅ **Integration scenarios** - Write to PLCs, other Node-RED instances, etc.  
+
+### Configuration
+
+1. **Config Node:** Select your u-OS connection
+2. **Provider ID:** Target provider to write to (e.g., `u_os_adm`, `u_os_sbm`)
+3. **Variable ID:** Numeric ID of the variable to write
+
+### Finding Variable IDs
+
+Same as Read node - check u-OS Web UI:
+
+1. Go to **Data Hub** → **Providers** → Select target provider
+2. Click **Variables** tab
+3. Note the **ID** column
 
+### Input Format
+
+Send the new value as `msg.payload`:
+
+**Toggle Boolean:**
+```javascript
+msg.payload = false;
+return msg;
 ```
-[Inject] → [DataHub - IN] → [Debug]
-           (u_os_sbm)
 
-[Inject: {"temp": 22}] → [DataHub - OUT]
-                         (nodered)
+**Update Number:**
+```javascript
+msg.payload = 42.5;
+return msg;
 ```
 
-**Copy this flow:**
+**Change String:**
+```javascript
+msg.payload = "stopped";
+return msg;
+```
+
+### Output
+
+Outputs confirmation when write command is sent:
+
 ```json
-[{"id":"inject1","type":"inject","name":"Trigger Read"},
- {"id":"datahub-in","type":"datahub-input","connection":"config1","providerId":"u_os_sbm","manualVariables":"manufacturer_name:0"},
- {"id":"debug1","type":"debug"}]
+{
+  "success": true,
+  "providerId": "u_os_adm",
+  "variableId": 5,
+  "value": false
+}
 ```
 
+### Example Flow
+
+```
+[Inject: false] → [DataHub - Write] → [Debug]
+                  (Provider: u_os_adm,
+                   Variable ID: 5)
+```
+
+### Important Notes
+
+⚠️ **Requires write permissions:** OAuth client must have `hub.variables.readwrite` scope  
+⚠️ **Provider must accept writes:** Some providers are read-only  
+⚠️ **Variable must exist:** The variable ID must be valid  
+
+---
+
+## Troubleshooting
+
+### No Output from IN Node
+
+✓ Config node deployed?  
+✓ Provider ID correct? (check u-OS Web UI → Data Hub → Providers)  
+✓ Variable IDs correct? (check u-OS Web UI → Variables)  
+✓ Inject signal sent to input port?  
+
+### "Variable not found" Error
+
+- Double-check IDs in the Variables table
+- Verify IDs match those in u-OS Web UI
+
+### Connection Test Fails
+
+- Check Host/Port are correct and device is reachable
+- Verify Client ID/Secret match exactly
+- Ensure OAuth client exists in u-OS
+- Verify all `hub.variables.*` scopes are granted
+
+### Why Manual IDs?
+
+Auto-discovery requires special permissions on the provider definition endpoint, which are often restricted for security. The manual table works **without** this permission by querying specific IDs directly.
+
 ---
 
 ## FAQ
 
-### Q: Why manual IDs? Can't it auto-discover?
-**A:** Auto-discovery requires `hub.variables.readonly` permission on the **provider definition** endpoint, which is often restricted. The manual table works **without** this permission because it queries specific IDs directly.
+### Q: Can I use the provider created by Provider node in the Read node?
+**A:** **No, don't do this!** The Provider node's provider only exists while Node-RED runs. On restart, it disappears and the Read node fails. Read from **system providers** (`u_os_sbm`, `u_os_adm`) or other persistent apps instead.
+
+### Q: What's the difference between Provider and Write nodes?
+**A:**  
+- **DataHub - Provider:** Creates your **own** provider. Other apps read **from** you.
+- **DataHub - Write:** Sends commands **to other** providers. You write **to** them.
 
 ### Q: Where do I get Client ID/Secret?
-**A:** u-Control Web Interface → **System** → **Access Control** → **OAuth Clients** → **Add Client**
+**A:** u-OS Web Interface → **System** → **Access Control** → **OAuth Clients** → **Add Client**
 
 ### Q: What are the required OAuth scopes?
 **A:** 
-- **Read (IN Node):** `hub.variables.readonly`
-- **Write (OUT Node):** `hub.variables.provide` + `hub.variables.readwrite`
+- **Read Node:** `hub.variables.readonly`
+- **Provider Node:** `hub.variables.provide` + `hub.variables.readwrite`
+- **Write Node:** `hub.variables.readwrite`
 - **Recommended:** Select all `hub.variables.*` scopes when creating the client
 
 ### Q: Can I use this outside the local network?
-**A:** Yes, if your u-Control device is reachable over the network and you configure the correct Host/Port.
+**A:** Yes, if your u-OS device is reachable over the network and you configure the correct Host/Port.
 
 ### Q: Event vs Poll - which is better?
 **A:** **Event** (default) is more efficient. Use **Poll** only if you need guaranteed periodic readings regardless of value changes.
 
 ---
 
-## Changelog
-
-See [GitHub Releases](https://github.com/uiff/nats-NodeRed-Node-uc20/releases)
-
----
-
 ## Support
 
 **Issues, Questions, or Feature Requests:**  
-Contact [IoTUeli](https://www.linkedin.com/in/iotueli/) or open an issue on [GitHub](https://github.com/uiff/nats-NodeRed-Node-uc20)
+Contact [IoTUeli](https://iotueli.ch) or open an issue on [GitHub](https://github.com/uiff/nats-NodeRed-Node-uc20)
 
 ---
 

package/lib/payloads.js

@@ -17,6 +17,10 @@ import { VariableValueBoolean, VariableValueBooleanT } from './fbs/weidmueller/u
 import { TimestampT } from './fbs/weidmueller/ucontrol/hub/timestamp.js';
 import { ReadVariablesQueryResponseT } from './fbs/weidmueller/ucontrol/hub/read-variables-query-response.js';
 import { ReadVariablesQueryRequestT } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
+import { ReadVariablesQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
+import { ReadProviderDefinitionQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-provider-definition-query-request.js';
+import { WriteVariablesCommandT } from './fbs/weidmueller/ucontrol/hub/write-variables-command.js';
+
 const DEFAULT_QUALITY = 'GOOD';
 export function buildProviderDefinitionEvent(defs) {
     const fingerprint = computeFingerprint(defs);
@@ -44,7 +48,6 @@ export function buildReadVariablesResponse(defs, states, fingerprint) {
     return builder.asUint8Array();
 }
 // Helper to omit field if null/empty
-import { ReadVariablesQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-variables-query-request.js';
 
 export function buildReadVariablesQuery(ids) {
     const builder = new flatbuffers.Builder(128);
@@ -64,7 +67,6 @@ export function buildReadVariablesQuery(ids) {
     return builder.asUint8Array();
 }
 // Helper to build definition query
-import { ReadProviderDefinitionQueryRequest } from './fbs/weidmueller/ucontrol/hub/read-provider-definition-query-request.js';
 
 export function buildReadProviderDefinitionQuery() {
     const builder = new flatbuffers.Builder(32);
@@ -73,6 +75,52 @@ export function buildReadProviderDefinitionQuery() {
     builder.finish(offset);
     return builder.asUint8Array();
 }
+
+// Encode write variables command
+export function encodeWriteVariablesCommand(variables) {
+    // variables: [{id: number, value: any}, ...]
+    const varList = new VariableListT();
+    varList.items = variables.map(v => {
+        const varT = new VariableT();
+        varT.id = v.id;
+        varT.quality = VariableQuality.GOOD;
+        varT.timestamp = nowNs();
+
+        // Encode value based on type
+        const val = v.value;
+        if (typeof val === 'boolean') {
+            const boolVal = new VariableValueBooleanT();
+            boolVal.value = val;
+            varT.value = boolVal;
+            varT.valueType = VariableValue.Boolean;
+        } else if (Number.isInteger(val)) {
+            const intVal = new VariableValueInt64T();
+            intVal.value = BigInt(val);
+            varT.value = intVal;
+            varT.valueType = VariableValue.Int64;
+        } else if (typeof val === 'number') {
+            const floatVal = new VariableValueFloat64T();
+            floatVal.value = val;
+            varT.value = floatVal;
+            varT.valueType = VariableValue.Float64;
+        } else if (typeof val === 'string') {
+            const strVal = new VariableValueStringT();
+            strVal.value = val;
+            varT.value = strVal;
+            varT.valueType = VariableValue.String;
+        } else {
+            throw new Error(`Unsupported value type: ${typeof val}`);
+        }
+
+        return varT;
+    });
+
+    const cmd = new WriteVariablesCommandT(varList);
+    const builder = new flatbuffers.Builder(512);
+    builder.finish(cmd.pack(builder));
+    return builder.asUint8Array();
+}
+
 export function decodeVariableList(list) {
     if (!list)
         return [];
@@ -98,121 +146,176 @@ export function decodeVariableList(list) {
             case VariableValue.Boolean: {
                 const holder = new VariableValueBoolean();
                 item.value(holder);
-                decoded = !!holder.value();
+                decoded = holder.value();
                 break;
             }
-            case VariableValue.String:
-            default: {
+            case VariableValue.String: {
                 const holder = new VariableValueString();
                 item.value(holder);
-                decoded = holder.value()?.toString() ?? '';
+                decoded = holder.value();
                 break;
             }
+            default:
+                decoded = null;
         }
-        const ts = item.timestamp();
-        const seconds = ts ? Number(ts.seconds()) : 0;
-        const nanos = ts ? ts.nanos() : 0;
+        const quality = decodeQuality(item.quality());
+        const timestampNs = decodeTimestamp(item.timestamp());
         result.push({
             id: item.id(),
             value: decoded,
-            timestampNs: seconds * 1000000000 + nanos,
-            quality: DEFAULT_QUALITY,
+            quality,
+            timestampNs,
         });
     }
     return result;
 }
-// Added to support NATS-based definition fetching
+import { ProviderList } from './fbs/weidmueller/ucontrol/hub/provider-list.js';
+import { ReadProvidersQueryResponse } from './fbs/weidmueller/ucontrol/hub/read-providers-query-response.js';
 import { ReadProviderDefinitionQueryResponse } from './fbs/weidmueller/ucontrol/hub/read-provider-definition-query-response.js';
-
-export function decodeProviderDefinition(buffer) {
-    const bb = new flatbuffers.ByteBuffer(buffer);
-    const response = ReadProviderDefinitionQueryResponse.getRootAsReadProviderDefinitionQueryResponse(bb);
-    const providerDef = response.providerDefinition();
-
-    if (!providerDef) return [];
-
+import { VariableList } from './fbs/weidmueller/ucontrol/hub/variable-list.js';
+export function decodeProviderList(bb) {
+    const response = ReadProvidersQueryResponse.getRootAsReadProvidersQueryResponse(bb);
+    const list = response.providers();
+    if (!list)
+        return [];
     const result = [];
-    const len = providerDef.variableDefinitionsLength();
-    for (let i = 0; i < len; i++) {
-        const item = providerDef.variableDefinitions(i);
-        if (!item) continue;
-
-        // Inverse mapping of DataType/AccessType needed if we want full fidelity,
-        // but for now we mainly need ID and Key.
-        result.push({
-            id: item.id(),
-            key: item.key(),
-            dataType: 'UNKNOWN', // Mapping back from Enum to String if strictly needed
-            access: item.accessType() === VariableAccessType.READ_WRITE ? 'READ_WRITE' : 'READ_ONLY'
-        });
+    for (let i = 0; i < list.itemsLength(); i += 1) {
+        const prov = list.items(i);
+        if (!prov)
+            continue;
+        result.push({ id: prov.id() || '' });
     }
     return result;
 }
-
-function toFlatDefinition(def) {
-    const result = new VariableDefinitionT();
-    result.id = def.id;
-    result.key = def.key;
-    result.experimental = Boolean(def.experimental);
-    result.dataType = mapDataType(def.dataType);
-    result.accessType = def.access === 'READ_WRITE' ? VariableAccessType.READ_WRITE : VariableAccessType.READ_ONLY;
-    return result;
-}
-function buildVariableList(defs, states, fingerprint) {
-    const statesMap = new Map(states.map((s) => [s.id, s]));
-    const items = [];
-    for (const def of defs) {
-        const state = statesMap.get(def.id);
-        if (!state)
+export function decodeProviderDefinition(bb) {
+    const response = ReadProviderDefinitionQueryResponse.getRootAsReadProviderDefinitionQueryResponse(bb);
+    const def = response.providerDefinition();
+    if (!def)
+        return null;
+    const variableDefs = [];
+    for (let i = 0; i < def.variableDefinitionsLength(); i += 1) {
+        const varDef = def.variableDefinitions(i);
+        if (!varDef)
             continue;
-        const variable = new VariableT();
-        variable.id = def.id;
-        const [valueType, value] = toValueUnion(def.dataType, state.value);
-        variable.valueType = valueType;
-        variable.value = value;
-        variable.timestamp = toTimestamp(state.timestampNs);
-        variable.quality = VariableQuality.GOOD;
-        items.push(variable);
+        variableDefs.push({
+            id: varDef.id(),
+            key: varDef.key() || '',
+            dataType: decodeDataType(varDef.dataType()),
+            access: decodeAccessType(varDef.accessType()),
+        });
     }
-    const list = new VariableListT();
-    list.providerDefinitionFingerprint = fingerprint;
-    list.baseTimestamp = items.length ? (items[0].timestamp ?? toTimestamp(Date.now() * 1000000)) : toTimestamp(Date.now() * 1000000);
-    list.items = items;
-    return list;
+    return {
+        fingerprint: def.fingerprint(),
+        variables: variableDefs,
+    };
 }
-function toTimestamp(ns) {
-    const ts = new TimestampT();
-    ts.seconds = BigInt(Math.floor(ns / 1000000000));
-    ts.nanos = ns % 1000000000;
-    return ts;
+function buildVariableList(defs, states, fingerprint) {
+    const variables = defs.map((def) => encodeVariableState(def, states[def.id]));
+    const list = new VariableListT(fingerprint, variables);
+    return list;
 }
-function toValueUnion(type, value) {
-    switch (type) {
+function encodeVariableState(def, state) {
+    const varT = new VariableT();
+    varT.id = def.id;
+    varT.quality = VariableQuality[state?.quality?.toUpperCase?.()] ?? VariableQuality[DEFAULT_QUALITY];
+    varT.timestamp = state?.timestamp !== undefined ? new TimestampT(BigInt(state.timestamp)) : nowNs();
+    const value = state?.value;
+    switch (def.dataType) {
         case 'INT64': {
-            const holder = new VariableValueInt64T();
-            holder.value = BigInt(Math.trunc(Number(value)));
-            return [VariableValue.Int64, holder];
+            const intVal = new VariableValueInt64T();
+            intVal.value = (value !== null && value !== undefined) ? BigInt(value) : BigInt(0);
+            varT.value = intVal;
+            varT.valueType = VariableValue.Int64;
+            break;
         }
         case 'FLOAT64': {
-            const holder = new VariableValueFloat64T();
-            holder.value = Number(value);
-            return [VariableValue.Float64, holder];
+            const floatVal = new VariableValueFloat64T();
+            floatVal.value = (value !== null && value !== undefined) ? Number(value) : 0.0;
+            varT.value = floatVal;
+            varT.valueType = VariableValue.Float64;
+            break;
         }
         case 'BOOLEAN': {
-            const holder = new VariableValueBooleanT();
-            holder.value = Boolean(value);
-            return [VariableValue.Boolean, holder];
+            const boolVal = new VariableValueBooleanT();
+            boolVal.value = (value !== null && value !== undefined) ? Boolean(value) : false;
+            varT.value = boolVal;
+            varT.valueType = VariableValue.Boolean;
+            break;
         }
         case 'STRING':
         default: {
-            const holder = new VariableValueStringT();
-            holder.value = String(value);
-            return [VariableValue.String, holder];
+            const strVal = new VariableValueStringT();
+            strVal.value = (value !== null && value !== undefined) ? String(value) : '';
+            varT.value = strVal;
+            varT.valueType = VariableValue.String;
+            break;
         }
     }
+    return varT;
+}
+function nowNs() {
+    return new TimestampT(BigInt(Date.now() * 1_000_000));
+}
+function decodeTimestamp(ts) {
+    return ts ? Number(ts.value()) : 0;
+}
+function decodeDataType(dt) {
+    switch (dt) {
+        case VariableDataType.INT64:
+            return 'INT64';
+        case VariableDataType.FLOAT64:
+            return 'FLOAT64';
+        case VariableDataType.BOOLEAN:
+            return 'BOOLEAN';
+        case VariableDataType.STRING:
+        default:
+            return 'STRING';
+    }
+}
+function decodeAccessType(dt) {
+    switch (dt) {
+        case VariableAccessType.READWRITE:
+            return 'READWRITE';
+        case VariableAccessType.READONLY:
+        default:
+            return 'READONLY';
+    }
+}
+function decodeQuality(q) {
+    switch (q) {
+        case VariableQuality.BAD:
+            return 'BAD';
+        case VariableQuality.UNCERTAIN:
+            return 'UNCERTAIN';
+        case VariableQuality.GOOD_LOCAL_OVERRIDE:
+            return 'GOOD_LOCAL_OVERRIDE';
+        case VariableQuality.GOOD:
+        default:
+            return 'GOOD';
+    }
+}
+function toFlatDefinition(def) {
+    const varDef = new VariableDefinitionT();
+    varDef.id = def.id;
+    varDef.key = def.key;
+    varDef.dataType = mapDataType(def.dataType);
+    varDef.accessType = mapAccessType(def.access);
+    if (def.experimental !== undefined && def.experimental !== null) {
+        varDef.experimental = Boolean(def.experimental);
+    }
+    return varDef;
+}
+function mapAccessType(access) {
+    switch (access?.toUpperCase?.()) {
+        case 'READWRITE':
+            return VariableAccessType.READWRITE;
+        case 'READONLY':
+        default:
+            return VariableAccessType.READONLY;
+    }
 }
-function mapDataType(type) {
-    switch (type) {
+function mapDataType(dataType) {
+    switch (dataType?.toUpperCase?.()) {
         case 'INT64':
             return VariableDataType.INT64;
         case 'FLOAT64':

package/nodes/datahub-input.html

@@ -17,7 +17,7 @@
       if (this.name) return this.name;
       return "DataHub - IN";
     },
-    paletteLabel: "DataHub - IN",
+    paletteLabel: "DataHub - Read",
     oneditprepare: function () {
       const node = this;
 
@@ -131,7 +131,7 @@
 </script>
 
 <script type="text/html" data-help-name="datahub-input">
-    <p>Reads variables from the u-OS Data Hub via NATS and outputs their values as JSON messages.</p>
+    <p><b>DataHub - Read</b> reads variables from u-OS Data Hub providers and outputs their values as JSON messages.</p>
     
     <h3>Quick Start</h3>
     <ol>

package/nodes/datahub-output.html

@@ -14,7 +14,7 @@
     label: function () {
       return this.name || `DataHub - OUT ${this.providerId || ''}`;
     },
-    paletteLabel: "DataHub - OUT",
+    paletteLabel: "DataHub - Provider",
     labelStyle: function () {
       return this.name ? 'node_label_italic' : '';
     }
@@ -37,7 +37,7 @@
 </script>
 
 <script type="text/html" data-help-name="datahub-output">
-  <p><strong>DataHub Output</strong> registers (if needed) and writes variables for the provider you specify.</p>
+  <p><b>DataHub - Provider</b> creates your own Data Hub provider that other applications can read from in real-time.</p>
   <dl>
     <dt>u-OS Config</dt>
     <dd>Connection node with host/port and OAuth credentials.</dd>

package/nodes/datahub-write.html

@@ -0,0 +1,127 @@
+<script type="text/javascript">
+    RED.nodes.registerType('datahub-write', {
+        category: 'u-OS DataHub NATS',
+        color: '#e74c3c',
+        defaults: {
+            name: { value: "" },
+            connection: { type: "uos-config", required: true },
+            providerId: { value: "", required: true },
+            variableId: { value: "", required: false },
+            variableName: { value: "", required: false }
+        },
+        inputs: 1,
+        outputs: 1,
+        icon: "white/datahub-output.svg",
+        label: function () {
+            if (this.name) return this.name;
+            return `Write → ${this.providerId || 'provider'}`;
+        },
+        paletteLabel: "DataHub - Write",
+        oneditprepare: function () {
+            // Nothing special needed for now
+        }
+    });
+</script>
+
+<script type="text/html" data-template-name="datahub-write">
+    <div class="form-row">
+        <label for="node-input-name"><i class="fa fa-tag"></i> Name</label>
+        <input type="text" id="node-input-name" placeholder="Optional">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-connection"><i class="fa fa-globe"></i> Config</label>
+        <input type="text" id="node-input-connection">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-providerId"><i class="fa fa-server"></i> Provider ID</label>
+        <input type="text" id="node-input-providerId" placeholder="e.g. u_os_adm">
+    </div>
+
+    <div class="form-row">
+        <label for="node-input-variableId"><i class="fa fa-hashtag"></i> Variable ID</label>
+        <input type="number" id="node-input-variableId" placeholder="e.g. 5">
+    </div>
+
+    <div class="form-tips">
+        <i class="fa fa-info-circle"></i> Send <code>msg.payload</code> with the value to write (e.g., <code>true</code>, <code>42</code>, <code>"hello"</code>)
+    </div>
+</script>
+
+<script type="text/html" data-help-name="datahub-write">
+    <p><b>DataHub - Write</b> sends write commands to external Data Hub providers to change variable values.</p>
+    
+    <h3>Purpose</h3>
+    <p>Control variables in <b>other providers</b> (not your own). Use this to:</p>
+    <ul>
+        <li>Toggle flags (e.g., <code>enable_mode = true</code>)</li>
+        <li>Update setpoints (e.g., <code>target_temp = 25.5</code>)</li>
+        <li>Control external devices via Data Hub</li>
+    </ul>
+
+    <h3>Configuration</h3>
+    
+    <h4>Provider ID</h4>
+    <p>The target provider to write to (e.g., <code>u_os_adm</code>, <code>u_os_sbm</code>).</p>
+    <p><b>Find it:</b> u-OS Web UI → Data Hub → Providers</p>
+
+    <h4>Variable ID</h4>
+    <p>The numeric ID of the variable to write.</p>
+    <p><b>Find it:</b> u-OS Web UI → Data Hub → Providers → (Select Provider) → Variables tab</p>
+
+    <h3>Input Format</h3>
+    <p>Send the new value as <code>msg.payload</code>:</p>
+
+    <h4>Example: Toggle Boolean</h4>
+    <pre><code>msg.payload = false;
+return msg;</code></pre>
+
+    <h4>Example: Update Number</h4>
+    <pre><code>msg.payload = 42.5;
+return msg;</code></pre>
+
+    <h4>Example: Change String</h4>
+    <pre><code>msg.payload = "stopped";
+return msg;</code></pre>
+
+    <h3>Output</h3>
+    <p>Outputs a confirmation message when the write command is sent:</p>
+    <pre><code>{
+  "success": true,
+  "providerId": "u_os_adm",
+  "variableId": 5,
+  "value": false
+}</code></pre>
+
+    <h3>Example Flow</h3>
+    <pre><code>[Inject: false] → [DataHub - Write] → [Debug]
+                   (Provider: u_os_adm, Variable ID: 5)</code></pre>
+
+    <h3>Important Notes</h3>
+    <ul>
+        <li>⚠️ <b>Requires write permissions:</b> Your OAuth client must have <code>hub.variables.readwrite</code> scope</li>
+        <li>⚠️ <b>Provider must accept writes:</b> Some providers are read-only</li>
+        <li>⚠️ <b>Variable must exist:</b> The variable ID must be valid in the target provider</li>
+    </ul>
+
+    <h3>Troubleshooting</h3>
+    
+    <h4>No Response / Error</h4>
+    <ul>
+        <li>Check Provider ID is correct (u-OS Web UI → Data Hub → Providers)</li>
+        <li>Verify Variable ID exists (Providers → Variables tab)</li>
+        <li>Ensure OAuth client has <code>hub.variables.readwrite</code> scope</li>
+    </ul>
+
+    <h4>Permission Denied</h4>
+    <ul>
+        <li>Check OAuth client scopes in u-OS (System → Access Control → OAuth Clients)</li>
+        <li>Verify provider allows writes (some system providers are read-only)</li>
+    </ul>
+
+    <div style="margin-top:15px; padding-top:10px; border-top:1px solid #ddd; font-size:0.85em; color:#666;">
+        <p><b>Developed by <a href="https://iotueli.ch" target="_blank">IoTUeli</a></b></p>
+        <p>Not an official Weidmüller product. Community contribution.</p>
+    </div>
+</script>

package/nodes/datahub-write.js

@@ -0,0 +1,87 @@
+import { encodeWriteVariablesCommand } from '../lib/payloads.js';
+
+export default function (RED) {
+    function DataHubWriteNode(config) {
+        RED.nodes.createNode(this, config);
+        const node = this;
+
+        // Get config node
+        const configNode = RED.nodes.getNode(config.connection);
+        if (!configNode) {
+            node.error('Missing u-OS config');
+            node.status({ fill: 'red', shape: 'dot', text: 'no config' });
+            return;
+        }
+
+        // Store configuration
+        this.providerId = config.providerId?.trim();
+        this.variableId = config.variableId ? parseInt(config.variableId, 10) : null;
+
+        if (!this.providerId) {
+            node.error('Provider ID is required');
+            node.status({ fill: 'red', shape: 'dot', text: 'no provider ID' });
+            return;
+        }
+
+        if (this.variableId === null || isNaN(this.variableId)) {
+            node.error('Variable ID is required and must be a number');
+            node.status({ fill: 'red', shape: 'dot', text: 'invalid variable ID' });
+            return;
+        }
+
+        node.status({ fill: 'green', shape: 'ring', text: 'ready' });
+
+        // Handle incoming messages
+        node.on('input', async function (msg) {
+            const value = msg.payload;
+
+            if (value === undefined || value === null) {
+                node.warn('msg.payload is empty, nothing to write');
+                return;
+            }
+
+            try {
+                // Get NATS connection from config node
+                const nc = await configNode.getNatsConnection();
+                if (!nc) {
+                    node.error('NATS connection not available');
+                    node.status({ fill: 'red', shape: 'dot', text: 'no connection' });
+                    return;
+                }
+
+                // Build write command
+                const writeCommand = encodeWriteVariablesCommand([
+                    {
+                        id: node.variableId,
+                        value: value
+                    }
+                ]);
+
+                // Publish write command
+                const subject = `v1.loc.${node.providerId}.vars.cmd.write`;
+                nc.publish(subject, writeCommand);
+
+                node.status({ fill: 'green', shape: 'dot', text: `wrote: ${value}` });
+
+                // Output confirmation
+                msg.payload = {
+                    success: true,
+                    providerId: node.providerId,
+                    variableId: node.variableId,
+                    value: value
+                };
+                node.send(msg);
+
+            } catch (err) {
+                node.error(`Write failed: ${err.message}`, msg);
+                node.status({ fill: 'red', shape: 'dot', text: 'write error' });
+            }
+        });
+
+        node.on('close', function () {
+            node.status({});
+        });
+    }
+
+    RED.nodes.registerType('datahub-write', DataHubWriteNode);
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "node-red-contrib-uos-nats",
-  "version": "0.1.65",
-  "description": "Node-RED nodes for Weidmüller u-OS Data Hub. Read and write variables via NATS protocol with OAuth2 authentication. Supports event-based subscriptions and manual variable mapping.",
+  "version": "0.1.67",
+  "description": "Node-RED nodes for Weidmüller u-OS Data Hub. Read, write, and provide variables via NATS protocol with OAuth2 authentication. Supports event-based subscriptions and manual variable mapping.",
   "author": {
     "name": "IoTUeli",
     "url": "https://www.linkedin.com/in/iotueli/"
@@ -31,7 +31,10 @@
     "plc",
     "variables",
     "oauth2",
-    "flatbuffers"
+    "flatbuffers",
+    "write",
+    "read",
+    "provider"
   ],
   "engines": {
     "node": ">=14.0.0"
@@ -46,7 +49,8 @@
     "nodes": {
       "uos-config": "nodes/uos-config.js",
       "datahub-input": "nodes/datahub-input.js",
-      "datahub-output": "nodes/datahub-output.js"
+      "datahub-output": "nodes/datahub-output.js",
+      "datahub-write": "nodes/datahub-write.js"
     }
   }
 }