@science-corporation/synapse 0.13.0 → 2.0.0

package/src/api/proto.json

@@ -150,37 +150,52 @@
             }
           }
         },
-        "SpikeDetectConfig": {
+        "SpikeBinnerConfig": {
           "fields": {
-            "mode": {
-              "type": "SpikeDetectMode",
-              "id": 1
-            },
-            "thresholdUV": {
+            "binSizeMs": {
               "type": "uint32",
-              "id": 2
-            },
+              "id": 1
+            }
+          }
+        },
+        "TemplateMatcher": {
+          "fields": {
             "templateUV": {
               "rule": "repeated",
               "type": "uint32",
-              "id": 3
-            },
-            "sort": {
-              "type": "bool",
-              "id": 4
-            },
-            "binSizeMs": {
+              "id": 1
+            }
+          }
+        },
+        "Thresholder": {
+          "fields": {
+            "thresholdUV": {
               "type": "uint32",
-              "id": 5
+              "id": 1
+            }
+          }
+        },
+        "SpikeDetectorConfig": {
+          "oneofs": {
+            "config": {
+              "oneof": [
+                "thresholder",
+                "templateMatcher"
+              ]
             }
           },
-          "nested": {
-            "SpikeDetectMode": {
-              "values": {
-                "kThreshold": 0,
-                "kTemplate": 1,
-                "kWavelet": 2
-              }
+          "fields": {
+            "thresholder": {
+              "type": "Thresholder",
+              "id": 1
+            },
+            "templateMatcher": {
+              "type": "TemplateMatcher",
+              "id": 2
+            },
+            "samplesPerSpike": {
+              "type": "uint32",
+              "id": 3
             }
           }
         },
@@ -212,7 +227,8 @@
             "kBroadband": 2,
             "kSpiketrain": 3,
             "kTimestamps": 4,
-            "kImage": 5
+            "kImage": 5,
+            "kWaveforms": 6
           }
         },
         "DiskWriterConfig": {
@@ -223,14 +239,33 @@
             }
           }
         },
+        "UDPUnicastConfig": {
+          "fields": {
+            "destinationAddress": {
+              "type": "string",
+              "id": 1
+            },
+            "destinationPort": {
+              "type": "uint32",
+              "id": 2
+            }
+          }
+        },
         "StreamOutConfig": {
+          "oneofs": {
+            "transport": {
+              "oneof": [
+                "udpUnicast"
+              ]
+            }
+          },
           "fields": {
             "label": {
               "type": "string",
               "id": 1
             },
-            "multicastGroup": {
-              "type": "string",
+            "udpUnicast": {
+              "type": "UDPUnicastConfig",
               "id": 2
             }
           }
@@ -240,6 +275,10 @@
             "throughputMbps": {
               "type": "float",
               "id": 1
+            },
+            "failedSendCount": {
+              "type": "uint64",
+              "id": 2
             }
           }
         },
@@ -435,6 +474,11 @@
               "requestType": "QueryRequest",
               "responseType": "QueryResponse"
             },
+            "StreamQuery": {
+              "requestType": "StreamQueryRequest",
+              "responseType": "StreamQueryResponse",
+              "responseStream": true
+            },
             "ListFiles": {
               "requestType": "google.protobuf.Empty",
               "responseType": "ListFilesResponse"
@@ -471,10 +515,11 @@
             "kBroadbandSource": 3,
             "kElectricalStimulation": 4,
             "kOpticalStimulation": 5,
-            "kSpikeDetect": 6,
+            "kSpikeDetector": 6,
             "kSpikeSource": 7,
             "kSpectralFilter": 8,
-            "kDiskWriter": 9
+            "kDiskWriter": 9,
+            "kSpikeBinner": 10
           }
         },
         "NodeConfig": {
@@ -486,10 +531,11 @@
                 "broadbandSource",
                 "electricalStimulation",
                 "opticalStimulation",
-                "spikeDetect",
+                "spikeDetector",
                 "spectralFilter",
                 "diskWriter",
-                "spikeSource"
+                "spikeSource",
+                "spikeBinner"
               ]
             }
           },
@@ -522,8 +568,8 @@
               "type": "OpticalStimulationConfig",
               "id": 8
             },
-            "spikeDetect": {
-              "type": "SpikeDetectConfig",
+            "spikeDetector": {
+              "type": "SpikeDetectorConfig",
               "id": 9
             },
             "spectralFilter": {
@@ -537,6 +583,10 @@
             "spikeSource": {
               "type": "SpikeSourceConfig",
               "id": 12
+            },
+            "spikeBinner": {
+              "type": "SpikeBinnerConfig",
+              "id": 13
             }
           }
         },
@@ -747,6 +797,14 @@
             }
           }
         },
+        "StreamQueryRequest": {
+          "fields": {
+            "request": {
+              "type": "QueryRequest",
+              "id": 1
+            }
+          }
+        },
         "QueryResponse": {
           "oneofs": {
             "response": {
@@ -776,6 +834,38 @@
             }
           }
         },
+        "StreamQueryResponse": {
+          "oneofs": {
+            "response": {
+              "oneof": [
+                "impedance",
+                "selfTest"
+              ]
+            }
+          },
+          "fields": {
+            "code": {
+              "type": "StatusCode",
+              "id": 1
+            },
+            "message": {
+              "type": "string",
+              "id": 2
+            },
+            "timestampNs": {
+              "type": "uint64",
+              "id": 3
+            },
+            "impedance": {
+              "type": "ImpedanceResponse",
+              "id": 4
+            },
+            "selfTest": {
+              "type": "SelfTestResponse",
+              "id": 5
+            }
+          }
+        },
         "StatusCode": {
           "values": {
             "kOk": 0,

package/src/config.ts

@@ -5,7 +5,8 @@ import DiskWriter from "./nodes/disk_writer";
 import ElectricalStimulation from "./nodes/electrical_stimulation";
 import OpticalStimulation from "./nodes/optical_stimulation";
 import SpectralFilter from "./nodes/spectral_filter";
-import SpikeDetect from "./nodes/spike_detect";
+import SpikeBinner from "./nodes/spike_binner";
+import SpikeDetector from "./nodes/spike_detector";
 import SpikeSource from "./nodes/spike_source";
 import StreamIn from "./nodes/stream_in";
 import StreamOut from "./nodes/stream_out";
@@ -19,7 +20,8 @@ const kNodeTypeObjectMap = {
   [synapse.NodeType.kSpikeSource]: SpikeSource,
   [synapse.NodeType.kOpticalStimulation]: OpticalStimulation,
   [synapse.NodeType.kSpectralFilter]: SpectralFilter,
-  [synapse.NodeType.kSpikeDetect]: SpikeDetect,
+  [synapse.NodeType.kSpikeBinner]: SpikeBinner,
+  [synapse.NodeType.kSpikeDetector]: SpikeDetector,
   [synapse.NodeType.kStreamIn]: StreamIn,
   [synapse.NodeType.kStreamOut]: StreamOut,
 };

package/src/demo.ts

@@ -11,15 +11,17 @@ import StreamIn from "./nodes/stream_in";
 import StreamOut from "./nodes/stream_out";
 import { discover } from "./utils/discover";
 import { getName } from "./utils/enum";
+import { getClientIp } from "./utils/ip";
 
 const cli = yargs(hideBin(process.argv))
   .help()
   .command("discover", "Discover synapse devices")
   .command("read", "Read from StreamOut node", {
-    "multicast-group": {
-      alias: "m",
+    "udp-port": {
+      alias: "p",
       type: "string",
-      description: "Multicast group",
+      description: "UDP port",
+      default: "50038",
     },
     output: {
       alias: "o",
@@ -93,7 +95,7 @@ const info = async (device: Device) => {
 const read = async (device: Device, argv: any) => {
   console.log("Reading from device's StreamOut node...");
 
-  const { multicastGroup, output } = argv;
+  const { udpPort, output } = argv;
   let status = null;
   let stream = null;
   if (output) {
@@ -122,9 +124,12 @@ const read = async (device: Device, argv: any) => {
   });
   const nodeStreamOut = new StreamOut(
     {
-      multicastGroup,
+      udpUnicast: {
+        destinationPort: udpPort,
+        destinationAddress: await getClientIp(),
+      },
     },
-    onMessage
+    { onMessage }
   );
 
   status = config.add([nodeEphys, nodeStreamOut]);
@@ -148,7 +153,11 @@ const read = async (device: Device, argv: any) => {
     return;
   }
 
-  nodeStreamOut.start();
+  status = await nodeStreamOut.start();
+  if (!status.ok()) {
+    console.error("failed to start stream out node: ", status.message);
+    return;
+  }
 
   let running = true;
   process.on("SIGINT", function () {
@@ -159,6 +168,7 @@ const read = async (device: Device, argv: any) => {
     running = false;
     nodeStreamOut.stop();
     device.stop();
+    process.exit();
   });
 };
 
@@ -280,7 +290,9 @@ const main = async () => {
   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})`);
+      const addr = `${device.host}:${device.port}`;
+      const serial = `[${device.serial}]`;
+      console.log(`${addr.padEnd(21)} ${device.capability.padStart(16)} ${serial.padStart(34)} "${device.name}"`);
     }
     return;
   }

package/src/device.ts

@@ -18,7 +18,7 @@ class Device {
     if (!status.ok() || !client) {
       throw new Error(`Failed to create client for ${uri}: ${status.message}`);
     }
-    this.rpc = client;
+    this.rpc = client as synapse.SynapseDevice;
   }
 
   async configure(config: Config, options: CallOptions = {}): Promise<Status> {
@@ -90,6 +90,39 @@ class Device {
     });
   }
 
+  async streamQuery(
+    query: synapse.IStreamQueryRequest,
+    options: CallOptions = {},
+    callbacks: {
+      onData: (data: synapse.StreamQueryResponse) => void;
+      onEnd?: () => void;
+      onError?: (err: Error) => void;
+      onStatus?: (status: Status) => void;
+    }
+  ) {
+    const { onData, onEnd, onError, onStatus } = callbacks;
+    const call = this.rpc.streamQuery(query, options);
+    call.on("data", (data: synapse.StreamQueryResponse) => {
+      onData(data);
+    });
+    if (onEnd) {
+      call.on("end", () => {
+        onEnd();
+      });
+    }
+    if (onError) {
+      call.on("error", (err: ServiceError) => {
+        onError(err);
+      });
+    }
+    if (onStatus) {
+      call.on("status", (grpcStatus) => {
+        onStatus?.(new Status(grpcStatus.code, grpcStatus.details));
+      });
+    }
+    return call;
+  }
+
   // Logs
 
   async getLogs(

package/src/nodes/index.ts

@@ -3,7 +3,8 @@ export { default as DiskWriter } from "./disk_writer";
 export { default as ElectricalStimulation } from "./electrical_stimulation";
 export { default as OpticalStimulation } from "./optical_stimulation";
 export { default as SpectralFilter } from "./spectral_filter";
-export { default as SpikeDetect } from "./spike_detect";
+export { default as SpikeBinner } from "./spike_binner";
+export { default as SpikeDetector } from "./spike_detector";
 export { default as SpikeSource } from "./spike_source";
 export { default as StreamIn } from "./stream_in";
 export { default as StreamOut } from "./stream_out";

package/src/nodes/spike_binner.ts

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

package/src/nodes/spike_detector.ts

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

package/src/nodes/stream_out.ts

@@ -2,80 +2,97 @@ import dgram from "dgram";
 
 import { synapse } from "../api/api";
 import Node from "../node";
+import { Status, StatusCode } from "../utils/status";
+import { getClientIp } from "../utils/ip";
 
-const kMulticastTTL = 3;
+const kDefaultStreamOutPort = 50038;
+const kSocketBufferSize = 5 * 1024 * 1024; // 5MB
 
 class StreamOut extends Node {
   type = synapse.NodeType.kStreamOut;
-  config: synapse.IStreamOutConfig;
-  _socket: dgram.Socket;
+  _destinationAddress: string;
+  _destinationPort: number;
+  _label: string;
+  _socket: dgram.Socket | null;
   _onMessage: ((msg: Buffer) => void) | null;
+  _onError: ((error: Error) => void) | null;
 
-  constructor(config: synapse.IStreamOutConfig, onMessage?: (msg: Buffer) => void) {
+  constructor(
+    config: synapse.IStreamOutConfig,
+    callbacks?: { onMessage?: (msg: Buffer) => void; onError?: (error: Error) => void }
+  ) {
     super();
 
-    this.config = config;
-    this._onMessage = onMessage;
+    const { udpUnicast } = config || {};
+    this._destinationAddress = udpUnicast?.destinationAddress;
+    this._destinationPort = udpUnicast?.destinationPort || kDefaultStreamOutPort;
+    this._label = config.label;
+    this._onMessage = callbacks?.onMessage;
+    this._onError = callbacks?.onError;
   }
 
-  async start(): Promise<boolean> {
-    if (this.device === null) {
-      return false;
-    }
-
-    const socket = this.device.sockets.find((s) => s.nodeId === this.id);
-    if (!socket) {
-      return false;
-    }
-
-    const split = socket.bind.split(":");
-    if (split.length !== 2) {
-      return false;
-    }
-
-    const port = parseInt(split[1]);
-    if (isNaN(port)) {
-      return false;
-    }
-
-    const host = this.config.multicastGroup;
-    if (!host) {
-      return false;
-    }
+  async start(): Promise<Status> {
+    try {
+      this._socket = dgram.createSocket("udp4");
+
+      if (!this._destinationAddress) {
+        try {
+          const ip = await getClientIp();
+          if (!ip) {
+            return new Status(StatusCode.INTERNAL, "failed to get client ip");
+          }
+          this._destinationAddress = ip;
+        } catch (e) {
+          console.error(e);
+          return new Status(StatusCode.INTERNAL, `failed to get client ip: ${e}`);
+        }
+      }
+      if (!this._destinationPort) {
+        this._destinationPort = kDefaultStreamOutPort;
+      }
 
-    this._socket = dgram.createSocket("udp4");
+      this._socket.on("message", (msg: Buffer) => {
+        this._onMessage?.(msg);
+      });
 
-    this._socket.on("error", () => {});
+      this._socket.on("error", (error: Error) => {
+        this._onError?.(error);
+      });
 
-    this._socket.on("message", (msg: Buffer) => {
-      this._onMessage?.(msg);
-    });
+      await new Promise<void>((resolve, reject) => {
+        if (!this._socket) return reject(new Error("Socket is null"));
 
-    this._socket.bind(port, host, () => {
-      if (!this._socket) {
-        return;
-      }
+        this._socket.bind(this._destinationPort, this._destinationAddress, () => {
+          this._socket.setRecvBufferSize(kSocketBufferSize);
+          resolve();
+        });
+      });
 
-      if (this.config.multicastGroup) {
-        this._socket.setMulticastTTL(kMulticastTTL);
-        this._socket.addMembership(this.config.multicastGroup);
-      }
-    });
-
-    return true;
+      return new Status();
+    } catch (e) {
+      return new Status(StatusCode.INTERNAL, `failed to start stream out node: ${e}`);
+    }
   }
 
-  async stop(): Promise<boolean> {
+  async stop(): Promise<Status> {
     if (this._socket) {
       this._socket.close();
     }
 
-    return true;
+    return new Status();
   }
 
   toProto(): synapse.NodeConfig {
+    const config: synapse.IStreamOutConfig = {
+      label: this._label,
+      udpUnicast: {
+        destinationAddress: this._destinationAddress,
+        destinationPort: this._destinationPort,
+      },
+    };
+
     return super.toProto({
-      streamOut: this.config,
+      streamOut: config,
     });
   }
 
@@ -85,7 +102,7 @@ class StreamOut extends Node {
       throw new Error("Invalid config, missing streamOut");
     }
 
-    return new StreamOut(streamOut);
+    return new StreamOut(streamOut, undefined);
   }
 }
 

package/src/utils/ip.ts

@@ -0,0 +1,35 @@
+import dgram from "dgram";
+
+export const getClientIp = async (): Promise<string | null> => {
+  return new Promise((resolve, reject) => {
+    try {
+      const socket = dgram.createSocket("udp4");
+
+      socket.on("error", (err) => {
+        console.error(err);
+        socket.close();
+        reject(err);
+      });
+
+      socket.bind(0, () => {
+        try {
+          socket.connect(53, "8.8.8.8", () => {
+            try {
+              const address = socket.address();
+              socket.close();
+              resolve(address.address);
+            } catch (e) {
+              socket.close();
+              reject(e);
+            }
+          });
+        } catch (e) {
+          socket.close();
+          reject(e);
+        }
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+};

package/synapse-api/.github/pull_request_template.md

@@ -0,0 +1,10 @@
+# Summary
+Brief overview of the changes
+
+# Changes
+* Detailed breakdown of what changed and why. If there are new/changed API concepts, explain how they are meant to be used.
+
+# Testing
+How can this change be tested?
+
+Please provide a link to a reference server and client implementation in synapse-python.

package/synapse-api/README.md

@@ -1,4 +1,4 @@
-# Synapse API 1.1
+# Synapse API 2.0.0
 
 The Synapse Protocol defines a standard interface for interacting with a wide range of possible neural interface devices.
 

package/synapse-api/api/datatype.proto

@@ -9,4 +9,5 @@ enum DataType {
     kSpiketrain = 3;
     kTimestamps = 4;
     kImage = 5;
+    kWaveforms = 6;
 }