From 6cf97522754cdee6b5ad6cb76b101bf78266b08f Mon Sep 17 00:00:00 2001 From: cmayer Date: Tue, 14 May 2019 22:39:57 +0200 Subject: [PATCH] preparations for XOR scrambling work on 110C mode (intermediate) --- examples/test_s4285.grc | 8 +- lib/adaptive_dfe_impl.cc | 27 ++- lib/adaptive_dfe_impl.h | 7 +- python/msg_proxy.py | 1 + python/physical_layer/MIL_STD_188_110A.py | 10 +- python/physical_layer/MIL_STD_188_110C.py | 194 ++++++++++++++++------ python/physical_layer/MIL_STD_188_110D.py | 25 +-- python/physical_layer/common.py | 14 +- python/physical_layer_driver.py | 2 +- 9 files changed, 207 insertions(+), 81 deletions(-) diff --git a/examples/test_s4285.grc b/examples/test_s4285.grc index 8841afe..78c4605 100644 --- a/examples/test_s4285.grc +++ b/examples/test_s4285.grc @@ -164,7 +164,7 @@ value - '600/L' + '1200/L' _enabled @@ -240,7 +240,7 @@ options - ['2400/L', '1200/L', '600/L', '300/L', '150/L', '75/L'] + ['2400/L', '1200/L', '600/L', '300/L', '150/L', '75/L', '2400/S', '1200/S', '600/S', '300/S', '150/S', '75/S'] orient @@ -877,11 +877,11 @@ file - /Users/chm/Software/gr-digitalhf/examples/on5kq.ddns.net_2019-03-20T12_49_38Z_2381.40_iq.wav + /Users/chm/Downloads/sdr.loginto.me_2019-05-14T13_46_37Z_7938.80_iq.wav _coordinate - (10, 154) + (21, 154) _rotation diff --git a/lib/adaptive_dfe_impl.cc b/lib/adaptive_dfe_impl.cc index 401e113..b04ef59 100644 --- a/lib/adaptive_dfe_impl.cc +++ b/lib/adaptive_dfe_impl.cc @@ -83,6 +83,7 @@ adaptive_dfe_impl::adaptive_dfe_impl(int sps, // samples per symbol , _constellation_index() , _symbols() , _scramble() + , _scramble_xor() , _descrambled_symbols() , _symbol_counter(0) , _save_soft_decisions(false) @@ -280,7 +281,12 @@ gr_complex adaptive_dfe_impl::filter(gr_complex const* start, gr_complex const* float const err = std::abs(descrambled_filter_output - descrambled_symbol); std::vector const soft_dec = constell->calc_soft_dec (descrambled_filter_output, _npwr[_constellation_index].filter(err)); - std::copy(soft_dec.begin(), soft_dec.end(), std::back_inserter >(_vec_soft_decisions)); + // std::cout << "SD: " << descrambled_filter_output << " : "; + for (int j=0, m=soft_dec.size(); j0.5) + std::cout << "err= " << std::abs(err) << std::endl; // taps_samples for (int j=0; j<_nB+_nF+1; ++j) { _last_taps_samples[j] = _taps_samples[j]; @@ -311,7 +319,7 @@ gr_complex adaptive_dfe_impl::filter(gr_complex const* start, gr_complex const* for (int j=_nB+1-2*_sps; j<_nB+1+2*_sps+1; ++j) acc += std::conj(_last_taps_samples[j]) * _taps_samples[j]; float const frequency_err = gr::fast_atan2f(acc)/(1+0*_num_samples_since_filter_update); // frequency error (rad/sample) - std::cout << "frequency_err " << frequency_err << " " << _num_samples_since_filter_update << std::endl; + GR_LOG_DEBUG(d_logger, str(boost::format("frequency_err= %f %d") % frequency_err % _num_samples_since_filter_update)); _control_loop.advance_loop(frequency_err); _control_loop.phase_wrap(); _control_loop.frequency_limit(); @@ -390,8 +398,7 @@ void adaptive_dfe_impl::update_constellations(pmt::pmt_t data) { int const n = pmt::length(data); _constellations.resize(n); _npwr.resize(n); - std::cout << "adaptive_dfe_impl::update_constellations " << data << std::endl; - std::cout << "adaptive_dfe_impl::update_constellations n=" << n << std::endl; + GR_LOG_DEBUG(d_logger, str(boost::format("update_constellations %s n=%d") % data % n)); unsigned int const rotational_symmetry = 0; unsigned int const dimensionality = 1; @@ -415,6 +422,18 @@ void adaptive_dfe_impl::update_frame_info(pmt::pmt_t data) _constellation_index = pmt::to_long(pmt::dict_ref(data, pmt::intern("constellation_idx"), pmt::PMT_NIL)); _save_soft_decisions = pmt::to_bool(pmt::dict_ref(data, pmt::intern("save_soft_dec"), pmt::PMT_F)); bool const do_continue = pmt::to_bool(pmt::dict_ref(data, pmt::intern("do_continue"), pmt::PMT_F)); + + // make table +-1 + std::vector const scr_xor = pmt::u8vector_elements(pmt::dict_ref(data, pmt::intern("scramble_xor"), pmt::PMT_NIL)); + _scramble_xor.resize(scr_xor.size()); + gr::digital::constellation_sptr constell = _constellations[_constellation_index]; + for (int i=0, n=scr_xor.size(); ibits_per_symbol(); j _npwr; int _npwr_max_time_constant; int _constellation_index; - std::vector _symbols; - std::vector _scramble; - std::vector _descrambled_symbols; + std::vector _symbols; + std::vector _scramble; // PSK-8 scramble symbols + std::vector > _scramble_xor; // signs for XOR scrambling + std::vector _descrambled_symbols; int _symbol_counter; bool _save_soft_decisions; diff --git a/python/msg_proxy.py b/python/msg_proxy.py index cf1b5e6..2df9207 100644 --- a/python/msg_proxy.py +++ b/python/msg_proxy.py @@ -74,6 +74,7 @@ class msg_proxy(gr.basic_block): msg_out = pmt.make_dict() msg_out = pmt.dict_add(msg_out, pmt.intern('symb'), pmt.to_pmt(symb['symb'])) msg_out = pmt.dict_add(msg_out, pmt.intern('scramble'), pmt.to_pmt(symb['scramble'])) + msg_out = pmt.dict_add(msg_out, pmt.intern('scramble_xor'), pmt.to_pmt(symb['scramble_xor'])) msg_out = pmt.dict_add(msg_out, pmt.intern('constellation_idx'), pmt.to_pmt(constellation_idx)) msg_out = pmt.dict_add(msg_out, pmt.intern('do_continue'), pmt.to_pmt(np.bool(do_continue))) msg_out = pmt.dict_add(msg_out, pmt.intern('save_soft_dec'), pmt.to_pmt(np.bool(save_soft_dec))) diff --git a/python/physical_layer/MIL_STD_188_110A.py b/python/physical_layer/MIL_STD_188_110A.py index 61be7c6..bb4fe41 100644 --- a/python/physical_layer/MIL_STD_188_110A.py +++ b/python/physical_layer/MIL_STD_188_110A.py @@ -199,9 +199,7 @@ class PhysicalLayer(object): self._frame_counter = 0 scramble_for_frame = common.n_psk(8, np.array([self._scr_data.next() for _ in range(self._frame_len)])) - a = np.array(zip(scramble_for_frame, - scramble_for_frame), - common.SYMB_SCRAMBLE_DTYPE) + a = common.make_scr(scramble_for_frame, scramble_for_frame) n_unknown = self._mode['unknown'] a['symb'][0:n_unknown] = 0 if self._mode['known'] != 0 and self._frame_counter >= self._num_frames_per_block-2: @@ -296,10 +294,8 @@ class PhysicalLayer(object): @staticmethod def get_preamble(): """preamble symbols + scrambler""" - return np.array(zip(PRE_SCRAMBLE*PRE_SYMBOLS, - PRE_SCRAMBLE), - common.SYMB_SCRAMBLE_DTYPE) - + return common.make_scr(PRE_SCRAMBLE*PRE_SYMBOLS, + PRE_SCRAMBLE) def get_preamble_z(self): """preamble symbols for preamble correlation""" a = PhysicalLayer.get_preamble() diff --git a/python/physical_layer/MIL_STD_188_110C.py b/python/physical_layer/MIL_STD_188_110C.py index 6bc1a17..5e315c0 100644 --- a/python/physical_layer/MIL_STD_188_110C.py +++ b/python/physical_layer/MIL_STD_188_110C.py @@ -3,11 +3,12 @@ from __future__ import print_function import numpy as np import common +from digitalhf.digitalhf_swig import viterbi27 ## ---- constellations ----------------------------------------------------------- BPSK=np.array(zip(np.exp(2j*np.pi*np.arange(2)/2), [0,1]), common.CONST_DTYPE) QPSK=np.array(zip(np.exp(2j*np.pi*np.arange(4)/4), [0,1,3,2]), common.CONST_DTYPE) -PSK8=np.array(zip(np.exp(2j*np.pi*np.arange(8)/8), [0,1,3,2,7,6,4,5]), common.CONST_DTYPE) +PSK8=np.array(zip(np.exp(2j*np.pi*np.arange(8)/8), [1,0,2,3,7,6,4,5]), common.CONST_DTYPE) QAM16=np.array( zip([+0.866025+0.500000j, 0.500000+0.866025j, 1.000000+0.000000j, 0.258819+0.258819j, -0.500000+0.866025j, 0.000000+1.000000j, -0.866025+0.500000j, -0.258819+0.258819j, @@ -104,29 +105,93 @@ MINI_PROBE=[common.n_psk(8, np.array([0,0,0,0,0,2,4,6,0,4,0,4,0,6,4,2,0,0,0,0,0, TO_DIBIT=[(0,0),(0,1),(1,1),(1,0)] ## ---- rate ------------------------------------------------------------------- -TO_RATE={(0,0,0): {'baud': 0, 'bits_per_symbol': 0}, ## reserved - (0,0,1): {'baud': 3200, 'bits_per_symbol': 2, 'ci': MODE_QPSK}, - (0,1,0): {'baud': 4800, 'bits_per_symbol': 3, 'ci': MODE_8PSK}, - (0,1,1): {'baud': 6400, 'bits_per_symbol': 4, 'ci': MODE_16QAM}, - (1,0,0): {'baud': 8000, 'bits_per_symbol': 5, 'ci': MODE_32QAM}, - (1,0,1): {'baud': 9600, 'bits_per_symbol': 6, 'ci': MODE_64QAM}, - (1,1,0): {'baud':12800, 'bits_per_symbol': 6, 'ci': MODE_64QAM}, - (1,1,1): {'baud': 0, 'bits_per_symbol': 0}} ## reserved +TO_RATE={(0,0,0): {'baud': '--------', 'bits_per_symbol': 0}, ## reserved + (0,0,1): {'baud': '3200 bps', 'bits_per_symbol': 2, 'ci': MODE_QPSK}, + (0,1,0): {'baud': '4800 bps', 'bits_per_symbol': 3, 'ci': MODE_8PSK}, + (0,1,1): {'baud': '6400 bps', 'bits_per_symbol': 4, 'ci': MODE_16QAM}, + (1,0,0): {'baud': '8000 bps', 'bits_per_symbol': 5, 'ci': MODE_32QAM}, + (1,0,1): {'baud': '9600 bps', 'bits_per_symbol': 6, 'ci': MODE_64QAM}, + (1,1,0): {'baud':'12800 bps', 'bits_per_symbol': 6, 'ci': MODE_64QAM}, + (1,1,1): {'baud': '--------', 'bits_per_symbol': 0}} ## reserved ## ---- interleaver ------------------------------------------------------------ -TO_INTERLEAVER={(0,0,0): {'frames': -1, 'name': 'illegal'}, - (0,0,1): {'frames': 1, 'name': 'Ultra Short (US)'}, - (0,1,0): {'frames': 3, 'name': 'Very Short (VS)'}, - (0,1,1): {'frames': 9, 'name': 'Short (S)'}, - (1,0,0): {'frames': 18, 'name': 'Medium (M)'}, - (1,0,1): {'frames': 36, 'name': 'Long (L)'}, - (1,1,0): {'frames': 72, 'name': 'very Long (VL)'}, - (1,1,1): {'frames': -1, 'name': 'illegal'}} +TO_INTERLEAVER={(0,0,0): {'frames': -1, 'id': '--', 'name': 'illegal'}, + (0,0,1): {'frames': 1, 'id': 'US', 'name': 'Ultra Short'}, + (0,1,0): {'frames': 3, 'id': 'VS', 'name': 'Very Short'}, + (0,1,1): {'frames': 9, 'id': 'S', 'name': 'Short'}, + (1,0,0): {'frames': 18, 'id': 'M', 'name': 'Medium'}, + (1,0,1): {'frames': 36, 'id': 'L', 'name': 'Long'}, + (1,1,0): {'frames': 72, 'id': 'VL', 'name': 'Very Long'}, + (1,1,1): {'frames': -1, 'id': '--', 'name': 'illegal'}} + +MP_COUNTER=[(0,0,1), ## 1st + (0,1,0), ## 2nd + (0,1,1), ## 3rd + (1,0,0)] ## 4th + +## ---- interleaver size +INTL_SIZE = { ## 1 3 9 18 36 72 + '--------': {'US': 0, 'VS': 0, 'S': 0, 'M': 0, 'L': 0, 'VL': 0}, + '3200 bps': {'US': 512, 'VS': 1536, 'S': 4608, 'M': 9216, 'L': 18432, 'VL': 36864}, + '4800 bps': {'US': 768, 'VS': 2304, 'S': 6912, 'M': 13824, 'L': 27648, 'VL': 55296}, + '6400 bps': {'US': 1024, 'VS': 3072, 'S': 9216, 'M': 18432, 'L': 36864, 'VL': 73728}, + '8000 bps': {'US': 1280, 'VS': 3840, 'S': 11520, 'M': 23040, 'L': 46080, 'VL': 92160}, + '9600 bps': {'US': 1536, 'VS': 4608, 'S': 13824, 'M': 27648, 'L': 55296, 'VL': 110592} +} + +## ---- interleaver increment +INTL_INCR = { ## 1 3 9 18 36 72 + '--------': {'US': 0, 'VS': 0, 'S': 0, 'M': 0, 'L': 0, 'VL': 0}, + '3200 bps': {'US': 97, 'VS': 229, 'S': 805, 'M': 1393, 'L': 3281, 'VL': 6985}, + '4800 bps': {'US': 145, 'VS': 361, 'S': 1045, 'M': 2089, 'L': 5137, 'VL': 10273}, + '6400 bps': {'US': 189, 'VS': 481, 'S': 1393, 'M': 3281, 'L': 6985, 'VL': 11141}, + '8000 bps': {'US': 201, 'VS': 601, 'S': 1741, 'M': 3481, 'L': 8561, 'VL': 14441}, + '9600 bps': {'US': 229, 'VS': 805, 'S': 2089, 'M': 5137, 'L': 10273, 'VL': 17329} +} + +## ---- deinterleaver+depuncturer +class DeIntl_DePunct(object): + """deinterleave""" + def __init__(self, size, incr): + self._size = size + self._i = 0 + self._array = np.zeros(size, dtype=np.float32) + self._idx = np.mod(incr*np.arange(size, dtype=np.uint32), size) + print('deinterleaver: ', size, incr, self._idx[0:100]) + + def fetch(self, a): + pass + + def load(self, a): + n = len(a) + i = self._i + if i==0: + self._array[:] = 0 + print('deinterleaver load buffer:', i,len(self._array),n) + assert(i+n <= self._size) + self._array[i:i+n] = a + self._i += n + result = np.zeros(0, dtype=np.float64) + if self._i == self._size: + print('==== TEST ====', self._array) + #tmp = np.zeros(self._size, dtype=np.float32) + tmp = self._array[self._idx] + result = np.zeros(self._size*6//4, dtype=np.float64) + assert(len(result[0::6]) == len(tmp[0::4])) + assert(len(result[1::6]) == len(tmp[1::4])) + assert(len(result[2::6]) == len(tmp[2::4])) + assert(len(result[5::6]) == len(tmp[3::4])) + result[0::6] = tmp[0::4] + result[1::6] = tmp[1::4] + result[2::6] = tmp[2::4] + result[3::6] = 0 + result[4::6] = 0 + result[5::6] = tmp[3::4] + print('==================== interleaver is full! ====================', + len(result[0::6]), len(tmp[0::4]), np.sum(result==0)) + self._i = 0 + return result -MP_COUNTER=[(0,0,1), - (0,1,0), - (0,1,1), - (1,0,0)] ## ---- physcal layer class ----------------------------------------------------- class PhysicalLayer(object): @@ -138,7 +203,8 @@ class PhysicalLayer(object): self._frame_counter = -2 self._constellations = [BPSK, QPSK, PSK8, QAM16, QAM32, QAM64] self._preamble = self.get_preamble() - self._interleaver_length = 72 ## set in decode_reinserted preamble to the actual value + self._scramble = ScrambleData() + self._viterbi_decoder = viterbi27(0x6d, 0x4f) def get_constellations(self): return self._constellations @@ -153,6 +219,8 @@ class PhysicalLayer(object): print('-------------------- get_frame --------------------', self._frame_counter) success = True if self._frame_counter == -2: ## ---- preamble + self._deintl_depunct = None + self._mode = {} self._preamble_offset = 0 self._frame_counter += 1 return [self._preamble,MODE_BPSK,success,False] @@ -215,46 +283,67 @@ class PhysicalLayer(object): def decode_reinserted_preamble(self, symbols): ## decode D0,D1,D2 + success = True z = np.array([np.mean(symbols[-71+i*13:-71+(i+1)*13]) for i in range(3)]) - print('decode_reinserted_preamble', symbols[0:-71], symbols[-71:-71+3*13], symbols[-71+4*13:], z) + if np.mean(np.abs(z)) < 0.4: + return False + print('decode_reinserted_preamble', + '\nHH', symbols[0:-71], + '\nD0', symbols[-71 :-71+13], + '\nD1', symbols[-71+13:-71+26], + '\nD2', symbols[-71+26:-71+39], + '\nTT', symbols[-71+4*13:], z) d0d1d2 = map(np.uint8, np.mod(np.round(np.angle(z)/np.pi*2),4)) dibits = [TO_DIBIT[idx] for idx in d0d1d2] - self._mode = {'rate': tuple([x[0] for x in dibits]), - 'interleaver': tuple([x[1] for x in dibits])} - print('======== rate,interleaver:', - TO_RATE[self._mode['rate']], - TO_INTERLEAVER[self._mode['interleaver']]) - self._interleaver_length = TO_INTERLEAVER[self._mode['interleaver']]['frames'] - rate_info = TO_RATE[self._mode['rate']] - print('rate_info', rate_info) + mode = {'rate': tuple([x[0] for x in dibits]), + 'interleaver': tuple([x[1] for x in dibits])} + if self._mode != {}: + success = (mode == self._mode) + if not success: + return success + self._mode = mode + self._rate_info = rate_info = TO_RATE[self._mode['rate']] + self._intl_info = intl_info = TO_INTERLEAVER[self._mode['interleaver']] + + print('======== rate,interleaver:', rate_info, intl_info) + self._interleaver_frames = intl_info['frames'] + baud = rate_info['baud'] + intl_id = intl_info['id'] + intl_size = INTL_SIZE[baud][intl_id] + intl_incr = INTL_INCR[baud][intl_id] + if self._deintl_depunct == None: + self._deintl_depunct = DeIntl_DePunct(size=intl_size, + incr=intl_incr) self._constellation_index = rate_info['ci'] print('constellation index', self._constellation_index) - scr = ScrambleData() - iscr = [scr.next(rate_info['bits_per_symbol']) for _ in range(256)] + self._scramble.reset() + num_bits = max(3, rate_info['bits_per_symbol']) + iscr = np.array([self._scramble.next(num_bits) for _ in range(256)], + dtype=np.uint8) + print('iscr=', iscr) + self._data_scramble = np.ones (256, dtype=np.complex64) + self._data_scramble_xor = np.zeros(256, dtype=np.uint8) if rate_info['ci'] > MODE_8PSK: - self._data_scramble = np.ones(256, dtype=np.complex64) + self._data_scramble_xor = iscr else: - constell = self._constellations[rate_info['ci']] - self._data_scramble = constell[iscr]['points'] - success = True ## TODO + self._data_scramble = common.n_psk(8, iscr) return success def make_reinserted_preamble(self, offset, success): - """ offset= 0 -> 1st reinserted preamble + """ offset= 0 -> 1st reinsesrted preamble offset=-72 -> all following reinserted preambles""" - a=np.array(zip(REINSERTED_PREAMBLE[offset:], - REINSERTED_PREAMBLE[offset:]), - common.SYMB_SCRAMBLE_DTYPE) + a = common.make_scr(REINSERTED_PREAMBLE[offset:], REINSERTED_PREAMBLE[offset:]) a['symb'][-71:-71+3*13] = 0 ## D0,D1,D2 - print('make_reinserted_preamble', offset, success, len(a['symb']), a['symb'], a['scramble']) + print('make_reinserted_preamble', offset, success, len(a['symb'])) if not success: - self._frame_counter = -1 + self._frame_counter = -2 return a def make_data_frame(self, success): self._preamble_offset = -72 ## all following reinserted preambles start at index -72 a = np.zeros(256+31, common.SYMB_SCRAMBLE_DTYPE) - a['scramble'][:256] = self._data_scramble + a['scramble'][:256] = self._data_scramble + a['scramble_xor'][:256] = self._data_scramble_xor n = (self._frame_counter-1)%72 if self._frame_counter == 72: self._frame_counter = -1 @@ -267,18 +356,25 @@ class PhysicalLayer(object): a['symb'][256:] = MINI_PROBE[self._mp[m]] a['scramble'][256:] = MINI_PROBE[self._mp[m]] if not success: - self._frame_counter = -1 + self._frame_counter = -2 return a def decode_soft_dec(self, soft_dec): - return soft_dec + r = self._deintl_depunct.load(soft_dec) + if r.shape[0] == 0: + return [] + self._viterbi_decoder.reset() + decoded_bits = self._viterbi_decoder.udpate(r) + print('bits=', decoded_bits[:100]) + print('quality={}% ({},{})'.format(120.0*self._viterbi_decoder.quality()/(2*len(decoded_bits)), + self._viterbi_decoder.quality(), + len(decoded_bits))) + return decoded_bits @staticmethod def get_preamble(): """preamble symbols + scrambler""" - return np.array(zip(PREAMBLE, - PREAMBLE), - common.SYMB_SCRAMBLE_DTYPE) + return common.make_scr(PREAMBLE, PREAMBLE) def get_preamble_z(self): """preamble symbols for preamble correlation""" diff --git a/python/physical_layer/MIL_STD_188_110D.py b/python/physical_layer/MIL_STD_188_110D.py index 9ed8e82..695f55d 100644 --- a/python/physical_layer/MIL_STD_188_110D.py +++ b/python/physical_layer/MIL_STD_188_110D.py @@ -772,9 +772,14 @@ class PhysicalLayer(object): else: self._state = 'MP' a = np.zeros(self._unknown, common.SYMB_SCRAMBLE_DTYPE) + a['scramble'][:] = 1 self._scr_data.reset() - for i in range(self._unknown): ## TODO: handle QAM modes - a['scramble'][i] = np.exp(2j*np.pi*self._scr_data.next()/8) + if self._wid_mode <= MODE_8PSK: ## not QAM + for i in range(self._unknown): + a['scramble'][i] = np.exp(2j*np.pi*self._scr_data.next()/8) + else: ## QAM modes + for i in range(self._unknown): + a['scramble_xor'][i] = self._scr_data.next() return self._data_mode,a def get_doppler(self, iq_samples): @@ -869,16 +874,12 @@ class PhysicalLayer(object): CNT_SCR = common.n_psk(8, np.concatenate([CNT_PN for _ in range(4)]))[:len(CNT_SYMB)] WID_SCR = common.n_psk(8, np.concatenate([WID_PN for _ in range(5)]))[:len(WID_SYMB)] - self._fixed_s = np.array(zip(SYNC_SCR*SYNC_SYMB, - SYNC_SCR), - common.SYMB_SCRAMBLE_DTYPE) - self._cnt_s = np.array(zip(CNT_SCR*CNT_SYMB, - CNT_SCR), - common.SYMB_SCRAMBLE_DTYPE) - self._wid_s = np.array(zip(WID_SCR*WID_SYMB, - WID_SCR), - common.SYMB_SCRAMBLE_DTYPE) - + self._fixed_s = common.make_scr(SYNC_SCR*SYNC_SYMB, + SYNC_SCR) + self._cnt_s = common.make_scr(CNT_SCR*CNT_SYMB, + CNT_SCR) + self._wid_s = common.make_scr(WID_SCR*WID_SYMB, + WID_SCR) def decode_soft_dec(self, soft_dec): print('decode_soft_dec', len(soft_dec), soft_dec.dtype) diff --git a/python/physical_layer/common.py b/python/physical_layer/common.py index eac06e3..a34e336 100644 --- a/python/physical_layer/common.py +++ b/python/physical_layer/common.py @@ -6,7 +6,19 @@ CONST_DTYPE=np.dtype([('points', np.complex64), ('symbols', np.int32)]) SYMB_SCRAMBLE_DTYPE=np.dtype([('symb', np.complex64), - ('scramble', np.complex64)]) + ('scramble', np.complex64), + ('scramble_xor', np.uint8)]) + +def make_scr(s1, s2=None, s3=None): + a = np.zeros(len(s1), SYMB_SCRAMBLE_DTYPE) + a['symb'][:] = s1 + if s2 is not None: + assert(len(s2) == len(s1)) + a['scramble'][:] = s2 + if s3 is not None: + assert(len(s3) == len(s1)) + a['scramble_xor'][:] = s3 + return a def n_psk(n,x): """n-ary PSK constellation""" diff --git a/python/physical_layer_driver.py b/python/physical_layer_driver.py index 68be3f1..cea0a48 100644 --- a/python/physical_layer_driver.py +++ b/python/physical_layer_driver.py @@ -60,7 +60,7 @@ class physical_layer_driver(gr.hier_block2): self._corr_est = digital.corr_est_cc(symbols = (preamble_samples.tolist()), sps = sps, mark_delay = preamble_offset, - threshold = 0.5, + threshold = 0.3, threshold_method = 1) self._doppler_correction = digitalhf.doppler_correction_cc(preamble_length, len(preamble_samples)) self._adaptive_filter = digitalhf.adaptive_dfe(sps, nB, nF, nW, mu, alpha)