def StdDev(self, msg_pmt):
# veficcación del formato PMT
if pmt.is_blob(msg_pmt):
blob = msg_pmt
#print "is blob"
elif pmt.is_pair(msg_pmt):
blob = pmt.cdr(msg_pmt)
else:
print "Formato desconocido"
return
vec = pmt.cdr(
msg_pmt) #se toma del diccionario en formato pmt la llave
#print "sin convertir",vec,vec.__class__
vecp = pmt.to_python(vec) #se convierte de pmt a vector en python
self.d_Std = np.array(
vecp) # se crea una variable que se pueda mmanipular
Std1 = np.std(
self.d_Std
) # se calcula la desviación estandar del vector que llego
#print (self.d_Std)
#print (Std1)
Std12 = float(Std1)
#print (Std12)
#Stdv = pmt.from_float(Std12) #se convierte a float el valor obtenido
Stdv1 = pmt.make_f32vector(
1, Std12
) # se crea un vector de tipo PMT para despues ser interpretado por el bloque PDU to Tagged Stream; debe ser "1" en el primer argumento o no funciona.
self.message_port_pub(pmt.intern("out"), pmt.cons(pmt.PMT_NIL, Stdv1))
def dice_csi_tags(self, data, type, num_inputs, num_tags, tag_pos, vlen=1):
tags = []
expected_result = np.empty([np.size(data, 0)*np.size(data,1)], dtype=complex)
if type == 'MMSE':
# Add an SNR tag at the start of the stream for MMSE.
tags.append(gr.tag_utils.python_to_tag((0,
pmt.string_to_symbol("snr"),
pmt.make_f32vector(num_inputs, 1e8),
pmt.from_long(0))))
for i in range(0, num_tags):
# Randomly generate CSI for one symbol.
csi = (np.random.randn(vlen, num_inputs, num_inputs) + 1j * np.random.randn(vlen, num_inputs, num_inputs))
# Assign the CSI vector to a PMT vector.
csi_pmt = pmt.make_vector(vlen, pmt.make_vector(num_inputs, pmt.make_c32vector(num_inputs, 1.0)))
for k, carrier in enumerate(csi):
carrier_vector_pmt = pmt.make_vector(num_inputs, pmt.make_c32vector(num_inputs, csi[k][0][0]))
for l, rx in enumerate(csi[k]):
line_vector_pmt = pmt.make_c32vector(num_inputs, csi[k][l][0])
for m, tx in enumerate(csi[k][l]):
pmt.c32vector_set(v=line_vector_pmt, k=m, x=csi[k][l][m])
pmt.vector_set(carrier_vector_pmt, l, line_vector_pmt)
pmt.vector_set(csi_pmt, k, carrier_vector_pmt)
# Append stream tags with CSI to data stream.
tags.append(gr.tag_utils.python_to_tag((tag_pos[i],
pmt.string_to_symbol("csi"),
csi_pmt,
pmt.from_long(0))))
# Calculate expected result.
expected_result[tag_pos[i]*num_inputs::] = np.reshape(np.transpose(np.dot(np.linalg.inv(csi), data[::, tag_pos[i]::])), (np.size(data, 0)*(np.size(data,1)-tag_pos[i])))
return tags, expected_result
def msg_handler(self, p):
length = pmt.length(p)
for i in range(0,length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
if str(key) == "power":
output = pmt.f32vector_elements(value)[0]
output = 10 * math.log(output, 10)
output = pmt.make_f32vector(1, output)
if i==0:
outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_dB"), output))
output = pmt.nth(1, element)
if i==0:
outpmt = pmt.list1(pmt.list2(key, output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(key, output))
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def msg_handler(self, p):
length = pmt.length(p)
# iterate over all elements
for i in range(0, length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
initial_phase = None
# when we found the phase key
if str(key) == "phase" and pmt.length(value) >= 1:
# print "length of vector: ", pmt.length(value)
value = pmt.f32vector_elements(value)[0]
self.last_val = value
# save that value
initial_phase = value
value = value - self.subtract
while value < -numpy.pi:
value = value + numpy.pi
while value > numpy.pi:
value = value - numpy.pi
initial_phase = pmt.make_f32vector(1, initial_phase)
initial_phase = pmt.list2(pmt.string_to_symbol("phase_initial"), initial_phase)
outvalue = pmt.make_f32vector(1, value)
output = pmt.list2(pmt.string_to_symbol(str(key)), outvalue)
else:
output = element
if i == 0:
outpmt = pmt.list1(output)
else:
outpmt = pmt.list_add(outpmt, output)
if initial_phase != None:
outpmt = pmt.list_add(outpmt, initial_phase)
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def notest_debug(self):
src = blocks.vector_source_c(range(100), False, 1, [])
separator = inspector_test.signal_separator_c(32000, firdes.WIN_HAMMING, 0.1, 100)
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
def test_001_t(self):
src = blocks.vector_source_c(list(range(10000)), False, 1, [])
separator = inspector_test.signal_separator_c(
32000, firdes.WIN_HAMMING, 0.1, 100, False,
inspector_test.map_float_vector({0.0: [0.0]}))
vec_sink = blocks.vector_sink_c(1)
ext = inspector_test.signal_extractor_c(0)
snk = blocks.vector_sink_c(1)
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
taps = filter.firdes.low_pass(1, 32000, 500, 50, firdes.WIN_HAMMING,
6.76)
self.tb.connect(src, separator)
self.tb.connect(src, vec_sink)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
self.tb.msg_connect((separator, 'sig_out'), (ext, 'sig_in'))
self.tb.connect(ext, snk)
self.tb.start()
time.sleep(0.3)
self.tb.stop()
self.tb.wait()
data = vec_sink.data()
sig = numpy.zeros(len(vec_sink.data()), dtype=complex)
for i in range(len(vec_sink.data())):
sig[i] = data[i] * numpy.exp(
-1j * 2 * numpy.pi * 12500 * i * 1 / 32000)
taps = filter.firdes.low_pass(1, 32000, 900, 90, firdes.WIN_HAMMING,
6.76)
sig = numpy.convolve(sig, taps, 'full')
out = numpy.empty([0])
decim = 32000 / 20 / 100
j = 0
for i in range(len(sig) / decim):
out = numpy.append(out, sig[j])
j += decim
data = snk.data()
for i in range(min(len(out), len(data))):
self.assertComplexAlmostEqual2(out[i], data[i], abs_eps=0.01)
def no_test_sebastian (self):
src = blocks.vector_source_c(range(100), False, 1, [])
separator = inspector_test.signal_separator_c(32000, firdes.WIN_HAMMING, 0.1, 100)
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12490)
pmt.f32vector_set(flanks, 1, 12510)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
self.tb.connect(src, separator)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
self.tb.run()
def test_001_t (self):
src = blocks.vector_source_c(range(10000), False, 1, [])
separator = inspector_test.signal_separator_c(32000, firdes.WIN_HAMMING, 0.1, 100, False, inspector_test.map_float_vector({0.0:[0.0]}))
vec_sink = blocks.vector_sink_c(1)
ext = inspector_test.signal_extractor_c(0)
snk = blocks.vector_sink_c(1)
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 20)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
taps = filter.firdes.low_pass(1, 32000, 500, 50, firdes.WIN_HAMMING, 6.76)
self.tb.connect(src, separator)
self.tb.connect(src, vec_sink)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
self.tb.msg_connect((separator, 'sig_out'), (ext, 'sig_in'))
self.tb.connect(ext, snk)
self.tb.start()
time.sleep(0.3)
self.tb.stop()
self.tb.wait()
data = vec_sink.data()
sig = numpy.zeros(len(vec_sink.data()), dtype=complex)
for i in range(len(vec_sink.data())):
sig[i] = data[i]*numpy.exp(-1j*2*numpy.pi*12500*i*1/32000)
taps = filter.firdes.low_pass(1, 32000, 900, 90, firdes.WIN_HAMMING, 6.76)
sig = numpy.convolve(sig, taps, 'full')
out = numpy.empty([0])
decim = 32000/20/100
j = 0
for i in range(len(sig)/decim):
out = numpy.append(out, sig[j])
j += decim
data = snk.data()
for i in range(min(len(out), len(data))):
self.assertComplexAlmostEqual2(out[i], data[i], abs_eps=0.01)
def test_001_t (self):
# set up fg
src = blocks.vector_source_c(range(1024), False, 1, [])
# pack message
msg = pmt.make_vector(1, pmt.PMT_NIL)
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, 12500)
pmt.f32vector_set(flanks, 1, 8)
pmt.vector_set(msg, 0, flanks)
msg_src = blocks.message_strobe(msg, 100)
separator = inspector_test.signal_separator_c(1024, firdes.WIN_HAMMING, 0.1, 1)
extractor = inspector.signal_extractor_c(0)
taps = firdes.low_pass(1, 1024, 2, 0.1*2, firdes.WIN_HAMMING, 6.76)
reference = numpy.convolve(range(1024), taps, 'same')
#xlator = filter.freq_xlating_fir_filter_ccf(160, taps, 12500, 32000)
stv1 = blocks.stream_to_vector(gr.sizeof_gr_complex, 128)
#stv2 = blocks.stream_to_vector(gr.sizeof_gr_complex, 128)
snk1 = blocks.vector_sink_c(128)
#snk2 = blocks.vector_sink_c(128)
null1 = blocks.null_sink(gr.sizeof_gr_complex)
# connect this
self.tb.connect(src, separator)
self.tb.msg_connect((msg_src, 'strobe'), (separator, 'map_in'))
#self.tb.connect(src, xlator)
#self.tb.connect(xlator, null1)
self.tb.msg_connect((separator, 'msg_out'), (extractor, 'sig_in'))
self.tb.connect(extractor, stv1)
#self.tb.connect(xlator, stv2)
self.tb.connect(stv1, snk1)
#self.tb.connect(stv2, snk2)
self.tb.start()
time.sleep(0.5)
self.tb.stop()
# check data
data1 = snk1.data()
#data2 = snk2.data()
data2 = reference[0::8]
for i in range(min(len(data2), len(data1))):
self.assertComplexAlmostEqual(data1[i], data2[i], 4)
def msg_handler(self, p):
#os.system("pwd")
#time.sleep(1)
fd = open(self.filename, "r")
s = fd.readline()
fd.close()
#print "Got string ", s
try:
s = float(s)
except ValueError:
s = -200000.0
p = pmt.list_add(p, pmt.list2(pmt.string_to_symbol(self.key), pmt.make_f32vector(1, s)))
#if(s>-100000.0):
self.message_port_pub(pmt.string_to_symbol("out"), p)
def general_work(self, input_items, output_items):
in0 = input_items[0]
# Singular value decomposition of matrix "X"
[u, _, _] = np.linalg.svd(in0.T)
us = u[:, 0:self.n]
# Eigenvalue classification
# s = abs(s)
# snr_aval = 10 * np.log10((s[0] - s[-1]) / (self.m * s[-1]))
# data = np.zeros((self.m, 3))
# with open(
# "/mnt/d/Users/grigo/Google Drive/Facultad/Balseiro/PI Lucas/git-repository/digital-beamforming/machine_learning/"
# + self.file_name,
# "a",
# ) as fd:
# for i in range(self.m):
# if i < self.n:
# fd.write(str(s[i]) + ", " + str(snr_aval) + ", 1\n")
# else:
# fd.write(str(s[i]) + ", " + str(snr_aval) + ", 0\n")
for i in range(self.n):
us_aux = us[:, i].reshape(self.mx, self.my)
self.u1_x[:, i] = us_aux[0:self.mx - 1, :].reshape(
(self.mx - 1) * self.my)
self.u2_x[:, i] = us_aux[1:self.mx, :].reshape(
(self.mx - 1) * self.my)
self.u1_y[:, i] = us_aux[:, 0:self.my - 1].reshape(
(self.my - 1) * self.mx)
self.u2_y[:, i] = us_aux[:, 1:self.my].reshape(
(self.my - 1) * self.mx)
[_, _, vv_x] = np.linalg.svd(np.append(self.u1_x, self.u2_x, axis=1))
vv_x = vv_x.T
vv12_x = vv_x[0:self.n, self.n:2 * self.n]
vv22_x = vv_x[self.n:2 * self.n, self.n:2 * self.n]
# Calculate the engenvalues of Psi
psi_x = -vv12_x @ np.linalg.inv(vv22_x)
[phi_x, _] = np.linalg.eig(psi_x)
[_, _, vv_y] = np.linalg.svd(np.append(self.u1_y, self.u2_y, axis=1),
full_matrices=False)
vv_y = vv_y.T
vv12_y = vv_y[0:self.n, self.n:2 * self.n]
vv22_y = vv_y[self.n:2 * self.n, self.n:2 * self.n]
# Calculate the engenvalues of Psi
psi_y = -vv12_y @ np.linalg.inv(vv22_y)
[phi_y, _] = np.linalg.eig(psi_y)
for i in range(self.n):
arg = (np.angle(phi_x[i])**2 + np.angle(phi_y[i])**2) / (
(self.k * self.d)**2)
# if abs(arg) > 1:
# print("DoA Esprit: Arg in arccos greater than 1 for i=%.2lf" % i)
# CAMBIAR ESTO Y HACER QUE IF < 1
# if i == (self.n - 1):
# self.consume(0, self.spd)
# return 0
# else:
# DOA estimation
if abs(arg) <= 1:
self.phi = np.arctan2(np.angle(phi_y[i]), np.angle(phi_x[i]))
self.theta = np.arccos(np.sqrt(arg))
doa = pmt.make_f32vector(3, 0.0)
# print("doa=(", theta, ",", phi, ")")
pmt.f32vector_set(doa, 0, float(self.theta))
# print("doa_msg=", doa)
pmt.f32vector_set(doa, 1, float(self.phi))
pmt.f32vector_set(doa, 2, float(i))
doa_msg = pmt.cons(pmt.to_pmt("doa_msg"), doa)
self.message_port_pub(pmt.intern("doa_port"), doa_msg)
self.consume(0, self.spd)
return 0
import pmt
from pmt.pmt_swig import serialize
import zmq
import numpy as np
# %%
_PROTOCOL = "tcp://"
_SERVER = "127.0.0.1"
_PORT = ":5558"
_ADDR = _PROTOCOL + _SERVER + _PORT
# %%
context = zmq.Context()
sock = context.socket(zmq.REP)
rc = sock.bind(_ADDR)
#%%
flanks = pmt.make_f32vector(2, 0.0)
pmt.f32vector_set(flanks, 0, np.radians(15))
pmt.f32vector_set(flanks, 1, np.radians(70))
c = pmt.cons(pmt.to_pmt("doa"), flanks)
#%%
sock.recv()
#%%
sock.send(pmt.serialize_str(c))
# %% De acá para arriba anda
key0 = pmt.intern("doa")
val0 = pmt.from_long(123)
val1 = pmt.from_long(234)
val_list = pmt.list2(val0, val1)
pmt.length(val_list)
# %%
a = pmt.make_dict()
def build_and_run_flowgraph(self,
repetitions,
data_length,
num_inputs_min,
num_inputs_max,
equalizer_type,
vlen=[1, 1]):
for a in range(repetitions):
num_inputs = np.random.randint(low=num_inputs_min,
high=num_inputs_max + 1)
# Generate random input data.
data = np.random.randn(
data_length * num_inputs * vlen[a]) + 1j * np.random.randn(
data_length * num_inputs * vlen[a])
# Randomly generate CSI for one symbol.
csi = (np.random.randn(vlen[a], num_inputs, num_inputs) +
1j * np.random.randn(vlen[a], num_inputs, num_inputs))
# Assign the CSI vector to a PMT vector.
csi_pmt = pmt.make_vector(
vlen[a],
pmt.make_vector(num_inputs,
pmt.make_c32vector(num_inputs, 1.0)))
for k, carrier in enumerate(csi):
carrier_vector_pmt = pmt.make_vector(
num_inputs, pmt.make_c32vector(num_inputs, csi[k][0][0]))
for l, rx in enumerate(csi[k]):
line_vector_pmt = pmt.make_c32vector(
num_inputs, csi[k][l][0])
for m, tx in enumerate(csi[k][l]):
pmt.c32vector_set(v=line_vector_pmt,
k=m,
x=csi[k][l][m])
pmt.vector_set(carrier_vector_pmt, l, line_vector_pmt)
pmt.vector_set(csi_pmt, k, carrier_vector_pmt)
# Append stream tags with CSI to data stream.
tags = [(gr.tag_utils.python_to_tag(
(0, pmt.string_to_symbol("csi"), csi_pmt, pmt.from_long(0))))]
if equalizer_type == 'MMSE':
# Add an SNR tag at the start of the stream for MMSE.
tags.append(
gr.tag_utils.python_to_tag(
(0, pmt.string_to_symbol("snr"),
pmt.make_f32vector(num_inputs,
1e8), pmt.from_long(0))))
# Build up the test flowgraph.
src = blocks.vector_source_c(data=data, repeat=False, tags=tags)
vblast_encoder = digital.vblast_encoder_cc(num_inputs)
demux = []
channels = []
for i in range(0, vlen[a]):
for j in range(0, num_inputs):
demux.append(
blocks.keep_m_in_n(gr.sizeof_gr_complex, 1, vlen[a],
i))
# Simulate channel with matrix multiplication.
channels.append(blocks.multiply_matrix_cc_make(csi[i]))
mux = []
s2v = []
for i in range(0, num_inputs):
mux.append(
blocks.stream_mux(gr.sizeof_gr_complex, [1] * vlen[a]))
s2v.append(
blocks.stream_to_vector(gr.sizeof_gr_complex, vlen[a]))
vblast_decoder = digital.vblast_decoder_cc(num_inputs,
equalizer_type, vlen[a])
sink = blocks.vector_sink_c()
self.tb.connect(src, vblast_encoder)
for n in range(0, num_inputs):
for i in range(0, vlen[a]):
self.tb.connect((vblast_encoder, n),
demux[i * num_inputs + n],
(channels[i], n))
self.tb.connect((channels[i], n), (mux[n], i))
self.tb.connect(mux[n], s2v[n], (vblast_decoder, n))
self.tb.connect(vblast_decoder, sink)
# Run flowgraph.
self.tb.run()
'''
Check if the expected result (=the data itself, because
we do a loopback) equals the actual result. '''
self.assertComplexTuplesAlmostEqual(data, sink.data(), 2)
def msg_handler(self, p):
verbose = False
length = pmt.length(p)
if verbose:
print "PMT contrains " + str(length) + " key/value pairs"
for i in range(0,length):
element = pmt.nth(i, p)
key = pmt.nth(0, element)
value = pmt.nth(1, element)
if verbose:
print "Key of " + str(i) + "th element: " + str(key)
print "Value of " + str(i) + "th element: " + str(value)
print
found = False
for j in range(0, len(self.n)):
if str(key) == self.kk[j]:
found = True
if verbose:
print "found the key " + str(key)
#rotate the values, the latest one disappears
self.prev_values[j] = numpy.roll(self.prev_values[j], -1)
#set the vector accordingly
self.prev_values[j][-1] = pmt.f32vector_elements(value)[0]
output = sum(self.prev_values[j])/len(self.prev_values[j])
output = pmt.make_f32vector(1, output)
if i==0:
outpmt = pmt.list1(pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol(str(key) + "_filtered"), output))
output = pmt.nth(1, element)
if i==0:
outpmt = pmt.list1(pmt.list2(key, output))
else:
outpmt = pmt.list_add(outpmt, pmt.list2(key, output))
if verbose:
print
#iterate over all keys
for i in range(0, len(self.kk)):
minimum = self.prev_values[i][0]
maximum = self.prev_values[i][0]
#iterate over all saved values
for j in range(0, self.n[i]):
if self.prev_values[i][j] < minimum:
minimum = self.prev_values[i][j]
if self.prev_values[i][j] > maximum:
maximum = self.prev_values[i][j]
#print out a min, diff, max for every key
difference = maximum-minimum
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("min"), pmt.make_f32vector(1, minimum)))
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("max"), pmt.make_f32vector(1, maximum)))
outpmt = pmt.list_add(outpmt, pmt.list2(pmt.string_to_symbol("diff"), pmt.make_f32vector(1, difference)))
self.message_port_pub(pmt.string_to_symbol("out"), outpmt)
def SNR_in(self,msg):
# Envia mensaje:
SNRv=pmt.to_double(msg)
self.d_SNR=np.float64(SNRv)
self.d_grx=np.float64(self.Rxgain)
# evidencia
xp1 = self.d_SNR
xp2 = self.d_FER
xp3 = 10*np.log10(self.d_pot/ 46);
xp4 = self.d_grx
# fusificacion
u11=1./(1+pl.exp(dp1[0]*(xp1-mp1[0])))
u12=pl.exp((-0.5*(xp1-mp1[1])**2)/((dp1[1])**2))
u13=1./(1+pl.exp(dp1[2]*(mp1[2]-xp1)))
# funciones de pertenencia entrada FER
u21=1./(1+pl.exp(dp2[0]*(xp2-mp2[0])))
u22=pl.exp((-0.5*(xp2-mp2[1])**2)/((dp2[1])**2))
u23=1./(1+pl.exp(dp2[2]*(mp2[2]-xp2)))
# funciones de pertenencia entrada Potencia
u31=1./(1+pl.exp(dp3[0]*(xp3-mp3[0])))
u32=pl.exp((-0.5*(xp3-mp3[1])**2)/((dp3[1])**2))
u33=1./(1+pl.exp(dp3[2]*(mp3[2]-xp3)))
# funciones de pertenencia entrada GRx
u41=1./(1+pl.exp(dp4[0]*(xp4-mp4[0])))
u42=pl.exp((-0.5*(xp4-mp4[1])**2)/((dp4[1])**2))
u43=1./(1+pl.exp(dp4[2]*(mp4[2]-xp4)))
# funciones de pertenencia salida
# Le pega el universo
uC1=1./(1+pl.exp(dpy[0]*(y-mpy[0])))
uC2=pl.exp((-0.5*(y-mpy[1])**2)/((dpy[1])**2))
uC3=pl.exp((-0.5*(y-mpy[2])**2)/((dpy[2])**2))
uC4=pl.exp((-0.5*(y-mpy[3])**2)/((dpy[3])**2))
uC5=1./(1+pl.exp(dpy[4]*(mpy[4]-y)))
# C?lculo de los antecedentes de las reglas (x1 es Ai Y x2 es Bj) T-Norma m?nimo
A1=[u11, u31]#1X1X
Ar1 = min (A1)
A2= [u11, u21, u32]#112X
Ar2 = min (A2)
A3= [u21, u33, u41]#X131
Ar3 = min (A3)
A4= [u21, u33, u42]#X132
Ar4 = min (A4)
A5= [u21, u33, u43]#X133
Ar5 = min (A5)
A6= [u11, u22, u32]#122X
Ar6 = min (A6)
A7 =[u11, u22, u33]#123X
Ar7 = min (A7)
A8 =[u11, u23, u32]#132X
Ar8 = min (A8)
A9 =[u11, u23, u33]#133X
Ar9 = min (A9)
A10 =[u12, u21, u31, u41]#2111
Ar10 = min (A10)
A11 =[u12,u21,u31,u43]#2113 #CAMBIAR REGLA from 2112
Ar11 = min (A11)
A12 =[u12,u21,u33,u42]#2133
Ar12 = min (A12)
A13 =[u12,u22,u31,u41]#2211
Ar13 = min (A13)
A14 =[u12,u22,u31,u42]#2212
Ar14 = min (A14)
A15 =[u12,u22,u32]#222X
Ar15 = min (A15)
A16 =[u12,u22,u33,u41]#2231
Ar16 = min (A16)
A17 =[u12,u22,u33,u42]#2232
Ar17= min (A17)
A18 =[u12,u22,u33,u43]#2233
Ar18= min (A18)
A19 =[u12,u23,u31]#231X
Ar19= min (A19)
A20 =[u12,u23,u32]#232X
Ar20= min (A20)
A21 =[u12,u23,u33]#233X
Ar21 = min (A21)
A22 =[u13,u21,u31]#311X
Ar22 = min (A22)
A23 =[u13,u21,u41]#31X1
Ar23 = min (A23)
A24 =[u13,u21,u42]#31X2
Ar24 = min (A24)
A25 =[u13,u21,u43]#31X3
Ar25 = min (A25)
A26 =[u13,u22,u41]#32X1
Ar26 = min (A26)
A27 =[u13,u22,u42]#32X2
Ar27 = min (A27)
A28 =[u13,u22,u43]#32X3
Ar28 = min (A28)
A29 =[u13,u23,u41]#33X1
Ar29 = min (A29)
A30 =[u13,u23,u33]#333X
Ar30 = min (A30)
# C?lculo de la implicaci?n Mamdani para todas las reglas
for i in range(296):
r1 = min (Ar1,uC1[i])
r2 = min (Ar2,uC2[i])
r3 = min (Ar3,uC3[i])
r4 = min (Ar4,uC4[i])
r5 = min (Ar5,uC5[i])
r6 = min (Ar6,uC3[i])
r7 = min (Ar7,uC3[i])
r8 = min (Ar8,uC2[i])
r9 = min (Ar9,uC3[i])
r10= min (Ar10,uC3[i])
r11= min (Ar11,uC4[i])
r12= min (Ar12,uC4[i])
r13= min (Ar13,uC2[i])
r14= min (Ar14,uC2[i])
r15= min (Ar15,uC3[i])
r16= min (Ar16,uC3[i])
r17= min (Ar17,uC3[i])
r18= min (Ar18,uC4[i])
r19= min (Ar19,uC1[i])
r20= min (Ar20,uC2[i])
r21= min (Ar21,uC3[i])
r22= min (Ar22,uC3[i])
r23= min (Ar23,uC3[i])
r24= min (Ar24,uC4[i])
r25= min (Ar25,uC5[i])
r26= min (Ar26,uC3[i])
r27= min (Ar27,uC4[i])
r28= min (Ar28,uC5[i])
r29= min (Ar29,uC3[i])
r30= min (Ar30,uC3[i])
f0[i]=max(r1,r2,r3,r4,r5,r6,r7,r8,r9,r10,r11,r12,r13,r14,r15,r16,r17,r18,r19,r20,r21,r22,r23,r24,r25,r26,r27,r28,r29,r30)
aux[i]=y[i]*f0[i]
# Defusificacion centroide discreto.
aux2=sum(aux)/sum(f0)
self.threshold = float(aux2)
send_pmt = pmt.make_f32vector(5, ord(' ')) # Crea PMT vacio
pmt.f32vector_set(send_pmt, 0, float(xp1))
pmt.f32vector_set(send_pmt, 1, float(xp2))
pmt.f32vector_set(send_pmt, 2, float(xp3))
pmt.f32vector_set(send_pmt, 3, float(xp4))
pmt.f32vector_set(send_pmt, 4, float(self.threshold))
# Envia mensaje:
self.message_port_pub(pmt.intern('threshold out'), pmt.cons(pmt.PMT_NIL, send_pmt))
