@em-foundation/emscope 25.4.0 → 25.5.3

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## VERSION-25.5.0
+
+* support for Otii-3 analyzer and battery emulator
+* new `emscope grab -O, --otii3` option
+* new `emscope grab -B, --battery-profile <index>` option
+* new `emscope --soc <percent>` option
+
+## VERSION-25-4.1
+
+* more robust port enumeration fix for PPK
+
 ## VERSION-25-4.0
 
 * added `--json` option

package/README.md

@@ -1,15 +1,4 @@
 <p align="center">
-    <img src="docs/images/logo.png" alt="EM•Scope Logo" width="400">
-</p>
-<br>
-<p align="center">
-    <img src="docs/images/tagline.png" alt="EM•Scope TagLine" width="750">
-</p>
-
------
-
-The **EM&bull;Scope** tool streamlines the capture, analysis, display, and delivery of real-time power-consumption measurements &ndash; used to characterize the overall energy efficiency of resource-constrained embedded systems.&thinsp; To encourage benchmarks for different HW/SW configurations performing comparable tasks, **EM&bull;Scope** introduces a novel metric for quantifying energy efficiency &ndash; the **EM&bull;erald**.
- 
-<p align="right">
-  <a href="https://github.com/em-foundation/emscope/blob/docs-stable/docs/ReadMore.md">read more<b>&nbsp;&#x27a6;</b></a>
-</p>
+  <img src="https://raw.githubusercontent.com/em-foundation/emscope/main/docs/images/splash.png"
+       alt="EM•Scope" width="840">
+</p>

package/dist/emscope

@@ -32,6 +32,7 @@ var require_constants = __commonJS({
     "use strict";
     var WIN_SLASH = "\\\\/";
     var WIN_NO_SLASH = `[^${WIN_SLASH}]`;
+    var DEFAULT_MAX_EXTGLOB_RECURSION = 0;
     var DOT_LITERAL = "\\.";
     var PLUS_LITERAL = "\\+";
     var QMARK_LITERAL = "\\?";
@@ -82,6 +83,7 @@ var require_constants = __commonJS({
       SEP: "\\"
     };
     var POSIX_REGEX_SOURCE = {
+      __proto__: null,
       alnum: "a-zA-Z0-9",
       alpha: "a-zA-Z",
       ascii: "\\x00-\\x7F",
@@ -98,6 +100,7 @@ var require_constants = __commonJS({
       xdigit: "A-Fa-f0-9"
     };
     module2.exports = {
+      DEFAULT_MAX_EXTGLOB_RECURSION,
       MAX_LENGTH: 1024 * 64,
       POSIX_REGEX_SOURCE,
       // regular expressions
@@ -648,6 +651,213 @@ var require_parse = __commonJS({
     var syntaxError = (type2, char) => {
       return `Missing ${type2}: "${char}" - use "\\\\${char}" to match literal characters`;
     };
+    var splitTopLevel = (input) => {
+      const parts = [];
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let value = "";
+      let escaped = false;
+      for (const ch of input) {
+        if (escaped === true) {
+          value += ch;
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          value += ch;
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          value += ch;
+          continue;
+        }
+        if (quote === 0) {
+          if (ch === "[") {
+            bracket++;
+          } else if (ch === "]" && bracket > 0) {
+            bracket--;
+          } else if (bracket === 0) {
+            if (ch === "(") {
+              paren++;
+            } else if (ch === ")" && paren > 0) {
+              paren--;
+            } else if (ch === "|" && paren === 0) {
+              parts.push(value);
+              value = "";
+              continue;
+            }
+          }
+        }
+        value += ch;
+      }
+      parts.push(value);
+      return parts;
+    };
+    var isPlainBranch = (branch) => {
+      let escaped = false;
+      for (const ch of branch) {
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (/[?*+@!()[\]{}]/.test(ch)) {
+          return false;
+        }
+      }
+      return true;
+    };
+    var normalizeSimpleBranch = (branch) => {
+      let value = branch.trim();
+      let changed = true;
+      while (changed === true) {
+        changed = false;
+        if (/^@\([^\\()[\]{}|]+\)$/.test(value)) {
+          value = value.slice(2, -1);
+          changed = true;
+        }
+      }
+      if (!isPlainBranch(value)) {
+        return;
+      }
+      return value.replace(/\\(.)/g, "$1");
+    };
+    var hasRepeatedCharPrefixOverlap = (branches) => {
+      const values = branches.map(normalizeSimpleBranch).filter(Boolean);
+      for (let i = 0; i < values.length; i++) {
+        for (let j = i + 1; j < values.length; j++) {
+          const a = values[i];
+          const b = values[j];
+          const char = a[0];
+          if (!char || a !== char.repeat(a.length) || b !== char.repeat(b.length)) {
+            continue;
+          }
+          if (a === b || a.startsWith(b) || b.startsWith(a)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    };
+    var parseRepeatedExtglob = (pattern, requireEnd = true) => {
+      if (pattern[0] !== "+" && pattern[0] !== "*" || pattern[1] !== "(") {
+        return;
+      }
+      let bracket = 0;
+      let paren = 0;
+      let quote = 0;
+      let escaped = false;
+      for (let i = 1; i < pattern.length; i++) {
+        const ch = pattern[i];
+        if (escaped === true) {
+          escaped = false;
+          continue;
+        }
+        if (ch === "\\") {
+          escaped = true;
+          continue;
+        }
+        if (ch === '"') {
+          quote = quote === 1 ? 0 : 1;
+          continue;
+        }
+        if (quote === 1) {
+          continue;
+        }
+        if (ch === "[") {
+          bracket++;
+          continue;
+        }
+        if (ch === "]" && bracket > 0) {
+          bracket--;
+          continue;
+        }
+        if (bracket > 0) {
+          continue;
+        }
+        if (ch === "(") {
+          paren++;
+          continue;
+        }
+        if (ch === ")") {
+          paren--;
+          if (paren === 0) {
+            if (requireEnd === true && i !== pattern.length - 1) {
+              return;
+            }
+            return {
+              type: pattern[0],
+              body: pattern.slice(2, i),
+              end: i
+            };
+          }
+        }
+      }
+    };
+    var getStarExtglobSequenceOutput = (pattern) => {
+      let index = 0;
+      const chars = [];
+      while (index < pattern.length) {
+        const match = parseRepeatedExtglob(pattern.slice(index), false);
+        if (!match || match.type !== "*") {
+          return;
+        }
+        const branches = splitTopLevel(match.body).map((branch2) => branch2.trim());
+        if (branches.length !== 1) {
+          return;
+        }
+        const branch = normalizeSimpleBranch(branches[0]);
+        if (!branch || branch.length !== 1) {
+          return;
+        }
+        chars.push(branch);
+        index += match.end + 1;
+      }
+      if (chars.length < 1) {
+        return;
+      }
+      const source = chars.length === 1 ? utils.escapeRegex(chars[0]) : `[${chars.map((ch) => utils.escapeRegex(ch)).join("")}]`;
+      return `${source}*`;
+    };
+    var repeatedExtglobRecursion = (pattern) => {
+      let depth = 0;
+      let value = pattern.trim();
+      let match = parseRepeatedExtglob(value);
+      while (match) {
+        depth++;
+        value = match.body.trim();
+        match = parseRepeatedExtglob(value);
+      }
+      return depth;
+    };
+    var analyzeRepeatedExtglob = (body, options) => {
+      if (options.maxExtglobRecursion === false) {
+        return { risky: false };
+      }
+      const max = typeof options.maxExtglobRecursion === "number" ? options.maxExtglobRecursion : constants.DEFAULT_MAX_EXTGLOB_RECURSION;
+      const branches = splitTopLevel(body).map((branch) => branch.trim());
+      if (branches.length > 1) {
+        if (branches.some((branch) => branch === "") || branches.some((branch) => /^[*?]+$/.test(branch)) || hasRepeatedCharPrefixOverlap(branches)) {
+          return { risky: true };
+        }
+      }
+      for (const branch of branches) {
+        const safeOutput = getStarExtglobSequenceOutput(branch);
+        if (safeOutput) {
+          return { risky: true, safeOutput };
+        }
+        if (repeatedExtglobRecursion(branch) > max) {
+          return { risky: true };
+        }
+      }
+      return { risky: false };
+    };
     var parse = (input, options) => {
       if (typeof input !== "string") {
         throw new TypeError("Expected a string");
@@ -778,6 +988,8 @@ var require_parse = __commonJS({
         token.prev = prev;
         token.parens = state.parens;
         token.output = state.output;
+        token.startIndex = state.index;
+        token.tokensIndex = tokens.length;
         const output = (opts.capture ? "(" : "") + token.open;
         increment("parens");
         push({ type: type2, value: value2, output: state.output ? "" : ONE_CHAR });
@@ -785,6 +997,26 @@ var require_parse = __commonJS({
         extglobs.push(token);
       };
       const extglobClose = (token) => {
+        const literal = input.slice(token.startIndex, state.index + 1);
+        const body = input.slice(token.startIndex + 2, state.index);
+        const analysis = analyzeRepeatedExtglob(body, opts);
+        if ((token.type === "plus" || token.type === "star") && analysis.risky) {
+          const safeOutput = analysis.safeOutput ? (token.output ? "" : ONE_CHAR) + (opts.capture ? `(${analysis.safeOutput})` : analysis.safeOutput) : void 0;
+          const open = tokens[token.tokensIndex];
+          open.type = "text";
+          open.value = literal;
+          open.output = safeOutput || utils.escapeRegex(literal);
+          for (let i = token.tokensIndex + 1; i < tokens.length; i++) {
+            tokens[i].value = "";
+            tokens[i].output = "";
+            delete tokens[i].suffix;
+          }
+          state.output = token.output + open.output;
+          state.backtrack = true;
+          push({ type: "paren", extglob: true, value, output: "" });
+          decrement("parens");
+          return;
+        }
         let output = token.close + (opts.capture ? ")" : "");
         let rest;
         if (token.type === "negate") {
@@ -10550,6 +10782,18 @@ function charFromCodepoint(c) {
     (c - 65536 & 1023) + 56320
   );
 }
+function setProperty(object, key, value) {
+  if (key === "__proto__") {
+    Object.defineProperty(object, key, {
+      configurable: true,
+      enumerable: true,
+      writable: true,
+      value
+    });
+  } else {
+    object[key] = value;
+  }
+}
 var simpleEscapeCheck = new Array(256);
 var simpleEscapeMap = new Array(256);
 for (i = 0; i < 256; i++) {
@@ -10669,7 +10913,7 @@ function mergeMappings(state, destination, source, overridableKeys) {
   for (index = 0, quantity = sourceKeys.length; index < quantity; index += 1) {
     key = sourceKeys[index];
     if (!_hasOwnProperty$1.call(destination, key)) {
-      destination[key] = source[key];
+      setProperty(destination, key, source[key]);
       overridableKeys[key] = true;
     }
   }
@@ -10709,16 +10953,7 @@ function storeMappingPair(state, _result, overridableKeys, keyTag, keyNode, valu
       state.position = startPos || state.position;
       throwError(state, "duplicated mapping key");
     }
-    if (keyNode === "__proto__") {
-      Object.defineProperty(_result, keyNode, {
-        configurable: true,
-        enumerable: true,
-        writable: true,
-        value: valueNode
-      });
-    } else {
-      _result[keyNode] = valueNode;
-    }
+    setProperty(_result, keyNode, valueNode);
     delete overridableKeys[keyNode];
   }
   return _result;
@@ -12306,7 +12541,6 @@ var jsYaml = {
   safeLoadAll,
   safeDump
 };
-var js_yaml_default = jsYaml;
 
 // src/Core.ts
 var TAB = "    ";
@@ -12315,6 +12549,7 @@ var Capture = class _Capture {
   static #CFILE = "capture.yaml";
   static #SAMPLING_RATE = /* @__PURE__ */ new Map([
     ["JS220", 1e6],
+    ["Otii3", 5e4],
     ["PPK2", 1e5]
   ]);
   static #LOAD_KEYS = [
@@ -12342,7 +12577,7 @@ var Capture = class _Capture {
     cap._sampling_rate = _Capture.#SAMPLING_RATE.get(device) ?? 0;
     cap._sample_count = duration * cap.sampling_rate;
     cap._current_ds = new SampleSet(cap.sample_count);
-    cap._voltage_ds = new SampleSet(device == "JS220" ? cap.sample_count : 0);
+    cap._voltage_ds = new SampleSet(device == "PPK2" ? 0 : cap.sample_count);
     const wd = cap.#workdir;
     if (import_fs.default.existsSync(wd)) {
       import_fs.default.rmSync(wd, { recursive: true });
@@ -12355,7 +12590,7 @@ var Capture = class _Capture {
     cap._rootdir = rootdir;
     fail(`captured data not found locally, try running 'emscope pack -u'`, !import_fs.default.existsSync(_Capture.workdir(rootdir)));
     const ytxt = import_fs.default.readFileSync(cap.#cpath, "utf-8");
-    const yobj = js_yaml_default.load(ytxt);
+    const yobj = jsYaml.load(ytxt);
     for (const k of _Capture.#LOAD_KEYS) {
       cap[`_${k}`] = yobj.capture[k];
     }
@@ -12363,6 +12598,7 @@ var Capture = class _Capture {
     cap.current_ds.load(cap.#workdir, "current");
     switch (cap.device) {
       case "JS220":
+      case "Otii3":
         cap._voltage_ds = new SampleSet(cap.sample_count);
         cap.voltage_ds.load(cap.#workdir, "voltage");
         break;
@@ -12371,7 +12607,7 @@ var Capture = class _Capture {
         break;
     }
     if (import_fs.default.existsSync(cap.#apath)) {
-      cap._aobj = js_yaml_default.load(import_fs.default.readFileSync(cap.#apath, "utf-8"));
+      cap._aobj = jsYaml.load(import_fs.default.readFileSync(cap.#apath, "utf-8"));
     }
     return cap;
   }
@@ -12431,7 +12667,7 @@ var Capture = class _Capture {
   }
   bind(aobj) {
     this._aobj = aobj;
-    const ytxt = js_yaml_default.dump(aobj, { indent: 4, flowLevel: 4 });
+    const ytxt = jsYaml.dump(aobj, { indent: 4, flowLevel: 4 });
     import_fs.default.writeFileSync(this.#apath, ytxt);
     infoMsg(`wrote '${_Capture.#AFILE}'`);
   }
@@ -12452,7 +12688,7 @@ var Capture = class _Capture {
     this.voltage_ds.save(this.#workdir, "voltage");
     const cobj = Object.fromEntries(_Capture.#SAVE_KEYS.map((k) => [k, this[k]]));
     const yobj = { capture: cobj };
-    const ytxt = js_yaml_default.dump(yobj, { indent: 4, flowLevel: 4 });
+    const ytxt = jsYaml.dump(yobj, { indent: 4, flowLevel: 4 });
     import_fs.default.writeFileSync(this.#cpath, ytxt);
     infoMsg(`wrote '${_Capture.#CFILE}'`);
   }
@@ -12620,6 +12856,21 @@ function fail(msg, cond = true) {
     process.exit(1);
   }
 }
+function findConfig() {
+  let dir = process.cwd();
+  let fpath = "";
+  while (true) {
+    const full = import_path.default.join(dir, "emscope-local.json");
+    if (import_fs.default.existsSync(full)) {
+      fpath = full;
+      break;
+    }
+    const parent = import_path.default.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return fpath === "" ? void 0 : JSON.parse(import_fs.default.readFileSync(fpath, "utf-8"));
+}
 function infoMsg(msg) {
   console.log(`${TAB}${msg}`);
 }
@@ -12689,6 +12940,7 @@ ${dpath}:`);
 }
 
 // src/Detecter.ts
+var NO_CURRENT = 0;
 function exec(opts) {
   const cap = Capture.load(opts.capture);
   let params = {};
@@ -12787,6 +13039,7 @@ function measureSleep(osig) {
     const wsig = win.toSignal();
     const cur = wsig.avg();
     const m = win.toMarker();
+    if (cur < NO_CURRENT) continue;
     if (cur < min_cur) {
       min_cur = cur;
       std = wsig.std();
@@ -13100,6 +13353,379 @@ async function execCapture(opts) {
   });
 }
 
+// src/Driver_Otti3.ts
+var import_net = __toESM(require("net"));
+async function execCapture2(opts) {
+  const jobj = findConfig();
+  fail("can't find 'emscope-local.json'", jobj === void 0);
+  const config = jobj.otii3;
+  const cap = Capture.create(opts.capture, opts.duration, "Otii3");
+  const progress = new Progress("capturing: ");
+  const otii = new OtiiSession("127.0.0.1", 1905);
+  await otii.connect();
+  if (!await otii.isLoggedIn()) {
+    await otii.login(config.username, config.password);
+  }
+  for (const license of await otii.getLicenses()) {
+    await otii.reserveLicense(license.id);
+  }
+  const dev = await otii.requireDevice();
+  const projectId = await otii.getOrCreateProject();
+  await otii.addToProject(dev.device_id);
+  await otii.setMainVoltage(dev.device_id, opts.voltage);
+  await otii.setMaxCurrent(dev.device_id, 0.5);
+  await otii.enableChannel(dev.device_id, "mc", true);
+  await otii.enableChannel(dev.device_id, "mv", true);
+  const bp = opts.batteryProfile;
+  const soc = opts.soc ?? 100;
+  fail("missing battery profile index", bp !== void 0 && typeof bp != "number");
+  if (bp) {
+    await batteryConfig(otii, bp, soc, dev.device_id, config);
+  } else {
+    await otii.setSupplyPowerBox(dev.device_id);
+  }
+  await otii.setMain(dev.device_id, true);
+  await progress.spin(2500);
+  await record(otii, cap, progress, projectId, dev.device_id);
+  await otii.setSupplyPowerBox(dev.device_id);
+  await otii.close();
+  return cap;
+}
+async function batteryConfig(otii, bidx, soc, deviceId, config) {
+  const bname = config.batteries[bidx];
+  fail("invalid battery index", typeof bname != "string");
+  const profiles = await otii.getBatteryProfiles();
+  let bprof = profiles.find((p) => p.name === bname);
+  fail("no corresponding profile found", bprof === void 0);
+  await otii.setSupplyBatteryEmulator(deviceId, {
+    batteryProfileId: bprof.battery_profile_id,
+    soc
+  });
+}
+async function record(otii, cap, progress, projectId, deviceId) {
+  const t0 = Date.now();
+  const t1 = t0 + cap.duration * 1e3;
+  await otii.startRecording(projectId);
+  try {
+    while (true) {
+      const now = Date.now();
+      if (now >= t1) {
+        break;
+      }
+      progress.update(`${((now - t0) / 1e3).toFixed(3)} s`);
+      await new Promise((resolve) => setTimeout(resolve, 100));
+    }
+  } finally {
+    await otii.setMain(deviceId, false);
+    await otii.stopRecording(projectId);
+  }
+  const recordingId = await otii.getLastRecording(projectId);
+  const current = await otii.getAllChannelData(recordingId, deviceId, "mc");
+  for (const sample of current.values) {
+    cap.current_ds.add(sample);
+  }
+  const voltage = await otii.getAllChannelData(recordingId, deviceId, "mv");
+  for (const sample of voltage.values) {
+    cap.voltage_ds.add(sample);
+  }
+  await otii.deleteRecording(recordingId);
+  progress.clear();
+}
+var OtiiSession = class {
+  constructor(host = "127.0.0.1", port = 1905, debug = false) {
+    this.host = host;
+    this.port = port;
+    this.debug = debug;
+    this.socket = new import_net.default.Socket();
+    this.rx = "";
+    this.nextId = 1;
+    this.ready = false;
+    this.pending = /* @__PURE__ */ new Map();
+    this.socket.on("data", (chunk) => this.onData(chunk));
+    this.socket.on("error", (err) => this.onError(err));
+    this.socket.on("close", () => this.onClose());
+  }
+  async connect(timeoutMs = 5e3) {
+    if (this.ready) {
+      return;
+    }
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        cleanup();
+        reject(new Error("timeout waiting for connect banner"));
+      }, timeoutMs);
+      const onError = (err) => {
+        cleanup();
+        reject(err);
+      };
+      const cleanup = () => {
+        clearTimeout(timer);
+        this.socket.off("error", onError);
+        this._onBanner = void 0;
+      };
+      this.socket.on("error", onError);
+      this._onBanner = () => {
+        cleanup();
+        resolve();
+      };
+      this.socket.connect(this.port, this.host, () => {
+        this.log(`socket connected to ${this.host}:${this.port}`);
+      });
+    });
+  }
+  async close() {
+    if (this.socket.destroyed) {
+      return;
+    }
+    await new Promise((resolve) => {
+      this.socket.once("close", () => resolve());
+      this.socket.end();
+    });
+  }
+  async getDevices(timeoutSec = 5) {
+    const data = await this.cmd("otii_get_devices", { timeout: timeoutSec }, (timeoutSec + 3) * 1e3);
+    return data?.devices ?? [];
+  }
+  async requireDevice(deviceId) {
+    const devices = await this.getDevices();
+    if (deviceId) {
+      const dev = devices.find((d) => d.device_id === deviceId);
+      if (!dev) {
+        throw new Error(`device not found: ${deviceId}`);
+      }
+      return dev;
+    }
+    if (devices.length === 0) {
+      throw new Error("no devices found");
+    }
+    return devices[0];
+  }
+  async getOrCreateProject() {
+    const active = await this.cmd("otii_get_active_project");
+    const projectId = active?.project_id;
+    if (projectId != null && projectId !== -1) {
+      return projectId;
+    }
+    const created = await this.cmd("otii_create_project");
+    if (created?.project_id == null) {
+      throw new Error("failed to create project");
+    }
+    return created.project_id;
+  }
+  async addToProject(deviceId) {
+    await this.cmd("arc_add_to_project", { device_id: deviceId }, 1e4);
+  }
+  async setMainVoltage(deviceId, value) {
+    await this.cmd("arc_set_main_voltage", { device_id: deviceId, value });
+  }
+  async setMaxCurrent(deviceId, value) {
+    await this.cmd("arc_set_max_current", { device_id: deviceId, value });
+  }
+  async enableChannel(deviceId, channel, enable) {
+    await this.cmd("arc_enable_channel", { device_id: deviceId, channel, enable });
+  }
+  async setMain(deviceId, value) {
+    await this.cmd("arc_set_main", { device_id: deviceId, enable: value });
+  }
+  async startRecording(projectId) {
+    await this.cmd("project_start_recording", { project_id: projectId }, 1e4);
+  }
+  async stopRecording(projectId) {
+    await this.cmd("project_stop_recording", { project_id: projectId }, 1e4);
+  }
+  async getLastRecording(projectId) {
+    const data = await this.cmd("project_get_last_recording", { project_id: projectId }, 1e4);
+    const recordingId = data?.recording_id;
+    if (recordingId == null || recordingId === -1) {
+      throw new Error("no recording found");
+    }
+    return recordingId;
+  }
+  async deleteRecording(recordingId) {
+    await this.cmd("recording_delete", {
+      recording_id: recordingId
+    });
+  }
+  async getChannelDataCount(recordingId, deviceId, channel) {
+    const data = await this.cmd("recording_get_channel_data_count", {
+      recording_id: recordingId,
+      device_id: deviceId,
+      channel
+    }, 15e3);
+    return data.count;
+  }
+  async getChannelData(recordingId, deviceId, channel, index, count) {
+    const data = await this.cmd("recording_get_channel_data", {
+      recording_id: recordingId,
+      device_id: deviceId,
+      channel,
+      index,
+      count
+    }, 3e4);
+    return {
+      interval: data.interval,
+      values: data.values ?? []
+    };
+  }
+  async getAllChannelData(recordingId, deviceId, channel) {
+    const total = await this.getChannelDataCount(recordingId, deviceId, channel);
+    let index = 0;
+    let remaining = total;
+    const chunkSize = 1e5;
+    let interval = 0;
+    const values = [];
+    while (remaining > 0) {
+      const count = Math.min(remaining, chunkSize);
+      const data = await this.cmd("recording_get_channel_data", {
+        recording_id: recordingId,
+        device_id: deviceId,
+        channel,
+        index,
+        count
+      }, 3e4);
+      if (index === 0) {
+        interval = data.interval;
+      }
+      values.push(...data.values ?? []);
+      index += count;
+      remaining -= count;
+    }
+    return { interval, values };
+  }
+  async getBatteryProfiles() {
+    const data = await this.cmd("otii_get_battery_profiles");
+    return data?.battery_profiles ?? [];
+  }
+  async setSupplyBatteryEmulator(deviceId, opts) {
+    await this.cmd("arc_set_supply_battery_emulator", {
+      device_id: deviceId,
+      battery_profile_id: opts.batteryProfileId,
+      ...opts.series !== void 0 ? { series: opts.series } : {},
+      ...opts.parallel !== void 0 ? { parallel: opts.parallel } : {},
+      ...opts.soc !== void 0 ? { soc: opts.soc } : {},
+      ...opts.usedCapacity !== void 0 ? { used_capacity: opts.usedCapacity } : {},
+      ...opts.socTracking !== void 0 ? { soc_tracking: opts.socTracking } : {}
+    }, 1e4);
+  }
+  async setSupplyPowerBox(deviceId) {
+    await this.cmd("arc_set_supply_power_box", {
+      device_id: deviceId
+    }, 1e4);
+  }
+  async isLoggedIn() {
+    const data = await this.cmd("otii_is_logged_in");
+    return data.logged_in;
+  }
+  async login(username, password) {
+    await this.cmd("otii_login", { username, password }, 1e4);
+  }
+  async getLicenses() {
+    const data = await this.cmd("otii_get_licenses");
+    return data?.licenses ?? [];
+  }
+  async hasLicense(licenseType) {
+    const data = await this.cmd("otii_has_license", { license_type: licenseType });
+    return data.has_license;
+  }
+  async reserveLicense(licenseId) {
+    await this.cmd("otii_reserve_license", { license_id: licenseId }, 1e4);
+  }
+  async returnLicense(licenseId) {
+    await this.cmd("otii_return_license", { license_id: licenseId }, 1e4);
+  }
+  async logout() {
+    await this.cmd("otii_logout", void 0, 1e4);
+  }
+  async cmd(cmd, data, timeoutMs = 3e3) {
+    const rsp = await this.request(cmd, data, timeoutMs);
+    return rsp.data;
+  }
+  async request(cmd, data, timeoutMs = 3e3) {
+    if (!this.ready) {
+      throw new Error("not connected");
+    }
+    const transId = String(this.nextId++);
+    const req = {
+      type: "request",
+      cmd,
+      trans_id: transId
+    };
+    if (data !== void 0) {
+      req.data = data;
+    }
+    return await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(transId);
+        reject(new Error(`timeout waiting for ${cmd}`));
+      }, timeoutMs);
+      this.pending.set(transId, { resolve, reject, timer });
+      this.logObj("send", req);
+      this.socket.write(JSON.stringify(req) + "\r\n");
+    });
+  }
+  onData(chunk) {
+    this.rx += chunk.toString("utf8");
+    for (; ; ) {
+      const idx = this.rx.indexOf("\r\n");
+      if (idx < 0) {
+        break;
+      }
+      const line = this.rx.slice(0, idx).trim();
+      this.rx = this.rx.slice(idx + 2);
+      if (!line) {
+        continue;
+      }
+      const msg = JSON.parse(line);
+      this.logObj("recv", msg);
+      if (msg.type === "information" && (msg.info === "connected" || msg.message === "connected")) {
+        this.ready = true;
+        const onBanner = this._onBanner;
+        onBanner?.();
+        continue;
+      }
+      if (!msg.trans_id) {
+        continue;
+      }
+      const p = this.pending.get(msg.trans_id);
+      if (!p) {
+        continue;
+      }
+      clearTimeout(p.timer);
+      this.pending.delete(msg.trans_id);
+      if (msg.type === "error") {
+        p.reject(new Error(msg.errorcode ?? `server error for ${msg.cmd}`));
+      } else {
+        p.resolve(msg);
+      }
+    }
+  }
+  onError(err) {
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  onClose() {
+    const err = new Error("socket closed");
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(err);
+    }
+    this.pending.clear();
+  }
+  log(msg) {
+    if (this.debug) {
+      console.log(msg);
+    }
+  }
+  logObj(prefix, obj) {
+    if (this.debug) {
+      console.log(`${prefix}:`, obj);
+    }
+  }
+};
+
 // src/Driver_PPK2.ts
 var import_serialport = __toESM(require_dist13());
 var mode_cmd_map = /* @__PURE__ */ new Map([
@@ -13117,7 +13743,7 @@ var MEAS_LOGIC = generateMask(8, 24);
 var MAX_PAYLOAD_COUNTER = 63;
 var DATALOSS_THRESHOLD = 500;
 var getMaskedValue = (value, { mask, pos }) => (value & mask) >> pos;
-async function execCapture2(opts) {
+async function execCapture3(opts) {
   const path_list = await findDevices();
   const progress = new Progress("capturing: ");
   const port = new import_serialport.SerialPort({ path: path_list[0], baudRate: 9600, autoOpen: false });
@@ -13158,18 +13784,57 @@ async function powerOn(voltage) {
   progress.done();
 }
 async function findDevices() {
-  let res = new Array();
+  let candidates = new Array();
   for (const port of await import_serialport.SerialPort.list()) {
     const vid = port.vendorId;
     const pid = port.productId;
     if (vid == "1915" && pid.toLowerCase() == "c00a") {
-      res.push(port.path);
+      candidates.push(port.path);
+    }
+  }
+  fail("no PPK2 analyzer found", candidates.length == 0);
+  if (candidates.length == 1) return candidates;
+  const res = new Array();
+  for (const path of candidates) {
+    if (await probeDataPort(path)) {
+      res.push(path);
     }
   }
-  fail("no PPK2 analyzer found", res.length == 0);
-  res.sort();
+  fail("no PPK2 data port found (tried probing all candidates)", res.length == 0);
   return res;
 }
+async function probeDataPort(path, timeoutMs = 500) {
+  let port;
+  try {
+    port = new import_serialport.SerialPort({ path, baudRate: 9600, autoOpen: false });
+    await new Promise((resolve, reject) => {
+      port.open((err) => err ? reject(err) : resolve());
+    });
+    return await new Promise((resolve) => {
+      let responded = false;
+      const onData = () => {
+        if (!responded) {
+          responded = true;
+          resolve(true);
+        }
+      };
+      port.on("data", onData);
+      port.write([25 /* GET_META_DATA */]);
+      setTimeout(() => {
+        if (!responded) {
+          responded = true;
+          resolve(false);
+        }
+      }, timeoutMs);
+    });
+  } catch {
+    return false;
+  } finally {
+    if (port?.isOpen) {
+      await new Promise((resolve) => port.close(() => resolve()));
+    }
+  }
+}
 function parseMods(mods) {
   mods = mods.replace("END", "").trim().toLowerCase().replace(/-nan/g, "null").replace(/\n/g, ',\n"').replace(/: /g, '": ');
   let res;
@@ -13378,6 +14043,8 @@ async function exec3(opts) {
     }
     c = await execCapture(opts);
   } else if (opts.ppk2) {
+    c = await execCapture3(opts);
+  } else if (opts.otii3) {
     c = await execCapture2(opts);
   } else {
     fail("you must specify an analyzer device");
@@ -13573,7 +14240,7 @@ function printEventInfo(cap, markers) {
     avg += egy * scale;
     const dur = (cap.current_sig.offToSecs(m.width) * 1e3).toFixed(2).padStart(5, " ");
     const off_s = cap.current_sig.offToSecs(m.offset).toFixed(2).padStart(5, " ");
-    infoMsg(`${lab} :: time = ${off_s} s, energy = ${uJoules(egy)}, duration = ${dur} s`);
+    infoMsg(`${lab} :: time = ${off_s} s, energy = ${uJoules(egy)}, duration = ${dur} ms`);
     lab = String.fromCharCode(lab.charCodeAt(0) + 1);
   }
   infoMsg("----");
@@ -13672,7 +14339,7 @@ var {
 var CAP = ["-c --capture <directory path>", "working capture directory", "."];
 var VERS = version();
 var CMD = new Command("emscope").option("-C, --capture-glob [name pattern]", `apply this command to each matching child capture directory (default "**")`).version(VERS);
-CMD.command("grab").description("record power signals with an attached capture device").option(CAP[0], CAP[1], CAP[2]).option("-d --duration <value>", "capture duration in seconds", parseFloat, 3).option("-J --js220", "use a Joulescope JS220 device").option("-P --ppk2", "use a Nordic PPK2 device").addOption(new Option("-A --ampere-mode", "enable PPK ampere mode").conflicts(["sourceMode", "js220"])).addOption(new Option("-S --source-mode", "enable PPK source mode").default(true).conflicts(["ampereMode", "js220"])).addOption(new Option("-p, --ppk2-supply [voltage]", "supply JS220 voltage from a PPK").argParser(parseFloat).conflicts("ppk2")).addOption(new Option("-v, --voltage [value]", "source voltage").argParser(parseFloat).default(3.3).conflicts("js220")).action((opts, cmd) => execCmd(exec3, opts, cmd.parent.opts()));
+CMD.command("grab").description("record power signals with an attached capture device").option(CAP[0], CAP[1], CAP[2]).option("-d --duration <value>", "capture duration in seconds", parseFloat, 3).option("-J --js220", "use a Joulescope JS220 device").option("-O --otii3", "use a Qoitech Otii3 device").option("-P --ppk2", "use a Nordic PPK2 device").addOption(new Option("-A --ampere-mode", "enable PPK ampere mode").conflicts(["sourceMode", "otii3", "js220"])).addOption(new Option("-S --source-mode", "enable PPK source mode").default(true).conflicts(["ampereMode", "otii3", "js220"])).addOption(new Option("-B, --battery-profile <index>", "use Otii battery profile (implies -O)").argParser(parseFloat).implies({ otii3: true }).conflicts(["js220", "ppk2"])).addOption(new Option("-p, --ppk2-supply <voltage>", "supply JS220 voltage from a PPK").argParser(parseFloat).conflicts(["otii3", "ppk2"])).addOption(new Option("-v, --voltage [value]", "source voltage").argParser(parseFloat).default(3.3).conflicts("js220")).addOption(new Option("--soc <percent>", "battery state of charge (implies -O)").argParser(parseFloat).implies({ otii3: true })).action((opts, cmd) => execCmd(exec3, opts, cmd.parent.opts()));
 CMD.command("scan").description("analyze captured data and locate active events").option(CAP[0], CAP[1], CAP[2]).option("-d, --min-duration <milliseconds>", "remove events whose duration is under a threshold", parseFloat).option("-e, --min-energy <microJoules>", "remove events whose energy is under a threshold", parseFloat).option("-g, --gap <milliseconds>", "combine adjacent events whose gap is under a threshold", parseFloat).option("-t --trim <event count>", "remove extra events", parseFloat).option("--refresh", "(re-)scan using the last set of options").action((opts, cmd) => execCmd(exec, opts, cmd.parent.opts()));
 CMD.command("view").description("present captured data in different formats").option(CAP[0], CAP[1], CAP[2]).option("-e --event-info", "characterize power consumption when active").option("-j --jls-file [event ID]", "generate a Joulescope .jls file containing events").option("-s --sleep-info", "characterize power consumption when inactive").option("-w --what-if [event period]", `extrapolate results for a given event period (default: '00:00:01')`, parseHms).option("--score", "only print the EM\u2022eralds benchmark score").option("--json", "output results as JSON (machine-readable)").action((opts, cmd) => execCmd(exec4, opts, cmd.parent.opts()));
 CMD.command("pack").description(`bundle captured data into an 'emscope.zip' file`).option(CAP[0], CAP[1], CAP[2]).option("-a --about-file", `update the 'ABOUT.md' file only`).option("-s,--status", `status of the 'emscope.zip' file`).option("-u --unpack", `deflate the 'emscope.zip' file for local use`).option("-z --zip-file", `generate the 'emscope.zip' file`).option("--restore", `restores the 'emscope.zip' LFS descriptor (debug only)`).action((opts, cmd) => execCmd(exec2, opts, cmd.parent.opts()));
@@ -13685,6 +14352,5 @@ try {
 /*! Bundled license information:
 
 js-yaml/dist/js-yaml.mjs:
-  (*! js-yaml 4.1.0 https://github.com/nodeca/js-yaml @license MIT *)
+  (*! js-yaml 4.1.1 https://github.com/nodeca/js-yaml @license MIT *)
 */
-//# sourceMappingURL=emscope.map

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@em-foundation/emscope",
-    "version": "25.4.0",
+    "version": "25.5.3",
     "description": "benchmark energy efficiency in resource-constrained embedded systems",
     "bin": {
         "emscope": "dist/emscope"