updated formula to db/Hz

Author: GvozdevLeonid

python_hackrf/pyhackrf_tools/pyhackrf_sweep.pyx

@@ -84,7 +84,7 @@ def sweep_callback(object device, cnp.ndarray[cnp.int8_t, ndim=1] buffer, int bu
     cdef str time_str = timestamp.strftime('%Y-%m-%d, %H:%M:%S.%f')
 
     cdef dict current_device_data = device_data[device.serialno]
-    cdef double norm_factor = 1.0 / current_device_data['fft_size']
+    cdef double norm_factor = current_device_data['sample_rate'] / current_device_data['fft_size']
     cdef uint32_t data_length = current_device_data['fft_size'] * 2
     cdef object sweep_style = current_device_data['sweep_style']
     cdef uint32_t sample_rate = current_device_data['sample_rate']
@@ -94,13 +94,13 @@ def sweep_callback(object device, cnp.ndarray[cnp.int8_t, ndim=1] buffer, int bu
     cdef uint64_t start_frequency = current_device_data['start_frequency']
 
     cdef cnp.ndarray fftwOut
-    cdef cnp.ndarray pwr
+    cdef cnp.ndarray dbph
 
-    cdef uint32_t pwr_1_start = 1 + (fft_size * 5) // 8
-    cdef uint32_t pwr_1_stop = 1 + (fft_size * 5) // 8 + fft_size // 4
+    cdef uint32_t fft_1_start = 1 + (fft_size * 5) // 8
+    cdef uint32_t fft_1_stop = 1 + (fft_size * 5) // 8 + fft_size // 4
 
-    cdef uint32_t pwr_2_start = 1 + fft_size // 8
-    cdef uint32_t pwr_2_stop = 1 + fft_size // 8 + fft_size // 4
+    cdef uint32_t fft_2_start = 1 + fft_size // 8
+    cdef uint32_t fft_2_stop = 1 + fft_size // 8 + fft_size // 4
 
     cdef uint64_t frequency = 0
     cdef uint32_t index = 0
@@ -138,10 +138,10 @@ def sweep_callback(object device, cnp.ndarray[cnp.int8_t, ndim=1] buffer, int bu
         index += (pyhackrf.PY_BYTES_PER_BLOCK - data_length)
 
         fftwOut = fft((buffer[index:index + data_length:2] / 128 + 1j * buffer[index + 1:index + data_length:2] / 128) * window)
-        pwr = np.log10(np.abs(fftwOut) ** 2 * norm_factor) * 10.0
+        dbph = np.log10(np.abs(fftwOut) ** 2 * norm_factor) * 10.0
 
         if sweep_style == pyhackrf.py_sweep_style.LINEAR:
-            pwr = fftshift(pwr)
+            dbph = fftshift(dbph)
 
         index += data_length
 
@@ -151,18 +151,18 @@ def sweep_callback(object device, cnp.ndarray[cnp.int8_t, ndim=1] buffer, int bu
                 line = struct.pack('I', record_length)
                 line += struct.pack('Q', frequency)
                 line += struct.pack('Q', frequency + sample_rate // 4)
-                line += struct.pack('<' + 'f' * (fft_size // 4), *pwr[pwr_1_start:pwr_1_stop])
+                line += struct.pack('<' + 'f' * (fft_size // 4), *dbph[fft_1_start:fft_1_stop])
                 line += struct.pack('I', record_length)
                 line += struct.pack('Q', frequency + sample_rate // 2)
                 line += struct.pack('Q', frequency + (sample_rate * 3) // 4)
-                line += struct.pack('<' + 'f' * (fft_size // 4), *pwr[pwr_2_start:pwr_2_stop])
+                line += struct.pack('<' + 'f' * (fft_size // 4), *dbph[fft_2_start:fft_2_stop])
 
             else:
                 record_length = 16 + fft_size * 4
                 line = struct.pack('I', record_length)
                 line += struct.pack('Q', frequency)
                 line += struct.pack('Q', frequency + sample_rate)
-                line += struct.pack('<' + 'f' * fft_size, *pwr)
+                line += struct.pack('<' + 'f' * fft_size, *dbph)
 
             current_device_data['file'].write(line)
 
@@ -172,39 +172,39 @@ def sweep_callback(object device, cnp.ndarray[cnp.int8_t, ndim=1] buffer, int bu
                     'timestamp': time_str,
                     'start_frequency': frequency,
                     'stop_frequency': frequency + sample_rate // 4,
-                    'array': pwr[pwr_1_start:pwr_1_stop]
+                    'array': dbph[fft_1_start:fft_1_stop]
                 })
                 current_device_data['queue'].put({
                     'timestamp': time_str,
                     'start_frequency': frequency + sample_rate // 2,
                     'stop_frequency': frequency + (sample_rate * 3) // 4,
-                    'array': pwr[pwr_2_start:pwr_2_stop]
+                    'array': dbph[fft_2_start:fft_2_stop]
                 })
 
             else:
                 current_device_data['queue'].put({
                     'timestamp': time_str,
                     'start_frequency': frequency,
                     'stop_frequency': frequency + sample_rate,
-                    'array': pwr
+                    'array': dbph
                 })
 
         else:
             if sweep_style == pyhackrf.py_sweep_style.INTERLEAVED:
                 line = f'{time_str}, {frequency}, {frequency + sample_rate // 4}, {sample_rate / fft_size}, {fft_size}, '
-                pwr_1 = pwr[pwr_1_start:pwr_1_stop]
-                for i in range(len(pwr_1)):
-                    line += f'{pwr_1[i]:.10f}, '
+                dbph_1 = dbph[fft_1_start:fft_1_stop]
+                for i in range(len(dbph_1)):
+                    line += f'{dbph_1[i]:.10f}, '
                 line += f'\n{time_str}, {frequency + sample_rate // 2}, {frequency + (sample_rate * 3) // 4}, {sample_rate / fft_size}, {fft_size}, '
-                pwr_2 = pwr[pwr_2_start:pwr_2_stop]
-                for i in range(len(pwr_2)):
-                    line += f'{pwr_2[i]:.10f}, '
+                dbph_2 = dbph[fft_2_start:fft_2_stop]
+                for i in range(len(dbph_2)):
+                    line += f'{dbph_2[i]:.10f}, '
                 line = line[:len(line) - 2] + '\n'
 
             else:
                 line = f'{time_str}, {frequency}, {frequency + sample_rate}, {sample_rate / fft_size}, {fft_size}, '
-                for i in range(len(pwr)):
-                    line += f'{pwr[i]:.2f}, '
+                for i in range(len(dbph)):
+                    line += f'{dbph[i]:.2f}, '
                 line = line[:len(line) - 2] + '\n'
 
             current_device_data['file'].write(line)