def __init__(self, root, server):
self._root = root
self.server = server
self.poller = Multiplexer.BestMultiplexer()
self.socketmap = {}
self.workers = []
self.protocol = Protocol.Protocol(root, self)
# legacy vars
self.thread = thread.get_ident()
self.num = 0
def __init__(self, k=4.0, tchannel=1, voltage=0):
gr.hier_block2.__init__(
self,
"channel",
gr.io_signature(1, 1, gr.sizeof_float * 1),
gr.io_signature(1, 1, gr.sizeof_float * 1),
)
##################################################
# Parameters
##################################################
self.k = k
self.tchannel = tchannel
self.voltage = voltage
##################################################
# Blocks
##################################################
self.channels_fading_model_0_0 = channels.fading_model(
8, 5 / 32000, False, 4.0, 0)
self.channels_fading_model_0 = channels.fading_model(
8, 5 / 32000, True, k, 0)
self.blocks_float_to_complex_0_0 = blocks.float_to_complex(1)
self.blocks_float_to_complex_0 = blocks.float_to_complex(1)
self.blocks_complex_to_float_0_0_0 = blocks.complex_to_float(1)
self.blocks_complex_to_float_0 = blocks.complex_to_float(1)
self.blocks_add_xx_0 = blocks.add_vff(1)
self.analog_noise_source_x_0 = analog.noise_source_f(
analog.GR_GAUSSIAN, voltage, 0)
self.Multiplexer_mux_0 = Multiplexer.mux(tchannel)
##################################################
# Connections
##################################################
self.connect((self.Multiplexer_mux_0, 0), (self, 0))
self.connect((self.analog_noise_source_x_0, 0),
(self.blocks_add_xx_0, 0))
self.connect((self.blocks_add_xx_0, 0), (self.Multiplexer_mux_0, 0))
self.connect((self.blocks_complex_to_float_0, 0),
(self.Multiplexer_mux_0, 2))
self.connect((self.blocks_complex_to_float_0_0_0, 0),
(self.Multiplexer_mux_0, 1))
self.connect((self.blocks_float_to_complex_0, 0),
(self.channels_fading_model_0_0, 0))
self.connect((self.blocks_float_to_complex_0_0, 0),
(self.channels_fading_model_0, 0))
self.connect((self.channels_fading_model_0, 0),
(self.blocks_complex_to_float_0_0_0, 0))
self.connect((self.channels_fading_model_0_0, 0),
(self.blocks_complex_to_float_0, 0))
self.connect((self, 0), (self.blocks_add_xx_0, 1))
self.connect((self, 0), (self.blocks_float_to_complex_0, 0))
self.connect((self, 0), (self.blocks_float_to_complex_0_0, 0))
def Run2by1(self,
binInput,
modulationScheme,
noiseDeviation=0.05,
transmitPower=1,
estimationMethod=None,
decoderType=DecoderType.ML):
binOutput = ''
binInput = self.PadBinary(binInput, modulationScheme)
rec = Receiver()
al = AlamoutiScheme(transmitPower)
numTransmissions = 0
hData = []
inputStrings = self.SplitInput(binInput)
progress = 0.0
self.progressInt = 0
for binString in inputStrings:
transmissions = al.CreateTransmissions(binString, modulationScheme)
for n in range(len(transmissions[0]) / 2):
ch0 = FadingChannel(noiseDeviation)
ch1 = FadingChannel(noiseDeviation)
hData.append(abs(ch0.h))
if (estimationMethod == None):
transmissionEx = deepcopy(transmissions[0][0]).wave
#Timeslot1
ch0.ApplyFadingToTransmission(transmissions[0][2 * n])
ch1.ApplyFadingToTransmission(transmissions[1][2 * n])
r0 = rec.CombineReceivedTransmissions(
transmissions[0][2 * n], transmissions[1][2 * n])
#Timeslot2
ch0.ApplyFadingToTransmission(transmissions[0][(2 * n) +
1])
ch1.ApplyFadingToTransmission(transmissions[1][(2 * n) +
1])
r1 = rec.CombineReceivedTransmissions(
transmissions[0][(2 * n) + 1],
transmissions[1][(2 * n) + 1])
#Channel Estimation
h0 = ch0.h
h1 = ch1.h
else:
#Timeslot1
Mux10 = Multiplexer.Multiplexer(estimationMethod,
transmissions[0][2 * n])
Mux11 = Multiplexer.Multiplexer(estimationMethod,
transmissions[1][2 * n])
transmissions[0][2 * n].OverideWave(Mux10.wave)
transmissions[1][2 * n].OverideWave(Mux11.wave)
if n == 0:
transmissionEx = deepcopy(transmissions[0][0]).wave
ch0.ApplyFadingToTransmission(transmissions[0][2 * n])
ch1.ApplyFadingToTransmission(transmissions[1][2 * n])
Demux1 = Demultiplexer.Demultiplexer(
estimationMethod, transmissions[0][2 * n].wave,
transmissions[1][2 * n].wave)
transmissions[0][2 * n].OverideWave(Demux1.s0)
transmissions[1][2 * n].OverideWave(Demux1.s1)
r0 = rec.CombineReceivedTransmissions(
transmissions[0][2 * n], transmissions[1][2 * n])
#Timeslot2
Mux20 = Multiplexer.Multiplexer(
estimationMethod, transmissions[0][(2 * n) + 1])
Mux21 = Multiplexer.Multiplexer(
estimationMethod, transmissions[1][(2 * n) + 1])
transmissions[0][(2 * n) + 1].OverideWave(Mux20.wave)
transmissions[1][(2 * n) + 1].OverideWave(Mux21.wave)
ch0.ApplyFadingToTransmission(transmissions[0][(2 * n) +
1])
ch1.ApplyFadingToTransmission(transmissions[1][(2 * n) +
1])
Demux2 = Demultiplexer.Demultiplexer(
estimationMethod, transmissions[0][(2 * n) + 1].wave,
transmissions[1][(2 * n) + 1].wave)
transmissions[0][(2 * n) + 1].OverideWave(Demux2.s0)
transmissions[1][(2 * n) + 1].OverideWave(Demux2.s1)
r1 = rec.CombineReceivedTransmissions(
transmissions[0][(2 * n) + 1],
transmissions[1][(2 * n) + 1])
#Channel Estimation
h0 = Demux1.h0
h1 = Demux1.h1
#Combining
output = rec.AlamoutiCombine2by1(h0, h1, r0, r1)
#Detection/Demodulation
if decoderType == DecoderType.ML:
binOutput += rec.MLDSymbolToBinary(output[0],
modulationScheme,
transmitPower)
binOutput += rec.MLDSymbolToBinary(output[1],
modulationScheme,
transmitPower)
# else use sphere detection
numTransmissions += 4
progress = float(len(binOutput)) / float(len(binInput))
self.progressInt = int(progress * 1000)
numErrors = 0
for n in range(len(binInput)):
if binInput[n] != binOutput[n]:
numErrors += 1
self.BinaryToImage(binOutput)
BER = float(numErrors) / float(len(binInput))
res = SimulationResults(binOutput, BER, len(binInput), numErrors,
numTransmissions, hData, transmissionEx)
return res
def stop():
return Multiplexer.shared().stop()
def run():
return Multiplexer.shared().run()
