@science-corporation/synapse 1.1.0 → 2.2.2

package/synapse-api/api/nodes/spike_detector.proto

@@ -0,0 +1,19 @@
+syntax = "proto3";
+
+package synapse;
+
+message TemplateMatcher {
+  repeated uint32 template_uV = 1;
+}
+
+message Thresholder {
+  uint32 threshold_uV = 1;
+}
+
+message SpikeDetectorConfig {
+  oneof config {
+    Thresholder thresholder = 1;
+    TemplateMatcher template_matcher = 2;
+  }
+  uint32 samples_per_spike = 3;
+}

package/synapse-api/api/performance.proto

@@ -0,0 +1,29 @@
+syntax = "proto3";
+
+package synapse;
+
+// Statistics about the performance of a function call or block of computation
+message FunctionProfile {
+    string name = 1;
+
+    // How often has this been called
+    uint64 call_count = 2;
+
+    // What was the minimal time it took for this function to execute
+    uint64 min_duration_ns = 3;
+
+    // Maximum execution for this function
+    uint64 max_duration_ns = 4;
+
+    // Average (mean) of this function over all samples
+    uint64 average_duration_ns = 5;
+
+    // Median execution time over all samples
+    uint64 median_duration_ns = 6;
+
+    // p99 duration
+    uint64 p99_duration_ns = 7;
+
+    // The last measurement duration
+    uint64 latest_duration_ns = 8;
+}

package/synapse-api/api/query.proto

@@ -4,6 +4,8 @@ package synapse;
 
 import "api/channel.proto";
 import "api/status.proto";
+import "api/tap.proto";
+import "api/device.proto";
 
 message SampleQuery {
   repeated Channel channels = 1;
@@ -46,20 +48,44 @@ message QueryRequest {
     kImpedance = 1;
     kSample = 2;
     kSelfTest = 3;
+    kListTaps = 4;
+    kGetSettings = 5;
   }
   QueryType query_type = 1;
   oneof query {
     ImpedanceQuery impedance_query = 2;
     SampleQuery sample_query = 3;
     SelfTestQuery self_test_query = 4;
+    ListTapsQuery list_taps_query = 5;
+    GetSettingsQuery get_settings_query = 6;
   }
 }
 
+message StreamQueryRequest {
+  QueryRequest request = 1;
+
+  // Other options to fill in specific to a stream
+}
+
 message QueryResponse {
   Status status = 1;
   repeated uint32 data = 2;
   oneof response {
     ImpedanceResponse impedance_response = 3;
     SelfTestResponse self_test_response = 4;
+    ListTapsResponse list_taps_response = 5;
+    GetSettingsResponse get_settings_response = 6;
+  }
+}
+
+message StreamQueryResponse {
+  StatusCode code = 1;
+  string message = 2;
+  uint64 timestamp_ns = 3;
+  
+  // We need to switch on the test being run
+  oneof response {
+    ImpedanceResponse impedance = 4;
+    SelfTestResponse self_test = 5;
   }
-}
+}

package/synapse-api/api/status.proto

@@ -41,8 +41,13 @@ message Status {
   string message = 1;
   StatusCode code = 2;
   DeviceState state = 3;
-  repeated NodeSocket sockets = 4;
+  // repeated NodeSocket sockets = 4;
+  reserved 4;
   DevicePower power = 5;
   DeviceStorage storage = 6;
   SignalChainStatus signal_chain = 7;
+
+  // If the device supports a time sync server (see time.proto)
+  // Then the UDP echo server will be available at this port
+  uint32 time_sync_port = 8; // Port number (0-65535) for the UDP time sync server
 }

package/synapse-api/api/synapse.proto

@@ -3,41 +3,13 @@ syntax = "proto3";
 package synapse;
 
 import "google/protobuf/empty.proto";
-import "api/node.proto";
+
 import "api/query.proto";
 import "api/status.proto";
 import "api/files.proto";
 import "api/logging.proto";
-
-message Peripheral {
-  enum Type {
-    kUnknown = 0;
-    kBroadbandSource = 1;
-    kElectricalStimulation = 2;
-    kOpticalStimulation = 3;
-    kSpikeSource = 4;
-  }
-  string name = 1;
-  string vendor = 2;
-  uint32 peripheral_id = 3;
-  Type type = 4;
-  string address = 5;
-}
-
-message DeviceInfo {
-  string name = 1;
-  string serial = 2;
-  uint32 synapse_version = 3;
-  uint32 firmware_version = 4;
-  Status status = 5;
-  repeated Peripheral peripherals = 6;
-  DeviceConfiguration configuration = 7;
-}
-
-message DeviceConfiguration {
-  repeated NodeConfig nodes = 1;
-  repeated NodeConnection connections = 2;
-}
+import "api/app.proto";
+import "api/device.proto";
 
 service SynapseDevice {
   rpc Info(google.protobuf.Empty) returns (DeviceInfo) {}
@@ -45,11 +17,17 @@ service SynapseDevice {
   rpc Start(google.protobuf.Empty) returns (Status) {}
   rpc Stop(google.protobuf.Empty) returns (Status) {}
   rpc Query(QueryRequest) returns (QueryResponse) {}
+  rpc StreamQuery(StreamQueryRequest) returns (stream StreamQueryResponse) {}
+
+  rpc DeployApp(stream AppPackageChunk) returns (stream AppDeployResponse) {}
 
   rpc ListFiles(google.protobuf.Empty) returns (ListFilesResponse) {}
   rpc WriteFile(WriteFileRequest) returns (WriteFileResponse) {}
   rpc ReadFile(ReadFileRequest) returns (stream ReadFileResponse) {}
   rpc DeleteFile(DeleteFileRequest) returns (DeleteFileResponse) {}
+
   rpc GetLogs(LogQueryRequest) returns (LogQueryResponse) {}
   rpc TailLogs(TailLogsRequest) returns (stream LogEntry) {}
+
+  rpc UpdateDeviceSettings(UpdateDeviceSettingsRequest) returns (UpdateDeviceSettingsResponse) {}
 }

package/synapse-api/api/tap.proto

@@ -0,0 +1,35 @@
+syntax = "proto3";
+
+package synapse;
+
+enum TapType {
+    TAP_TYPE_UNSPECIFIED = 0;
+
+    // The tap will be producing data
+    TAP_TYPE_PRODUCER = 1;
+
+    // The tap type will be consuming data
+    TAP_TYPE_CONSUMER = 2; 
+}
+
+message TapConnection {
+    // Unique name id for this tap
+    string name = 1;
+
+    // What is the zmq endpoint to connect to
+    string endpoint = 2;
+
+    // What is the protobuf message to expect over this 
+    string message_type = 3;
+
+    // Is this tap meant to be producing or consuming
+    TapType tap_type = 4;
+}
+
+message ListTapsQuery {
+
+}
+
+message ListTapsResponse {
+    repeated TapConnection taps = 1;
+}

package/synapse-api/api/time.proto

@@ -0,0 +1,53 @@
+syntax = "proto3";
+
+package synapse;
+
+/**
+ * Used for precise time synchronization over UDP between clients and a server
+ * In most cases, the server is the Synapse device.enum
+ * 
+ * How it works:
+ *  1. Client generates a random client_id on first connection
+ *  2. Client increments the sequence number on each packet (to detect drops)
+ *  3. Client records the send time and sends the packet to the server over udp.
+ *    - The server port will be available through the Status message
+ *    - Try to timestamp the packet as close as possible to the send to minimize
+ *      the calculated offset error. Future improvements could support hardware timestamps
+ *  4. Server records the receive time
+ *  5. Server immediately echos it back to the client, recording the send time
+ *  6. Client records the receive time when the packet returns
+ * 
+ * With these times, the client can calculate
+ *  - Round Trip Time: (client_receive_time_ns - client_send_time_ns)
+ *  - Network Latency (assumes symmetric paths): rtt / 2
+ *  - Clock offset: https://en.wikipedia.org/wiki/Network_Time_Protocol#Clock_synchronization_algorithm
+ * 
+ * Implementation notes:
+ *  - All timestamps are monotonic nanoseconds since Unix epoch
+ *  - The server acts as a passive reflector
+ *  - Multiple sync packets (8 or so) should be sent with a short period (200 ms) between
+*/
+message TimeSyncPacket {
+    fixed32 client_id = 1;
+    fixed32 sequence = 2;
+
+    fixed64 client_send_time_ns = 3;
+    fixed64 server_receive_time_ns = 4;
+    fixed64 server_send_time_ns = 5;
+    fixed64 client_receive_time_ns = 6;
+}
+
+// Defines the time synchronization method for device timestamps
+enum TimeSource {
+    TIME_SOURCE_UNKNOWN = 0;
+        
+    // Use std::chrono::steady_clock (monotonic, immune to system time changes)
+    // Note: The epoch is implementation-defined (often system boot time)
+    TIME_SOURCE_STEADY_CLOCK = 1;
+  
+    // Calculate timestamps based on sample counter and sampling rate
+    // counter_diff = (counter - first_counter)
+    // timestamp_ns = (counter_diff * 1e9 / sample_rate) + initial_steady_clock_value
+    // Where initial_steady_clock_value = get_steady_clock_now() at start
+    TIME_SOURCE_SAMPLE_COUNTER = 2;
+}