def test_conv_encode_viterbi_decode(self): niters = 10 blocklength = 1000 for i in range(niters): msg = randint(0, 2, blocklength) coded_bits = conv_encode(msg, self.trellis_1) decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_1, 15) assert_array_equal(decoded_bits[:-2], msg) coded_bits = conv_encode(msg, self.trellis_1) coded_syms = 2.0 * coded_bits - 1 decoded_bits = viterbi_decode(coded_syms, self.trellis_1, 15, 'unquantized') assert_array_equal(decoded_bits[:-2], msg) coded_bits = conv_encode(msg, self.trellis_2) decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_2, 15) assert_array_equal(decoded_bits[:-2], msg) coded_bits = conv_encode(msg, self.trellis_2) coded_syms = 2.0 * coded_bits - 1 decoded_bits = viterbi_decode(coded_syms, self.trellis_2, 15, 'unquantized') assert_array_equal(decoded_bits[:-2], msg)
def test_conv_encode_viterbi_decode(self): niters = 10 blocklength = 1000 for i in xrange(niters): msg = randint(0, 2, blocklength) coded_bits = conv_encode(msg, self.trellis_1) decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_1, 15) assert_array_equal(decoded_bits[:-2], msg) coded_bits = conv_encode(msg, self.trellis_2) decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis_2, 15) assert_array_equal(decoded_bits[:-2], msg)
def encode(self, message: np.ndarray) -> np.ndarray: """ Use the configured trellis to perform convolutional encoding on the given message bits. :param message: array of message bits (minimum length determined by trellis) :return: array of encoded message bits ready for modulation """ # prepend length to message message_length = len(message) data_type = np.dtype('uint8') data_type = data_type.newbyteorder('>') length_bytes = np.frombuffer(message_length.to_bytes(LENGTH_SIZE, byteorder='big', signed=False), dtype=data_type) message = np.insert(message, 0, length_bytes) # convert bytes to bit array bits = np.unpackbits(message, bitorder='big') # perform the convolution encoding encoded = cc.conv_encode(bits, self._trellis, termination='cont') logging.info( 'Encoded {}-byte message into {}-bit convolution coded parity message' .format(message_length, len(encoded))) return encoded
def conv_enc(X_train_raw, args): import commpy.channelcoding.convcode as cc num_block = X_train_raw.shape[0] block_len = X_train_raw.shape[1] x_code = [] M = np.array([2]) # Number of delay elements in the convolutional encoder generator_matrix = np.array([[args.enc1, args.enc2]]) feedback = args.feedback trellis = cc.Trellis(M, generator_matrix, feedback=feedback) # Create trellis data structure for idx in range(num_block): xx = cc.conv_encode(X_train_raw[idx, :, 0], trellis, 'rsc') xx1 = xx[::2] xx2 = xx[1::2] xx1 = xx1[:-int(M)] xx2 = xx2[:-int(M)] xx = np.array([xx1, xx2]).T # xx = xx[:-2*int(M)] # xx = xx.reshape((block_len, 2)) x_code.append(xx) return np.array(x_code)
def turbo_compute((idx, x)): ''' Compute Turbo Decoding in 1 iterations for one SNR point. ''' np.random.seed() message_bits = np.random.randint(0, 2, args.block_len) coded_bits = cc.conv_encode(message_bits, trellis1) received = corrupt_signal(coded_bits, noise_type=args.noise_type, sigma=test_sigmas[idx], vv=args.v, radar_power=args.radar_power, radar_prob=args.radar_prob, denoise_thd=args.radar_denoise_thd) # make fair comparison between (100, 204) convolutional code and (100,200) RNN decoder, set the additional bit to 0 received[-2 * int(M):] = 0.0 decoded_bits = cc.viterbi_decode(received.astype(float), trellis1, tb_depth, decoding_type='unquantized') decoded_bits = decoded_bits[:-int(M)] num_bit_errors = hamming_dist(message_bits, decoded_bits) return num_bit_errors
def conv_encoder(message_bits, fb): generator_matrix = np.array([[07, 05]]) M = np.array([2]) if fb == True: trellis = cc.Trellis(M, generator_matrix, feedback=7) else: trellis = cc.Trellis(M, generator_matrix) return 2 * cc.conv_encode(np.asarray(message_bits), trellis) - 1
def modulate(bits): res = cc.conv_encode(bits, trellis1, 'cont') puncture_matrix = Wifi80211._get_puncture_matrix(coding[0], coding[1]) res_p = res if puncture_matrix: res_p = cc.puncturing(res, puncture_matrix) return modem.modulate(res_p)
def test_conv_encode_viterbi_decode(self): niters = 10 blocklength = 1000 for n in range(niters): msg = randint(0, 2, blocklength) # Previous tests for i in range(len(self.trellis)): coded_bits = conv_encode(msg, self.trellis[i]) decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis[i], 15) assert_array_equal(decoded_bits[:len(msg)], msg) coded_bits = conv_encode(msg, self.trellis[i], termination='cont') decoded_bits = viterbi_decode(coded_bits.astype(float), self.trellis[i], 15) assert_array_equal(decoded_bits, msg) coded_bits = conv_encode(msg, self.trellis[i]) coded_syms = 2.0 * coded_bits - 1 decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'unquantized') assert_array_equal(decoded_bits[:len(msg)], msg) coded_bits = conv_encode(msg, self.trellis[i]) coded_syms = 10.0 * coded_bits - 5 + randn(len(coded_bits)) * 2 decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft') assert_array_equal(decoded_bits[:len(msg)], msg) coded_bits = conv_encode(msg, self.trellis[i], termination='cont') coded_syms = 10.0 * coded_bits - 5 + randn(len(coded_bits)) * 2 decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft') assert_array_equal(decoded_bits, msg) coded_bits = conv_encode(msg, self.trellis[i]) coded_syms = (2.0 * coded_bits - 1) * inf decoded_bits = viterbi_decode(coded_syms, self.trellis[i], 15, 'soft') assert_array_equal(decoded_bits[:len(msg)], msg) coded = conv_encode(msg, self.trellis[i], termination='cont') coded_bits = coded.astype(float) coded_bits[coded_bits == 1.0] = inf coded_bits[coded_bits == 0.0] = -inf decoded_bits = viterbi_decode(coded_bits, self.trellis[i], 15, 'soft') assert_array_equal(decoded_bits, msg)
def convolutional_encode(message_bits, generator_matrix, memory): """ Given a sequence of input bits and a particular generator_matrix, along with a memory specification, generates the corresponding Trellis and then the convolution code. Returns encoded bits """ trellis = cc.Trellis(memory, generator_matrix) coded_bits = cc.conv_encode(message_bits, trellis) return coded_bits
def conv_enc(X_train_raw, args): num_block = X_train_raw.shape[0] block_len = X_train_raw.shape[1] x_code = [] generator_matrix = np.array([[args.enc1, args.enc2]]) M = np.array([args.M]) # Number of delay elements in the convolutional encoder trellis = cc.Trellis(M, generator_matrix,feedback=args.feedback)# Create trellis data structure for idx in range(num_block): xx = cc.conv_encode(X_train_raw[idx, :, 0], trellis) xx = xx[2*int(M):] xx = xx.reshape((block_len, 2)) x_code.append(xx) return np.array(x_code)
def stack_runner(IterationTimes, snr, index, metrics): memory = array([8]) g_matrix = array([[0o515, 0o677]]) trellis = cc.Trellis(memory, g_matrix) BPSKMod = cm.PSKModem(2) CodeError = 0 total_result = 0.0 for i in range(IterationTimes): # encode # set the message size message_bits = np.random.randint(0, 2, 128) # print(message_bits) encoded_code = cc.conv_encode(message_bits, trellis) BPSK_modedbits = BPSKMod.modulate(encoded_code) AWGNreceived_bits = cch.awgn(BPSK_modedbits, snr + 3, 0.5) result = stack_soft_decoder(AWGNreceived_bits, metrics, trellis) print("pass: {}, {}".format(i, index)) if len(result) != 136: continue else: BitErrors = str( array(message_bits) ^ array(result[0:len(message_bits)])).count('1') # print(result) # print(BitErrors) # print(result_int) # print(message_bits_int) BER = BitErrors / 128 if BitErrors > 0: CodeError += 1 total_result += BER # i += 1 # print(i) # print(result) CER = CodeError / IterationTimes AverageBER = total_result / IterationTimes return CER
def test_conv_encode(self): for i in range(len(self.trellis)): assert_array_equal(conv_encode(self.mes, self.trellis[i], 'cont'), self.desired_encode_msg[i])
nb_errors = np.zeros(test_sigmas.shape) map_nb_errors = np.zeros(test_sigmas.shape) # Traceback depth of the decoder tb_depth = 10 #5*(M.sum() + 1) print('traceback depth: ' + str(tb_depth)) for idx in xrange(SNR_points): print(idx) for iterations in xrange(iterations_number): message_bits = np.random.randint(0, 2, k) coded_bits = cc.conv_encode(message_bits, trellis) # print('coded_bits: ') # print(coded_bits) if NType == 'iid': noise = test_sigmas[idx] * np.random.standard_normal( coded_bits.shape) # Define noise uu = np.sqrt(0.5) * np.random.standard_normal(coded_bits.shape) vv = np.sqrt(0.5) * np.random.standard_normal(coded_bits.shape) rayleigh_coeff = np.sqrt(uu**2 + vv**2) received = rayleigh_coeff * (2 * coded_bits - 1) + noise # Modulation plus noise # print('received: ') # print(received)
def play_file(): # Read in the Input File f = open(args.input_file, 'r') context = f.readlines() f.close() if (len(context) != 1): print("wrong input file") exit() text = context[0] ######### bit part message_bits = [] for i in text: if i == '0': message_bits.append(0) elif i == '1': message_bits.append(1) text_encoded = cc.conv_encode(message_bits, trellis, code_type='default', puncture_matrix=None) print('Actual bits number: ', len(text_encoded)) ########### bit_num = len(text_encoded) print('Transmit bits number: ', bit_num) num_bin = '{:016b}'.format(bit_num) num_bits = [] for i in num_bin: if i == '0': num_bits.append(0) elif i == '1': num_bits.append(1) num_encoded = cc.conv_encode(num_bits, trellis, code_type='default', puncture_matrix=None) # print(num_encoded) output_wave = np.zeros(500 * bit_len + (bit_num) * bit_len) index = 0 # send the first packet index = add_preamble(output_wave, index) for i in num_encoded: if i == 0: index += add_zero(output_wave, index) elif i == 1: index += add_one(output_wave, index) num = 0 for i in text_encoded: if num % packet_size == 0: index += 10 * bit_len index = add_preamble(output_wave, index) num += 1 if i == 0: index += add_zero(output_wave, index) elif i == 1: index += add_one(output_wave, index) sd.play(output_wave, blocking=True)
# Number of delay elements in the convolutional encoder M = np.array([2]) # Create trellis data structure trellis = cc.Trellis(M, generator_matrix) # Traceback depth of the decoder tb_depth = 5*(M.sum() + 1) for i in range(10): # Generate random message bits to be encoded message_bits = np.random.randint(0, 2, 1000) # Encode message bits coded_bits = cc.conv_encode(message_bits, trellis) # Introduce bit errors (channel) #coded_bits[4] = 0 #coded_bits[7] = 0 # Decode the received bits decoded_bits = cc.viterbi_decode(coded_bits.astype(float), trellis, tb_depth) num_bit_errors = hamming_dist(message_bits, decoded_bits[:-M]) #num_bit_errors = 1 if num_bit_errors !=0: #print(num_bit_errors, "Bit Errors found!") #print(message_bits) #print(decoded_bits[tb_depth+3:])
def dstardd_encode(self, header, data): # Generate Header CRC genpoly = 0x8408; crc = 0xffff for i in xrange(39): crc ^= ord(header[i]) for j in xrange(8): if(crc & 0x01): crc >>= 1; crc ^= genpoly; else: crc >>=1 ; crc ^= 0xffff; print ("Header CRC: ",crc) header = header + chr(crc&0xff) + chr((crc>>8)&0xff) print ("Full header: ",repr(header)); # Convolution of header block memory = np.array([2]) g_matrix = np.array([[0o7, 0o5]]) tr = Trellis(memory, g_matrix, 0, 'default') bits = np.array([0] * 660); for i in xrange(41): byte = ord(header[i]) for j in xrange(8): bits[i*8+j] = (byte>>j)&0x01; encoded = conv_encode(bits, tr) # Interleaving of header block interleaved = [0] * 660 for i in xrange(12): for j in xrange(28) : interleaved[i*28 + j] = encoded[i + j*24]; for i in xrange(12,24) : for j in xrange(27): interleaved[i*27 + j + 12] = encoded[i + j*24]; # Note: interleaved[i] enthaelt nun die 660header bits lenbits = [0]*16 datalen = len(data) for i in xrange(16): lenbits[i] = (datalen>>i)&0x01 databits = [0] * (datalen*8) for i in xrange(datalen): for j in xrange(8): databits[i*8+j] = (ord(data[i])>>j) & 0x01 content = chr(datalen&0xff) + chr((datalen>>8)&0xff) + data print("content for dstar crc: ", repr(content)) dstarcrc = zlib.crc32(content) & 0xffffffff crcbits = [(dstarcrc>>i)&1 for i in range(0,32)] all = interleaved + lenbits + databits + crcbits # Scramble complete frame including header, data length and data self.sr = 0x7f all = self.scramble(all) return all
def modulate(bits): return modem.modulate(cc.conv_encode(bits, trellis1, 'cont'))
def commpy_encode_sequence(self,u,terminate=False): if terminate: return cc.conv_encode(u, self.trellisNSC, code_type = 'default') else: return cc.conv_encode(u, self.trellisNSC, code_type = 'default')[:-2*self.trellisNSC.total_memory]
# g_matrix = array([[ 109 , 79]]) # G(D) = [1+D^2, 1+D+D^2] memory = array([3]) g_matrix = array([[ 109 , 79]]) # G(D) = [1+D^2, 1+D+D^2] trellis = cc.Trellis(memory, g_matrix) # a='111101011' # message_bits = np.array(list(a)) # coded_bits = cc.conv_encode(message_bits, trellis, code_type='default', puncture_matrix=None) # print(coded_bits) bit_num = 8414 print(bit_num) num_bin = '{:016b}'.format(bit_num) num_bits = [ ] for i in num_bin: if i =='0': num_bits.append(0) elif i == '1': num_bits.append(1) num_encoded = cc.conv_encode(num_bits, trellis, code_type='default', puncture_matrix=None) print(num_encoded) # coded_bits = np.array([0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0]) # print(coded_bits) ans = cc.viterbi_decode(num_encoded, trellis, tb_depth=None, decoding_type='hard') print(ans) # print(str(message_bits)) # ans = np.array2string(np.random.randint(0,2,10000)) # ans+= '\n' # print (ans) # output_file = open("INPUT.txt", "w") # output_file.write(ans)
def conv_encoder(message_bits): generator_matrix = np.array([[05, 07]]) M = np.array([2]) trellis = cc.Trellis(M, generator_matrix) return 2*cc.conv_encode(np.asarray(message_bits), trellis)-1
def conv_encoder(message_bits, trellis): return 2*cc.conv_encode(np.asarray(message_bits), trellis)-1