nep-cli 0.1.5 → 0.1.7

package/bin/index.js

@@ -267,7 +267,7 @@ program
 
 program
   .command('ip')
-  .description('Display current Wi-Fi and Ethernet IP addresses')
+  .description('Display current Wi-Fi and Ethernet IP addresses of this computer')
   .action(() => {
     const interfaces = os.networkInterfaces();
 
@@ -324,7 +324,7 @@ program
 
 program
   .command('open [programName]')
-  .description('Open a program in Windows/macOS')
+  .description('Open a NEP+ GUI')
   .action(async (programName) => {
     const programs = ['cameras', 'hxri'];
 
@@ -364,54 +364,11 @@ program
     });
   });
 
-  program
-  .command('open [programName]')
-  .description('Open NEP+ GUI')
-  .action(async (programName) => {
-    const programs = ['cameras', 'hxri'];
-
-    // If a program name is provided as an argument, use it; otherwise, show autocomplete
-    if (!programName) {
-      const autoComplete = new AutoComplete({
-        name: 'program',
-        message: 'Select a program:',
-        choices: programs,
-      });
-      programName = await autoComplete.run();
-    } else if (!programs.includes(programName)) {
-      const autoComplete = new AutoComplete({
-        name: 'program',
-        message: 'Invalid program name. Select a valid program:',
-        choices: programs,
-      });
-      programName = await autoComplete.run();
-    }
-
-    // Get the username of the logged-in user
-    const username = os.userInfo().username;
-
-    // Specify the path to the executable
-    const appFolderName = 'nepplus' + "-" + programName;
-    const executableName = 'nepplus' + "-" + `${programName}.exe`;
-    const executablePath = `C:\\Users\\${username}\\AppData\\Local\\Programs\\${appFolderName}\\${executableName}`;
-
-    // Run the executable with proper escaping
-    exec(`"${executablePath}"`, (error, stdout, stderr) => {
-      if (error) {
-        console.error(`Error: ${error.message}`);
-        return;
-      }
-      console.log(`stdout: ${stdout}`);
-      console.error(`stderr: ${stderr}`);
-    });
-  });
-
-
 
 
 program
   .command('master')
-  .description('Start NEP master in Local host')
+  .description('Start NEP master in localhost')
   .action(async () => {
     try {
       var node = new nep.Node("nep-cli");
@@ -428,22 +385,40 @@ program
   });
 
 program
-  .command('master-ip <ip>' )
-  .description('Start NEP master in some specific IP')
-  .action(async (ip) => {
-
-    
-    console.log(`IP Address: ${ip}`);
-    var node = new nep.Node("nep-cli");
-    nep_configuration["IP"] = ip;
-    var master = new MasterLocal(IP = ip);
-    var info = new nep.MasterInfoServer(IP = ip, topics = topic_register);
+  .command('master-wifi')
+  .description('Start NEP master in Wi-Fi network')
+  .action(async () => {
 
-  });
+    const interfaces = os.networkInterfaces();
 
+    // Find Wi-Fi interface
+    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
+    if (wifiInterface) {
+      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
+      if (wifiIPv4) {
+        console.log(`Wi-Fi IP Address: ${wifiIPv4.address}`);
+        try {
+          var node = new nep.Node("nep-cli");
+          nep_configuration["IP"] = wifiIPv4.address;
+          var master = new MasterLocal(IP = wifiIPv4.address);
+          var info = new nep.MasterInfoServer(IP = wifiIPv4.address, topics = topic_register);
+        } catch (error) {
+          if (error.message.includes('EADDRINUSE')) {
+            console.error("Error: Address already in use. Another instance of NEP master might be running.");
+          } else {
+            console.error("An error occurred:", error.message);
+          }
+        }
 
+      } else {
+        console.log('No Wi-Fi IPv4 address found.');
+      }
+    } else {
+      console.log('Wi-Fi interface not found.');
+    }
+  });
 program
-  .command('eth')
+  .command('master-eth')
   .description('Start NEP master in Ethernet network')
   .action(async () => {
 
@@ -468,39 +443,20 @@ program
 
 
 program
-  .command('wifi')
-  .description('Start NEP master in Wi-Fi network')
-  .action(async () => {
+  .command('master-ip <ip>')
+  .description('Start NEP master in some specific IP')
+  .action(async (ip) => {
 
-    const interfaces = os.networkInterfaces();
 
-    // Find Wi-Fi interface
-    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
-    if (wifiInterface) {
-      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
-      if (wifiIPv4) {
-        console.log(`Wi-Fi IP Address: ${wifiIPv4.address}`);
-        try {
-          var node = new nep.Node("nep-cli");
-          nep_configuration["IP"] = wifiIPv4.address;
-          var master = new MasterLocal(IP = wifiIPv4.address);
-          var info = new nep.MasterInfoServer(IP = wifiIPv4.address, topics = topic_register);
-        } catch (error) {
-          if (error.message.includes('EADDRINUSE')) {
-            console.error("Error: Address already in use. Another instance of NEP master might be running.");
-          } else {
-            console.error("An error occurred:", error.message);
-          }
-        }
+    console.log(`IP Address: ${ip}`);
+    var node = new nep.Node("nep-cli");
+    nep_configuration["IP"] = ip;
+    var master = new MasterLocal(IP = ip);
+    var info = new nep.MasterInfoServer(IP = ip, topics = topic_register);
 
-      } else {
-        console.log('No Wi-Fi IPv4 address found.');
-      }
-    } else {
-      console.log('Wi-Fi interface not found.');
-    }
   });
 
+
 program
   .command('topics')
   .description('Get list of NEP+ topics')
@@ -555,7 +511,7 @@ program
   });
 
 program
-  .command('eth-topics')
+  .command('topics-eth')
   .description('Get list of NEP+ topics over Ethernet')
   .action(async () => {
     const interfaces = os.networkInterfaces();
@@ -578,7 +534,7 @@ program
 
 
 program
-  .command('wifi-topics')
+  .command('topics-wifi')
   .description('Get list of NEP+ topics over Wi-Fi')
   .action(async () => {
     const interfaces = os.networkInterfaces();
@@ -607,32 +563,374 @@ program
               resolve(results);
             });
 
-            const timeoutPromise = new Promise((resolve, reject) => {
-              setTimeout(() => {
-                reject(new Error("Timed out, NEP master over Wi-Fi was not found"));
-              }, TIMEOUT_DURATION);
-            });
+            const timeoutPromise = new Promise((resolve, reject) => {
+              setTimeout(() => {
+                reject(new Error("Timed out, NEP master over Wi-Fi was not found"));
+              }, TIMEOUT_DURATION);
+            });
+
+            const results = await Promise.race([responsePromise, timeoutPromise]);
+
+            if (results["state"] === "success") {
+              availableTopics = results["input"]; // Store the topics here
+              console.log("");
+              results["input"].forEach(element => {
+                console.log(element);
+              });
+            } else {
+              console.log("No topics yet");
+            }
+          } catch (error) {
+            console.error("Error:", error.message);
+          } finally {
+            process.exit();
+          }
+        }
+
+        await getTopics();
+
+      } else {
+        console.log('No Wi-Fi IPv4 address found.');
+      }
+    } else {
+      console.log('Wi-Fi interface not found.');
+    }
+  });
+
+
+program
+  .command('listen <topic>')
+  .description('Subscribe to a NEP+ topic and display JSON messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "json", callback, conf);
+    };
+
+    var master_ip = "127.0.0.1";
+    async function run() {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
+        }
+      }
+    }
+
+    run();
+  });
+
+program
+  .command('listen-eth <topic>')
+  .description('Subscribe to a NEP+ topic over Ethernet and display JSON messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "json", callback, conf);
+    };
+
+    async function run(master_ip) {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
+        }
+      }
+    }
+
+    // Find Ethernet interface
+    const ethernetInterface = interfaces['Ethernet'] || interfaces['Ethernet 2'] || interfaces['eth0'] || interfaces['イーサネット'] || interfaces['enp0s10'];
+    if (ethernetInterface) {
+      const ethernetIPv4 = ethernetInterface.find(iface => iface.family === 'IPv4');
+      if (ethernetIPv4) {
+        console.log(`Ethernet IP Address: ${ethernetIPv4.address}`);
+        run(ethernetIPv4.address)
+      } else {
+        console.log('No Ethernet IPv4 address found.');
+      }
+    } else {
+      console.log('Ethernet interface not found.');
+    }
+  });
+
+program
+  .command('listen-wifi <topic>')
+  .description('Subscribe to a NEP+ topic over Wi-Fi and display JSON messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "json", callback, conf);
+    };
+
+    async function run(master_ip) {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
+        }
+      }
+    }
+
+    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
+    if (wifiInterface) {
+      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
+      if (wifiIPv4) {
+        run(wifiIPv4.address);
+      } else {
+        console.log('No Wi-Fi IPv4 address found.');
+      }
+    } else {
+      console.log('Wi-Fi interface not found.');
+    }
+  });
+
+
+program
+  .command('echo <topic>')
+  .description('Subscribe to a NEP+ topic and display raw string messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "string", callback, conf);
+    };
+
+    var master_ip = "127.0.0.1";
+    async function run() {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
+        }
+      }
+    }
+
+    run();
+  });
+
+program
+  .command('echo-eth <topic>')
+  .description('Subscribe to a NEP+ topic over Ethernet and display raw string messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "string", callback, conf);
+    };
+
+    async function run(master_ip) {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
+        }
+      }
+    }
+
+    // Find Ethernet interface
+    const ethernetInterface = interfaces['Ethernet'] || interfaces['Ethernet 2'] || interfaces['eth0'] || interfaces['イーサネット'] || interfaces['enp0s10'];
+    if (ethernetInterface) {
+      const ethernetIPv4 = ethernetInterface.find(iface => iface.family === 'IPv4');
+      if (ethernetIPv4) {
+        console.log(`Ethernet IP Address: ${ethernetIPv4.address}`);
+        run(ethernetIPv4.address)
+      } else {
+        console.log('No Ethernet IPv4 address found.');
+      }
+    } else {
+      console.log('Ethernet interface not found.');
+    }
+  });
+
+program
+  .command('echo-wifi <topic>')
+  .description('Subscribe to a NEP+ topic over Wi-Fi and display raw string messages')
+  .action(async (topic) => {
+    const interfaces = os.networkInterfaces();
+
+    var opensub = function (master_ip = "127.0.0.1") {
+      var callback = function (msg) {
+        var date = new Date();
+        var dateString = date.toISOString();
+        console.log(dateString);
+
+        if (msg.length > 10000) {
+          console.log("the message is too long to be displayed");
+        } else {
+          console.log(msg);
+        }
+      };
+
+      var node = new nep.Node("nep-cli-sub");
+      var conf = node.hybrid(master_ip);
+      sub = node.new_sub(topic, "string", callback, conf);
+    };
+
+    async function run(master_ip) {
+      var requester = new zmq.Request();
+      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
 
-            const results = await Promise.race([responsePromise, timeoutPromise]);
+      let msg = { "input": "topics" };
+      var message = JSON.stringify(msg);
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
 
-            if (results["state"] === "success") {
-              availableTopics = results["input"]; // Store the topics here
-              console.log("");
-              results["input"].forEach(element => {
-                console.log(element);
-              });
-            } else {
-              console.log("No topics yet");
-            }
-          } catch (error) {
-            console.error("Error:", error.message);
-          } finally {
-            process.exit();
-          }
+      if (results["state"] === "failure") {
+        console.log("Topic is not registered");
+      } else {
+        console.log("");
+        if (results["input"].includes(topic)) {
+          opensub(master_ip);
+        } else {
+          console.log("Topic is not registered");
         }
+      }
+    }
 
-        await getTopics();
-
+    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
+    if (wifiInterface) {
+      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
+      if (wifiIPv4) {
+        run(wifiIPv4.address);
       } else {
         console.log('No Wi-Fi IPv4 address found.');
       }
@@ -641,7 +939,6 @@ program
     }
   });
 
-
 program
   .command('publish <topic> <message>')
   .description('Publish a message to a NEP+ topic')
@@ -688,11 +985,9 @@ program
     run()
   });
 
-
-
 program
-  .command('eth-publish <topic> <message>')
-  .description('Publish a message to a NEP+ topic over Ethernet')
+  .command('publish-eth <topic> <message>')
+  .description('Publish a JSON message to a NEP+ topic over Ethernet')
   .action((topic, message) => {
 
     const interfaces = os.networkInterfaces();
@@ -756,8 +1051,8 @@ program
   });
 
 program
-  .command('wifi-publish <topic> <message>')
-  .description('Publish a message to a NEP+ topic over Wi-Fi')
+  .command('publish-wifi <topic> <message>')
+  .description('Publish a JSON message to a NEP+ topic over Wi-Fi')
   .action((topic, message) => {
 
     const interfaces = os.networkInterfaces();
@@ -821,48 +1116,95 @@ program
 
 
 program
-  .command('listen <topic>')
-  .description('Subscribe to a NEP+ topic')
+  .command('hz <topic>')
+  .description('Monitor the publishing rate of a NEP+ topic in localhost')
   .action(async (topic) => {
     const interfaces = os.networkInterfaces();
+    const master_ip = "127.0.0.1"; // Change to the appropriate master IP
 
-    var opensub = function (master_ip = "127.0.0.1") {
-      var callback = function (msg) {
-        var date = new Date();
-        var dateString = date.toISOString();
-        console.log(dateString);
+    const opensub = function () {
+      const timestamps = []; // To store message timestamps
 
-        if (msg.length > 10000) {
-          console.log("the message is too long to be displayed");
-        } else {
-          console.log(msg);
+      const callback = function (msg) {
+        const date = new Date();
+        const timestamp = date.getTime();
+
+        timestamps.push(timestamp);
+
+        // Remove timestamps older than ten seconds
+        const tenSecondsAgo = timestamp - 10000;
+        while (timestamps[0] < tenSecondsAgo) {
+          timestamps.shift();
         }
       };
 
-      var node = new nep.Node("nep-cli-sub");
-      var conf = node.hybrid(master_ip);
-      sub = node.new_sub(topic, "json", callback, conf);
+      const messageFormat = topic.endsWith("/image") ? "string" : "string";
+      const node = new nep.Node("nep-cli-sub");
+      const conf = node.hybrid(master_ip);
+      const sub = node.new_sub(topic, messageFormat, callback, conf);
+
+      setInterval(() => {
+        // Calculate statistics for the last 10 seconds
+        const now = Date.now();
+        const tenSecondsAgo = now - 10000;
+        const recentTimestamps = timestamps.filter((ts) => ts > tenSecondsAgo);
+        const rate = recentTimestamps.length / 10; // Messages per second for a 10-second window
+
+        console.log("Average rate:", rate.toFixed(2), "Hz");
+        console.log("Min:", (10 / Math.max(rate, 0.1)).toFixed(2), "s");
+        console.log("Max:", (10 / Math.min(rate, 10)).toFixed(2), "s");
+        console.log("Std dev:", calculateStdDev(recentTimestamps, now).toFixed(2), "s");
+        console.log("Window:", recentTimestamps.length);
+        console.log("");
+      }, 1000);
     };
 
-    var master_ip = "127.0.0.1";
+    const calculateStdDev = (timestamps) => {
+      if (timestamps.length < 2) {
+        return 0; // Standard deviation is not meaningful with less than two timestamps
+      }
+
+      // Calculate the time intervals between consecutive timestamps
+      const timeIntervals = [];
+      for (let i = 1; i < timestamps.length; i++) {
+        const interval = timestamps[i] - timestamps[i - 1];
+        timeIntervals.push(interval);
+      }
+
+      // Calculate the mean (average) of the time intervals
+      const mean = timeIntervals.reduce((acc, val) => acc + val, 0) / timeIntervals.length;
+
+      // Calculate the squared differences from the mean
+      const squaredDifferences = timeIntervals.map((interval) => Math.pow(interval - mean, 2));
+
+      // Calculate the mean of the squared differences
+      const meanSquaredDifference = squaredDifferences.reduce((acc, val) => acc + val, 0) / squaredDifferences.length;
+
+      // Calculate the square root of the mean squared difference
+      const stdDeviation = Math.sqrt(meanSquaredDifference);
+
+      return stdDeviation;
+    };
+
+
     async function run() {
-      var requester = new zmq.Request();
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+      const requester = new zmq.Request();
+      requester.connect(`tcp://${master_ip}:${PORT_MASTER_INFO}`);
 
-      let msg = { "input": "topics" };
-      var message = JSON.stringify(msg);
+      const msg = { "input": "topics" };
+      const message = JSON.stringify(msg);
       await requester.send(message);
       const [result] = await requester.receive();
-      var results = JSON.parse(result.toString());
+      const results = JSON.parse(result.toString());
 
       if (results["state"] === "failure") {
-        console.log("Topic is not registered");
+        console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
       } else {
         console.log("");
         if (results["input"].includes(topic)) {
-          opensub(master_ip);
+          opensub();
         } else {
-          console.log("Topic is not registered");
+          console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
         }
       }
     }
@@ -870,126 +1212,224 @@ program
     run();
   });
 
+
 program
-  .command('eth-listen <topic>')
-  .description('Subscribe to a NEP+ topic over Ethernet')
+  .command('hz-wifi <topic>')
+  .description('Monitor the publishing rate of a NEP+ topic over Wi-Fi')
   .action(async (topic) => {
     const interfaces = os.networkInterfaces();
 
-    var opensub = function (master_ip = "127.0.0.1") {
-      var callback = function (msg) {
-        var date = new Date();
-        var dateString = date.toISOString();
-        console.log(dateString);
 
-        if (msg.length > 10000) {
-          console.log("the message is too long to be displayed");
-        } else {
-          console.log(msg);
+    const opensub = function (master_ip) {
+      const timestamps = []; // To store message timestamps
+
+      const callback = function (msg) {
+        const date = new Date();
+        const timestamp = date.getTime();
+
+        timestamps.push(timestamp);
+
+        // Remove timestamps older than ten seconds
+        const tenSecondsAgo = timestamp - 10000;
+        while (timestamps[0] < tenSecondsAgo) {
+          timestamps.shift();
         }
       };
 
-      var node = new nep.Node("nep-cli-sub");
-      var conf = node.hybrid(master_ip);
-      sub = node.new_sub(topic, "json", callback, conf);
+      const messageFormat = topic.endsWith("/image") ? "string" : "string";
+      const node = new nep.Node("nep-cli-sub");
+      const conf = node.hybrid(master_ip);
+      const sub = node.new_sub(topic, messageFormat, callback, conf);
+
+      setInterval(() => {
+        // Calculate statistics for the last 10 seconds
+        const now = Date.now();
+        const tenSecondsAgo = now - 10000;
+        const recentTimestamps = timestamps.filter((ts) => ts > tenSecondsAgo);
+        const rate = recentTimestamps.length / 10; // Messages per second for a 10-second window
+
+        console.log("Average rate:", rate.toFixed(2), "Hz");
+        console.log("Min:", (10 / Math.max(rate, 0.1)).toFixed(2), "s");
+        console.log("Max:", (10 / Math.min(rate, 10)).toFixed(2), "s");
+        console.log("Std dev:", calculateStdDev(recentTimestamps, now).toFixed(2), "s");
+        console.log("Window:", recentTimestamps.length);
+        console.log("");
+      }, 1000);
+    };
+
+    const calculateStdDev = (timestamps) => {
+      if (timestamps.length < 2) {
+        return 0; // Standard deviation is not meaningful with less than two timestamps
+      }
+
+      // Calculate the time intervals between consecutive timestamps
+      const timeIntervals = [];
+      for (let i = 1; i < timestamps.length; i++) {
+        const interval = timestamps[i] - timestamps[i - 1];
+        timeIntervals.push(interval);
+      }
+
+      // Calculate the mean (average) of the time intervals
+      const mean = timeIntervals.reduce((acc, val) => acc + val, 0) / timeIntervals.length;
+
+      // Calculate the squared differences from the mean
+      const squaredDifferences = timeIntervals.map((interval) => Math.pow(interval - mean, 2));
+
+      // Calculate the mean of the squared differences
+      const meanSquaredDifference = squaredDifferences.reduce((acc, val) => acc + val, 0) / squaredDifferences.length;
+
+      // Calculate the square root of the mean squared difference
+      const stdDeviation = Math.sqrt(meanSquaredDifference);
+
+      return stdDeviation;
     };
 
+
     async function run(master_ip) {
-      var requester = new zmq.Request();
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+      const requester = new zmq.Request();
+      requester.connect(`tcp://${master_ip}:${PORT_MASTER_INFO}`);
 
-      let msg = { "input": "topics" };
-      var message = JSON.stringify(msg);
+      const msg = { "input": "topics" };
+      const message = JSON.stringify(msg);
       await requester.send(message);
       const [result] = await requester.receive();
-      var results = JSON.parse(result.toString());
+      const results = JSON.parse(result.toString());
 
       if (results["state"] === "failure") {
-        console.log("Topic is not registered");
+        console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
       } else {
         console.log("");
         if (results["input"].includes(topic)) {
           opensub(master_ip);
         } else {
-          console.log("Topic is not registered");
+          console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
         }
       }
     }
 
-    // Find Ethernet interface
-    const ethernetInterface = interfaces['Ethernet'] || interfaces['Ethernet 2'] || interfaces['eth0'] || interfaces['イーサネット'] || interfaces['enp0s10'];
-    if (ethernetInterface) {
-      const ethernetIPv4 = ethernetInterface.find(iface => iface.family === 'IPv4');
-      if (ethernetIPv4) {
-        console.log(`Ethernet IP Address: ${ethernetIPv4.address}`);
-        run(ethernetIPv4.address)
+    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
+    if (wifiInterface) {
+      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
+      if (wifiIPv4) {
+        console.log(`Wi-Fi IP Address: ${wifiIPv4.address}`);
+        run(wifiIPv4.address)
       } else {
-        console.log('No Ethernet IPv4 address found.');
+        console.log('No Wi-Fi IPv4 address found.');
       }
     } else {
-      console.log('Ethernet interface not found.');
+      console.log('Wi-Fi interface not found.');
     }
   });
 
 program
-  .command('wifi-listen <topic>')
-  .description('Subscribe to a NEP+ topic over Wi-Fi')
+  .command('hz-eth <topic>')
+  .description('Monitor the publishing rate of a NEP+ topic over Ethernet')
   .action(async (topic) => {
     const interfaces = os.networkInterfaces();
 
-    var opensub = function (master_ip = "127.0.0.1") {
-      var callback = function (msg) {
-        var date = new Date();
-        var dateString = date.toISOString();
-        console.log(dateString);
 
-        if (msg.length > 10000) {
-          console.log("the message is too long to be displayed");
-        } else {
-          console.log(msg);
+    const opensub = function (master_ip) {
+      const timestamps = []; // To store message timestamps
+
+      const callback = function (msg) {
+        const date = new Date();
+        const timestamp = date.getTime();
+
+        timestamps.push(timestamp);
+
+        // Remove timestamps older than ten seconds
+        const tenSecondsAgo = timestamp - 10000;
+        while (timestamps[0] < tenSecondsAgo) {
+          timestamps.shift();
         }
       };
 
-      var node = new nep.Node("nep-cli-sub");
-      var conf = node.hybrid(master_ip);
-      sub = node.new_sub(topic, "json", callback, conf);
+      const messageFormat = topic.endsWith("/image") ? "string" : "string";
+      const node = new nep.Node("nep-cli-sub");
+      const conf = node.hybrid(master_ip);
+      const sub = node.new_sub(topic, messageFormat, callback, conf);
+
+      setInterval(() => {
+        // Calculate statistics for the last 10 seconds
+        const now = Date.now();
+        const tenSecondsAgo = now - 10000;
+        const recentTimestamps = timestamps.filter((ts) => ts > tenSecondsAgo);
+        const rate = recentTimestamps.length / 10; // Messages per second for a 10-second window
+
+        console.log("Average rate:", rate.toFixed(2), "Hz");
+        console.log("Min:", (10 / Math.max(rate, 0.1)).toFixed(2), "s");
+        console.log("Max:", (10 / Math.min(rate, 10)).toFixed(2), "s");
+        console.log("Std dev:", calculateStdDev(recentTimestamps, now).toFixed(2), "s");
+        console.log("Window:", recentTimestamps.length);
+        console.log("");
+      }, 1000);
+    };
+
+    const calculateStdDev = (timestamps) => {
+      if (timestamps.length < 2) {
+        return 0; // Standard deviation is not meaningful with less than two timestamps
+      }
+
+      // Calculate the time intervals between consecutive timestamps
+      const timeIntervals = [];
+      for (let i = 1; i < timestamps.length; i++) {
+        const interval = timestamps[i] - timestamps[i - 1];
+        timeIntervals.push(interval);
+      }
+
+      // Calculate the mean (average) of the time intervals
+      const mean = timeIntervals.reduce((acc, val) => acc + val, 0) / timeIntervals.length;
+
+      // Calculate the squared differences from the mean
+      const squaredDifferences = timeIntervals.map((interval) => Math.pow(interval - mean, 2));
+
+      // Calculate the mean of the squared differences
+      const meanSquaredDifference = squaredDifferences.reduce((acc, val) => acc + val, 0) / squaredDifferences.length;
+
+      // Calculate the square root of the mean squared difference
+      const stdDeviation = Math.sqrt(meanSquaredDifference);
+
+      return stdDeviation;
     };
 
+
     async function run(master_ip) {
-      var requester = new zmq.Request();
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
+      const requester = new zmq.Request();
+      requester.connect(`tcp://${master_ip}:${PORT_MASTER_INFO}`);
 
-      let msg = { "input": "topics" };
-      var message = JSON.stringify(msg);
+      const msg = { "input": "topics" };
+      const message = JSON.stringify(msg);
       await requester.send(message);
       const [result] = await requester.receive();
-      var results = JSON.parse(result.toString());
+      const results = JSON.parse(result.toString());
 
       if (results["state"] === "failure") {
-        console.log("Topic is not registered");
+        console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
       } else {
         console.log("");
         if (results["input"].includes(topic)) {
           opensub(master_ip);
         } else {
-          console.log("Topic is not registered");
+          console.log("Topic is not registered, use *nep topics* to see the list of avaliable topics");
         }
       }
     }
 
-    const wifiInterface = interfaces['Wi-Fi'] || interfaces['Wi-Fi 2'] || interfaces['wlan0'] || interfaces['wlo1'];
-    if (wifiInterface) {
-      const wifiIPv4 = wifiInterface.find(iface => iface.family === 'IPv4');
-      if (wifiIPv4) {
-        run(wifiIPv4.address);
+    const ethernetInterface = interfaces['Ethernet'] || interfaces['Ethernet 2'] || interfaces['eth0'] || interfaces['イーサネット'] || interfaces['enp0s10'];
+    if (ethernetInterface) {
+      const ethernetIPv4 = ethernetInterface.find(iface => iface.family === 'IPv4');
+      if (ethernetIPv4) {
+        console.log(`Ethernet IP Address: ${ethernetIPv4.address}`);
+        run(ethernetIPv4.address)
       } else {
-        console.log('No Wi-Fi IPv4 address found.');
+        console.log('No Ethernet IPv4 address found.');
       }
     } else {
-      console.log('Wi-Fi interface not found.');
+      console.log('Ethernet interface not found.');
     }
   });
 
+
 program
   .command('docs')
   .description('Open the NEP+ documentation in the default browser')
@@ -1012,6 +1452,14 @@ function timeoutPromise(ms) {
   });
 }
 
+function timeoutPromise(ms) {
+  return new Promise((resolve, reject) => {
+    setTimeout(() => {
+      reject(new Error("Request timed out"));
+    }, ms);
+  });
+}
+
 async function getAndDisplayTopics(master_ip) {
   const TIMEOUT_DURATION = 5000;
 
@@ -1031,7 +1479,7 @@ async function getAndDisplayTopics(master_ip) {
 
     const timeoutPromise = new Promise((resolve, reject) => {
       setTimeout(() => {
-        reject(new Error("Timed out, NEP master over Ethernet was not found"));
+        reject(new Error("Timed out, NEP master over Wi-Fi was not found"));
       }, TIMEOUT_DURATION);
     });
 
@@ -1053,84 +1501,51 @@ async function getAndDisplayTopics(master_ip) {
   }
 }
 
-program
-  .command('image <topic>')
-  .description('Start image server')
-  .action((topic, options) => {
-    async function run() {
-      var requester = new zmq.Request;
-      var master_ip = "127.0.0.1"
-      var port = PORT_IMAGE
 
-     
 
-      requester.connect("tcp://" + master_ip + ":" + PORT_MASTER_INFO);
-
-      let msg = { "input": "topics" }
-      var message = JSON.stringify(msg);
-      await requester.send(message)
-      const [result] = await requester.receive()
-      var results = JSON.parse(result.toString())
-      //console.log(results);
-    
-    
-        const programs = results["input"];
-        const filteredList = programs.filter(value => value.includes("image"));
-
-        if (!topic) {
-          const autoComplete = new AutoComplete({
-            name: 'program',
-            message: 'Select a program:',
-            choices: filteredList,
-          });
-          topic = await autoComplete.run();
-        } else if (!filteredList.includes(topic)) {
-          const autoComplete = new AutoComplete({
-            name: 'program',
-            message: 'Invalid program name. Select a valid program:',
-            choices: filteredList,
-          });
-          topic = await autoComplete.run();
-        }
-        
-        
-        startServer(port, topic);
-        open(`http://localhost:${port}`);
-    
-    }
-    run()
-   
-  });
 
- // Function to start the server
-function startServer(port, topic) {
-  const app = express();
-  const server = http.createServer(app);
-  const io = socketIo(server);
+async function getAndDisplayTopics(master_ip) {
+  const TIMEOUT_DURATION = 5000;
 
-  var node = new nep.Node("nep-cli");
+  var requester = new zmq.Request();
+  requester.connect(`tcp://${master_ip}:${PORT_MASTER_INFO}`);
 
-  function getImage(msg) {
-    // Send the received image data as-is to connected clients
-    io.sockets.emit('image', { image: msg });
-  }
+  let msg = { "input": "topics" };
+  var message = JSON.stringify(msg);
 
-  var sub = node.new_sub(topic, "image", getImage);
+  try {
+    const responsePromise = new Promise(async (resolve, reject) => {
+      await requester.send(message);
+      const [result] = await requester.receive();
+      var results = JSON.parse(result.toString());
+      resolve(results);
+    });
 
-  app.get('/', (req, res) => {
-    res.sendFile(__dirname + '/image.html'); // Serve your HTML file
-  });
+    const timeoutPromise = new Promise((resolve, reject) => {
+      setTimeout(() => {
+        reject(new Error("Timed out, NEP master over Ethernet was not found"));
+      }, TIMEOUT_DURATION);
+    });
 
-  server.listen(port, () => {
-    console.log(`Server is running on http://localhost:${port}`);
-  });
+    const results = await Promise.race([responsePromise, timeoutPromise]);
 
-  io.on('connection', (socket) => {
-    const frameRate = 30; // Desired frame rate
-    const interval = 1000 / frameRate; // Interval between frames
-  });
+    if (results["state"] === "success") {
+      availableTopics = results["input"];
+      console.log("");
+      results["input"].forEach(element => {
+        console.log(element);
+      });
+    } else {
+      console.log("No topics yet");
+    }
+  } catch (error) {
+    console.error("Error:", error.message);
+  } finally {
+    process.exit();
+  }
 }
 
+
 program.parse(process.argv);