def wava(upperbound, snr, trellis):
BPSK_Mode = cm.PSKModem(2)
last_state1 = 0
last_metric1 = 0
last_state2 = 0
last_metric2 = 0
BitErrors = 0
for i in range(upperbound):
message_bits = np.random.randint(0, 2, 128)
# tail biting encode
tbencodedbits = tb_encoder.conv_encode_tb(message_bits, trellis)
# BPSK
BPSK_bits = BPSK_Mode.modulate(tbencodedbits)
# through the channel
receive_code_channel = cch.awgn(BPSK_bits, snr)
# demodulate
receive_code = BPSK_Mode.demodulate(receive_code_channel,
demod_type='hard')
# no tail viterbi
decoded_bits_notb = tb_encoder.viterbi_decoder_notail(
receive_code, trellis, last_state1, last_metric1)
decoded_bits_tb = tb_viterbi.tb_viterbi_decode(receive_code, trellis,
last_state2,
last_metric2)
# decoded_bits_notb = async_result1.get()
# decoded_bits_tb = async_result2.get()
# reset the values of last state
last_state1 = decoded_bits_notb[1]
last_metric1 = decoded_bits_notb[2]
last_state2 = decoded_bits_tb[1]
last_metric2 = decoded_bits_tb[2]
print(i)
# compare these two results
if np.array_equal(decoded_bits_tb[0], decoded_bits_notb[0]):
result1 = decoded_bits_notb[0]
elif i == upperbound - 1:
result1 = decoded_bits_tb[0]
else:
continue
BitErrors = str(array(message_bits) ^ result1).count('1')
print(BitErrors)
break
return BitErrors
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 newmethodrunner(iterationtimes, eb_n0, index, metrics):
memory = array([8])
g_matrix = array([[0o515, 0o677]])
trellis = cc.Trellis(memory, g_matrix)
BPSKMod = cm.PSKModem(2)
# set the message size
total_error = 0
cer = 0
for d in range(iterationtimes):
message_bits = np.random.randint(0, 2, 128)
result = 0
# print(message_bits)
encoded_code = tb_encoder.conv_encode_tb(message_bits, trellis)
BPSK_modedbits = BPSKMod.modulate(encoded_code)
r_code = cch.awgn(BPSK_modedbits, eb_n0 + 3, 0.5)
# r_code = BPSKMod.demodulate(AWGNreceived_bits, demod_type='hard')
# part_code = BPSKMod.demodulate(r_code[240:], demod_type='hard')
part_decode = shortviterbi1.short_viterbi(np.append(r_code[240:], r_code[0:64]), trellis, 'unquantized')[0]
# part_decode = message_bits[120:]
# print(part_decode)
# print(len(part_decode))
initial_code = part_decode[0:8][::-1]
# initial_code = message_bits[120:][::-1]
initial_state = bitarray2dec(initial_code)
# print(initial_state)
initial_metric = 0
result = stack_decoder_fixed_tb(r_code, metrics, trellis, initial_state, initial_metric)[0]
print("pass: {}, {}".format(d, index))
# print(result)
bit_error = str(message_bits ^ array(result)).count('1')
if bit_error > 0:
cer += 1
# print(bit_error)
total_error += bit_error
averageber = total_error/(iterationtimes * 128)
a_cer = cer/iterationtimes
return a_cer, averageber
def awgn(self, snr):
self.x = awgn(self.x, snr)
def monteTransmit(EbNo, transArr, sourceData, code=0, source=0):
BERarr = [None] * len(EbNo)
M = 64
numErrs = 0
answer = ""
sourceData = ''.join(map(turnBin, sourceData))
sourceData = np.array(list(sourceData), dtype=int)
for i in range(0, len(EbNo)):
SNR = EbNo[i]
# Simulating data transmission over a channel
mod = PSKModem(M)
modArr = mod.modulate(transArr)
# recieving and decoding data
if code == 1:
answer = 'Hamming Encoded'
r = totWithHammSize - noHammSize
rateHamming = 1 - (r / (2**r - 1))
recieveArr = awgn(modArr, SNR, rate=rateHamming)
demodArr = mod.demodulate(recieveArr, 'hard')
decodedData = hammDec(demodArr)
decodedData = ''.join([str(i) for i in decodedData])
elif code == 2:
rateLDPC = len(sourceData) / len(demodArr)
recieveArr = awgn(modArr, SNR, rate=rateLDPC)
demodArr = mod.demodulate(recieveArr, 'hard')
answer = 'LDPC encoded'
decodedData = ldpc_bp_decode(demodArr,
sourceData,
decoder_algorithm=SPA,
n_iters=100)
numErrs += np.sum(sourceData != decodedData)
BERarr[i] = numErrs / decodedData.size
elif code == 3:
rateConvolutional = 1 / 2
recieveArr = awgn(modArr, SNR, rate=rateConvolutional)
demodArr = mod.demodulate(recieveArr, 'hard')
answer = 'Convolutional encoded'
decodedData = demodArr.viterbi_decode(coded_bits,
trellis,
tb_depth=None,
decoding_type='hard')
numErrs += np.sum(sourceData != decodedData)
BERarr[i] = numErrs / decodedData.size
elif code == 4:
rateTurbo = 1 / 2
recieveArr = awgn(modArr, SNR, rate=rateTurbo)
demodArr = mod.demodulate(recieveArr, 'hard')
answer = 'Turbo encoded'
map_decode(sys_symbols,
non_sys_symbols,
trellis,
noise_variance,
L_int,
mode='decode')
decodedData = dturbo_decode(sys_symbols,
non_sys_symbols_1,
non_sys_symbols_2,
trellis,
noise_variance,
number_iterations,
interleaver,
L_int=None)
numErrs += np.sum(sourceData != decodedData)
BERarr[i] = numErrs / decodedData.size
if code == 0:
answer = 'Original Data'
recieveArr = awgn(modArr, SNR, rate=1)
demodArr = mod.demodulate(recieveArr, 'hard')
decodedData = ''.join([str(i) for i in demodArr])
# decodedData = deCompAlgo[source](decodedData) #Decompress our to the original source
# decodedData = ''.join(map(turnBin, decodedData))
decodedData = np.array(list(decodedData), dtype=int)
numErrs += np.sum(decodedData != transArr)
BERarr[i] = numErrs / len(transArr)
plt.semilogy(EbNo[::-1], BERarr, label=answer)
print(answer)
print("The number of errors in our code is ", numErrs)
print("The Bit error ratio is ", BERarr[i])
print("\n")
return demodArr