def send_data(modulated_data, snr, verbose=True):
if verbose:
print("Sending data over AWGN-Channel")
channel = komm.AWGNChannel(snr=snr,
signal_power=1) # creating new AWGNChannel
received_data = channel(modulated_data) # sending data over channel
return received_data
def ARQ_simulation(tx_bin, modulator, snr):
parity = Parity('odd')
awgn = komm.AWGNChannel(snr=10**(snr / 10.))
# make the data a multiple of 7
if (len(tx_bin) % 7 != 0):
tx_bin = np.int8(np.append(tx_bin, np.zeros(7 - len(tx_bin) % 7)))
# transmission
rx_bin = []
ARQ_counter = 0
for i in range(0, len(tx_bin), 7):
temp = tx_bin[i:i + 7]
temp = np.append(temp, parity.parity_cal(temp))
tx_data = modulator.modulate(temp)
rx_data = awgn(tx_data)
rx_byte = modulator.demodulate(rx_data)
while (parity.parity_cal(rx_byte[0:7]) != rx_byte[7]):
# parity check fail, need resend
rx_data = awgn(tx_data)
rx_byte = modulator.demodulate(rx_data)
ARQ_counter += 1
rx_bin = np.int8(np.append(rx_bin, rx_byte[0:7]))
return BER_cal(tx_bin, rx_bin)
def modulations():
while 1:
print("-----------MODULATION-PROJECT-----------")
print("1. ASK modulation")
print("2. PSK modulation")
print("3. APSK modulation")
print("4. Exit")
action = input()
input_len = 10000 * 3
inputs = [random.choice([0, 1]) for _ in range(input_len)]
if action == '1':
modulation = komm.ASKModulation(4)
print("ASK modulation")
elif action == '2':
modulation = komm.PSKModulation(4)
print("PSK modulation")
elif action == '3':
modulation = komm.APSKModulation((4, 4), (1.0, 2.0))
print("APSK modulation")
elif action == '4':
sys.exit(0)
channel = komm.AWGNChannel(1.0)
modulated = modulation.modulate(inputs)
transmitted = channel(modulated)
demodulated = modulation.demodulate(transmitted)
errors = 0
for d, i in zip(demodulated, inputs):
if d != i:
errors += 1
error_rate = errors / input_len * 100
print(f"Input size: {input_len}")
print(f"Error rate: {error_rate}%")
def CON_snr_ber_simulation(tx_bin, snr, modulate, BCH_encoder, C_encoder, C_decoder, tblen, method):
# BCH encode
tx_bin_rearrange = np.reshape(tx_bin, (int(len(tx_bin) / BCH_encoder.dimension), BCH_encoder.dimension))
pool = ThreadPool(8)
tx_encoded_data = pool.map(BCH_encoder.encode, tx_bin_rearrange)
tx_encoded_data = np.array(tx_encoded_data).flatten()
pool.close()
pool.join()
# convolution encode
tx_enc_c = np.uint8(C_encoder(np.append(tx_encoded_data,np.zeros(tblen))))
# modulate
tx_data = modulate.modulate(tx_enc_c)
# transaction
awgn = komm.AWGNChannel(snr=10**(snr/10.))
rx_data = awgn(tx_data)
# demodulate
rx_enc_c = modulate.demodulate(rx_data, decision_method = method)
# Convolution decode
rx_encoded_data = C_decoder(rx_enc_c)[tblen:]
# BCH decode
rx_encoded_data = np.reshape(rx_encoded_data, (int(len(rx_encoded_data) / BCH_encoder.length), BCH_encoder.length))
pool = ThreadPool(8)
rx_bin = pool.map(BCH_encoder.decode, rx_encoded_data)
pool.close()
pool.join()
rx_bin = np.array(rx_bin).flatten()
return BER_cal(tx_bin, rx_bin)
def _simulate(self):
order = 2**self._parameters['log_order']
amplitude = self._parameters['amplitude']
phase_offset = self._parameters['phase_offset']
labeling = self._parameters['labeling']
noise_power_db = self._parameters['noise_power_db']
modulation = komm.PSKModulation(order, amplitude, phase_offset, labeling)
modulation._constellation = np.round(modulation._constellation, 12) # Only for pedagogical reasons
awgn = komm.AWGNChannel()
num_symbols = 200*order
noise_power = 10**(noise_power_db / 10)
awgn.signal_power = modulation.energy_per_symbol
awgn.snr = awgn.signal_power / noise_power
num_bits = modulation.bits_per_symbol * num_symbols
bits = np.random.randint(2, size=num_bits)
sentword = modulation.modulate(bits)
recvword = awgn(sentword)
self.output = {
'title': str(modulation),
'constellation': modulation.constellation,
'labels': [''.join(str(b) for b in komm.int2binlist(modulation.labeling[i], width=modulation.bits_per_symbol)) for i in range(order)],
'gaussian_clouds': recvword,
}
def single_test(amplitudes, phase_offsets, orders, snr, signal_power,
signal_len, sygnal_wejsciowy):
channel = komm.AWGNChannel(snr=snr, signal_power=signal_power)
modulation = komm.APSKModulation(orders=orders,
amplitudes=amplitudes,
phase_offsets=phase_offsets)
sygnal_zakodowany = modulation.modulate(sygnal_wejsciowy)
sygnal_zaklocony = channel(sygnal_zakodowany)
sygnal_wyjsciowy = modulation.demodulate(sygnal_zaklocony)
ber = get_ber(sygnal_wejsciowy, sygnal_wyjsciowy)
return round(ber / signal_len, 3), modulation.bits_per_symbol
def snr_ber_simulation(tx_bin, snr, modulate):
BER = []
tx_data = modulate.modulate(tx_bin)
for i in range (0, len(snr)):
awgn = komm.AWGNChannel(snr=10**(snr[i]/10.))
rx_data = awgn(tx_data)
rx_bin = modulate.demodulate(rx_data)
BER.append(BER_cal(tx_bin, rx_bin))
# plt.figure()
# plt.title("constellation diagram")
# plt.scatter(rx_data.real,rx_data.imag,s=1,marker=".")
# plt.axes().set_aspect('equal')
return BER
def generate_data():
global amplitudes, phase_offsets, orders, snr, signal_power, number_of_tests, signal_len #, digits
sheet_name = input(">> Nazwa arkusza: ")
# Kanal i modulacja
channel = komm.AWGNChannel(snr=snr, signal_power=signal_power)
modulation = komm.APSKModulation(orders=orders,
amplitudes=amplitudes,
phase_offsets=phase_offsets)
# Wypisanie wynikow od excela
wb = openpyxl.load_workbook(filename="Wyniki.xlsx")
ws = wb.create_sheet(sheet_name) # Utworzenie arkusza
# Ustalenie naglowkow
ws['A1'] = "Numer"
ws['B1'] = "BER"
ws['C1'] = "Szybkosc transmisji"
# Wypisanie danych symulacji
ws['M1'] = "Amplituda"
ws['M2'] = "Przesuniecie fazowe"
ws['M3'] = "Rzad"
ws['M4'] = "SNR"
ws['M5'] = "Moc sygnalu"
ws['M6'] = "Liczba testow"
ws['M7'] = "Dlugosc sygnalu"
ws['N1'] = str(amplitudes)
ws['N2'] = str(phase_offsets)
ws['N3'] = str(orders)
ws['N4'] = str(snr)
ws['N5'] = str(signal_power)
ws['N6'] = str(number_of_tests)
ws['N7'] = str(signal_len)
#Petla
for i in range(1, number_of_tests + 1):
# Sygnaly
sygnal_wejsciowy = generate_random_signal()
sygnal_zakodowany = modulation.modulate(sygnal_wejsciowy)
sygnal_zaklocony = channel(sygnal_zakodowany)
sygnal_wyjsciowy = modulation.demodulate(sygnal_zaklocony)
#BER
ber = get_ber(sygnal_wejsciowy, sygnal_wyjsciowy)
ws.cell(row=i + 1, column=1).value = i # Numer
ws.cell(row=i + 1, column=2).value = ber # BER
ws.cell(row=i + 1, column=3).value = modulation.bits_per_symbol
wb.save("Wyniki.xlsx")
print(
f"Zakonczono testy - wyniki znajduja sie w pliku Wyniki.xlsx w arkuszu {sheet_name}"
)
input("Wcisnij ENTER, aby kontynuowac ...")
def CCODE_snr_ber_simulation(tx_bin, snr, modulation, encoder, decoder, tblen,
method):
# encode
tx_enc = np.uint8(encoder(np.append(tx_bin, np.zeros(tblen))))
# modulate
tx_data = modulation.modulate(tx_enc)
# transaction
awgn = komm.AWGNChannel(snr=10**(snr / 10.))
rx_data = awgn(tx_data)
# demodulate
rx_enc = modulation.demodulate(rx_data, decision_method=method)
# decode
rx_bin = np.uint8(decoder(rx_enc))[tblen:]
return BER_cal(tx_bin, rx_bin)
def BCH_snr_ber_simulation(tx_bin, snr, modulate, encoder):
if (encoder != -1):
# encode
tx_bin_rearrange = np.reshape(
tx_bin, (int(len(tx_bin) / encoder.dimension), encoder.dimension))
pool = ThreadPool(8)
tx_encoded_data = pool.map(encoder.encode, tx_bin_rearrange)
pool.close()
pool.join()
# for i in range (0, len(tx_bin_rearrange)):
# tx_encoded_data.append(encoder.encode(tx_bin_rearrange[i]))
else:
tx_encoded_data = tx_bin
# modulate
tx_data = modulate.modulate(np.array(tx_encoded_data).flatten())
# transaction
awgn = komm.AWGNChannel(snr=10**(snr / 10.))
rx_data = awgn(tx_data)
# demodulate
rx_encoded_data = modulate.demodulate(rx_data)
# decode
if (encoder != -1):
rx_encoded_data = np.reshape(
rx_encoded_data,
(int(len(rx_encoded_data) / encoder.length), encoder.length))
pool = ThreadPool(8)
rx_bin = pool.map(encoder.decode, rx_encoded_data)
pool.close()
pool.join()
# for j in range(0, len(rx_encoded_data)):
# rx_bit_stream.append(encoder.decode(rx_encoded_data[j]))
else:
rx_bin = rx_encoded_data
rx_bin = np.array(rx_bin).flatten()
BER = BER_cal(tx_bin, rx_bin)
return BER
def constellation_demo(modulation, noise_power_db, xlim, ylim):
awgn = komm.AWGNChannel()
num_symbols = 10000
noise_power = 10**(noise_power_db / 10)
awgn.signal_power = modulation.energy_per_symbol
awgn.snr = awgn.signal_power / noise_power
num_bits = modulation.bits_per_symbol * num_symbols
bits = np.random.randint(2, size=num_bits)
sentword = modulation.modulate(bits)
recvword = awgn(sentword)
_, ax = plt.subplots(figsize=(16, 10))
ax.scatter(recvword.real, recvword.imag, color='xkcd:light blue', s=1)
ax.scatter(modulation.constellation.real,
modulation.constellation.imag,
color='xkcd:blue',
s=8**2)
for (i, point) in enumerate(modulation.constellation):
binary_label = ''.join(
str(b) for b in komm.int2binlist(modulation.labeling[i],
width=modulation.bits_per_symbol))
ax.text(point.real,
point.imag + 0.075 * xlim[0],
binary_label,
horizontalalignment='center')
ax.set_title(repr(modulation))
ax.set_xlabel('Re')
ax.set_ylabel('Im')
ax.axis('square')
ax.set_xlim(xlim)
ax.set_ylim(ylim)
ax.grid()
info_text = 'SNR = {:.1f} dB\n'.format(10 * np.log10(awgn.snr))
info_text += 'Eb/N0 = {:.1f} dB'.format(
10 * np.log10(awgn.snr / modulation.bits_per_symbol))
ax.text(1.125 * xlim[1],
0.0,
info_text,
horizontalalignment='left',
verticalalignment='center')
plt.show()
def main():
parity = Parity('odd')
tx_im = Image.open("DC4_150x100.pgm")
tx_bin = np.unpackbits(np.array(tx_im))
modulator = komm.QAModulation(4, base_amplitudes=1 / np.sqrt(2))
# modulator = komm.PSKModulation(2)
snr = 4
awgn = komm.AWGNChannel(snr=10**(snr / 10.))
# make the data a multiple of 7
if (len(tx_bin) % 7 != 0):
tx_bin = np.int8(np.append(tx_bin, np.zeros(7 - len(tx_bin) % 7)))
# transmission
rx_bin = []
ARQ_counter = 0
for i in range(0, len(tx_bin), 7):
temp = tx_bin[i:i + 7]
temp = np.append(temp, parity.parity_cal(temp))
tx_data = modulator.modulate(temp)
rx_data = awgn(tx_data)
rx_byte = modulator.demodulate(rx_data)
while (parity.parity_cal(rx_byte[0:7]) != rx_byte[7]):
# parity check fail, need resend
rx_data = awgn(tx_data)
rx_byte = modulator.demodulate(rx_data)
ARQ_counter += 1
rx_bin = np.int8(np.append(rx_bin, rx_byte[0:7]))
print("ARQ counter = " + str(ARQ_counter))
print("BER = " + str(BER_cal(tx_bin, rx_bin)))
import numpy as np
import komm
# ---- Parameters
feedforward_polynomials = [[0o117, 0o155]]
L = 1000
snr = 2.0
decoding_method = 'viterbi_soft'
# ----
convolutional_code = komm.ConvolutionalCode(feedforward_polynomials)
code = komm.TerminatedConvolutionalCode(convolutional_code, num_blocks=L)
awgn = komm.AWGNChannel(snr=snr)
bpsk = komm.PAModulation(2)
soft_or_hard = getattr(code, '_decode_' + decoding_method).input_type
message = np.random.randint(2, size=L)
codeword = code.encode(message)
sentword = bpsk.modulate(codeword)
recvword = awgn(sentword)
demodulated = bpsk.demodulate(recvword, decision_method=soft_or_hard)
message_hat = code.decode(demodulated, method=decoding_method)
print(f'{np.count_nonzero(message != message_hat)} / {len(message)}')
Npixels = tx_im.size[1] * tx_im.size[0]
# # plot input image
# plt.figure(1)
# plt.title('Input Image')
# plt.imshow(np.array(tx_im),cmap="gray",vmin=0,vmax=255)
# create an instance of the qpsk modulation scheme
qpsk = komm.PSKModulation(4, phase_offset=np.pi / 4)
# maximim SNR[dB] value
max_snr = 10
num_bits = 8 * Npixels
# list of additive white gaussian noise sources with SNR in range 0 to max_snr
awgn = [komm.AWGNChannel(snr=10**(x / 10.)) for x in range(max_snr)]
# array to store simulated bit error ratio
ber = np.zeros(max_snr)
# array to store signal-to-noise[dB] ratio for the channel
snr = np.zeros(max_snr)
# rate 1/2 code with [0o7, 0o5] as the feedforward polynomial
code, tblen = FEC.ConvCode.create_conv_codes()
# flatten the image into a 1D array and
# append tblen zeros to compensate for the decoder delay
tx_bin = np.append(np.unpackbits(np.array(tx_im)), np.zeros(tblen))
# simulate channel encoding
encoder = komm.ConvolutionalStreamEncoder(code)
def modulatedinchannel(modulated):
awgn = komm.AWGNChannel(snr=100.0, signal_power=1.0)
sentsignal = awgn(modulated)
return sentsignal[0] #einfach ganz lollig
import numpy as np
import komm
mod = komm.PAModulation(order=2)
#mod = komm.ASKModulation(order=4)
#mod = komm.PSKModulation(order=2)
#mod = komm.PSKModulation(order=4)
#mod = komm.PSKModulation(order=8)
#mod = komm.QAModulation(order=16, labeling='reflected_2d')
#mod = komm.ComplexModulation(constellation=[0, 1, 1j, -1])
M = mod.order
snr = 100.0
awgn = komm.AWGNChannel(snr=snr, signal_power=mod.energy_per_symbol)
mod.channel_snr = snr
num_symbols = 100_000
bits = np.random.randint(2, size=num_symbols * mod.bits_per_symbol)
sent = mod.modulate(bits)
recv = awgn(sent)
recv = [0.5 + 0.707j, -0.9 - 0.4j]
if isinstance(mod, komm.RealModulation):
recv = np.real(recv)
demodulated_hard = mod.demodulate(recv, 'hard')
demodulated_soft = mod.demodulate(recv, 'soft')
print(f'mod = {mod}')
print(f'mod.constellation = {mod.constellation.tolist()}')
print(f'mod.order = {mod.order}')
print(f'mod.bits_per_symbol = {mod.bits_per_symbol}')
print(f'mod.labeling = {mod.labeling}')
print(f'mod._mapping = {mod._inverse_mapping}')
import numpy as np
import sindrome
import komm
param = {}
param['n'] = 7
param['k'] = 4
b = np.random.randint(2, size=param['n'])
#code = komm.HammingCode(param['n']-param['k'])
#param['c'] = code.encode(u)
mod = komm.PAModulation(2)
s = mod.modulate(b)
awgn = komm.AWGNChannel(snr=1.0, signal_power=1.0)
r = awgn(s)
u_hat = sindrome.decode_SDD(r, param)
print('b = {}\n û = {}'.format(b, u_hat))
'''
% Codigo de Hamming
codigo.n = 7;
codigo.k = 4;
% Taxa do codigo
R = codigo.k/codigo.n;
% Matriz geradora
Ik = eye(k,k);
p = [1 1 0;1 0 1;0 1 1;1 1 1];
codigo.G = [Ik,p];
% Palavras codigo
u_decimal = [0:2^codigo.k-1];
def SimulateBER(snrArray, txBin, Npixels, modulatioInfo):
nSNR = len(snrArray)
rxDataArray = np.empty(len(txBin))
BitErrorArray = np.empty(2)
berArray = np.empty(0)
mod = 0
# Create Modulation Scheme Object
if (modulatioInfo.get("mod") == "PSK"):
mod = komm.PSKModulation(modulatioInfo.get("order"))
if (modulatioInfo.get("mod") == 'QAM'):
mod = komm.QAModulation(modulatioInfo.get("order"))
# Normalize energy per symbol
baseAmplitude = 1 / (np.sqrt(mod.energy_per_symbol))
mod = komm.QAModulation(modulatioInfo.get("order"), baseAmplitude)
print("Modulation to be used:")
print(
str(modulatioInfo.get("order")) + " " + str(modulatioInfo.get("mod")))
print("Bits Per Symbol: " + str(mod.bits_per_symbol))
print("Energy Per Symbol: " + str(mod.energy_per_symbol))
print("\n")
# Modulate Data
txData = mod.modulate(txBin)
# For each transmision
for i in range(nSNR):
# Calculate based on db
awgn = komm.AWGNChannel(snr=10**(snrArray[i] / 10.))
# Simulate noise in channel
rxData = awgn(txData)
# Demodulate Data
rxBin = mod.demodulate(rxData)
# Append demodulated data as a new row
rxDataArray = np.vstack([rxDataArray, rxBin])
awgn = komm.AWGNChannel(snr=10**(snrArray[10] / 10.))
rx_data = awgn(txData)
rx_bin = mod.demodulate(rx_data)
# Plot few rx bits
plt.figure()
plt.axes().set_aspect("equal")
plt.scatter(rx_data[:10000].real, rx_data[:10000].imag, s=1, marker=".")
plt.show()
rx_im = np.packbits(rx_bin).reshape(tx_im.size[1], tx_im.size[0])
plt.figure()
plt.imshow(np.array(rx_im), cmap="gray", vmin=0, vmax=255)
plt.show()
# Measuring Bit Error Ratio
# For each transmision
for j in range(1, nSNR + 1):
# Reset number of bit errors
BitErrorCount = 0
# Compute bit errors
# i.e For each pixel
for i in range(Npixels * 8):
# If pixel value does not match
if (rxDataArray[j][i] != txBin[i]):
# Increment error count
BitErrorCount += 1
# Calculate bit error rate for transmision
ber = BitErrorCount / (Npixels * 8)
berArray = np.append(berArray, ber)
# Append new dimension containing bit count and bit error rate
BitErrorArray = np.vstack([BitErrorArray, [BitErrorCount, ber]])
print("Bit Error Array:")
print(BitErrorArray)
print("\n")
plt.figure()
plt.scatter(snrArray, berArray) #plot points
plt.plot(snrArray, berArray) #plot lines
plt.yscale("log")
plt.ylabel('$BER$')
plt.xlabel('$SNR$')
plt.title((str(modulatioInfo.get("order")) + " " +
str(modulatioInfo.get("mod"))))
plt.grid(True)
#plt.show()
# Calculate theoretical BER
# Modify k parameter i.e. bits per symbol
k = mod.bits_per_symbol
errfcDataSet = np.empty(0)
# For Each SNR
for i in range(nSNR):
# Calculate Theorethical BER
errfc = 0.5 * scipy.special.erfc(
math.sqrt((10**(snrArray[i] / 10)) / k))
errfcDataSet = np.append(errfcDataSet, errfc)
plt.plot(snrArray, errfcDataSet, color='r')
plt.show()
print("Errfc Data Set:")
print(errfcDataSet)
print("\n")
return berArray, errfcDataSet
import numpy as np
import komm
awgn = komm.AWGNChannel(snr=12.0, signal_power='measured')
power = lambda v: np.real(np.vdot(v, v)) / len(v)
#s = 2.0 * (-1.0)**np.random.randint(2, size=100000)
s = 2.0 * (-1.0)**np.random.randint(
2, size=100000) + 2.0j * (-1.0)**np.random.randint(2, size=100000)
r = awgn(s)
print(s)
print(r)
print(power(s))
print(power(r))
print(power(r - s))
print(power(s) / power(r - s))
import numpy as np import komm code = komm.BCHCode(4, 2) bpsk = komm.PAModulation(2) awgn = komm.AWGNChannel(2.0) print(code) print((code.length, code.dimension, code.minimum_distance)) print(code._available_decoding_methods()) print(code._default_encoder()) print(code._default_decoder(np.float)) print(code.generator_polynomial) #print(code.generator_matrix) print(code.parity_polynomial) #print(code.parity_check_matrix) n_words = 1_000 message = np.random.randint(2, size=n_words * code.dimension) codeword = code.encode(message) sentword = bpsk.modulate(codeword) recvword = awgn(sentword) demodulated_hard = bpsk.demodulate(recvword) message_hat = code.decode(demodulated_hard) #print(message) #print(codeword) #print(demodulated_hard) #print((codeword != recvword_hard).astype(np.int))
def SimulateParityBits(snrArray, txBin, Npixels, modulatioInfo):
nSNR = len(snrArray)
rxBinDecoded = np.empty(0)
rxIncorrect = True
mod = 0
if (modulatioInfo.get("mod") == "PSK"):
mod = komm.PSKModulation(modulatioInfo.get("order"))
if (modulatioInfo.get("mod") == 'QAM'):
mod = komm.QAModulation(
modulatioInfo.get("order")) # add baseAmplitude
print("Base Amplitude is: " + str(mod.energy_per_symbol))
# Normalize Enerhy per symbol
baseAmplitude = 1 / (np.sqrt(mod.energy_per_symbol))
print("New Base Amplitude is: " + str(baseAmplitude))
mod = komm.QAModulation(modulatioInfo.get("order"), baseAmplitude)
print("Modulation to be used:")
print(
str(modulatioInfo.get("order")) + " " + str(modulatioInfo.get("mod")))
print("Bits Per Symbol: " + str(mod.bits_per_symbol))
print("Energy Per Symbol: " + str(mod.energy_per_symbol))
print("\n")
print("Simulating ARQ based on parity bit check!")
print("Adding Parity Bits!")
# Add parity bits
# For each pixel
for i in range(Npixels):
startIndex = i * 8
# If the sum of on bits is not even
if (((np.sum(txBin[startIndex:startIndex + 7])) % 2) != 0):
# Change parity bit to 1
txBin[(startIndex + 7)] = 1
# The sum of on bits is even
else:
# Change parity bit to 0
txBin[(startIndex + 7)] = 0
# Modulate data
txDataParity = mod.modulate(txBin)
print("Simulating Transmision!")
indexFactor = int(8 / mod.bits_per_symbol)
berArray = np.empty(0)
arqArray = np.empty(0)
for c in range(nSNR):
print("Simulating SNR: " + str(snrArray[c]))
# Set Average Gausian Noise to reflect new SNR
awgn = komm.AWGNChannel(snr=10**(snrArray[c] / 10.))
ARQ = 0
# For Each Symbol
for i in range(Npixels):
# Compute Index of the codeword
startIndex = i * indexFactor
# Until the Parity bit check is not passed
while (rxIncorrect):
# Simulate noise in the channel during transmision only
rxData = awgn(txDataParity[startIndex:startIndex +
indexFactor])
# Demodulate Data
rxBin = mod.demodulate(rxData)
# Check if parity = 0
if ((np.sum(rxBin) % 2) != 0):
# Error During Transmision
# Increment Request Counter
ARQ += 1
else:
# Passed parity check, assume data is correct
# Append Data Bits to final binary array
rxBinDecoded = np.append(rxBinDecoded, rxBin)
# Set while loop flag to false indicating this codeword has been rx without error
rxIncorrect = False
#Set while loop flag to true to process next codeword
rxIncorrect = True
# Convert to real int
rxBinDecoded = np.real(rxBinDecoded)
rxBinDecoded = rxBinDecoded.astype(int)
# For SNR 10 Plot graphs
if (c == 0):
# Plot few rx bits
# plt.figure()
# plt.axes().set_aspect("equal")
# plt.scatter(rxBinDecoded[:10000].real,rxBinDecoded[:10000].imag,s=1,marker=".")
# plt.show()
rx_im = np.packbits(rxBinDecoded).reshape(tx_im.size[1],
tx_im.size[0])
plt.figure()
plt.imshow(np.array(rx_im), cmap="gray", vmin=0, vmax=255)
plt.show()
# Count Bit errors
print("Computing BER: " + str(snrArray[c]))
BitErrorCount = 0
# For each bit in the rx data
for i in range(Npixels * 8):
# If bit value does not match
if (rxBinDecoded[i] != txBin[i]):
# Increment error count
BitErrorCount += 1
# Calculate bit error rate for the transmision
berArray = np.append(berArray, (BitErrorCount / (Npixels * 8)))
arqArray = np.append(arqArray, (ARQ / (Npixels * 8)))
print("BER Array:")
print(berArray)
print("\n")
print("ARQ Array:")
print(arqArray)
print("\n")
plt.figure()
plt.scatter(snrArray, berArray) #plot points
plt.plot(snrArray, berArray) #plot lines
plt.yscale("log")
plt.ylabel('$BER$')
plt.xlabel('$SNR$')
plt.title((str(modulatioInfo.get("order")) + " " +
str(modulatioInfo.get("mod")) + " BER"))
plt.grid(True)
# Calculate theoretical BER
# Modify k parameter i.e. bits per symbol
k = mod.bits_per_symbol
errfcDataSet = np.empty(0)
# For Each SNR
for i in range(nSNR):
# Calculate Theorethical BER
errfc = 0.5 * scipy.special.erfc(
math.sqrt((10**(snrArray[i] / 10)) / k))
errfcDataSet = np.append(errfcDataSet, errfc)
plt.plot(snrArray, errfcDataSet, color='r')
plt.show()
plt.figure()
plt.scatter(snrArray, arqArray) #plot points
plt.plot(snrArray, arqArray) #plot lines
plt.yscale("log")
plt.ylabel('$ARQ Rate$')
plt.xlabel('$SNR$')
plt.title((str(modulatioInfo.get("order")) + " " +
str(modulatioInfo.get("mod")) + " ARQ/nBits"))
plt.grid(True)
return berArray, arqArray, rxBinDecoded
ber_th = np.empty(max_snr)
# array to store signal-to-noise[dB] ratio for the channel
snr = np.empty(max_snr)
# array to store automatic-repeat-request ratio
arq_ratio = np.empty(max_snr)
string = ' '.join([
"Performing", args.scheme, "for signal-to-noise ratio in range 0 to",
str(max_snr - 1), "dB..."
])
print(string)
# loop to to simulate the transmission with SNR[dB] up to the maximum value
while n < max_snr:
# additive white gaussian noise source with SNR=n[dB]
awgn = komm.AWGNChannel(snr=10**(n / 10.))
# reset the counter which adds the total number of ARQs
arq = 0
# array to store received binary sequence
rx_bin = np.empty(num_bits, dtype=int)
# list to store received complex-valued data
rx_data = []
# loop to simulate the transmission of an 8-bit word at a time
for j in range(0, num_bits, 8):
# replace the LSB of each 8-bit word with even parity bit
temp = tx_bin[j:j + 8]
temp[-1] = np.sum(temp[:-1]) % 2
tx_bin[j:j + 8] = temp
# simulate modulation
import numpy as np import komm #code = komm.CyclicCode(length=7, generator_polynomial=0o13) # Hamming(3) code = komm.CyclicCode(length=23, generator_polynomial=0o5343) # Golay() #code = komm.CyclicCode(length=127, generator_polynomial=0o3447023271); code._minimum_distance = 9 awgn = komm.AWGNChannel(snr=4.0) bpsk = komm.PAModulation(2) print(code) print((code.length, code.dimension, code.minimum_distance)) print(code._available_decoding_methods()) print(code._default_encoder()) print(code._default_decoder(np.float)) print(code.generator_polynomial) #print(code.generator_matrix) print(code.parity_polynomial) #print(code.parity_check_matrix) n_words = 10_000 message = np.random.randint(2, size=n_words * code.dimension) codeword = code.encode(message) sentword = bpsk.modulate(codeword) recvword = awgn(sentword) demodulated_hard = bpsk.demodulate(recvword) message_hat = code.decode(demodulated_hard, method='meggitt') #print(message) #print(codeword)
