@science-corporation/synapse 0.9.0

package/src/config.ts

@@ -0,0 +1,110 @@
+import Node from "./node";
+import { synapse } from "./api/api";
+import ElectricalBroadband from "./nodes/electrical_broadband";
+import ElectricalStimulation from "./nodes/electrical_stimulation";
+import OpticalBroadband from "./nodes/optical_broadband";
+import OpticalStimulation from "./nodes/optical_stimulation";
+import SpectralFilter from "./nodes/spectral_filter";
+import SpikeDetect from "./nodes/spike_detect";
+import StreamIn from "./nodes/stream_in";
+import StreamOut from "./nodes/stream_out";
+
+type Connection = [number, number];
+const kNodeTypeObjectMap = {
+  [synapse.NodeType.kElectricalBroadband]: ElectricalBroadband,
+  [synapse.NodeType.kElectricalStimulation]: ElectricalStimulation,
+  [synapse.NodeType.kOpticalBroadband]: OpticalBroadband,
+  [synapse.NodeType.kOpticalStimulation]: OpticalStimulation,
+  [synapse.NodeType.kSpectralFilter]: SpectralFilter,
+  [synapse.NodeType.kSpikeDetect]: SpikeDetect,
+  [synapse.NodeType.kStreamIn]: StreamIn,
+  [synapse.NodeType.kStreamOut]: StreamOut,
+};
+
+class Config {
+  connections: Connection[] = [];
+  nodes: Node[] = [];
+
+  _genNodeId(): number {
+    return this.nodes.length + 1;
+  }
+
+  add(nodes: Node[]) {
+    for (const node of nodes) {
+      if (!this.addNode(node)) {
+        return false;
+      }
+    }
+    return true;
+  }
+
+  connect(fromNode: Node, toNode: Node): boolean {
+    if (fromNode.id === null || toNode.id === null) {
+      return false;
+    }
+    this.connections.push([fromNode.id, toNode.id]);
+    return true;
+  }
+
+  addNode(node: Node): boolean {
+    if (!!node.id) {
+      return false;
+    }
+    node.id = this._genNodeId();
+    this.nodes.push(node);
+    return true;
+  }
+
+  setDevice(device): boolean {
+    for (const node of this.nodes) {
+      node.device = device;
+    }
+    return true;
+  }
+
+  static fromProto(proto: synapse.IDeviceConfiguration): Config {
+    const { nodes = [], connections = [] } = proto;
+    const config = new Config();
+
+    for (const nodeProto of nodes) {
+      const { type } = nodeProto;
+      const NodeType = kNodeTypeObjectMap[type];
+      if (!NodeType) {
+        continue;
+      }
+
+      const node = NodeType.fromProto(nodeProto);
+      if (!!nodeProto.id) {
+        node.id = nodeProto.id;
+        config.nodes.push(node);
+      } else {
+        config.addNode(node);
+      }
+    }
+
+    for (const connection of connections) {
+      const from = config.nodes.find((node) => node.id === connection.srcNodeId);
+      const to = config.nodes.find((node) => node.id === connection.dstNodeId);
+      if (!from || !to) {
+        continue;
+      }
+      config.connect(from, to);
+    }
+
+    return config;
+  }
+
+  toProto(): synapse.DeviceConfiguration {
+    return new synapse.DeviceConfiguration({
+      nodes: this.nodes.map((node) => node.toProto()),
+      connections: this.connections.map((connection) => {
+        return {
+          srcNodeId: connection[0],
+          dstNodeId: connection[1],
+        };
+      }),
+    });
+  }
+}
+
+export default Config;

package/src/demo.ts

@@ -0,0 +1,303 @@
+import fs from "fs";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+import { synapse } from "./api/api";
+import Config from "./config";
+import Device from "./device";
+import ElectricalBroadband from "./nodes/electrical_broadband";
+import OpticalStimulation from "./nodes/optical_stimulation";
+import StreamIn from "./nodes/stream_in";
+import StreamOut from "./nodes/stream_out";
+import { discover } from "./utils/discover";
+import { getName } from "./utils/enum";
+
+const cli = yargs(hideBin(process.argv))
+  .help()
+  .command("discover", "Discover synapse devices")
+  .command("read", "Read from StreamOut node", {
+    "multicast-group": {
+      alias: "m",
+      type: "string",
+      description: "Multicast group",
+    },
+    output: {
+      alias: "o",
+      type: "string",
+      description: "Output file",
+    },
+    uri: {
+      alias: "u",
+      type: "string",
+      demandOption: true,
+    },
+  })
+  .command("write", "Write to StreamIn node", {
+    input: {
+      alias: "i",
+      type: "string",
+      description: "Input file",
+    },
+    uri: {
+      alias: "u",
+      type: "string",
+      demandOption: true,
+    },
+  });
+
+const info = async (device: Device) => {
+  console.log("Info()");
+
+  const info = await device.info();
+  const { serial, name, status, synapseVersion, firmwareVersion, peripherals, configuration } = info;
+
+  console.log(` - serial:                         ${serial}`);
+  console.log(` - name:                           ${name}`);
+  console.log(` - synapse version:                ${synapseVersion || "<unknown>"}`);
+  console.log(` - firmware version:               ${firmwareVersion || "<unknown>"}`);
+
+  console.log(
+    ` - status:                         ${status.code} (${getName(synapse.StatusCode, status.code)})${
+      status.message ? `: "${status.message}"` : ""
+    }`
+  );
+  console.log(`   - state:                          ${getName(synapse.DeviceState, status.state)}`);
+
+  console.log(`   - sockets:                        ${status.sockets?.length || 0}`);
+  status.sockets?.forEach(({ nodeId, bind }) => {
+    console.log(`     - node [${nodeId}] ${bind}`);
+  });
+
+  console.log(` - peripherals:                    ${peripherals?.length || 0}`);
+  peripherals?.forEach(({ name, peripheralId: id, vendor }) => {
+    console.log(`   - [${id}] ${name} (${vendor})`);
+  });
+
+  if (configuration) {
+    const { nodes } = configuration;
+    console.log(` - configuration:`);
+    console.log(`   - nodes:                        ${nodes?.length || 0}`);
+    nodes?.forEach(({ id, type }) => {
+      console.log(`     - [${id}] (${getName(synapse.NodeType, type)})`);
+    });
+  }
+
+  return true;
+};
+
+const read = async (device: Device, argv: any) => {
+  console.log("Reading from device's StreamOut node...");
+
+  const { multicastGroup, output } = argv;
+  let ok = true;
+  let stream = null;
+  if (output) {
+    console.log(`Writing to file: ${output}`);
+    stream = fs.createWriteStream(output);
+  }
+
+  const onMessage = (msg: Buffer) => {
+    const value = msg.readUInt32BE();
+    console.log(`StreamOut | recv: ${value}`);
+    if (stream) {
+      stream.write(msg);
+    }
+  };
+
+  const config = new Config();
+  const nodeEphys = new ElectricalBroadband({
+    peripheralId: 3,
+    channels: [{ id: 0, referenceId: 0, electrodeId: 1 }],
+    bitWidth: 12,
+    sampleRate: 16000,
+  });
+  const nodeStreamOut = new StreamOut(
+    {
+      multicastGroup,
+    },
+    onMessage
+  );
+
+  ok = config.add([nodeEphys, nodeStreamOut]);
+  ok = config.connect(nodeEphys, nodeStreamOut);
+  if (!ok) {
+    console.error("Failed to connect nodes");
+    return;
+  }
+
+  console.log("Configuring device...");
+  try {
+    ok = await device.configure(config);
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  console.log("Starting device...");
+  try {
+    ok = await device.start();
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  nodeStreamOut.start();
+
+  let running = true;
+  process.on("SIGINT", function () {
+    if (!running) {
+      return;
+    }
+
+    running = false;
+    nodeStreamOut.stop();
+    device.stop();
+  });
+};
+
+const write = async (device: Device, argv: any) => {
+  const { input } = argv;
+
+  if (input && !fs.existsSync(input)) {
+    console.error(`File not found: ${input}`);
+    return;
+  }
+
+  console.log("Writing to device's StreamOut node...");
+  let ok = true;
+
+  const config = new Config();
+  const nodeStreamIn = new StreamIn({
+    dataType: synapse.DataType.kBroadband,
+  });
+  const nodeOptical = new OpticalStimulation();
+
+  ok = config.add([nodeStreamIn, nodeOptical]);
+  ok = config.connect(nodeStreamIn, nodeOptical);
+  if (!ok) {
+    console.error("Failed to connect nodes");
+    return;
+  }
+
+  console.log("Configuring device...");
+  try {
+    ok = await device.configure(config);
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  console.log("Starting device...");
+  try {
+    ok = await device.start();
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  let running = true;
+  process.on("SIGINT", function () {
+    console.log("SIGINT", running);
+    if (!running) return;
+    console.log("stopping...");
+
+    running = false;
+    device.stop();
+
+    process.exit();
+  });
+
+  if (input) {
+    console.log(`Reading from file: ${input}`);
+    fs.open(input, "r", (err, fd) => {
+      console.log("Opened file");
+      const kBufSize = 4;
+      const buffer = Buffer.alloc(kBufSize);
+
+      if (err) {
+        console.error(err);
+        return;
+      }
+
+      const read = () => {
+        if (!running) {
+          fs.close(fd, () => {});
+          return;
+        }
+
+        fs.read(fd, buffer, 0, kBufSize, null, (err, n) => {
+          if (err) {
+            console.error(err);
+            return;
+          }
+
+          if (n === 0) {
+            return;
+          }
+
+          console.log(`StreamIn | send: ${buffer.readUInt32BE()}`);
+          nodeStreamIn.write(buffer.slice(0, n));
+          read();
+        });
+      };
+
+      read();
+    });
+
+    return;
+  }
+
+  let i = 0;
+  const kInterval = 1;
+  const buffer = Buffer.alloc(4);
+  const write = () => {
+    if (!running) {
+      device.stop();
+      return;
+    }
+
+    buffer.writeUInt32BE(i++);
+    nodeStreamIn.write(buffer);
+
+    setTimeout(write, kInterval);
+  };
+  setTimeout(write, kInterval);
+};
+
+const main = async () => {
+  const argv = cli.parseSync();
+
+  if (argv._.includes("discover")) {
+    const devices = await discover();
+    for (const device of devices) {
+      console.log(`${device.host}:${device.port}   ${device.capability}   ${device.name} (${device.serial})`);
+    }
+    return;
+  }
+
+  const { uri } = argv;
+  if (!uri) {
+    console.error("Missing URI");
+    return;
+  }
+
+  console.log(`Connecting to device @ ${uri}`);
+  const device = new Device(uri as string);
+
+  try {
+    await info(device);
+  } catch (e) {
+    console.error(e);
+    return;
+  }
+
+  if (argv._.includes("read")) {
+    return read(device, argv);
+  }
+
+  if (argv._.includes("write")) {
+    return write(device, argv);
+  }
+};
+
+main();

package/src/device.ts

@@ -0,0 +1,94 @@
+import { Channel, credentials } from "@grpc/grpc-js";
+
+import { synapse } from "./api/api";
+import Config from "./config";
+import { create } from "./utils/client";
+import { getName } from "./utils/enum";
+
+class Device {
+  rpc: any | null = null;
+  channel: Channel | null = null;
+  sockets: synapse.INodeSocket[] = [];
+
+  constructor(public uri: string) {
+    this.rpc = create(uri, credentials.createInsecure());
+    if (!this.rpc) {
+      throw new Error(`Failed to create client for ${uri}`);
+    }
+  }
+
+  async configure(config: Config): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      config.setDevice(this);
+
+      const proto = config.toProto();
+      this.rpc.configure(proto, (err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (this._handleStatusResponse(res!)) {
+            resolve(true);
+          } else {
+            reject(`Error configuring device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+          }
+        }
+      });
+    });
+  }
+
+  async info(): Promise<synapse.DeviceInfo> {
+    return new Promise((resolve, reject) => {
+      this.rpc.info({}, (err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          resolve(res!);
+        }
+      });
+    });
+  }
+
+  async start(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      this.rpc.start({}, (err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (this._handleStatusResponse(res!)) {
+            resolve(true);
+          } else {
+            reject(`Error starting device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+          }
+        }
+      });
+    });
+  }
+
+  async stop(): Promise<boolean> {
+    return new Promise((resolve, reject) => {
+      this.rpc.stop({}, (err, res) => {
+        if (err) {
+          reject(err);
+        } else {
+          if (this._handleStatusResponse(res!)) {
+            resolve(true);
+          } else {
+            reject(`Error stopping device: (code: ${getName(synapse.StatusCode, res.code)}) ${res.message}`);
+          }
+        }
+      });
+    });
+  }
+
+  _handleStatusResponse(status: synapse.Status): boolean {
+    const { code, sockets } = status;
+    if (code && (code as any) !== synapse.StatusCode.kOk) {
+      return false;
+    } else {
+      this.sockets = sockets || [];
+      return true;
+    }
+  }
+}
+
+export default Device;

package/src/index.ts

@@ -0,0 +1,4 @@
+export { default as Config } from "./config";
+export { default as Device } from "./device";
+export * from "./nodes";
+export { synapse } from "./api/api";

package/src/node.ts

@@ -0,0 +1,18 @@
+import { synapse } from "./api/api";
+import Device from "./device";
+
+class Node {
+  id?: number;
+  type: synapse.NodeType = synapse.NodeType.kNodeTypeUnknown;
+  device: Device | null = null;
+
+  toProto(config: synapse.INodeConfig = {}): synapse.NodeConfig {
+    return new synapse.NodeConfig({
+      ...config,
+      id: this.id,
+      type: this.type,
+    });
+  }
+}
+
+export default Node;

package/src/nodes/electrical_broadband.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class ElectricalBroadband extends Node {
+  type = synapse.NodeType.kElectricalBroadband;
+  config: synapse.IElectricalBroadbandConfig;
+
+  constructor(config: synapse.IElectricalBroadbandConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      electricalBroadband: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.NodeConfig): ElectricalBroadband {
+    const { electricalBroadband } = proto;
+    if (!electricalBroadband) {
+      throw new Error("Invalid config, missing electricalBroadband");
+    }
+
+    return new ElectricalBroadband(proto.electricalBroadband);
+  }
+}
+
+export default ElectricalBroadband;

package/src/nodes/electrical_stimulation.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class ElectricalStimulation extends Node {
+  type = synapse.NodeType.kElectricalStimulation;
+  config: synapse.IElectricalStimulationConfig;
+
+  constructor(config: synapse.IElectricalStimulationConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      electricalStimulation: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.INodeConfig): ElectricalStimulation {
+    const { electricalStimulation } = proto;
+    if (!electricalStimulation) {
+      throw new Error("Invalid config, missing electricalStimulation");
+    }
+
+    return new ElectricalStimulation(proto.electricalStimulation);
+  }
+}
+
+export default ElectricalStimulation;

package/src/nodes/index.ts

@@ -0,0 +1,8 @@
+export { default as ElectricalBroadband } from "./electrical_broadband";
+export { default as ElectricalStimulation } from "./electrical_stimulation";
+export { default as OpticalBroadband } from "./optical_broadband";
+export { default as OpticalStimulation } from "./optical_stimulation";
+export { default as SpectralFilter } from "./spectral_filter";
+export { default as SpikeDetect } from "./spike_detect";
+export { default as StreamIn } from "./stream_in";
+export { default as StreamOut } from "./stream_out";

package/src/nodes/optical_broadband.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class OpticalBroadband extends Node {
+  type = synapse.NodeType.kOpticalBroadband;
+  config: synapse.IOpticalBroadbandConfig;
+
+  constructor(config: synapse.IOpticalBroadbandConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      opticalBroadband: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.INodeConfig): OpticalBroadband {
+    const { opticalBroadband } = proto;
+    if (!opticalBroadband) {
+      throw new Error("Invalid config, missing opticalBroadband");
+    }
+
+    return new OpticalBroadband(proto.opticalBroadband);
+  }
+}
+
+export default OpticalBroadband;

package/src/nodes/optical_stimulation.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class OpticalStimulation extends Node {
+  type = synapse.NodeType.kOpticalStimulation;
+  config: synapse.IOpticalStimulationConfig;
+
+  constructor(config: synapse.IOpticalStimulationConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      opticalStimulation: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.INodeConfig): OpticalStimulation {
+    const { opticalStimulation } = proto;
+    if (!opticalStimulation) {
+      throw new Error("Invalid config, missing opticalStimulation");
+    }
+
+    return new OpticalStimulation(proto.opticalStimulation);
+  }
+}
+
+export default OpticalStimulation;

package/src/nodes/spectral_filter.ts

@@ -0,0 +1,30 @@
+import { synapse } from "../api/api";
+import Node from "../node";
+
+class SpectralFilter extends Node {
+  type = synapse.NodeType.kSpectralFilter;
+  config: synapse.ISpectralFilterConfig;
+
+  constructor(config: synapse.ISpectralFilterConfig = {}) {
+    super();
+
+    this.config = config;
+  }
+
+  toProto(): synapse.NodeConfig {
+    return super.toProto({
+      spectralFilter: this.config,
+    });
+  }
+
+  static fromProto(proto: synapse.INodeConfig): SpectralFilter {
+    const { spectralFilter } = proto;
+    if (!spectralFilter) {
+      throw new Error("Invalid config, missing spectralFilter");
+    }
+
+    return new SpectralFilter(proto.spectralFilter);
+  }
+}
+
+export default SpectralFilter;