diff --git a/lasp/lasp_avstream.py b/lasp/lasp_avstream.py
index 376745f..fce30ac 100644
--- a/lasp/lasp_avstream.py
+++ b/lasp/lasp_avstream.py
@@ -27,7 +27,7 @@ class AvStream:
         self.daqconfig = daqconfig
         try:
             daq = DAQDevice(daqconfig)
-            self.nchannels = len(daq.channels_enabled)
+            self.nchannels = len(daq.channels_en)
             self.samplerate = daq.input_rate
             self.blocksize = daq.blocksize
         except Exception as e:
diff --git a/lasp/lasp_common.py b/lasp/lasp_common.py
index 8b23986..5ecdff6 100644
--- a/lasp/lasp_common.py
+++ b/lasp/lasp_common.py
@@ -1,5 +1,5 @@
-# -*- coding: utf-8 -*-
 #!/usr/bin/env python3
+# -*- coding: utf-8 -*-
 import numpy as np
 from .wrappers import Window as wWindow
 """
@@ -7,14 +7,14 @@ Common definitions used throughout the code.
 """
 
 __all__ = ['P_REF', 'FreqWeighting', 'TimeWeighting', 'getTime', 'calfile',
-           'sens']
+           ]
 
 # Reference sound pressure level
 P_REF = 2e-5
 
 # Todo: fix This
-calfile = '/home/anne/wip/UMIK-1/cal/7027430_90deg.txt'
-sens = 0.053690387255872614
+# calfile = '/home/anne/wip/UMIK-1/cal/7027430_90deg.txt'
+calfile = None
 
 
 class Window:
diff --git a/lasp/lasp_measurement.py b/lasp/lasp_measurement.py
index a8646d6..3576f0f 100644
--- a/lasp/lasp_measurement.py
+++ b/lasp/lasp_measurement.py
@@ -94,7 +94,7 @@ def getSampWidth(dtype):
 
 
 def exportAsWave(fn, fs, data, force=False):
-    if not '.wav' in fn[-4:]:
+    if '.wav' not in fn[-4:]:
         fn += '.wav'
 
     nchannels = data.shape[1]
@@ -239,7 +239,8 @@ class Measurement:
 
     def praw(self, block=None):
         """
-        Returns the raw uncalibrated data, converted to floating point format.
+        Returns the uncalibrated acoustic pressure signal, converted to floating
+        point acoustic pressure values [Pa].
         """
         if block is not None:
             with self.file() as f:
@@ -293,6 +294,7 @@ class Measurement:
             raise ValueError('Invalid sensitivity value(s) given')
         with self.file('r+') as f:
             f.attrs['sensitivity'] = sens
+        self._sens = sens
 
     def exportAsWave(self, fn=None, force=False, sampwidth=None):
         """
diff --git a/lasp/lasp_playback.py b/lasp/lasp_playback.py
index 64c5a4e..a235533 100644
--- a/lasp/lasp_playback.py
+++ b/lasp/lasp_playback.py
@@ -15,23 +15,25 @@ from .lasp_atomic import Atomic
 from threading import Thread, Condition
 import h5py
 
+
 class Playback:
     """
-    Play back a single channel from a 
+    Play back a single channel from a
     """
-    def __init__(self, fn1, channel = 0, video=True, verbose=True):
+
+    def __init__(self, fn1, channel=0, video=True, verbose=True):
         """
-        
+
         """
         ext = '.h5'
         if not ext in fn1:
-            fn = fn1 +  ext
+            fn = fn1 + ext
         else:
             fn = fn1
 
         print('Filename: ', fn)
         self._fn = fn
-        
+
         self.channel = channel
         self._video = video
         self._aframectr = Atomic(0)
@@ -40,7 +42,7 @@ class Playback:
         if video:
             self._video_queue = queue.Queue()
 
-        with h5py.File(fn,'r') as f:
+        with h5py.File(fn, 'r') as f:
             self.samplerate = f.attrs['samplerate']
             self.nchannels = f.attrs['nchannels']
             self.blocksize = f.attrs['blocksize']
@@ -48,9 +50,9 @@ class Playback:
             if verbose:
                 print('Sample rate: ', self.samplerate)
                 print('Number of audio frames: ', self.nblocks*self.blocksize)
-                print('Recording time: ', self.nblocks*self.blocksize/self.samplerate)
-            
-            
+                print('Recording time: ', self.nblocks *
+                      self.blocksize/self.samplerate)
+
             if video:
                 try:
                     f['video']
@@ -58,24 +60,28 @@ class Playback:
                 except:
                     print('No video available in measurement file. Disabling video')
                     self._video = False
-            
+
     @property
     def T(self):
         return self._nblocks*self._blocksize/self._samplerate
-    
+
     def start(self):
-        with h5py.File(self._fn,'r') as f:
-            stream = sd.OutputStream(samplerate = self.samplerate,
-                                     blocksize = self.blocksize,
-                                     channels = 1,
-                                     dtype = 'int32',callback = self.audio_callback)
+        with h5py.File(self._fn, 'r') as f:
             self._ad = f['audio']
+            dtype = self._ad.dtype
+            dtype_str = str(dtype)
+            stream = sd.OutputStream(samplerate=self.samplerate,
+                                     blocksize=self.blocksize,
+                                     channels=1,
+                                     dtype=dtype_str,
+                                     callback=self.audio_callback)
+
             self._running <<= True
             if self._video:
                 self._vd = f['video']
                 videothread = Thread(target=self.video_thread_fcn)
                 videothread.start()
-                
+
             with stream:
                 try:
                     with self._running_cond:
@@ -83,44 +89,43 @@ class Playback:
                             self._running_cond.wait()
                 except KeyboardInterrupt:
                     print('Keyboard interrupt. Quit playback')
-                
+
             if self._video:
                 videothread.join()
-    
+
     def audio_callback(self, outdata, frames, time, status):
         """
-        
+
         """
         aframectr = self._aframectr()
         if aframectr < self.nblocks:
-            outdata[:,0] = self._ad[aframectr,:,self.channel]
+            outdata[:, 0] = self._ad[aframectr, :, self.channel]
             self._aframectr += 1
         else:
             self._running <<= False
             with self._running_cond:
                 self._running_cond.notify()
-        
+
     def video_thread_fcn(self):
         frame_ctr = 0
         nframes = self._vd.shape[0]
         video_frame_positions = self._video_frame_positions
         assert video_frame_positions.shape[0] == nframes
-        
+
         while self._running and frame_ctr < nframes:
             frame = self._vd[frame_ctr]
-            
+
             # Find corresponding audio frame
             corsp_aframe = video_frame_positions[frame_ctr]
-            
+
             while self._aframectr() <= corsp_aframe:
                 print('Sleep video...')
                 time.sleep(self.blocksize/self.samplerate/2)
 
-            cv.imshow("Video output. Press 'q' to quit",frame)
+            cv.imshow("Video output. Press 'q' to quit", frame)
             if cv.waitKey(1) & 0xFF == ord('q'):
                 self._running <<= False
-            
+
             frame_ctr += 1
         print('Ending video playback thread')
         cv.destroyAllWindows()
-    
diff --git a/lasp/lasp_slm.py b/lasp/lasp_slm.py
index 911ff3a..f6f51bf 100644
--- a/lasp/lasp_slm.py
+++ b/lasp/lasp_slm.py
@@ -8,7 +8,7 @@ from .wrappers import SPLowpass
 from .lasp_computewidget import ComputeWidget
 import numpy as np
 from .lasp_config import zeros
-from .lasp_common import (FreqWeighting, sens, calfile,
+from .lasp_common import (FreqWeighting, calfile,
                           TimeWeighting, getTime, P_REF)
 from .lasp_weighcal import WeighCal
 from .lasp_gui_tools import wait_cursor
@@ -197,8 +197,7 @@ class SlmWidget(ComputeWidget, Ui_SlmWidget):
             # variables defined at the top. # TODO: Change this to a more
             # robust variant.
             weighcal = WeighCal(fw, nchannels=1,
-                                fs=fs, calfile=calfile,
-                                sens=sens)
+                                fs=fs, calfile=calfile)
             praw = meas.praw()[istart:istop, [channel]]
 
             weighted = weighcal.filter_(praw)
@@ -260,8 +259,7 @@ class SlmWidget(ComputeWidget, Ui_SlmWidget):
             praw = meas.praw()[istart:istop, [channel]]
 
             weighcal = WeighCal(fw, nchannels=1,
-                                fs=fs, calfile=calfile,
-                                sens=sens)
+                                fs=fs, calfile=calfile)
 
             weighted = weighcal.filter_(praw)
 
diff --git a/lasp/lasp_weighcal.py b/lasp/lasp_weighcal.py
index 9868520..da24332 100644
--- a/lasp/lasp_weighcal.py
+++ b/lasp/lasp_weighcal.py
@@ -19,11 +19,11 @@ class WeighCal:
     """
     Frequency weighting and calibration FIR filter
     """
+    
     def __init__(self, fw=FreqWeighting.default,
                  nchannels=1,
                  fs=48000.,
-                 calfile=None,
-                 sens=1.0):
+                 calfile=None):
         """
         Initialize the frequency weighting and calibration FIR filters.
 
@@ -32,13 +32,12 @@ class WeighCal:
             nchannels: Number of channels for the input data
             fs: Sampling frequency [Hz]
             calfile: Calibration file to load.
-            sens: Sensitivity in units [\f$ Pa^{-1} \f$]
         """
 
         self.nchannels = nchannels
         self.fs = fs
         self.fw = fw
-        self.sens = sens
+
         self.calfile = calfile
 
         # Frequencies used for the filter design
@@ -83,7 +82,7 @@ class WeighCal:
         filtered = []
         for chan in range(nchan):
             filtered.append(self._fbs[chan].filter_(data[:, [chan]])[:, 0])
-        filtered = np.asarray(filtered).transpose()/self.sens
+        filtered = np.asarray(filtered).transpose()
         if filtered.ndim == 1:
             filtered = filtered[:, np.newaxis]
         return filtered