slm_open_api_package 0.2.10__py3-none-any.whl

slm_api/helpers/websocket_handler.py

@@ -0,0 +1,12 @@
+import websockets
+import asyncio
+from . import https_requests
+
+async def next_async_websocket(uri, packetHandler):
+    ssl_context = https_requests.build_ssl_context() if uri.startswith("wss://") else None
+    async with websockets.connect(uri, ping_interval=None, ssl=ssl_context) as websocket:
+        async for message in websocket:
+            try:
+                packetHandler(message)
+            except Exception as exc:
+                print(f"Error handling message from {uri}: {exc!r}")

slm_api/helpers/webxi_helper_functions.py

@@ -0,0 +1,79 @@
+import requests
+from pathlib import Path
+from slm_api.helpers.https_requests import get, put
+
+# Functions to turn on/off BB freq weights and sequences. These are used in the examples to make sure the wanted sequences are enabled on the SLM.
+def turn_off_bb_freq_weight(host):
+    
+    for endpoint in (
+        "/webxi/Applications/SLM/Setup/BBFreqWeightB",
+        "/webxi/Applications/SLM/Setup/BBFreqWeightZ",
+        "/webxi/Applications/SLM/Setup/BBFreqWeightA",
+        "/webxi/Applications/SLM/Setup/BBFreqWeightC",
+    ):
+        try:
+            put(host , endpoint, json=False, timeout=10)
+        except requests.exceptions.HTTPError as exc:
+            print(f"Skipping {endpoint}: {exc}")
+
+def turn_on_bb_freq_weight(host, weights, fast=False):
+    weights = [weights] if isinstance(weights, str) else weights
+    if not fast:
+        for weight in weights:
+            put(host , f"/webxi/Applications/SLM/Setup/BBFreqWeight{weight}", json=True)
+    else:
+        for weight in weights:
+            put(host , f"/webxi/Applications/SLM/Setup/FastBBFreqWeight{weight}", json=True)
+
+def turn_on_bb_leq(host, weights, fast=False):
+    weights = [weights] if isinstance(weights, str) else weights
+    if not fast:
+        for weight in weights:
+                put(host, f"/webxi/Applications/SLM/Setup/BB{weight}", json=True)
+    else:
+        for weight in weights:
+            put(host, f"/webxi/Applications/SLM/Setup/FastBB{weight}", json=True)
+
+
+def turn_off_CPB_freq_weight(host):
+    put(host , "/webxi/Applications/SLM/Setup/CPBFreqWeightB", json=False)
+    put(host , "/webxi/Applications/SLM/Setup/CPBFreqWeightZ", json=False)
+    put(host , "/webxi/Applications/SLM/Setup/CPBFreqWeightA", json=False)
+    put(host , "/webxi/Applications/SLM/Setup/CPBFreqWeightC", json=False)
+
+def turn_on_CPB_freq_weight(host, weights):
+    weights = [weights] if isinstance(weights, str) else weights
+    for weight in weights:
+        put(host , f"/webxi/Applications/SLM/Setup/CPBFreqWeight{weight}", json=True)
+
+def turn_on_cpb_leq(host, weights):
+    weights = [weights] if isinstance(weights, str) else weights
+    for weight in weights:
+        put(host , f"/webxi/Applications/SLM/Setup/{weight}", json=True)
+
+
+def _find_ip_file(caller_file=None):
+    """Walk up from caller_file (or cwd) to the nearest 'slm_ip' file, else the project root (pyproject.toml/.git)."""
+    start = Path(caller_file).resolve().parent if caller_file else Path.cwd().resolve()
+    for directory in (start, *start.parents):
+        if (directory / "slm_ip").is_file():
+            return directory / "slm_ip"
+        if (directory / "pyproject.toml").is_file() or (directory / ".git").exists() or (directory / "requirements.txt").is_file():
+            return directory / "slm_ip"
+    return start / "slm_ip"
+
+def set_host(caller_file=None):
+    """Resolve the SLM host. Pass __file__ to anchor the 'slm_ip' file search to your script."""
+    ip_path = _find_ip_file(caller_file)
+    ip = ip_path.read_text(encoding="utf-8").strip() if ip_path.is_file() else None
+    if not ip:
+        # First run (or missing IP): ask once and persist it to the ip file for next time
+        ip = input("No IP found. Enter the IP address of your SLM: ").strip()
+        if not ip:
+            raise RuntimeError(f'Missing SLM IP. Create a "{ip_path.name}" file containing the IP address.')
+        try:
+            ip_path.write_text(ip, encoding="utf-8")
+            print(f"Saved IP to {ip_path}")
+        except OSError as exc:
+            print(f"Warning: could not save IP to {ip_path} ({exc}). Create it manually with the IP address to skip this prompt.")
+    return ip

slm_api/helpers/webxi_root.pem

@@ -0,0 +1,24 @@
+-----BEGIN CERTIFICATE-----
+MIIEBTCCAu2gAwIBAgIJAPJZCza59BhGMA0GCSqGSIb3DQEBCwUAMIGYMQswCQYD
+VQQGEwJVSzEPMA0GA1UECAwGU3VycmV5MQ4wDAYDVQQHDAVFZ2hhbTEVMBMGA1UE
+CgwMU3BlY3RyaXMgcGxjMRgwFgYDVQQLDA9JbnN0cnVtZW50YXRpb24xDzANBgNV
+BAMMBndlYi14aTEmMCQGCSqGSIb3DQEJARYXQ2Fyc3Rlbi5IYW5zZW5AYmtzdi5j
+b20wHhcNMTgxMjE5MTQ1MzM4WhcNNDgxMjExMTQ1MzM4WjCBmDELMAkGA1UEBhMC
+VUsxDzANBgNVBAgMBlN1cnJleTEOMAwGA1UEBwwFRWdoYW0xFTATBgNVBAoMDFNw
+ZWN0cmlzIHBsYzEYMBYGA1UECwwPSW5zdHJ1bWVudGF0aW9uMQ8wDQYDVQQDDAZ3
+ZWIteGkxJjAkBgkqhkiG9w0BCQEWF0NhcnN0ZW4uSGFuc2VuQGJrc3YuY29tMIIB
+IjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAwBbiEL0V2VF7gVzRPb45pkJ/
+Uip84zS6MWgyCUWUuqYLSlpoLkfbsVPK7JUPUfUlhw4KjYFd7M6jra98hkqPaap8
+ybeCmu3o6m4zfP0cbQD3QCEjPDNVy8fLP08D1mF3C3ksoIhGgv/0OdIC5/mJ0CEB
+RBnr4xk8Sy7wa4TEOkH1eRtOvYQyKDGEBWcuWJER5fKhBn5ZdKta1ts78ELMy/8i
+MXXtKbPxR9ZMPuqQmeYkcT9CEDVMSYoCV4Yov7Edi6JZNp6U6hqYx8UxHtl7ljTt
+aOnICI+ACcvYWKgsBZcdl4ZQ0VUTDa3FD2zUI63Sx5U2/th1ChZoRjApx0BwpwID
+AQABo1AwTjAdBgNVHQ4EFgQUMpXkaVWWnTSjYLF8UHwCvWRxMyowHwYDVR0jBBgw
+FoAUMpXkaVWWnTSjYLF8UHwCvWRxMyowDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0B
+AQsFAAOCAQEAKcbCeH+WzWiXo5xWemVz/YLq3X/QJKB4UQgbyuXWItOjMvXGP0gi
+owEY8s4y/YPGhl0R3lHFz2yLHRX0Vc+LzAB/8ob0Q0nKNttqnE3ofgZhpzUcGxVI
+Yb2CpvHHdU4TXDYdLT4pkCb6+8pqlnOyRBBlJNvO5gKMSSvxcStVLp+2CwPhtex3
+u43FzdRvC3kp0MmW1PCZgm5LqVh1IEx2TBiy9/7W5IAoSIh0bE+fGWi7NfcgZsv1
+2ZmKe/6p2vbHbarBTiOgD3GISr47+yhjN8Qd4eYPRLswZDHwkEDTW+TUvCmgbAfa
+3WCwBk4+GVXcGL/yIEWaSAIZbgAq03JsYA==
+-----END CERTIFICATE-----

slm_api/mp3_example.py

@@ -0,0 +1,165 @@
+import asyncio
+
+import miniaudio
+import requests
+import sys
+import numpy as np
+import pyqtgraph as pg
+
+# Modules to convert webxi data
+from slm_api.webxi import webxi_stream as webxiStream
+from slm_api.helpers import stream_handler as stream  # SLM stream functions
+# Start/pause/Stop measurments functions
+from slm_api.helpers import measurment_handler as meas
+# Get sequences,
+from slm_api.helpers import sequence_handler as seq
+# Stream handler
+from slm_api.helpers import stream_handlers as sh
+
+# Async functions to control communication
+from slm_api.helpers import websocket_handler as webSocket
+from timeit import default_timer as timer
+
+# Buffer and decoder for the mp3 stream
+from slm_api.helpers.buffer import DataBuffer
+from slm_api.helpers.fft import dBfft
+import threading
+
+from slm_api.helpers.FigureHandler import FigureHandler
+from slm_api.helpers import TmpfileStateMachine
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+from slm_api.helpers.data_handler import CsvDataHandler, MultiDataHandler, DataHandler
+
+host = webxi_helper.set_host(__file__)
+sequenceID = 156
+
+
+
+# class streamHandler:
+#     def __init__(self, startStream=False):
+#         self.i = 0
+#         self.tmpFileSM = TmpfileStateMachine()
+#         self.max_input = 15.6263 / np.sqrt(2)
+#         self.streamInit()
+#         if startStream:
+#             self.startStream()
+
+#     def decode_mp3_stream(self, message):
+#         start = timer()
+#         package = webxiStream.WebxiStream.from_bytes(message)
+#         if package.header.message_type == webxiStream.WebxiStream.Header.EMessageType.e_sequence_data:
+#             # Get the encoded mp3 block
+#             mp3 = package.content.sequence_blocks[0]
+#             data = self.tmpFileSM.runStateMachine(mp3.frame)
+#             mp3DecodedData = miniaudio.mp3_read_s16(data)
+
+#             DataBuffer.append((np.asarray(mp3DecodedData.samples[-mp3DecodedData.num_frames:], dtype=np.int32) << 8) * self.calibrationFactor)
+
+#             end = timer()
+#             total = (end - start)
+#             if 0.0625 < total:
+#                 print(f"TotalTime: {total}")
+#         if not self.StreamRun:
+#             self._resolve()
+
+#     def get_calibration_factor(self):
+#         # Calculate calibration factor from the microphone sensitivity
+#         response = requests.get(f"{host}/WebXi/Applications/SLM/Outputs/Sensitivity")
+#         assert (response.status_code == 200)
+#         mic_sens = float(response.text) # V/Pa
+#         max_lvl = 20 * np.log10((self.max_input / mic_sens) / 20e-6)  # dB SPL re 20 uPa
+#         self.calibrationFactor = (20e-6 * 10 ** (max_lvl / 20)) / (2 ** 23 - 1) * np.sqrt(2)
+
+#     def streamInit(self):
+#         response = requests.put(f"{host}/WebXi/Applications/SLM/setup/AudioRecordingListenQuality", json=1)
+#         assert (response.status_code == 200)
+#         self.get_calibration_factor()
+#         self.ID, self.sequence = seq.get_sequence(host, sequenceID)
+#         # Get URI for stream
+#         self.streamName = "Mp3 stream"
+#         self.uri = stream.setup_stream(host, self.ID, self.streamName)
+
+#         # Start a measurement. This is needed to obtain data from the device
+#         meas.start_pause_measurement(host, True)
+
+#     def startStream(self):
+#         self.StreamRun = True
+#         asyncio.run(self.runStream())
+
+#     async def runStream(self):
+#         self.loop = asyncio.get_running_loop()
+#         self.fut = self.loop.create_future()
+#         # Create lambda function to use for the stream message. In this example is a function
+#         # call used
+#         self.msg_func = lambda msg: self.decode_mp3_stream(msg)
+#         # Initialize and run the websocket to retrieve data
+
+#         task = self.loop.create_task(webSocket.next_async_websocket(self.uri, self.msg_func))
+#         await self.fut
+#         task.cancel()
+#         meas.stop_measurement(host)
+
+#     def stopStream(self):
+#         self.StreamRun = False
+#         # Resolve the future directly; waiting for the next message may never happen
+#         if hasattr(self, "loop"):
+#             self.loop.call_soon_threadsafe(self._resolve)
+#         stream.delete_stream(host, self.streamName) # Cleaning up and deleting the stream used
+
+#     def _resolve(self):
+#         if not self.fut.done():
+#             self.fut.set_result(True)
+
+
+class figureHandler(FigureHandler):
+
+    def axisConfig(self):
+        self.plotTime.getAxis('left').setStyle(tickFont=pg.QtGui.QFont('Arial', 11))
+        self.plotTime.getAxis('bottom').setStyle(tickFont=pg.QtGui.QFont('Arial', 11))
+        self.plotTime.getAxis('left').setLabel('Approximately pressure', units='Pa', **self.labelStyle)
+        self.plotTime.getAxis('bottom').setLabel('Time', units='s', **self.labelStyle)
+        self.plotFreq.getAxis('left').setStyle(tickFont=pg.QtGui.QFont('Arial', 14))
+        self.plotFreq.getAxis('bottom').setStyle(tickFont=pg.QtGui.QFont('Arial', 14))
+        self.plotFreq.getAxis('left').setLabel('Approximately dB SPL re 20 µPa', **self.labelStyle)
+        self.plotFreq.getAxis('bottom').setLabel('Frequency', units='Hz', **self.labelStyle)
+
+    def update(self):
+        signal = DataBuffer.getPart(self.chunkToShow)
+        x = np.linspace(np.min(self.axis), np.max(self.axis), len(signal))
+        freq, s_dbfs = dBfft(signal, 32e3, self.fftHamming, ref=20e-6)  #Reference = 20µPa
+        # Average the fft for a smoother plot
+        avg = s_dbfs / 3 + self.old / 3 + self.oldold / 3
+        self.curveTime.setData(x, signal)
+        self.curveFreq.setData(freq, avg)
+        self.oldold = self.old
+        self.old = s_dbfs
+        if (self.i % 5 == 0):
+            # Autoscale and print min/max values every 0.5 seconds
+            min_Pa = np.round(min(signal), 2)
+            max_Pa = np.round(max(signal), 2)
+            fft_peak = np.round(max(avg), 2)
+            fft_min = np.round(min(avg), 2)
+            peak_freq = (freq[np.argmax(avg)])
+            if (min_Pa != max_Pa):
+                self.plotTime.setYRange(min_Pa * 1.2, max_Pa * 1.2)
+            if (np.isinf(fft_peak) == False):
+                self.plotFreq.setYRange(fft_min, fft_peak * 1.2)
+            print(f"Min: {min_Pa} Pa, Max: {max_Pa} Pa, Peak: {fft_peak} dB SPL, Peak freq: {peak_freq} Hz")
+        self.i += 1
+
+
+def on_close():
+    # streamer.data_handler.close()
+    streamer.stopStream()
+
+
+if __name__ == "__main__":
+    # streamer = streamHandler()
+    streamer = sh.WebXiStreamHandler(host, sequenceID, mode="mp3")
+    # streamer.setDataHandler(CsvDataHandler(r"C:\Users\SKREBSVINGAA\csv_test\csv_test.txt"))
+    # streamer.setDataHandler(PrintDataHandler())
+
+    fig = figureHandler()
+    fig.app.aboutToQuit.connect(on_close)
+    threading.Thread(target=streamer.startStream, daemon=True).start()
+    fig.run()

slm_api/multi_device_flac.py

@@ -0,0 +1,105 @@
+"""
+Multi-device FLAC/mp3 audio streaming
+--------------------------------------
+Streams FLAC- (or mp3-)encoded audio from several devices at once and plots
+each device's waveform + spectrum, same as flac_example.py/mp3_example.py's
+figureHandler, stacked in one window (one time/freq row pair per device).
+
+Note: WebXiStreamHandler._msg_func_audio also appends decoded samples to the
+module-level `DataBuffer` (helpers/buffer.py), which is a single shared buffer.
+With multiple devices, samples from all of them interleave in that shared
+buffer, so it isn't usable for per-device plotting here - each device instead
+gets its own `buffer` instance (BufferDataHandler below).
+"""
+
+import sys
+import time
+
+import numpy as np
+import pyqtgraph as pg
+from PyQt5 import QtWidgets
+
+from slm_api.helpers.buffer import buffer as Buffer
+from slm_api.helpers.fft import dBfft
+from slm_api.helpers.stream_handlers import WebXiStreamHandler, start_all_synced, stop_all
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+
+USE_MP3 = True  # False = FLAC (SequenceIdEnums.FLACSignal), True = mp3 (SequenceIdEnums.MP3Signal)
+SEQUENCE_ID = SequenceIdEnums.MP3Signal.value if USE_MP3 else SequenceIdEnums.FLACSignal.value
+SAMPLE_RATE = 32e3 if USE_MP3 else 2 ** 16  # matches mp3_example.py / flac_example.py dBfft() calls
+
+CHUNK_TO_SHOW = 2 ** 15
+
+
+class BufferDataHandler(DataHandler):
+    """Per-device handler: appends decoded samples into its own buffer instead
+    of the shared DataBuffer singleton, so devices don't mix samples together."""
+
+    def __init__(self):
+        self.buffer = Buffer(2 ** 16)
+
+    def handle(self, samples, **data):
+        self.buffer.append(samples)
+
+
+class PrintOnlyHandler:
+    """Periodically FFTs each device's buffer and prints Min/Max/Peak/Peak freq, no GUI."""
+
+    def __init__(self, labels_and_handlers):
+        self.labels_and_handlers = labels_and_handlers
+        self.fft_hamming = np.hamming(CHUNK_TO_SHOW)
+        self.old = [0] * len(labels_and_handlers)
+        self.oldold = [0] * len(labels_and_handlers)
+        self.i = 0
+
+    def update(self):
+        if self.i % 5 != 0:
+            self.i += 1
+            return
+        for idx, (label, handler) in enumerate(self.labels_and_handlers):
+            signal = handler.buffer.getPart(CHUNK_TO_SHOW)
+            freq, s_dbfs = dBfft(signal, SAMPLE_RATE, self.fft_hamming, ref=20e-6)  # Reference = 20µPa
+            avg = s_dbfs / 3 + self.old[idx] / 3 + self.oldold[idx] / 3
+            self.oldold[idx] = self.old[idx]
+            self.old[idx] = s_dbfs
+            min_Pa = np.round(min(signal), 2)
+            max_Pa = np.round(max(signal), 2)
+            fft_peak = np.round(max(avg), 2)
+            peak_freq = freq[np.argmax(avg)]
+            print(f"{label}  Min: {min_Pa} Pa, Max: {max_Pa} Pa, Peak: {fft_peak} dB SPL, Peak freq: {peak_freq} Hz")
+        self.i += 1
+
+
+if __name__ == "__main__":
+    devices = [
+        "192.168.1.183",
+        # "192.168.1.216",
+        # "192.168.1.191",
+    ]
+
+    streams = [
+        WebXiStreamHandler(
+            host=host, sequenceID=SEQUENCE_ID,
+            streamName=f"Stream_{host}", multi_device=True,
+            mode="mp3" if USE_MP3 else "flac",
+            # flac=True
+        )
+        for host in devices
+    ]
+    handlers = [BufferDataHandler() for _ in streams]
+    for s, h in zip(streams, handlers):
+        s.setDataHandler(h)
+
+    printer = PrintOnlyHandler([(s.host, h) for s, h in zip(streams, handlers)])
+
+    time.sleep(1)
+    start_all_synced(streams)
+
+    try:
+        while True:
+            printer.update()
+            time.sleep(0.1)  
+    except KeyboardInterrupt:
+        stop_all(streams)
+        print("\nStreams stopped by user.")

slm_api/multi_instrument_example.py

@@ -0,0 +1,74 @@
+"""
+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 time
+import datetime
+import threading
+from slm_api.helpers.stream_handlers import WebXiStreamHandler, start_all_synced, stop_all
+from slm_api.helpers.data_handler import DataHandler
+from slm_api.enums.sequence_id_enum import SequenceIdEnums
+from slm_api.enums.fast_log_intervals_enum import FastLogInterval
+from slm_api.helpers import webxi_helper_functions as webxi_helper
+
+
+FAST_LOGGING_INTERVAL_MS = FastLogInterval.interval_1000ms.value
+SEQUENCE_ID = SequenceIdEnums.LAeq.value
+SEQUENCE_NAME = SequenceIdEnums.LAeq.name
+
+
+
+
+class PrintDataHandler(DataHandler):
+    def __init__(self, label):
+        self.label = label
+
+    def handle(self, value, **data):
+        print(f"{self.label}  {SEQUENCE_NAME}: {value}")
+
+
+if __name__ == "__main__":
+    devices = [
+        "192.168.1.183",
+        "192.168.1.216",
+        "192.168.1.191",
+    ]
+
+    saving_format = "csv"
+    streams = []
+    for host in devices:
+        filename = f'{host}_{datetime.datetime.now().strftime("%H%M_%m%d%Y")}'
+        streams.append(
+            WebXiStreamHandler(
+                host=host, sequenceID=SEQUENCE_ID,
+                streamName=f"Stream_{host}", multi_device=True, mode="cpb",
+                saving=saving_format, saving_path=f"./saved_data/{filename}"
+            )
+        )
+    for s in streams:
+        s.setDataHandler(PrintDataHandler(s.host))
+
+    time.sleep(1)
+    start_all_synced(streams)
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        stop_all(streams)
+        print("\nStreams stopped by user.")

slm_api/screen_record_example.py

@@ -0,0 +1,64 @@
+"""
+Continuously streams the ScreenImage sequence (Name="ScreenImage", DataType="Byte",
+DataFormat="PNG") from the device. Unlike most metadata, this isn't a static REST
+resource - it's a streamed sequence, like the FLAC/mp3 audio sequences. Each received
+block's raw bytes are already a complete PNG file. The plot is refreshed with each
+new image received, like a (low frame rate) screen recording of the device.
+"""
+import io
+import threading
+import numpy as np
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+from PIL import Image
+
+from slm_api.helpers import sequence_handler as seq
+from slm_api.helpers import stream_handler as stream
+from slm_api.helpers import measurment_handler as meas
+from slm_api.helpers.webxi_helper_functions import set_host
+from slm_api.webxi import webxi_stream
+from slm_api.helpers.stream_handlers import WebXiStreamHandler
+
+
+host = set_host(__file__)
+
+
+class FigHandler:
+    def __init__(self, streamer):
+        self.streamer = streamer
+        self.fig, self.ax = plt.subplots()
+        self.ax.axis("off")
+        self.im = None
+        self.fig.canvas.mpl_connect("close_event", on_close)
+        self.fig.canvas.manager.set_window_title("SLM screen (live)")
+
+    def _update(self, i):
+        data = self.streamer.image_bytes
+        if data is None:
+            return
+        image = np.array(Image.open(io.BytesIO(data)))
+        if self.im is None or self.im.get_array().shape != image.shape:
+            self.ax.clear()
+            self.ax.axis("off")
+            self.im = self.ax.imshow(image)
+        else:
+            self.im.set_data(image)
+
+    def startAnimation(self):
+        # interval controls how often the plot polls for a new image, not how
+        # often the device actually sends one
+        self.ani = FuncAnimation(self.fig, self._update, interval=500)
+
+
+def on_close(event):
+    streamer.stopStream()
+
+
+if __name__ == "__main__":
+    streamer = WebXiStreamHandler(host, mode="screen_record")
+    fig = FigHandler(streamer)
+    fig.startAnimation()
+    threading.Thread(target=streamer.startStream, daemon=True).start()
+    plt.show()
+    stream.delete_stream(host, streamer.streamName)
+

slm_api/webxi/README.md

@@ -0,0 +1,25 @@
+
+
+# WebXi binary data streaming
+#### *An introduction*
+
+Aside from communicating with the SLM via HTTP/REST/JSON, the sound level meter (SLM) also offers WebXi data streams via WebSockets. A faster and more efficient way to stream continuous binary data with a minimized overhead.
+
+WebXi streams are setup on the SLM using JSON and REST. Once the WebXi streams has been configured data is streamed to the client (pushed from the SLM to the client via the network).
+
+Which data sources to stream from the SLM (sound data, status, events, etc.) are selected by the client during setup, using REST and JSON.
+
+Data leaving the SLM via the WebXi streams are time stamped from the same clock source.
+
+Binary WebXi data streams are documented as part of the '*WebXi protocol specification*', found in the [Documentation](../../Documentation) folder. Based on this documentation the WebXi streaming format has been described using **Kaitai**.
+
+The Kaitai(.kty) files may be compiled into parsers to be used from within various programming languages (C#, Java, Python, …).
+
+To generate parsers for Python use:
+* ksc webxi-stream.ksy -t python
+* ksc webxi-header.ksy -t python
+
+This creates two python files, one for parsing the data header and one for parsing the rest of the binary stream.
+
+Find more information about Kaitai here: https://kaitai.io
+

slm_api/webxi/__init__.py

@@ -0,0 +1,5 @@
+from .webxi_header import *
+from .webxi_stream import *
+
+#from .openapi_header import *
+#from .openapi_stream import *

slm_api/webxi/webxi-header.ksy

@@ -0,0 +1,32 @@
+meta:
+  id: webxi_header
+  endian: le
+seq:
+  - id: magic
+    contents: [0x42, 0x4b]
+  - id: header_length
+    type: u2
+  - id: message_type
+    type: u2
+    enum: e_message_type
+  - id: content_version
+    type: u2
+  - id: reserved2
+    type: u4
+  - id: time
+    type: u8
+  - id: content_length
+    type: u4
+
+enums:
+  e_message_type:
+    1: e_sequence_data
+    2: e_data_quality
+    3: state
+    4: status
+    5: trigger
+    6: node
+    7: sync
+    9: debug
+    10: package
+    11: aux_sequence_data