slm-open-api-package 0.1.0__tar.gz

slm_open_api_package-0.1.0/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.3
+Name: slm-open-api-package
+Version: 0.1.0
+Summary: Add your description here
+Author: Sofus Vingaard
+Author-email: Sofus Vingaard <sofus.krebsvingaard@hbkworld.com>
+Requires-Dist: requests
+Requires-Dist: numpy
+Requires-Dist: websockets
+Requires-Dist: kaitaistruct
+Requires-Dist: python-dotenv
+Requires-Dist: packaging
+Requires-Dist: pyqtgraph
+Requires-Dist: pyqt5
+Requires-Dist: pyqt5-qt5<5.15.11
+Requires-Dist: miniaudio
+Requires-Dist: matplotlib>=3.11.1
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+
+# open-api-package

slm_open_api_package-0.1.0/README.md

@@ -0,0 +1 @@
+# open-api-package

slm_open_api_package-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[project]
+name = "slm-open-api-package"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "requests",
+    "numpy",
+    "websockets",
+    "kaitaistruct",
+    "python-dotenv",
+    "packaging",
+    "pyqtgraph",
+    "PyQt5",
+    "PyQt5-Qt5<5.15.11",
+    "miniaudio",
+    "matplotlib>=3.11.1",
+]
+
+[[project.authors]]
+name = "Sofus Vingaard"
+email = "sofus.krebsvingaard@hbkworld.com"
+
+[project.scripts]
+open-api-package = "open_api_package:main"
+
+[tool.uv.build-backend]
+module-name = "open_api_package"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"

slm_open_api_package-0.1.0/pyproject.toml.orig

@@ -0,0 +1,32 @@
+[project]
+name = "slm-open-api-package"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+authors = [
+    { name = "Sofus Vingaard", email = "sofus.krebsvingaard@hbkworld.com" }
+]
+requires-python = ">=3.12"
+dependencies = [
+    "requests",
+    "numpy",
+    "websockets",
+    "kaitaistruct",
+    "python-dotenv",
+    "packaging",
+    "pyqtgraph",
+    "PyQt5",
+    "PyQt5-Qt5<5.15.11",
+    "miniaudio",
+    "matplotlib>=3.11.1",
+]
+
+[project.scripts]
+open-api-package = "open_api_package:main"
+
+[tool.uv.build-backend]
+module-name = "open_api_package"
+
+[build-system]
+requires = ["uv_build>=0.12.5,<0.13.0"]
+build-backend = "uv_build"

slm_open_api_package-0.1.0/src/open_api_package/__init__.py

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

slm_open_api_package-0.1.0/src/open_api_package/example_multi.py

@@ -0,0 +1,145 @@
+# 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 asyncio
+import requests
+import threading
+import sys, traceback
+import numpy as np
+import time
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation
+
+# Modules to convert webxi data
+from open_api_package.webxi import webxi_stream as webxiStream
+
+from open_api_package.helpers import sequence_handler as seq            # Get sequences, e.g. LAeq functions
+from open_api_package.helpers import stream_handler as stream           # SLM stream functions
+from open_api_package.helpers import measurment_handler as meas         # Start/pause/Stop measurments functions
+from open_api_package.helpers.Leq import MovingLeq, SLM_Setup_LAeq      # Class to hold moving Leq
+from open_api_package.helpers import websocket_handler as webSocket     # Async functions to control communication
+from open_api_package.helpers import webxi_helper_functions as webxi_helper
+from open_api_package.helpers import stream_handlers as sh
+
+host, ip = webxi_helper.set_host_ip(__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 streamHandler:
+
+#     def __init__(self, startStream = False):
+#         self.streamInit()
+#         if startStream:
+#             self.startStream()
+
+#     def streamInit(self):
+#         self.IDs = []
+#         self.sequences = []
+#         self.sequenceFuncs = []
+
+#         for x in sequenceNames:
+#             ID, sequence = seq.get_sequence(host, seq.getSequenceID(host, x))
+#             self.IDs.append(ID)
+#             self.sequences.append(sequence)
+#             self.sequenceFuncs.append(MovingLeq(10, storedata=True, windowSize=100))
+
+#         self.streamName = "MultipleSequences"
+#         self.uri = stream.setup_stream(host, ip, self.IDs, 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.print_data(msg, self.IDs, self.sequences, self.sequenceFuncs, self.fut) 
+#         # Initilize and run the websocket to retrive 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  
+#         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)
+
+#     def print_data(self, message, IDs, sequences, sequenceFuncs, fut):
+#         package = webxiStream.WebxiStream.from_bytes(message)
+#         if package.header.message_type == webxiStream.WebxiStream.Header.EMessageType.e_sequence_data:
+#             for ID, sequence, Func in zip(IDs, sequences, sequenceFuncs):
+#                 for data in package.content.sequence_blocks:
+#                     if data.sequence_id == ID:
+#                         value = stream.data_type_conv(sequence["DataType"], data.values, None)
+#                         value = (np.array(value) if isinstance(value, list) else value) / 100
+#                         move = Func.move(value)
+#                         seqName = sequence["Name"]
+#                         print(f"{seqName}: {value} and 10s avg: {move:.2f}")
+        
+#         if not self.StreamRun:
+#             self._resolve()
+
+class FigHandler:  
+   
+    def __init__(self, dataHandler):
+        self.fig, self.ax = plt.subplots(2,1,sharex=True, sharey=True)
+        axis = np.arange(-(len(dataHandler[0].getPlotData(True)) - 1),1,1)
+        self.dataHandler = dataHandler if isinstance(dataHandler, list) else [dataHandler]
+        self.ln1 = []
+        self.ln2 = []
+        for x, ii in zip(self.dataHandler, sequenceNames):
+            self.ln1.append((self.ax[0].plot(axis,x.getPlotData(True), label=ii))[0])
+            self.ln2.append((self.ax[1].plot(axis,x.getPlotData(False)))[0])
+        self.ax[1].set_xlim(left=np.min(axis), right=np.max(axis))
+        self.ax[1].set_ylim(bottom=30, top=100)
+        self.ax[0].set_ylabel("dB [SPL]")
+        self.ax[1].set_xlabel("Time [s]")
+        self.ax[1].set_ylabel("dB [SPL]")
+        self.ax[0].set_title('Moving avaraged')
+        self.ax[1].set_title('Instantaneous')
+        leg = self.ax[0].legend(loc='upper left')
+        self.ax[0].grid()
+        self.ax[1].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 _update(self, i): 
+        for idx, x in enumerate(self.dataHandler):
+            self.ln1[idx].set_ydata(x.getPlotData(True))
+            self.ln2[idx].set_ydata(x.getPlotData(False))
+
+    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, ip=ip, sequenceNames=sequenceNames, multi=True)
+    fig = FigHandler(streamer.sequenceFuncs)
+    fig.startAnimation()
+    threading.Thread(target=streamer.startStream, daemon=True).start()        
+    plt.show()

slm_open_api_package-0.1.0/src/open_api_package/flac_example.py

@@ -0,0 +1,160 @@
+import asyncio
+import requests
+import sys
+import pyqtgraph as pg
+import numpy as np
+from open_api_package.helpers import webxi_helper_functions as webxi_helper
+
+# Modules to convert webxi data
+from open_api_package.webxi import webxi_stream as webxiStream
+# Help functions located in the helpers folder
+# Read these files to get examples on how to communicate with the SLM
+from open_api_package.helpers import stream_handler as stream           # SLM stream functions
+# Start/pause/Stop measurments functions
+from open_api_package.helpers import measurment_handler as meas
+# Get sequences, 
+from open_api_package.helpers import sequence_handler as seq
+# Stream handler
+from open_api_package.helpers import stream_handlers as sh
+
+
+# Async functions to control communication
+from open_api_package.helpers import websocket_handler as webSocket
+from timeit import default_timer as timer
+# Buffer and decoder for the flac stream
+from open_api_package.helpers.buffer import DataBuffer
+from open_api_package.helpers.fft import dBfft
+from open_api_package.helpers import flac_stream_2_samples as flac2samples
+import threading
+
+from open_api_package.helpers.FigureHandler import FigureHandler
+
+# FLAC streaming is only available on 2255
+
+host, ip = webxi_helper.set_host_ip(__file__)
+
+sequenceID = 157
+
+
+# class streamHandler:
+#     def __init__(self, startStream=False):
+#         self.i = 0
+#         self.max_input = 15.6263 / np.sqrt(2) 
+#         self.streamInit()
+#         if startStream:
+#             self.startStream()
+    
+#     def decode_flac_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 flac block
+#             flac = package.content.sequence_blocks[0]          
+#             # Decode the compressed samples and add it to the data bufffer 
+#             DataBuffer.append(flac2samples.decode(flac, 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):
+#         # Enable audio recording analysis quality
+#         response = requests.put(f"{host}/WebXi/Applications/SLM/setup/AudioRecordingAnalysisQuality", 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 = "Flac stream"
+#         self.uri = stream.setup_stream(host, ip, 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_flac_stream(msg) 
+#         # Initilize and run the websocket to retrive 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('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('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, 2**16, 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.stopStream()
+
+if __name__ == "__main__":
+    # streamer = streamHandler()
+    streamer = sh.WebXiStreamHandler(host, ip, sequenceID = sequenceID, flac=True)
+    fig = figureHandler()
+    fig.app.aboutToQuit.connect(on_close)
+    threading.Thread(target=streamer.startStream, daemon=True).start()
+    fig.run()
+ 

slm_open_api_package-0.1.0/src/open_api_package/helpers/FigureHandler.py

@@ -0,0 +1,65 @@
+import pyqtgraph as pg
+import sys
+import numpy as np
+from PyQt5 import QtWidgets
+
+from abc import ABC, abstractmethod
+
+class FigureHandler(ABC):
+    def __init__(self):
+        self.i = 0
+        self.chunkToShow = 2 ** 15
+        self.fftSize = self.chunkToShow
+        self.fftHamming = np.hamming(self.fftSize)
+        # Used to store "old" spectrums for fft averaging
+        self.old = 0
+        self.oldold = 0
+
+        self.x = np.linspace(0.0, 10, self.chunkToShow)
+
+        ## Figures
+        self.axis = np.arange(self.chunkToShow)
+        self.axis = np.flip(self.axis * -1 / self.chunkToShow)
+        self.x = np.zeros(len(self.axis))
+        self.app = QtWidgets.QApplication(sys.argv)
+        self.win = pg.GraphicsLayoutWidget(title="Streaming")
+        self.win.setBackground('w')
+        self.win.resize(1000, 600)
+        self.plotTime = self.win.addPlot()
+        self.curveTime = self.plotTime.plot(self.x, self.axis)
+        self.curveTime.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+        self.plotTime.showGrid(x=True, y=True)
+        self.plotTime.setXRange(np.min(self.axis), np.max(self.axis))
+        self.plotTime.setYRange(-2, 2)
+        self.labelStyle = {'color': '#000', 'font-size': '13pt'}
+
+        # Subplot 2 (FFT)
+        # Calculate the frequency vector
+        self.win.nextRow()
+        self.plotFreq = self.win.addPlot()
+        freq = np.arange(self.fftSize//2 + 1) / (float(self.fftSize) / 32e3)
+        self.curveFreq = self.plotFreq.plot(freq, np.arange(len(freq)))
+        self.curveFreq.setPen(color='b', width=2, autoDownsample=True, clipToView=True)
+        self.plotFreq.setXRange(0, np.max(freq))
+        self.plotFreq.setYRange(-20, 130)
+        self.plotFreq.getAxis('bottom').enableAutoSIPrefix(enable=False)
+        self.plotFreq.setLogMode(x=True, y=False)
+        self.plotFreq.showGrid(x=True, y=True)
+        self.axisConfig()
+        self.win.show()
+
+        self.timer = pg.QtCore.QTimer()
+        self.timer.timeout.connect(self.update)
+        self.timer.start(int(0.1 * 1000))
+
+    def run(self):
+        QtWidgets.QApplication.instance().exec_()
+
+    @abstractmethod
+    def axisConfig(self):
+        pass
+
+    @abstractmethod
+    def update(self):
+        pass
+

slm_open_api_package-0.1.0/src/open_api_package/helpers/Leq.py

@@ -0,0 +1,87 @@
+import numpy as np
+import requests
+
+
+def SLM_Setup_LAeq(host):
+    # Enable logging mode
+    requests.put(host + "/webxi/Applications/SLM/Setup/ControlLoggingMode", json=1)
+    # Set the device in free runnign mode
+    requests.put(host + "/webxi/Applications/SLM/Setup/ControlMeasurementTimeControl", json=0)
+    # Enable A weight frequency broad band weighting, but first clear the other once to be sure
+    requests.put(host + "/webxi/Applications/SLM/Setup/BBFreqWeightB", json=False)
+    requests.put(host + "/webxi/Applications/SLM/Setup/BBFreqWeightC", json=False)
+    requests.put(host + "/webxi/Applications/SLM/Setup/BBFreqWeightZ", json=False)
+    requests.put(host + "/webxi/Applications/SLM/Setup/BBFreqWeightA", json=True)
+    # Enable LAeq mode on the device
+    requests.put(host + "/webxi/applications/slm/setup/BBLAeq", json=True)
+
+class MovingLeq:
+    """Class to create a moving Leq object.\n
+       Stores a window of Leq logging intervals to be combined into a total Leq\n
+       Calling move(new_interval) on the object will overwrite the oldest value in the       
+       window, recalculate the total Leq and return it."""
+
+    def __init__(self, window_length_sec, storedata=False, windowSize=None):
+        self.window_length = window_length_sec
+        windowSize = self.window_length * 10 + 1 if windowSize is None else windowSize
+
+        # Intialize an empty array, index to track oldest value, and window status
+        self.leq_window = np.zeros(window_length_sec)
+        self.leq_window.fill(np.nan)
+        self.storedata = storedata
+        if self.storedata:
+            self.rawData = LeqData(windowSize) # Used to store the raw data for plotting
+            self.leqData = LeqData(windowSize) # Used to store the Leq data for plotting
+        self.oldest_value_index = 0
+        self.leq_total = 0.0
+        self.window_full = False
+
+    def total_leq(self,window):
+        """ Function to combine several Leq periods into a total Leq, as per:\n
+            10 * log10(10^(L1/10) + 10^(L2/10) + ... 10^(Ln/10) / n)"""
+        sound_Pa = np.sum(np.power(10,window/10)) / len(window)
+        return 10 * np.log10(sound_Pa)
+
+    def move(self, new_value):
+        """Overwrite the oldest value in the array with the new logging interval
+         and update the oldest value index to point to the next oldest value"""
+        self.leq_window[self.oldest_value_index] = new_value
+        self.oldest_value_index += 1
+        
+        # Calculate the total Leq for the moving window and return it.
+        if self.window_full:            
+            self.leq_total = self.total_leq(self.leq_window)
+            self.oldest_value_index = self.oldest_value_index % self.window_length
+            if self.storedata:
+                self.leqData.move(self.leq_total)
+                self.rawData.move(new_value)
+            return self.leq_total
+
+        # If the moving window is not full of measured data, simply calculate total Leq
+        # for the data that is in the window (and ignore the empty part of the array)
+        else:
+            self.leq_total = self.total_leq(self.leq_window[:self.oldest_value_index])
+            self.oldest_value_index = self.oldest_value_index % self.window_length
+            if self.oldest_value_index == self.window_length - 1:
+                self.window_full = True
+            if self.storedata:
+                self.leqData.move(self.leq_total)
+                self.rawData.move(new_value)
+            return self.leq_total
+
+    def getPlotData(self,Leq):
+        if Leq:
+            return self.leqData.getData()
+        else:
+            return self.rawData.getData()
+
+class LeqData:
+    def __init__(self,window_length_sec):
+        self.leq_window = np.zeros(window_length_sec)
+        self.leq_window[:] = np.nan
+
+    def move(self, new_value):
+        self.leq_window = np.insert(self.leq_window[1:], self.leq_window.size-1,new_value)
+
+    def getData(self):
+        return self.leq_window

slm_open_api_package-0.1.0/src/open_api_package/helpers/__init__.py

@@ -0,0 +1,5 @@
+from .stream_handler import * 
+from .measurment_handler import *
+from .sequence_handler import * 
+from .Leq import *
+from .stream_handlers import *

slm_open_api_package-0.1.0/src/open_api_package/helpers/buffer.py

@@ -0,0 +1,27 @@
+import numpy as np
+
+class buffer:
+    def __init__(self, size):
+        self.size = size
+        self.data = np.zeros(self.size)
+
+    def append(self, x):
+        """
+        Adds data in the front of the buffer. Discard the oldest data if buffer is full
+        """
+        self.data =  np.append(self.data[-(self.size - len(x)) :: ] , x)
+
+    def get(self):
+        """
+        Returns the whole buffer
+        """
+        return self.data
+
+    def getPart(self, start = 2**16):
+        """
+        Returns X points of the newest data.
+        """
+        return self.data[-start :: ]
+
+# Create databuffer to store the converted package data
+DataBuffer = buffer(2**16)

slm_open_api_package-0.1.0/src/open_api_package/helpers/fft.py

@@ -0,0 +1,38 @@
+import numpy as np 
+
+def dBfft(x, fs, win=None, ref=32768):
+    """
+    Calculate spectrum in dB scale
+    Args:
+        x: input signal
+        fs: sampling frequency
+        win: vector containing window samples (same length as x).
+             If not provided, then rectangular window is used by default.
+        ref: reference value used for dBFS scale. 32768 for int16 and 1 for float
+
+    Returns:
+        freq: frequency vector
+        s_db: spectrum in dB scale
+    """
+    N = len(x)  # Length of input sequence
+
+    if win is None:
+        win = np.ones(1, N)
+    if len(x) != len(win):
+            raise ValueError('Signal and window must be of the same length')
+    x = x * win
+
+    # Calculate real FFT and frequency vector
+    sp = np.fft.rfft(x)
+    freq = np.arange((N / 2) + 1) / (float(N) / fs)
+
+    # Scale the magnitude of FFT by window and factor of 2,
+    # because we are using half of FFT spectrum.
+    s_mag = (np.abs(sp) * np.sqrt(2)) / np.sum(win)
+
+    for i in range(len(s_mag)):
+        if s_mag[i] == 0:
+            s_mag[i] = 1e-10
+    # Convert to dBFS
+    s_dbfs = 20 * np.log10(s_mag/ref)
+    return freq, s_dbfs