@tsplc/sim 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,605 @@
+// packages/sim/src/paths.ts
+var pathKey = Symbol("tsplc.path");
+var join = (segments) => segments.reduce((path, segment) => /^\d+$/.test(segment) ? `${path}[${segment}]` : path ? `${path}.${segment}` : segment, "");
+var proxy = (segments) => new Proxy(() => {
+  return;
+}, {
+  get: (_, key) => {
+    if (key === pathKey)
+      return join(segments);
+    if (typeof key === "symbol")
+      return;
+    return proxy([...segments, key]);
+  },
+  apply: (_, __, [index]) => proxy([...segments.slice(0, -1), String(index)])
+});
+var plcPaths = () => proxy([]);
+var pathName = (path) => {
+  const name = Reflect.get(path, pathKey);
+  if (typeof name !== "string" || !name)
+    throw new Error("Expected a path from plcPaths().");
+  return name;
+};
+// packages/sim/src/hardware.ts
+var pinIn = (type) => ({ direction: "in", type });
+var pinOut = (type) => ({ direction: "out", type });
+var analog = (path, range) => {
+  const [plcLow, plcHigh] = range.plc, [pinLow, pinHigh] = range.pin;
+  return {
+    path,
+    toPin: (plc) => pinLow + (plc - plcLow) * (pinHigh - pinLow) / (plcHigh - plcLow),
+    toPlc: (pin) => Math.round(plcLow + (pin - pinLow) * (plcHigh - plcLow) / (pinHigh - pinLow))
+  };
+};
+var defaultValue = (type) => type === "bool" ? false : type === "number" ? 0 : [];
+var isScaled = (wire) => ("toPin" in wire);
+var wirePath = (wire) => isScaled(wire) ? pathName(wire.path) : pathName(wire);
+var defineHardware = (model) => (options) => {
+  const state = model.setup(options.config);
+  const world = model.world();
+  const pins = Object.fromEntries(Object.entries(model.pins).map(([name, pin]) => [name, defaultValue(pin.type)]));
+  let dtMs = 0;
+  const context = () => ({
+    pins,
+    world,
+    config: options.config,
+    state,
+    dtMs
+  });
+  const wired = Object.entries(options.wiring).flatMap(([name, wire]) => {
+    const pin = model.pins[name];
+    if (!pin)
+      throw new Error(`${model.name} has no pin ${String(name)}.`);
+    const target = wire;
+    return target ? [{ name, pin, wire: target, path: wirePath(target) }] : [];
+  });
+  return {
+    model: model.name,
+    world,
+    reads: wired.filter(({ pin }) => pin.direction === "in").map(({ path }) => path),
+    update: (plc, elapsed) => {
+      dtMs = elapsed;
+      for (const { name, pin, wire, path } of wired) {
+        if (pin.direction !== "in" || !plc.has(path))
+          continue;
+        const value = plc.get(path);
+        Reflect.set(pins, name, isScaled(wire) ? wire.toPin(Number(value)) : value);
+      }
+      model.update(context());
+      const writes = new Map;
+      for (const { name, pin, wire, path } of wired) {
+        if (pin.direction !== "out")
+          continue;
+        const value = Reflect.get(pins, name);
+        writes.set(path, isScaled(wire) ? wire.toPlc(Number(value)) : value);
+      }
+      return writes;
+    },
+    view: () => model.view?.(context()) ?? { status: "idle" },
+    pins: () => ({ ...pins }),
+    actions: Object.keys(model.actions ?? {}),
+    act: (action, argument) => {
+      const handler = model.actions?.[action];
+      if (!handler)
+        throw new Error(`${model.name} has no action ${action}.`);
+      handler(context(), argument);
+    }
+  };
+};
+// packages/sim/src/line.ts
+var part = (options) => ({ kind: "part", ...options });
+var zone = (options) => part({
+  ...options.id !== undefined && { id: options.id },
+  label: "zone",
+  length: options.length,
+  devices: { controller: options.controller },
+  motion: ({ controller }) => ({ along: controller.world.out.motor }),
+  sense: ({ blocked }, { controller }) => {
+    controller.world.in.photoeye = blocked(options.eye ?? options.length - 50);
+  }
+});
+var section = (options) => part({
+  ...options.id !== undefined && { id: options.id },
+  label: "section",
+  length: options.length,
+  devices: options.motor ? { motor: options.motor } : {},
+  motion: () => ({ along: options.motor?.world.out.motor ?? options.speed ?? 0 })
+});
+var pickup = (options) => ({ kind: "pickup", ...options });
+var photoeye = (options) => ({
+  kind: "photoeye",
+  ...options
+});
+var reader = (options) => ({ kind: "reader", ...options });
+var conveyor = (options) => options;
+var station = (options = {}) => options;
+var targetNames = (line) => new Map([
+  ...Object.entries(line.conveyors).map(([name, target]) => [target, name]),
+  ...Object.entries(line.stations ?? {}).map(([name, target]) => [target, name])
+]);
+var defineLine = (line) => {
+  const names = targetNames(line);
+  for (const [id, item] of Object.entries(line.conveyors)) {
+    const next = item.next && "to" in item.next ? item.next.to : item.next;
+    const targets = [next];
+    for (const part of item.parts) {
+      if (part.kind === "part")
+        targets.push(part.exits?.left, part.exits?.right);
+      if (part.kind === "pickup")
+        targets.push(part.station);
+    }
+    for (const target of targets)
+      if (target !== undefined && !names.has(target))
+        throw new Error(`Conveyor ${id} leads to a conveyor or station missing from the line.`);
+  }
+  return line;
+};
+var keyed = (ids, make) => Object.fromEntries(ids.map((id) => [id, make(id)]));
+// packages/sim/src/simulation.ts
+import { setTimeout as delay } from "node:timers/promises";
+
+// packages/sim/src/layout.ts
+var scale = 0.05;
+var exitClearance = 1000;
+var direction = {
+  right: { x: 1, y: 0 },
+  left: { x: -1, y: 0 },
+  up: { x: 0, y: -1 },
+  down: { x: 0, y: 1 }
+};
+var leftOf = { right: "up", up: "left", left: "down", down: "right" };
+var rightOf = { right: "down", down: "left", left: "up", up: "right" };
+var lengthOf = (conveyor) => conveyor.parts.reduce((sum, part) => sum + (part.kind === "part" ? part.length : 0), 0);
+var travel = (from, heading, distance) => ({
+  x: from.x + direction[heading].x * distance,
+  y: from.y + direction[heading].y * distance
+});
+var pointAt = (route, mm) => {
+  let remaining = mm;
+  for (const [index, heading] of route.headings.entries()) {
+    const from = route.points[index], to = route.points[index + 1], length = Math.abs(to.x - from.x) + Math.abs(to.y - from.y);
+    if (remaining <= length || index === route.headings.length - 1)
+      return { point: travel(from, heading, remaining), heading };
+    remaining -= length;
+  }
+  throw new Error("A conveyor needs a route.");
+};
+var drawLine = (line) => {
+  const conveyors = Object.values(line.conveyors);
+  const isConveyor = new Set(conveyors);
+  const feeders = new Map;
+  for (const conveyor of conveyors) {
+    let position = 0;
+    for (const part of conveyor.parts) {
+      if (part.kind !== "part")
+        continue;
+      for (const side of ["left", "right"]) {
+        const exit = part.exits?.[side];
+        if (exit && isConveyor.has(exit))
+          feeders.set(exit, { from: conveyor, at: position + part.length / 2, side });
+      }
+      position += part.length;
+    }
+    const next = conveyor.next;
+    if (next && !("to" in next) && isConveyor.has(next))
+      feeders.set(next, { from: conveyor, at: position });
+  }
+  const routes = new Map;
+  const active = new Set;
+  const route = (conveyor) => {
+    const known = routes.get(conveyor);
+    if (known)
+      return known;
+    if (active.has(conveyor))
+      throw new Error("Conveyors with no `at` cannot feed each other.");
+    active.add(conveyor);
+    let start = conveyor.at ?? { x: 0, y: 0 };
+    let heading = conveyor.heading ?? "right";
+    const feeder = conveyor.at ? undefined : feeders.get(conveyor);
+    if (feeder) {
+      const exit = pointAt(route(feeder.from), feeder.at);
+      heading = !feeder.side ? exit.heading : feeder.side === "left" ? leftOf[exit.heading] : rightOf[exit.heading];
+      start = feeder.side ? travel(exit.point, heading, exitClearance) : exit.point;
+    }
+    const result = { points: [start], headings: [] };
+    let remaining = lengthOf(conveyor);
+    for (const turn of conveyor.turns ?? []) {
+      if (turn.after <= 0 || turn.after >= remaining)
+        throw new Error(`A turn ${turn.after} mm along must fall inside its conveyor.`);
+      result.headings.push(heading);
+      result.points.push(travel(result.points.at(-1), heading, turn.after));
+      remaining -= turn.after;
+      heading = turn.to;
+    }
+    result.headings.push(heading);
+    result.points.push(travel(result.points.at(-1), heading, remaining));
+    active.delete(conveyor);
+    routes.set(conveyor, result);
+    return result;
+  };
+  const pixels = (mm) => Math.round(mm * scale * 100) / 100;
+  return new Map(conveyors.map((conveyor) => [
+    conveyor,
+    route(conveyor).points.map(({ x, y }, index) => `${index ? "L" : "M"} ${pixels(x)} ${pixels(y)}`).join(" ")
+  ]));
+};
+
+// packages/sim/src/simulation.ts
+var same = (a, b) => Array.isArray(a) && Array.isArray(b) ? a.length === b.length && a.every((item, index) => item === b[index]) : a === b;
+var resolve = (id, conveyor, draw, name) => {
+  const segments = [];
+  const points = [];
+  let position = 0;
+  conveyor.parts.forEach((part, index) => {
+    const partId = part.id ?? `${id}[${index}]`;
+    if (part.kind !== "part") {
+      points.push({ id: partId, part, at: position + (part.offset ?? 0) });
+      return;
+    }
+    segments.push({ id: partId, part, start: position, end: position + part.length });
+    position += part.length;
+  });
+  return {
+    id,
+    draw,
+    length: position,
+    segments,
+    points,
+    ...conveyor.next !== undefined && {
+      next: "to" in conveyor.next ? { to: name(conveyor.next.to), at: conveyor.next.at } : { to: name(conveyor.next), at: 0 }
+    }
+  };
+};
+var devicesOf = (segment) => Object.entries(segment.part.devices).map(([name, device]) => [`${segment.id}.${name}`, device]);
+var along = (motion) => ("along" in motion) ? Math.max(0, motion.along) : 0;
+var createSimulation = (line, options) => {
+  const names = targetNames(line);
+  const name = (target) => {
+    const found = names.get(target);
+    if (found === undefined)
+      throw new Error("A part leads outside the line.");
+    return found;
+  };
+  const drawings = drawLine(line);
+  const tracks = new Map(Object.entries(line.conveyors).map(([id, item]) => [
+    id,
+    resolve(id, item, drawings.get(item), name)
+  ]));
+  const stations = new Map(Object.entries(line.stations ?? {}));
+  const devices = new Map;
+  const lineDevices = new Set(Object.keys(line.devices ?? {}));
+  for (const [id, device] of Object.entries(line.devices ?? {}))
+    devices.set(id, device);
+  for (const track of tracks.values()) {
+    for (const segment of track.segments)
+      for (const [id, device] of devicesOf(segment))
+        devices.set(id, device);
+    for (const point of track.points)
+      if (point.part.kind === "reader")
+        devices.set(point.id, point.part.device);
+  }
+  const reads = [...new Set([...devices.values()].flatMap((device) => device.reads))];
+  const placed = new Map;
+  const written = new Map;
+  const pendingReads = new Map;
+  let timeMs = 0, sequence = 0, error = null;
+  const onConveyor = (conveyor) => [...placed.values()].flatMap(({ load, place }) => place.kind === "conveyor" && place.conveyor === conveyor ? [{ load, place }] : []).sort((a, b) => b.place.head - a.place.head);
+  const footprints = (track) => [
+    ...onConveyor(track.id).map(({ load, place }) => ({ load, head: place.head, place })),
+    ...track.next && tracks.has(track.next.to) ? onConveyor(track.next.to).flatMap(({ load, place }) => place.from?.conveyor === track.id && place.head - place.from.at < load.length ? [{ load, head: track.length + place.head - place.from.at, place }] : []) : []
+  ];
+  const covers = (head, length, at) => head - length <= at && at <= head;
+  const stationLoads = (id) => [...placed.values()].filter(({ place }) => place.kind === "station" && place.station === id).length;
+  const sense = () => {
+    const writes = new Map;
+    for (const track of tracks.values()) {
+      const loads = footprints(track);
+      const blocked = (at) => loads.some(({ load, head, place }) => covers(head, load.length, at) && Math.abs(place.lateral) < load.width / 2);
+      for (const segment of track.segments) {
+        const onPart = loads.filter(({ load, head }) => head > segment.start && head - load.length < segment.end).map(({ load, head, place }) => ({
+          head: head - segment.start,
+          tail: head - load.length - segment.start,
+          lateral: place.lateral
+        }));
+        const sensed = segment.part.sense?.({
+          blocked: (at) => blocked(segment.start + at),
+          occupied: onPart.length > 0,
+          loads: onPart
+        }, segment.part.devices);
+        for (const [wire, value] of sensed ?? [])
+          writes.set(wirePath(wire), value);
+      }
+      for (const point of track.points) {
+        if (point.part.kind === "photoeye")
+          writes.set(wirePath(point.part.output), blocked(point.at));
+        else if (point.part.kind === "reader") {
+          const queue = pendingReads.get(point.id) ?? [];
+          point.part.device.world.in.read = queue.shift() ?? null;
+          pendingReads.set(point.id, queue);
+        }
+      }
+    }
+    for (const [id, item] of stations)
+      for (const sensor of item.sensors ?? [])
+        writes.set(wirePath(sensor.output), sensor.active({ loads: stationLoads(id) }));
+    return writes;
+  };
+  const enter = (target, load, head, from) => {
+    const track = tracks.get(target);
+    if (track) {
+      const blocked = onConveyor(target).some((other) => other.load !== load && other.place.head > head - load.length && other.place.head - other.load.length < head);
+      if (blocked)
+        return false;
+      placed.set(load.id, {
+        load,
+        place: {
+          kind: "conveyor",
+          conveyor: target,
+          head,
+          lateral: 0,
+          ...from !== undefined && { from }
+        }
+      });
+      return true;
+    }
+    const capacity = stations.get(target)?.capacity;
+    if (capacity !== undefined && stationLoads(target) >= capacity)
+      return false;
+    placed.set(load.id, { load, place: { kind: "station", station: target } });
+    return true;
+  };
+  const move = (dtMs) => {
+    for (const track of tracks.values()) {
+      const motions = new Map(track.segments.map((segment) => [segment, segment.part.motion(segment.part.devices)]));
+      let limit = Number.POSITIVE_INFINITY;
+      for (const { load, place } of onConveyor(track.id)) {
+        if (place.kind !== "conveyor")
+          continue;
+        const tail = place.head - load.length;
+        const middle = place.head - load.length / 2;
+        const across = track.segments.find((segment) => segment.start <= middle && middle <= segment.end);
+        const motion = across && motions.get(across);
+        if (across && motion && "across" in motion) {
+          place.lateral += motion.across * dtMs / 1000;
+          const width = across.part.width ?? 0;
+          const exit = across.part.exits?.[place.lateral > 0 ? "right" : "left"];
+          if (Math.abs(place.lateral) >= width && (exit === undefined || !enter(name(exit), load, load.length)))
+            place.lateral = Math.sign(place.lateral) * width;
+          limit = tail;
+          continue;
+        }
+        if (place.lateral !== 0) {
+          limit = tail;
+          continue;
+        }
+        const covered = track.segments.filter(({ start, end }) => start < place.head && end > Math.max(tail, 0));
+        const speed = covered.length ? Math.min(...covered.map((segment) => along(motions.get(segment) ?? { held: true }))) : 0;
+        let target = Math.min(place.head + speed * dtMs / 1000, limit);
+        let picked = false;
+        for (const point of track.points) {
+          if (target < point.at)
+            continue;
+          if (point.part.kind === "pickup") {
+            if (picked || place.head > point.at)
+              continue;
+            picked = enter(name(point.part.station), load, 0);
+            if (!picked)
+              target = point.at;
+          } else if (point.part.kind === "reader" && place.head < point.at)
+            pendingReads.set(point.id, [...pendingReads.get(point.id) ?? [], load.code]);
+        }
+        if (picked)
+          continue;
+        const next = track.next;
+        if (target > track.length && next !== undefined) {
+          const entered = enter(next.to, load, next.at + target - track.length, {
+            conveyor: track.id,
+            at: next.at
+          });
+          if (!entered)
+            place.head = track.length;
+        } else
+          place.head = Math.min(target, track.length);
+        limit = place.head - load.length;
+      }
+    }
+    for (const { load, place } of placed.values())
+      if (place.kind === "waiting")
+        enter(place.conveyor, load, load.length);
+  };
+  const pointView = (point) => {
+    switch (point.part.kind) {
+      case "reader":
+        return point.part.device.view();
+      case "photoeye":
+        return { status: written.get(wirePath(point.part.output)) ? "busy" : "idle" };
+      case "pickup":
+        return {
+          status: stationLoads(name(point.part.station)) ? "busy" : "idle",
+          label: name(point.part.station)
+        };
+    }
+  };
+  const segmentView = (segment) => {
+    const views = devicesOf(segment).map(([, device]) => device.view());
+    if (!views.length)
+      return {
+        status: along(segment.part.motion(segment.part.devices)) > 0 ? "running" : "stopped"
+      };
+    const order = ["fault", "warning", "busy", "running", "stopped", "idle"];
+    return views.reduce((worst, view) => order.indexOf(view.status) < order.indexOf(worst.status) ? view : worst);
+  };
+  const simulation = {
+    tick: async (dtMs) => {
+      const plc = await options.io.read(reads);
+      const writes = sense();
+      for (const device of devices.values())
+        for (const [path, value] of device.update(plc, dtMs))
+          writes.set(path, value);
+      const changed = new Map([...writes].filter(([path, value]) => !same(written.get(path), value)));
+      if (changed.size) {
+        await options.io.write(changed);
+        for (const [path, value] of changed)
+          written.set(path, value);
+      }
+      move(dtMs);
+      timeMs += dtMs;
+    },
+    run: async (signal, options = {}) => {
+      const periodMs = options.periodMs ?? 50;
+      let last = performance.now();
+      while (!signal.aborted) {
+        const now = performance.now();
+        if (!options.paused?.())
+          await simulation.step(Math.min(now - last, 1000));
+        last = now;
+        await delay(Math.max(0, periodMs - (performance.now() - now)), undefined, {
+          signal
+        }).catch(() => {
+          return;
+        });
+      }
+    },
+    step: async (dtMs) => {
+      try {
+        await simulation.tick(dtMs);
+        error = null;
+      } catch (cause) {
+        error = cause instanceof Error ? cause.message : String(cause);
+        written.clear();
+      }
+    },
+    addLoad: (conveyor, load) => {
+      const kind = line.loads[load.kind];
+      if (!kind)
+        throw new Error(`Unknown load kind ${load.kind}.`);
+      if (!tracks.has(conveyor))
+        throw new Error(`Unknown conveyor ${conveyor}.`);
+      const created = {
+        id: `L${++sequence}`,
+        length: kind.length,
+        width: kind.width ?? kind.length,
+        ...load
+      };
+      placed.set(created.id, { load: created, place: { kind: "waiting", conveyor } });
+      return created;
+    },
+    place: (id, target, at) => {
+      const entry = placed.get(id);
+      if (!entry)
+        throw new Error(`Unknown load ${id}.`);
+      if (tracks.has(target) && at === undefined)
+        entry.place = { kind: "waiting", conveyor: target };
+      else if (!enter(target, entry.load, (at ?? 0) + entry.load.length))
+        throw new Error(`No room for ${entry.load.code} at ${target}.`);
+    },
+    remove: (id) => {
+      placed.delete(id);
+    },
+    loads: () => [...placed.values()].map(({ load, place }) => ({ load, place })),
+    loadsAt: (station) => [...placed.values()].filter(({ place }) => place.kind === "station" && place.station === station).map(({ load }) => load),
+    act: (device, action, argument = "") => {
+      const target = devices.get(device);
+      if (!target)
+        throw new Error(`Unknown device ${device}.`);
+      target.act(action, argument);
+    },
+    state: () => ({
+      timeMs,
+      error,
+      conveyors: [...tracks.values()].map((track) => ({
+        id: track.id,
+        draw: track.draw,
+        length: track.length,
+        ...track.next !== undefined && { next: track.next.to },
+        parts: [
+          ...track.segments.map((segment) => ({
+            id: segment.id,
+            kind: segment.part.kind,
+            ...segment.part.label !== undefined && { label: segment.part.label },
+            start: segment.start,
+            end: segment.end,
+            ...segment.part.exits && {
+              exits: {
+                ...segment.part.exits.left && { left: name(segment.part.exits.left) },
+                ...segment.part.exits.right && { right: name(segment.part.exits.right) }
+              }
+            },
+            view: segmentView(segment)
+          })),
+          ...track.points.map((point) => ({
+            id: point.id,
+            kind: point.part.kind,
+            start: point.at,
+            end: point.at,
+            ...point.part.kind === "pickup" && {
+              station: name(point.part.station),
+              side: point.part.side ?? "right"
+            },
+            view: pointView(point)
+          }))
+        ]
+      })),
+      stations: [...stations].map(([id, item]) => ({
+        id,
+        label: item.label ?? id,
+        loads: stationLoads(id)
+      })),
+      loads: [...placed.values()].map(({ load, place }) => ({
+        id: load.id,
+        kind: load.kind,
+        code: load.code,
+        length: load.length,
+        width: load.width,
+        place: { ...place }
+      })),
+      devices: [...devices].map(([id, device]) => ({
+        id,
+        part: lineDevices.has(id) ? null : id.split(".")[0],
+        model: device.model,
+        view: device.view(),
+        pins: device.pins(),
+        actions: device.actions
+      }))
+    })
+  };
+  return simulation;
+};
+// packages/sim/src/io.ts
+var plcIo = (plc) => ({
+  read: async (paths) => {
+    const readings = await plc.read(paths);
+    return new Map(paths.map((path) => {
+      const reading = readings[path];
+      if (reading?.quality !== "good")
+        throw new Error(`Cannot read ${path}: ${reading?.status ?? "missing"}`);
+      return [path, reading.value];
+    }));
+  },
+  write: async (values) => {
+    await plc.write(values);
+  }
+});
+export {
+  analog,
+  conveyor,
+  createSimulation,
+  defineHardware,
+  defineLine,
+  keyed,
+  part,
+  pathName,
+  photoeye,
+  pickup,
+  pinIn,
+  pinOut,
+  plcIo,
+  plcPaths,
+  reader,
+  section,
+  station,
+  zone
+};
+
+//# debugId=68AEBE1381BBE02964756E2164756E21
+//# sourceMappingURL=index.js.map