@blueyerobotics/blueye-ts 1.5.0 → 3.0.0

package/README.md

@@ -15,13 +15,23 @@ import { BlueyeClient } from "@blueyerobotics/blueye-ts";
 
 const client = new BlueyeClient();
 
-const rep = await client.sendRequest("GetBatteryReq");
-const tel = await client.getTelemetry("BatteryTel");
+client.on("connected", async () => {
+  // request battery information
+  const batteryRep = await client.sendRequest("GetBatteryReq");
+  console.log("batteryRep:", batteryRep);
 
-console.log("Rep:", rep);
-console.log("Tel:", tel);
+  // get latest battery telemetry
+  const batteryTel = await client.getTelemetry("BatteryTel");
+  console.log("batteryTel:", batteryTel);
 
-client.sub.on("BatteryTel", data => {
-  console.log("Received BatteryTel:", data);
+  // send a control message to change the light intensity to 1
+  await client.sendControl("LightsCtrl", { lights: { value: 1 } });
 });
+
+// subscribe to battery telemetry updates
+client.on("BatteryTel", data => {
+  console.log("received BatteryTel:", data);
+});
+
+client.connect();
 ```

package/dist/example.js

@@ -3,12 +3,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const index_1 = require("./index");
 const main = async () => {
     const client = new index_1.BlueyeClient();
-    const rep = await client.sendRequest("GetBatteryReq");
-    const tel = await client.getTelemetry("BatteryTel");
-    console.log("Rep:", rep);
-    console.log("Tel:", tel);
-    client.sub.on("BatteryTel", data => {
-        console.log("Received BatteryTel:", data);
+    client.on("connected", async () => {
+        // request battery information
+        const batteryRep = await client.sendRequest("GetBatteryReq");
+        console.log("batteryRep:", batteryRep);
+        // get latest battery telemetry
+        const batteryTel = await client.getTelemetry("BatteryTel");
+        console.log("batteryTel:", batteryTel);
+        // send a control message to change the light intensity to 1
+        await client.sendControl("LightsCtrl", { lights: { value: 1 } });
     });
+    // subscribe to battery telemetry updates
+    client.on("BatteryTel", data => {
+        console.log("received BatteryTel:", data);
+    });
+    client.connect();
 };
 main();

package/dist/src/client.d.ts

@@ -9,23 +9,41 @@ export type Rep = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Rep`>>;
 export type Tel = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Tel`>>;
 export type Ctrl = keyof Pick<Protocol, Extract<ProtocolKey, `${string}Ctrl`>>;
 export type ReqToRep<T extends Req> = T extends `${infer Prefix}Req` ? `${Prefix}Rep` extends ProtocolKey ? Protocol[`${Prefix}Rep`] : never : never;
-export type MsgHandler<T extends Req> = Protocol[T];
-export type CreateArgs<T extends Req> = Parameters<MsgHandler<T>["create"]>[0];
+export type MsgHandler<T extends Req | Ctrl> = Protocol[T];
+export type CreateArgs<T extends Req | Ctrl> = Parameters<MsgHandler<T>["create"]>[0];
 export type DecodedOutput<T extends Req> = ReturnType<ReqToRep<T>["decode"]>;
 export type DecodedTelOutput<T extends Tel> = ReturnType<Protocol[T]["decode"]>;
+type State = "connecting" | "connected" | "disconnected";
 export type Events = {
+    [K in State]: [];
+} & {
     [K in Tel]: [DecodedTelOutput<K>];
 };
 export declare const isInProtocol: (key: string) => key is keyof typeof blueye.protocol;
-export declare class BlueyeClient {
+type Options = Partial<{
+    subUrl: string;
+    rpcUrl: string;
+    pubUrl: string;
     timeout: number;
-    private wsPubSub;
-    private wsReqRep;
-    private isReqRepConnected;
+    logLevel: LogLevel;
+    autoConnect: boolean;
+}>;
+export declare class BlueyeClient extends Emitter<Events> {
+    state: State;
+    timeout: number;
+    private subUrl;
+    private rpcUrl;
+    private pubUrl;
+    private sub;
+    private rpc;
+    private pub;
     private logger;
-    private pendingRequests;
-    sub: Emitter<Events>;
-    constructor(timeout?: number, logLevel?: LogLevel);
+    constructor({ subUrl, rpcUrl, pubUrl, timeout, logLevel, autoConnect }?: Options);
+    private updateState;
+    connect(): void;
+    disconnect(): void;
     sendRequest<T extends Req>(req: T, opts?: CreateArgs<T>): Promise<DecodedOutput<T> | null>;
     getTelemetry<T extends Tel>(type: T): Promise<DecodedTelOutput<T>>;
+    sendControl<T extends Ctrl>(ctrl: T, opts?: CreateArgs<T>): Promise<void>;
 }
+export {};

package/dist/src/client.js

@@ -4,93 +4,136 @@ exports.BlueyeClient = exports.isInProtocol = void 0;
 const protocol_definitions_1 = require("@blueyerobotics/protocol-definitions");
 const buffer_1 = require("buffer");
 const consola_1 = require("consola");
+const jszmq_1 = require("jszmq");
 const strict_event_emitter_1 = require("strict-event-emitter");
-const uuid_1 = require("uuid");
 const schema_1 = require("./schema");
-const WS_PUBSUB_URL = "ws://192.168.1.101:8765";
-const WS_REQREP_URL = "ws://192.168.1.101:8766";
+const DEFAULT_SUB_URL = "ws://192.168.1.101:9985";
+const DEFAULT_RPC_URL = "ws://192.168.1.101:9986";
+const DEFAULT_PUB_URL = "ws://192.168.1.101:9987";
 const isInProtocol = (key) => {
     return key in protocol_definitions_1.blueye.protocol;
 };
 exports.isInProtocol = isInProtocol;
-class BlueyeClient {
+class BlueyeClient extends strict_event_emitter_1.Emitter {
+    state = "disconnected";
     timeout;
-    wsPubSub;
-    wsReqRep;
-    isReqRepConnected = false;
+    subUrl;
+    rpcUrl;
+    pubUrl;
+    sub;
+    rpc;
+    pub;
     logger;
-    pendingRequests = new Map();
-    sub = new strict_event_emitter_1.Emitter();
-    constructor(timeout = 2000, logLevel = consola_1.LogLevels.info) {
+    constructor({ subUrl = DEFAULT_SUB_URL, rpcUrl = DEFAULT_RPC_URL, pubUrl = DEFAULT_PUB_URL, timeout = 2000, logLevel = consola_1.LogLevels.info, autoConnect = false } = {}) {
+        super();
         this.timeout = timeout;
         this.logger = (0, consola_1.createConsola)({ level: logLevel, formatOptions: { colors: true, compact: false } });
-        this.wsPubSub = new WebSocket(WS_PUBSUB_URL);
-        this.wsReqRep = new WebSocket(WS_REQREP_URL);
-        this.wsPubSub.addEventListener("open", () => {
-            this.logger.info("[WS] PubSub connected");
-        });
-        this.wsReqRep.addEventListener("open", () => {
-            this.isReqRepConnected = true;
-            this.logger.info("[WS] ReqRep connected");
-        });
-        this.wsPubSub.addEventListener("message", event => {
-            const { key, data } = schema_1.responseSchema.parse(JSON.parse(event.data));
+        this.subUrl = subUrl;
+        this.rpcUrl = rpcUrl;
+        this.pubUrl = pubUrl;
+        this.sub = new jszmq_1.Sub();
+        this.rpc = new jszmq_1.Req();
+        this.pub = new jszmq_1.Pub();
+        // @ts-ignore
+        this.sub.on("message", (topic, msg) => {
+            const { key, data } = schema_1.responseSchema.parse({ key: topic, data: msg });
+            if (!(0, exports.isInProtocol)(key) || !key.endsWith("Tel")) {
+                this.logger.warn("[sub] unknown protocol:", key);
+                return;
+            }
             const protocol = protocol_definitions_1.blueye.protocol[key];
             const message = protocol.decode(data);
-            this.logger.verbose("[WS] PubSub message:", key, message);
-            this.sub.emit(key, message);
-        });
-        this.wsReqRep.addEventListener("message", event => {
-            this.logger.debug("Response:", event.data);
-            const { id, key, data } = schema_1.responseSchema.parse(JSON.parse(event.data));
-            if (!id)
-                throw new Error("Response id is missing");
-            this.pendingRequests.get(id)?.({ key, data });
+            this.logger.verbose("[sub] message:", key, message);
+            this.emit(key, message);
         });
+        if (autoConnect) {
+            this.connect();
+        }
+    }
+    updateState(newState) {
+        this.state = newState;
+        this.logger.info(`[client] ${newState}`);
+        this.emit(newState);
+    }
+    connect() {
+        if (this.state === "connected") {
+            this.logger.warn("[client] already connected");
+            return;
+        }
+        if (this.state === "connecting") {
+            this.logger.warn("[client] already connecting");
+            return;
+        }
+        this.updateState("connecting");
+        this.sub.subscribe("");
+        this.sub.connect(this.subUrl);
+        this.rpc.connect(this.rpcUrl);
+        this.pub.connect(this.pubUrl);
+        this.updateState("connected");
+    }
+    disconnect() {
+        if (this.state === "disconnected") {
+            this.logger.warn("[client] already disconnected");
+            return;
+        }
+        if (this.state === "connecting") {
+            this.logger.warn("[client] cannot disconnect while connecting");
+            return;
+        }
+        this.sub.unsubscribe("");
+        this.sub.disconnect(this.subUrl);
+        this.rpc.disconnect(this.rpcUrl);
+        this.pub.disconnect(this.pubUrl);
+        this.updateState("disconnected");
     }
     async sendRequest(req, opts = {}) {
+        if (!(0, exports.isInProtocol)(req) || !req.endsWith("Req")) {
+            throw new Error(`[rpc] unknown protocol: ${req}`);
+        }
         const protocol = protocol_definitions_1.blueye.protocol[req];
         const message = protocol.create(opts);
         const encoded = protocol.encode(message).finish();
-        while (!this.isReqRepConnected) {
-            this.logger.debug("Waiting...");
-            await new Promise(res => setTimeout(res, 50));
-        }
-        const id = (0, uuid_1.v4)();
         const { key, data } = await Promise.race([
-            new Promise((_, reject) => setTimeout(() => reject(new Error("Request timed out")), this.timeout)),
+            new Promise((_, reject) => setTimeout(() => reject(new Error("[rpc] request timed out")), this.timeout)),
             new Promise(resolve => {
-                const request = JSON.stringify({
-                    id,
-                    key: `blueye.protocol.${req}`,
-                    data: buffer_1.Buffer.from(encoded).toString("base64")
+                // @ts-ignore
+                this.rpc.once("message", (topic, msg) => {
+                    resolve({ key: topic.toString().split(".").at(-1), data: msg });
                 });
-                this.pendingRequests.set(id, resolve);
-                this.wsReqRep.send(request);
+                this.rpc.send([buffer_1.Buffer.from(`blueye.protocol.${req}`), buffer_1.Buffer.from(encoded)]);
             })
         ]);
-        this.pendingRequests.delete(id);
         if (key === "Empty") {
             return null;
         }
+        if (!(0, exports.isInProtocol)(key) || !key.endsWith("Rep")) {
+            throw new Error(`[rpc] unknown response protocol: ${key}`);
+        }
         const rep = protocol_definitions_1.blueye.protocol[key];
         const result = rep.decode(data);
-        this.logger.debug("Decoded:", result);
+        this.logger.debug("[rpc] decoded:", result);
         return result;
     }
     async getTelemetry(type) {
         const response = await this.sendRequest("GetTelemetryReq", { messageType: type });
         const { payload } = schema_1.telemetrySchema.parse(response);
         const { typeUrl, value } = payload;
-        this.logger.debug(typeUrl);
-        if ((0, exports.isInProtocol)(typeUrl)) {
-            const result = protocol_definitions_1.blueye.protocol[typeUrl].decode(value);
-            this.logger.debug("Result:", result);
-            return result;
+        if (!(0, exports.isInProtocol)(typeUrl) || !typeUrl.endsWith("Tel")) {
+            throw new Error(`[rpc] unknown telemetry typeUrl: ${typeUrl}`);
         }
-        else {
-            throw new Error("Unknown typeUrl");
+        const result = protocol_definitions_1.blueye.protocol[typeUrl].decode(value);
+        this.logger.debug("[rpc] result:", result);
+        return result;
+    }
+    async sendControl(ctrl, opts = {}) {
+        if (!(0, exports.isInProtocol)(ctrl) || !ctrl.endsWith("Ctrl")) {
+            throw new Error(`[pub] unknown protocol: ${ctrl}`);
         }
+        const protocol = protocol_definitions_1.blueye.protocol[ctrl];
+        const message = protocol.create(opts);
+        const encoded = protocol.encode(message).finish();
+        this.logger.debug("[pub] sending control:", ctrl, message);
+        this.pub.send([buffer_1.Buffer.from(`blueye.protocol.${ctrl}`), buffer_1.Buffer.from(encoded)]);
     }
 }
 exports.BlueyeClient = BlueyeClient;

package/dist/src/schema.d.ts

@@ -1,17 +1,14 @@
 import { Buffer } from "buffer";
 import z from "zod";
 export declare const responseSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    key: z.ZodEffects<z.ZodString, string, string>;
-    data: z.ZodEffects<z.ZodString, Buffer, string>;
+    key: z.ZodEffects<z.ZodType<Buffer, z.ZodTypeDef, Buffer>, string, Buffer>;
+    data: z.ZodType<Buffer, z.ZodTypeDef, Buffer>;
 }, "strip", z.ZodTypeAny, {
     key: string;
     data: Buffer;
-    id?: string | undefined;
 }, {
-    key: string;
-    data: string;
-    id?: string | undefined;
+    key: Buffer;
+    data: Buffer;
 }>;
 export declare const telemetrySchema: z.ZodObject<{
     payload: z.ZodObject<{

package/dist/src/schema.js

@@ -7,12 +7,8 @@ exports.telemetrySchema = exports.responseSchema = void 0;
 const buffer_1 = require("buffer");
 const zod_1 = __importDefault(require("zod"));
 exports.responseSchema = zod_1.default.object({
-    id: zod_1.default.string().uuid().optional(),
-    key: zod_1.default.string().transform(val => val.split(".").at(-1)),
-    data: zod_1.default
-        .string()
-        .base64()
-        .transform(val => buffer_1.Buffer.from(val, "base64"))
+    key: zod_1.default.instanceof(buffer_1.Buffer).transform(val => val.toString().split(".").at(-1)),
+    data: zod_1.default.instanceof(buffer_1.Buffer)
 });
 exports.telemetrySchema = zod_1.default.object({
     payload: zod_1.default.object({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blueyerobotics/blueye-ts",
-  "version": "1.5.0",
+  "version": "3.0.0",
   "description": "A TypeScript client for interacting with Blueye underwater drones.",
   "repository": {
     "type": "git",
@@ -22,8 +22,8 @@
     "@blueyerobotics/protocol-definitions": "3.2.0-0f78a956",
     "buffer": "^6.0.3",
     "consola": "^3.4.2",
+    "jszmq": "^0.1.2",
     "strict-event-emitter": "^0.5.1",
-    "uuid": "^11.1.0",
     "zod": "^3.25.67"
   },
   "devDependencies": {