def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
ppseq = signalFunctions.grab_pulse_lens(signal.qad,
signal.qad_center,
signal.tolerance,
signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal.data[start:end]))
message = Message(bits, pause, message_type=self.default_message_type,
bit_len=bit_len, rssi=rssi, decoder=self.decoder, bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
ppseq = signalFunctions.grab_pulse_lens(signal.qad, signal.qad_center,
signal.tolerance,
signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal.data[start:end]))
message = Message(bits,
pause,
message_type=self.default_message_type,
bit_len=bit_len,
rssi=rssi,
decoder=self.decoder,
bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
signal = self.signal
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
signal._fulldata = np.concatenate(self.data_cache)
del self.data_cache[:]
signal._qad = None
bit_len = signal.bit_len
ppseq = grab_pulse_lens(signal.qad, signal.qad_center,
signal.tolerance, signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, self.rel_symbol_len)
i = 0
first_msg = True
for bits, pause in zip(bit_data, pauses):
if first_msg or self.messages[-1].pause > 8 * bit_len:
# Create new Message
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal._fulldata[start:end]))
message = Message(bits,
pause,
bit_len=bit_len,
rssi=rssi,
message_type=self.default_message_type)
self.messages.append(message)
first_msg = False
else:
# Append to last message
message = self.messages[-1]
nzeros = int(np.round(message.pause / bit_len))
message.plain_bits.extend([False] * nzeros)
message.plain_bits.extend(bits)
message.pause = pause
i += 1
def __are_bits_in_data(self, data):
self.signal._fulldata = data
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance, self.signal.modulation_type)
bit_data, pauses, _ = self._ppseq_to_bits(ppseq, bit_len)
return bool(bit_data)
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
self.signal._fulldata = np.concatenate(self.data_cache)
self.data_cache.clear()
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance,
self.signal.modulation_type,
self.signal.bit_len)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, write_bit_sample_pos=False)
i = 0
first_msg = True
for bits, pause in zip(bit_data, pauses):
if first_msg or self.messages[-1].pause > 8 * bit_len:
message = Message(bits,
pause,
bit_len=bit_len,
message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
first_msg = False
else:
# Append to last message
message = self.messages[-1]
nzeros = int(np.round(message.pause / bit_len))
message.plain_bits.extend([False] * nzeros)
message.plain_bits.extend(bits)
message.pause = pause
i += 1
def get_protocol_from_signal(self):
signal = self.signal
if signal is None:
self.messages = None
return
if self.messages is not None:
self.messages[:] = []
else:
self.messages = []
bit_len = signal.bit_len
try:
ppseq = signalFunctions.grab_pulse_lens(signal.qad,
signal.qad_center,
signal.tolerance,
signal.modulation_type,
signal.bit_len)
except TypeError:
# Remove this check in version 1.7
print(
"Extension method has changed! To fix this, first move to URHs base directory "
"then recompile the extensions using the following command:")
print("python3 src/urh/cythonext/build.py")
print("and finally restart the application")
sys.exit(1)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, pause_threshold=signal.pause_threshold)
if signal.message_length_divisor > 1 and signal.modulation_type_str == "ASK":
self.__ensure_message_length_multiple(
bit_data, signal.bit_len, pauses, bit_sample_pos,
signal.message_length_divisor)
i = 0
for bits, pause in zip(bit_data, pauses):
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal.data[start:end]))
message = Message(bits,
pause,
message_type=self.default_message_type,
bit_len=bit_len,
rssi=rssi,
decoder=self.decoder,
bit_sample_pos=bit_sample_pos[i])
self.messages.append(message)
i += 1
self.qt_signals.protocol_updated.emit()
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
self.signal._fulldata = np.concatenate(self.data_cache)
self.data_cache.clear()
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance, self.signal.modulation_type)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(ppseq, bit_len)
i = 0
first_msg = True
for bits, pause in zip(bit_data, pauses):
if first_msg or self.messages[-1].pause > 8 * bit_len:
# Create new Message
middle_bit_pos = bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(self.signal._fulldata[start:end]))
message = Message(bits, pause, bit_len=bit_len, rssi=rssi, message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
first_msg = False
else:
# Append to last message
message = self.messages[-1]
nzeros = int(np.round(message.pause / bit_len))
message.plain_bits.extend([False] * nzeros)
message.plain_bits.extend(bits)
message.pause = pause
i += 1
def __demodulate_data(self, data):
"""
Demodulates received IQ data and adds demodulated bits to messages
:param data:
:return:
"""
if len(data) == 0:
return
rssi_squared = np.mean(data.real**2 + data.imag**2)
is_above_noise = rssi_squared > self.signal.noise_threshold**2
if self.adaptive_noise and not is_above_noise:
self.signal.noise_threshold = 0.9 * self.signal.noise_threshold + 0.1 * np.max(
np.abs(data))
if is_above_noise:
self.data_cache.append(data)
self.pause_length = 0
return
else:
self.pause_length += len(data)
if self.pause_length < 10 * self.signal.bit_len:
self.data_cache.append(data)
return
if len(self.data_cache) == 0:
return
# clear cache and start a new message
self.signal._fulldata = np.concatenate(self.data_cache)
self.data_cache.clear()
self.signal._qad = None
bit_len = self.signal.bit_len
ppseq = grab_pulse_lens(self.signal.qad, self.signal.qad_center,
self.signal.tolerance,
self.signal.modulation_type,
self.signal.bit_len)
bit_data, pauses, bit_sample_pos = self._ppseq_to_bits(
ppseq, bit_len, write_bit_sample_pos=False)
for bits, pause in zip(bit_data, pauses):
message = Message(bits,
pause,
bit_len=bit_len,
message_type=self.default_message_type,
decoder=self.decoder)
self.messages.append(message)
self.message_sniffed.emit(len(self.messages) - 1)
def on_rcv_thread_index_changed(self, old_index, new_index):
signal = self.signal
data = self.rcv_thrd.data[old_index:new_index]
if self.__are_bits_in_data(data):
self.reading_data = True
elif self.conseq_non_data == 5:
self.reading_data = False
self.conseq_non_data = 0
else:
self.conseq_non_data += 1
if self.reading_data:
self.data_cache.append(data)
return
elif len(self.data_cache) == 0:
return
signal._fulldata = np.concatenate(self.data_cache)
del self.data_cache[:]
signal._qad = None
bit_len = signal.bit_len
ppseq = grab_pulse_lens(signal.qad, signal.qad_center,
signal.tolerance, signal.modulation_type)
del self.bit_sample_pos[:]
bit_data, pauses = self._ppseq_to_bits(ppseq, bit_len,
self.rel_symbol_len)
i = 0
first_block = True
old_nblocks = len(self.blocks)
for bits, pause in zip(bit_data, pauses):
if first_block or self.blocks[-1].pause > 8 * bit_len:
# Create new Block
middle_bit_pos = self.bit_sample_pos[i][int(len(bits) / 2)]
start, end = middle_bit_pos, middle_bit_pos + bit_len
rssi = np.mean(np.abs(signal._fulldata[start:end]))
block = ProtocolBlock(bits,
pause,
self.bit_alignment_positions,
bit_len=bit_len,
rssi=rssi)
self.blocks.append(block)
first_block = False
else:
# Append to last block
block = self.blocks[-1]
nzeros = int(np.round(block.pause / bit_len))
block.plain_bits.extend([False] * nzeros)
block.plain_bits.extend(bits)
block.pause = pause
i += 1
self.qt_signals.data_sniffed.emit(old_nblocks)
if self.sniff_file and not os.path.isdir(self.sniff_file):
# Write Header
if not os.path.isfile(self.sniff_file):
with open(self.sniff_file, "w") as f:
f.write("PROTOCOL:\n\n")
with open(self.sniff_file, "a") as myfile:
if self.plain_bits_str:
myfile.write("\n")
myfile.write("\n".join(self.plain_bits_str))
if not self.__store_data:
self.blocks[:] = []
