API WebSocket

ws://[username:password@]<IP>:8085
wss://[username:password@]<IP>:8085  (secured)

Authorization: Basic base64(username:password)

class OpenEMSClient {
  constructor(url) {
    this.url = url;
    this.ws = null;
    this.requestId = 0;
    this.pendingRequests = new Map();
  }

  connect() {
    this.ws = new WebSocket(this.url);
    this.ws.onopen = () => console.log("Connected");
    this.ws.onmessage = (event) => this.handleMessage(JSON.parse(event.data));
    this.ws.onerror = (error) => console.error("WebSocket error:", error);
    this.ws.onclose = () => console.log("Disconnected");
  }

  handleMessage(msg) {
    if (msg.id && this.pendingRequests.has(msg.id)) {
      const resolve = this.pendingRequests.get(msg.id);
      this.pendingRequests.delete(msg.id);
      resolve(msg.result || msg.error);
    } else if (msg.method === "subscribedChannels") {
      console.log("Channel update:", msg.params.channels);
    } else if (msg.method === "edgeConfig") {
      console.log("Configuration updated");
    }
  }

  send(method, params = {}) {
    const id = ++this.requestId;
    const request = { id, jsonrpc: "2.0", method, params };
    this.ws.send(JSON.stringify(request));
    return new Promise(resolve => {
      this.pendingRequests.set(id, resolve);
    });
  }

  async subscribeChannels(channels) {
    return this.send("subscribeChannels", { channels });
  }

  async getEdgeConfig() {
    return this.send("getEdgeConfig", {});
  }

  async setChannelValue(channel, value) {
    return this.send("setChannelValues", { [channel]: value });
  }
}

// Usage
const client = new OpenEMSClient("ws://x:user@localhost:8085");
client.connect();

setTimeout(async () => {
  await client.subscribeChannels(["_sum/GridActivePower", "_sum/EssSoc"]);
  await client.setChannelValue("ess0/SetActivePowerEquals", 5000);
}, 1000);

import asyncio
import json
import websockets
import base64

class OpenEMSClient:
    def __init__(self, url, username, password):
        self.url = url
        self.auth_header = f"Basic {base64.b64encode(f'{username}:{password}'.encode()).decode()}"
        self.request_id = 0

    async def connect(self):
        self.ws = await websockets.connect(
            self.url,
            extra_headers={"Authorization": self.auth_header}
        )
        await self.listen()

    async def listen(self):
        async for message in self.ws:
            data = json.loads(message)
            self.handle_message(data)

    def handle_message(self, msg):
        if msg.get("method") == "subscribedChannels":
            print("Channels:", msg["params"]["channels"])

    async def send(self, method, params=None):
        self.request_id += 1
        request = {
            "id": self.request_id,
            "jsonrpc": "2.0",
            "method": method,
            "params": params or {}
        }
        await self.ws.send(json.dumps(request))

    async def subscribe_channels(self, channels):
        await self.send("subscribeChannels", {"channels": channels})

    async def set_channel_value(self, channel, value):
        await self.send("setChannelValues", {channel: value})

# Usage
async def main():
    client = OpenEMSClient("ws://localhost:8085", "x", "user")
    await client.connect()

asyncio.run(main())