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
