slm_open_api_package 0.2.10__py3-none-any.whl

slm_api/CPB_example.py

@@ -0,0 +1,74 @@
+import threading
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+from slm_api.helpers import webxi_helper_functions as webxi_helper 
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.helpers.data_handler import CsvDataHandler,PickleDataHandler,JsonDataHandler,MultiDataHandler, DataHandler
+
+
+host = webxi_helper.set_host(__file__)
+# sequence_names = ["LAeq"]
+cpb_sequence_names = ["CPBLAeq"]
+
+
+sequenceID= SequenceIdEnums.CPBLAeq.value   
+
+class PrintHandler(DataHandler):
+    def handle(self, value, **data ):
+        print(f"{value}")
+
+
+class FigureHandler:
+    
+    def __init__(self, dataHandler):
+        self.dataHandler = dataHandler
+        self.fig, self.ax = plt.subplots(1,1, figsize=(10,5))
+        self.CPBFreq = dataHandler.calcFreqBands()
+        self.freq = [(i.replace("000.0","k")).replace(".0", "") for i in [str(i) for i in self.CPBFreq]]
+        self.ln = self.ax.bar(self.freq, np.zeros(len(self.freq)), width=.99)
+        self.ax.set_ylim(bottom=-20, top=120)
+        self.ax.grid(axis='y')
+        self.ax.set_ylabel("dB [SPL]")
+        self.ax.set_xlabel("Frequency band [Hz]")
+        self.fig.autofmt_xdate()
+        self.fig.tight_layout()
+        self.fig.canvas.mpl_connect('close_event', on_close)
+
+    def _update(self, i): 
+        for rect, h in zip(self.ln.patches, self.dataHandler.CPB_values):
+            rect.set_height(h)
+
+    def startAnimation(self):
+        self.ani = FuncAnimation(self.fig, self._update, interval=1000) 
+
+def on_close(event):
+    streamer.stopStream()
+    streamer.data_handler.close()
+
+
+if __name__ == "__main__":
+    # turns off all CPB freq weights
+    webxi_helper.turn_off_CPB_freq_weight(host)
+
+    # turns on the CPB freq weight we want to use, in this case A weight
+    webxi_helper.turn_on_CPB_freq_weight(host, ["A"])
+
+    # turns on the CPB eq we want to use
+    webxi_helper.turn_on_cpb_leq(host, cpb_sequence_names)
+
+    streamer = WebXiStreamHandler(host,
+                                  sequenceID=sequenceID, 
+                                  mode="cpb",
+                                  sequenceNames=cpb_sequence_names, 
+                                  saving_path=r"./saved_data/test_file",
+                                  saving="json")
+    # streamer.setDataHandler(JsonDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt"))
+    streamer.setDataHandler(PrintHandler())
+    
+    fig = FigureHandler(streamer)
+    threading.Thread(target=streamer.startStream, daemon=True).start()
+    fig.startAnimation()
+    plt.show()

slm_api/__init__.py

@@ -0,0 +1,5 @@
+"""Top-level package for slm_api (submodules are not auto-imported)."""
+
+
+def main() -> None:
+    print("Hello from open-api-package!")

slm_api/enums/fast_log_intervals_enum.py

@@ -0,0 +1,16 @@
+from enum import Enum
+
+class FastLogInterval(Enum):
+    """ControlBBFastLoggingInterval enum indices (member value = device index, name = ms/sample)."""
+    interval_1ms = 0
+    interval_2ms = 1
+    interval_4ms = 2
+    interval_8ms = 3
+    interval_16ms = 4
+    interval_32ms = 5
+    interval_63ms = 6
+    interval_125ms = 7
+    interval_250ms = 8
+    interval_500ms = 9
+    interval_1000ms = 10
+

slm_api/enums/sequence_id_enum.py

@@ -0,0 +1,352 @@
+from enum import Enum
+
+class SequenceIdEnums(Enum):
+    MeasurementCounter = 0
+    ElapsedTime = 1
+    StartTime = 2
+    LatchedOverload = 3
+    Overload = 4
+    Underrange = 5
+
+    LAeq = 6
+    LCeq = 7
+    LZeq = 8
+    LBeq = 9
+
+    LAIeq = 11
+
+    LAFmax = 12
+    LCFmax = 13
+    LZFmax = 14
+    LBFmax = 15
+
+    LASmax = 16
+    LCSmax = 17
+    LZSmax = 18
+    LBSmax = 19
+
+    LAImax = 20
+
+    LAFmin = 21
+    LCFmin = 22
+    LZFmin = 23
+    LBFmin = 24
+
+    LASmin = 25
+    LCSmin = 26
+    LZSmin = 27
+    LBSmin = 28
+
+    LApeak = 29
+    LCpeak = 30
+    LZpeak = 31
+    LBpeak = 32
+
+    LAFTeq = 34
+
+    CPBLAeq = 35
+    CPBLCeq = 36
+    CPBLZeq = 37
+    CPBLBeq = 38
+
+    CPBLAFmax = 40
+    CPBLCFmax = 41
+    CPBLZFmax = 42
+    CPBLBFmax = 43
+
+    CPBLASmax = 45
+    CPBLCSmax = 46
+    CPBLZSmax = 47
+    CPBLBSmax = 48
+
+    CPBLAFmin = 50
+    CPBLCFmin = 51
+    CPBLZFmin = 52
+    CPBLBFmin = 53
+
+    CPBLASmin = 55
+    CPBLCSmin = 56
+    CPBLZSmin = 57
+    CPBLBSmin = 58
+
+    LAF250ms = 60
+    LCF250ms = 61
+    LZF250ms = 62
+    LBF250ms = 63
+
+    LAS250ms = 64
+    LCS250ms = 65
+    LZS250ms = 66
+    LBS250ms = 67
+
+    LAF = 68
+    LCF = 69
+    LZF = 70
+    LBF = 71
+
+    LAS = 72
+    LCS = 73
+    LZS = 74
+    LBS = 75
+
+    CPBLAF = 76
+    CPBLCF = 77
+    CPBLZF = 78
+    CPBLBF = 79
+
+    CPBLAS = 81
+    CPBLCS = 82
+    CPBLZS = 83
+    CPBLBS = 84
+
+    LavS4 = 86
+    LavS5 = 87
+
+    L10 = 90
+
+    LAE = 91
+    LCE = 92
+    LZE = 93
+    LBE = 94
+
+    LApeak1s = 96
+    LCpeak1s = 97
+    LZpeak1s = 98
+    LBpeak1s = 99
+
+    LN1 = 101
+    LN2 = 102
+    LN3 = 103
+    LN4 = 104
+    LN5 = 105
+    CPBLN1 = 106
+    CPBLN2 = 107
+    CPBLN3 = 108
+    CPBLN4 = 109
+    CPBLN5 = 110
+
+    FastLAeq = 111
+    FastLCeq = 112
+    FastLZeq = 113
+    FastLBeq = 114
+
+    FastLAF = 115
+    FastLCF = 116
+    FastLZF = 117
+    FastLBF = 118
+
+    FastLAS = 119
+    FastLCS = 120
+    FastLZS = 121
+    FastLBS = 122
+
+    FastCPBLAeq = 123
+    FastCPBLCeq = 124
+    FastCPBLZeq = 125
+    FastCPBLBeq = 126
+
+    FastCPBLAF = 127
+    FastCPBLCF = 128
+    FastCPBLZF = 129
+    FastCPBLBF = 130
+
+    FastCPBLAS = 131
+    FastCPBLCS = 132
+    FastCPBLZS = 133
+    FastCPBLBS = 134
+
+    LAS125ms = 135
+    LCS125ms = 136
+    LZS125ms = 137
+    LBS125ms = 138
+
+    StopTime = 140
+
+    Latitude = 141
+    Longitude = 142
+    SerialNumber = 143
+    HWVersion = 144
+    SWVersion = 145
+    TimeZoneGMT = 146
+    Transducer = 147
+    Sensitivity = 148
+    Calibrated = 149
+    NoneValue = 150
+
+    LoggingIntervalTime = 151
+    BBFastLoggingIntervalTime = 152
+    CPBFastLoggingIntervalTime = 153
+    # Special enums for Sound Encoding
+    MP3PeriodTime = 154
+    FLACPeriodTime = 155
+    MP3Signal = 156
+    FLACSignal = 157
+
+    LAFSPL = 158
+    LCFSPL = 159
+    LZFSPL = 160
+    LBFSPL = 161
+    LASSPL = 162
+    LCSSPL = 163
+    LZSSPL = 164
+    LBSSPL = 165
+
+    LAI = 166
+    LAI250ms = 167
+    Altitude = 168
+    LatitudePrecision = 169
+    LongitudePrecision = 170
+    AltitudePrecision = 171
+    SLMTime = 172
+    CPBLAeq2nd = 173
+    CPBLCeq2nd = 174
+    CPBLZeq2nd = 175
+    CPBLBeq2nd = 176
+
+    CPBLAFmax2nd = 178
+    CPBLCFmax2nd = 179
+    CPBLZFmax2nd = 180
+    CPBLBFmax2nd = 181
+
+    CPBLASmax2nd = 183
+    CPBLCSmax2nd = 184
+    CPBLZSmax2nd = 185
+    CPBLBSmax2nd = 186
+
+    CPBLAFmin2nd = 188
+    CPBLCFmin2nd = 189
+    CPBLZFmin2nd = 190
+    CPBLBFmin2nd = 191
+
+    CPBLASmin2nd = 193
+    CPBLCSmin2nd = 194
+    CPBLZSmin2nd = 195
+    CPBLBSmin2nd = 196
+
+    CPBLAF2nd = 198
+    CPBLCF2nd = 199
+    CPBLZF2nd = 200
+    CPBLBF2nd = 201
+
+    CPBLAS2nd = 203
+    CPBLCS2nd = 204
+    CPBLZS2nd = 205
+    CPBLBS2nd = 206
+
+    StatLAeq = 208
+    StatLAF = 209
+    StatLAS = 210
+    StatCPBLAF = 211
+    StatCPBLCF = 212
+    StatCPBLZF = 213
+    StatCPBLBF = 214
+
+    StatCPBLAS = 216
+    StatCPBLCS = 217
+    StatCPBLZS = 218
+    StatCPBLBS = 219
+
+    BBStatLoggingIntervalTime = 221
+    CPBStatLoggingIntervalTime = 222
+
+    WindDirection = 223
+    WindSpeed = 224
+    WindDirectionAvg = 225
+    WindDirectionMin = 226
+    WindDirectionMax = 227
+    WindSpeedAvg = 228
+    WindSpeedMin = 229
+    WindSpeedMax = 230
+    Temperature = 231
+    Humidity = 232
+    Pressure = 233
+    Rainfall = 234
+
+    CICStatus = 235
+    CIC125Hz = 236
+    CIC1000Hz = 237
+    CIC4000Hz = 238
+    CPBEDT = 239
+    CPBT20 = 240
+    CPBT30 = 241
+    LAeqTaiSIL = 242
+    LCeqTaiSIL = 243
+    LZeqTaiSIL = 244
+    LBeqTaiSIL = 245
+
+    StatCPBLAeq = 247
+    StatCPBLCeq = 248
+    StatCPBLZeq = 249
+    StatCPBLBeq = 250
+
+    GeneratorOnSamplesStart = 252
+    FastCPBLAeq2nd = 253
+    FastCPBLCeq2nd = 254
+    FastCPBLZeq2nd = 255
+    FastCPBLBeq2nd = 256
+    FastCPBLAF2nd = 257
+    FastCPBLCF2nd = 258
+    FastCPBLZF2nd = 259
+    FastCPBLBF2nd = 260
+    FastCPBLAS2nd = 261
+    FastCPBLCS2nd = 262
+    FastCPBLZS2nd = 263
+    FastCPBLBS2nd = 264
+    GeneratorOnSamplesEnd = 265
+    DecayLength = 266
+    StdDev = 267
+    CICRunning = 268
+    LinearVibration = 269
+    PeakVibration = 270
+    Peak1sVibration = 271
+    FmaxVibration = 272
+    SmaxVibration = 273
+    FminVibration = 274
+    SminVibration = 275
+    TPeakVibration = 276
+    PeakPeakVibration = 277
+    CrestfactorVibration = 278
+    FVibration = 279
+    SVibration = 280
+    FVibration250ms = 281
+    SVibration250ms = 282
+    CPBLinearVibration = 283
+    CPBFmaxVibration = 284
+    CPBSmaxVibration = 285
+    CPBFminVibration = 286
+    CPBSminVibration = 287
+    CPBFVibration = 288
+    CPBSVibration = 289
+    FastLinearVibration = 290
+    FastFVibration = 291
+    FastSVibration = 292
+    FastCPBLinearVibration = 293
+    FastCPBFVibration = 294
+    FastCPBSVibration = 295
+    LinearVibration2nd = 296
+    PeakVibration2nd = 297
+    Peak1sVibration2nd = 298
+    FmaxVibration2nd = 299
+    SmaxVibration2nd = 300
+    FminVibration2nd = 301
+    SminVibration2nd = 302
+    TPeakVibration2nd = 303
+    PeakPeakVibration2nd = 304
+    CrestfactorVibration2nd = 305
+    FVibration2nd = 306
+    SVibration2nd = 307
+    FVibration250ms2nd = 308
+    SVibration250ms2nd = 309
+    LAeqMov = 310
+    LAeqMovMax = 311
+    LCeqMov = 312
+    LCeqMovMax = 313
+    LAeqMov2nd = 314
+    LAeqMovMax2nd = 315
+    LCeqMov2nd = 316
+    LCeqMovMax2nd = 317
+    DeltaLeqMov = 318
+    DeltaLeqMovMax = 319
+    DeltaLeqMov2nd = 320
+    DeltaLeqMovMax2nd = 321
+    ScreenImage = 322

slm_api/example_multi.py

@@ -0,0 +1,78 @@
+# This example will show how to stream multiple sequences at the same time using the same stream
+# For this example enable the wanted sequences on the device
+import threading
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+from slm_api.helpers import stream_handlers as sh
+from slm_api.helpers.data_handler import DataHandler, MultiDataHandler
+
+# UseHttps(use_https=False)
+
+host = webxi_helper.set_host(__file__)
+
+# This example will stream LAeq. Add more names to the list to plot several sequences at once.
+# Incase of error make sure the sequences are enabled on the SLM.
+sequenceNames = ["LAeq", "LCeq", "LAF"]
+
+class PrintHandler(DataHandler):
+    def handle(self, *, name, value, **data):
+        print(f"{name}: {value}")
+
+
+class FigHandler(DataHandler):
+    """Plot raw multi-sequence values received from the stream."""
+
+    def __init__(self, sequence_names, buffer_size=101):
+        self.buffers = {
+            name: np.full(buffer_size, np.nan)
+            for name in sequence_names
+        }
+        self.fig, self.ax = plt.subplots(1,1)
+        axis = np.arange(-(buffer_size - 1), 1, 1)
+        self.ln = []
+        for name in sequence_names:
+            self.ln.append((self.ax.plot(axis, self.buffers[name], label=name))[0])
+        self.ax.set_xlim(left=np.min(axis), right=np.max(axis))
+        self.ax.set_ylim(bottom=00, top=100)
+        self.ax.set_xlabel("Time [s]")
+        self.ax.set_ylabel("dB [SPL]")
+        self.ax.set_title('Instantaneous')
+        self.ax.grid()
+        self.fig.autofmt_xdate()
+        self.fig.tight_layout()
+        self.fig.canvas.mpl_connect('close_event', on_close)
+        self.fig.canvas.setWindowTitle('LAeq example') 
+
+    def handle(self, *, name, value, **data):
+        self.buffers[name] = np.append(self.buffers[name][1:], value)
+
+    def _update(self, i): 
+        for line, name in zip(self.ln, sequenceNames):
+            line.set_ydata(self.buffers[name])
+
+    def startAnimation(self):
+        self.ani = FuncAnimation(self.fig, self._update, interval=1000)    
+
+
+def on_close(event):
+    streamer.stopStream()
+
+if __name__ == "__main__":
+    # turns off all BB freq weights to prevent interference
+    webxi_helper.turn_off_bb_freq_weight(host)
+
+    # turns on the wanted BB freq weights for this example
+    webxi_helper.turn_on_bb_freq_weight(host, ["A", "C"])
+
+    # sets the sequences to true. You can add or remove sequences at the top of the file.
+    webxi_helper.turn_on_bb_leq(host, sequenceNames)
+
+    streamer = sh.WebXiStreamHandler(host=host, sequenceNames=sequenceNames, mode="multi", saving="json", saving_path=f"./saved_data/test")
+    fig = FigHandler(sequenceNames)
+    streamer.setDataHandler(MultiDataHandler(PrintHandler(), fig))
+    fig.startAnimation()
+    threading.Thread(target=streamer.startStream, daemon=True).start()        
+    plt.show()

slm_api/fast_log_example.py

@@ -0,0 +1,172 @@
+"""
+18. Stream FastLAF (Sequence 115)
+-----------------------------------
+Streams the FastLAF (LAeq) broadband Leq value from sequence 115
+and pretty-prints each received value to the terminal.
+
+Sequence 115 properties:
+  Name:            FastLAF
+  LocalName:       LAeq
+  FunctionType:    BroadbandLeq
+  DataType:        Int16
+  Scale:           0.01
+  Weighting:       A
+  AveragingMode:   Linear
+  Unit:            dB re 20uPa
+"""
+
+import asyncio
+import time
+import requests
+from datetime import datetime
+
+# Modules to convert webxi data
+import slm_api.webxi.webxi_stream as webxiStream
+
+# Reuse existing help functions
+import slm_api.helpers.stream_handler as stream
+import slm_api.helpers.measurment_handler as meas
+import slm_api.helpers.sequence_handler as seq
+import slm_api.helpers.websocket_handler as webSocket
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+from slm_api.helpers.data_handler import DataHandler
+
+from slm_api.helpers.stream_handler import *
+from slm_api.helpers import webxi_helper_functions as webxi_helper 
+# enums
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+
+# ---------- Configuration ---------- 
+host = webxi_helper.set_host(__file__)
+
+
+SCALE = 0.01  # Raw Int16 value * SCALE = dB
+
+# WebXi header timestamps are 64-bit fixed-point seconds since the Unix epoch
+# (Q32.32): upper 32 bits = whole seconds, lower 32 bits = fraction of a second.
+WEBXI_TICKS_PER_SECOND = 2 ** 32
+
+
+FAST_LOGGING_INTERVAL_MS = FastLogInterval.interval_1000ms.value
+SEQUENCE_ID = SequenceIdEnums.FastLAF.value
+
+class PrintDataHandler(DataHandler):
+    def handle(self, timestamp, name, local, value, unit):
+        print(f"{timestamp}{name} ({local}):  {value:7.2f} {unit}")
+
+
+
+# def webxi_time_to_epoch(header_time):
+#     """Convert a WebXi header time (Q32.32 fixed-point) to Unix epoch seconds."""
+#     return header_time / WEBXI_TICKS_PER_SECOND
+
+
+# def get_fast_logging_interval_s(host):
+#     """Read the configured broadband fast-logging interval and return it in seconds."""
+#     enum = requests.get(host + "/WebXi/Applications/SLM/Setup/ControlBBFastLoggingInterval").json()
+#     if enum not in FAST_LOGGING_INTERVAL_MS:
+#         raise ValueError(f"Unexpected ControlBBFastLoggingInterval value: {enum!r}")
+#     return FAST_LOGGING_INTERVAL_MS[enum] / 1000.0
+
+
+# def get_sequence_info(host, sequence_id):
+#     """Fetch and validate sequence 115 from the device."""
+#     seq_id, sequence = seq.get_sequence(host, sequence_id)
+#     return seq_id, sequence
+
+
+# def print_data(message, seq_id, sequence, interval_s):
+#     """Decode a websocket message and pretty-print each value with its own timestamp."""
+#     package = webxiStream.WebxiStream.from_bytes(message)
+#     if package.header.message_type != webxiStream.WebxiStream.Header.EMessageType.e_sequence_data:
+#         return
+
+#     # The header time is the time of the first sample; fall back to wall clock if
+#     # it is not in the expected Q32.32 format/epoch.
+#     start = webxi_time_to_epoch(package.header.time)
+#     if abs(start - time.time()) > 86400:
+#         start = time.time()
+
+#     # A 1-second package batches many fast-logged samples.
+#     samples = []
+#     for block in package.content.sequence_blocks:
+#         if block.sequence_id != seq_id:
+#             continue
+#         # Determine vector length from sequence metadata or byte count
+#         vector_length = sequence.get("VectorLength", None)
+#         if vector_length is None and sequence["DataType"] == "Int16":
+#             vector_length = len(block.values) // 2
+#         raw = stream.data_type_conv(sequence["DataType"], block.values, vector_length if vector_length and vector_length > 1 else None)
+#         if isinstance(raw, list):
+#             samples.extend(v * SCALE for v in raw)
+#         else:
+#             samples.append(raw * SCALE)
+
+#     if not samples:
+#         return
+
+#     name = sequence.get('Name', 'FastLAeq')
+#     local = sequence.get('LocalName', 'LAeq')
+#     unit = sequence.get('Unit', 'dB re 20uPa')
+#     for n, v in enumerate(samples):
+#         timestamp = datetime.fromtimestamp(start + n * interval_s).strftime("%H:%M:%S.%f")[:-3]
+#         print(f"[{timestamp}]  {name} ({local}):  {v:7.2f} {unit}")
+#     print(f"  >> {len(samples)} sample(s) in this rx block")
+
+
+# async def main():
+#     # Retrieve sequence metadata from device
+#     seq_id, sequence = get_sequence_info(host, SEQUENCE_ID)
+
+#     interval_s = get_fast_logging_interval_s(host)
+
+#     print("=" * 60)
+#     print(f"  Streaming: {sequence.get('Name', 'FastLAeq')}")
+#     print(f"  Sequence:  {SEQUENCE_ID}")
+#     print(f"  Weighting: {sequence.get('AcousticalWeighting', 'A')}")
+#     print(f"  Unit:      {sequence.get('Unit', 'dB re 20uPa')}")
+#     print(f"  Interval:  {interval_s * 1000:.0f} ms/sample")
+#     print("=" * 60)
+
+#     STREAM_NAME = "FastLAeqStream"
+
+#     # Setup websocket stream for sequence 115
+#     uri = stream.setup_stream(host, [seq_id], STREAM_NAME)
+
+#     # Start measurement (no-op if already running)
+#     meas.start_pause_measurement(host, True)
+
+#     # Stream and print values until interrupted (Ctrl+C)
+#     msg_func = lambda msg: print_data(msg, seq_id, sequence, interval_s)
+#     try:
+#         await webSocket.next_async_websocket(uri, msg_func)
+#     finally:
+#         # Delete the stream from the device
+#         stream_id = stream.get_stream_ID(host, STREAM_NAME)
+#         if stream_id is not None:
+#             response = requests.delete(f"{host}/WebXi/Streams/{stream_id}")
+#             print(f"\nStream deleted (status {response.status_code})")
+
+
+if __name__ == "__main__":
+    
+    try:
+        streamer = WebXiStreamHandler(host,
+                                      sequenceID = SEQUENCE_ID, 
+                                      mode="fast_logging",
+                                      fast_logging_interval=FAST_LOGGING_INTERVAL_MS,
+                                      saving="csv",
+                                      saving_path=r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt")
+        streamer.setDataHandler(PrintDataHandler())
+                                                 
+
+        streamer.startStream()
+        # asyncio.run(main())
+    except KeyboardInterrupt:
+        # streamID = get_stream_ID(host, streamer.streamName)
+        streamer.data_handler.close()
+        delete_stream(host, streamer.streamName)
+        meas.stop_measurement(host)
+        print("\nStream stopped by user.")
+