def main():
my_list_ble = dict()
my_list_wifi = dict()
for index_delay in range(len(delay)):
source_path = my.path_media + "json_file/relay_" + str(relay[index_relay]) + "/delay_" + str(
delay[index_delay]) + "/*_analysis.json"
cuts_path = my.path_media + "json_file/relay_" + str(relay[index_relay]) + "/outcomes/cuts/delay_x_" + str(
delay[index_delay]) + ".json"
files = my.get_grouped_files(source_path=source_path, delay=delay, index_delay=index_delay)
cuts = my.open_file_and_return_data(path=cuts_path)
i = 1
my_list_ble[delay[index_delay]] = dict()
my_list_wifi[delay[index_delay]] = dict()
for item in files:
data = my.open_file_and_return_data(path=item)['_mex']
l_ble, l_wifi = get_all_value_cuts(dataset=data, run=i, cut=cuts)
my_list_ble[delay[index_delay]][i] = l_ble
my_list_wifi[delay[index_delay]][i] = l_wifi
i += 1
df = get_list_and_return_df(my_list_ble, 'ble', 'latency')
define_base_plot()
# plot(df, "BLE", 'latency')
smooth_interpolation(df, 'ble', 'latency')
def main():
# path = my.get_argument()
my_data = dict()
try:
my_data = my.open_file_and_return_data(path=path)
# my.save_json_data_elegant(path=path_1, data=my_data)
print('\x1b[0;33;40m' + " Preprocessing completed! " + '\x1b[0m')
except Exception as e:
print(e)
return
try:
my_data = resolve_errors_preprocessing(data=my_data)
# my.save_json_data_elegant(path=path_1, data=my_data)
print('\x1b[0;33;40m' + " Error Preprocessing resoluted! " + '\x1b[0m')
except Exception as e:
print(e)
return
try:
my_data, checks = second_analysis(data=my_data)
# my.save_json_data_elegant(path=path_1, data=my_data)
print('\x1b[0;33;40m' + " Second Analysis completed! " + '\x1b[0m')
except Exception as e:
print(e)
return
try:
my_data = third_analysis(data=my_data)
print('\x1b[0;33;40m' + " Third Analysis completed! " + '\x1b[0m')
my.save_json_data_elegant(path=path_1, data=my_data)
except Exception as e:
print(e)
def preprocessing(path):
print("- {}".format(preprocessing.__name__))
check = False
data = my.open_file_and_return_data(code=0, path=path)
if data['analysis_status'] != 0:
raise Exception('\x1b[1;31;40m' + ' Preprocessing is already executed ' + '\x1b[0m')
data['error_first_analysis'] = []
print("\x1b[1;34;40m addr:{a}, delay:{d} n_mex:{n} [RELAY: {r}]\x1b[0m".format(a=data['_command']['addr'],
d=data['_command']['delay'],
n=data['_command']['n_mex'],
r=relay))
for i, mex in enumerate(data['messages']):
if not re.match(regular_expression_mex, mex['message_id']):
counter = mex['message_id'].count(',')
data['error_first_analysis'].append(
{'index': i, '#_comma': counter, 'time': mex['time'], 'string': mex['message_id']})
if not check:
check = True
else:
string = mex['message_id']
string = string.split(',')
check_string_mex(string)
mex['message_id'] = string[1]
mex['type_mex'] = string[0]
mex['ttl'] = string[2]
data['analysis_status'] = -1 if check else 1
# Faccio in modo da eseguire preprocessing solo una volta
# raw = my.open_file_and_return_data(path=path)
# raw['analysis_status'] = 1
# my.save_json_data_elegant(path=path, data=raw)
return data
def main_summary():
info = {'relay': [], 'delay': [], 'S': [], 'R': [], 'L': [], 'pdr': [], 'goodput': [], 'latency': []}
type_ = 0 # 1 -> normal, 0 -> cuts
for r in relay:
for d in delay:
if type_:
path = my.path_media + "json_file/" + tech + "/relay_" + str(r) + "/outcomes/delay_" + str(d) + ".json"
else:
path = my.path_media + "json_file/" + tech + "/relay_" + str(r) + "/x/delay_XXX_" + str(d) + ".json"
data = my.open_file_and_return_data(path=path)
info['relay'].append(r)
info['delay'].append(d)
if tech == 'ble_wifi_output':
info['S'].append(data['summary']['mex_']['total']['S'])
info['R'].append(data['summary']['mex_']['total']['R'])
info['L'].append(data['summary']['mex_']['total']['L'])
info['pdr'].append(data['summary']['statistic_']['total']['pdr'])
info['goodput'].append(data['summary']['statistic_']['total']['goodput'])
info['latency'].append(data['summary']['statistic_']['total']['latency']['mean'])
else:
info['S'].append(data['summary']['mex_']['S'])
info['R'].append(data['summary']['mex_']['R'])
info['L'].append(data['summary']['mex_']['L'])
info['pdr'].append(data['summary']['statistic_']['pdr'])
info['goodput'].append(data['summary']['statistic_']['goodput'])
info['latency'].append(data['summary']['statistic_']['latency']['mean'])
df = pd.DataFrame(info)
print(df.sort_values(by=['delay', 'relay']))
def analysis_preprocessing_2(start, end, l_min, l_max):
data_prepreocessing = my.open_file_and_return_data(code=0, path=path_1)
sent = 0
error = 0
received = 0
l_2 = set()
l_3 = 0
for value in data_prepreocessing['messages']:
if start <= dt.datetime.strptime(value['time'], '%Y-%m-%d %H:%M:%S.%f') <= end:
if l_min <= int(value['message_id']) <= l_max:
if value['type_mex'] == 'S':
sent = sent + 1
elif value['type_mex'] == 'P':
received = received + 1
l_2.add(int(value['message_id']))
elif value['type_mex'] == 'E':
error = error + 1
else:
l_3 += 1
print("Inviati: {}"
"\nRicevuti: {}"
"\nErrore: {}".format(sent, received, error))
print("Mex non considerati: {}".format(l_3))
return sent, received, error, l_2
def main():
files = my.get_grouped_files(source_path=source_path,
delay=delay,
index_delay=index_delay)
i = 1
my_list_ble = dict()
my_list_wifi = dict()
my_list_total = dict()
my_list_times = dict() # cambio delay_wifi_send
my_list_times_1 = dict() # cambio delay_wifi_send
for item in files:
print("\x1b[1;30;43m " + str(i) + " \x1b[1;34;40m " + item[28:] +
" \x1b[0m ")
data = my.open_file_and_return_data(path=item)
if i == 1:
my_dictionary['_command'] = data['_command']
l_ble, l_wifi, latency = statistics(data=data, run=i)
t, t1 = get_times_change_delay(data['_time'],
data['_command']['delay'],
data['_info'])
my_list_ble[i] = l_ble
my_list_wifi[i] = l_wifi
my_list_total[i] = latency
my_list_times[i] = t
my_list_times_1[i] = t1
i += 1
# Summary
summary_statistics()
save_statistics_data()
# PLOT
plot_1(my_list_ble, my_list_wifi, my_list_total, my_list_times,
my_list_times_1)
def main():
files = my.get_grouped_files(source_path=source_path,
delay=delay,
index_delay=index_delay)
path = delay_path + "delay_" + str(delay[index_delay]) + ".json"
data_delay = my.open_file_and_return_data(path=path)
i = 1
err = list()
dictionaries = dict()
data = dict()
for item in files:
data = my.open_file_and_return_data(path=item)
print("\x1b[1;30;43m " + item[28:] + " \x1b[0m ")
start = dt.datetime.strptime(data_delay[str(i)]['_info']['start'],
'%Y-%m-%d %H:%M:%S.%f')
end = dt.datetime.strptime(data_delay[str(i)]['_info']['end_sent'],
'%Y-%m-%d %H:%M:%S.%f')
# TODO shift focus about data --- duration 4 minute
new_start = start + dt.timedelta(0, 30) # right shift --> default 40 s
new_end = new_start + dt.timedelta(0, 240) # 4m <- (60s*4)
# end = end - dt.timedelta(0, 15)
new_diff = new_end - new_start
h, m, s = my.convert_timedelta(new_diff)
fault, outcome = analysis(data, new_start, new_end, i)
print("start: {} -- end: {} --- {}:{}.{} -- min: {} -- max: {}".format(
new_start, new_end, h, m, s, outcome['smaller'],
outcome['bigger']))
time = str(h) + ":" + str(m) + "." + str(s) + " [h:m.s]"
outcome['time'] = {
'old_start': start,
'old_end': end,
'new_start': new_start,
'new_end': new_end,
'new_time': time
}
err.append(fault)
dictionaries[i] = outcome
i += 1
mex_removed = (60 * 1000) / delay[index_delay]
total = data['_command']['n_mex'] - mex_removed
print("\x1b[1;34;40m [{}] Mex_removed: {} --> total: {} \x1b[0m ".format(
delay[index_delay], mex_removed, total))
print("err: --> ", err)
dictionaries['error'] = err
dictionaries['info'] = {'mex_removed': mex_removed, 'n_mex': total}
save_data(dictionaries)
def main():
files = my.get_grouped_files(source_path=source_path, delay=delay, index_delay=index_delay)
cuts = my.open_file_and_return_data(path=cuts_path)
i = 1
my_list_ble = dict()
for item in files:
print("\x1b[1;30;43m " + str(i) + " \x1b[1;34;40m " + item[28:] + " \x1b[0m ")
data = my.open_file_and_return_data(path=item)
if i == 1:
my_dictionary['_command'] = data['_command']
l_ble = statistics(data=data, run=i, x=cuts)
my_list_ble[i] = l_ble
i += 1
# Summary
summary_statistics()
# PLOT
plot_1(my_list_ble)
def get_sent_mex(path):
data = my.open_file_and_return_data(code=0, path=path)
mex = data['messages']
set_element = set()
for item in mex:
if item['type_mex'] == "S":
set_element.add(int(item['message_id']))
print("SENT MEX: {}".format(len(set_element)))
return set_element
def get_received_mex(path):
data = my.open_file_and_return_data(code=0, path=path)
set_element = set()
for item in data['messages']:
s = re.findall("level: [0-9]{1,5}", item['message_id'])
s = s[0].split(':')[1]
s = s.replace(' ', '')
set_element.add(int(s))
print("RECEIVED MEX: {}".format(len(set_element)))
return set_element
def main_cut():
my_list_ble = dict()
if directory == 'ble_wifi_output':
my_list_wifi = dict()
my_list_total = dict()
for index_delay in range(len(delay)):
source_path = my.path_media + "json_file/" + directory + "/relay_" + str(
relay[index_relay]) + "/" + str(
delay[index_delay]) + "/*_analysis.json"
cuts_path = my.path_media + "json_file/" + directory + "/relay_" + str(
relay[index_relay]) + "/x/delay_x_" + str(
delay[index_delay]) + ".json"
files = my.get_grouped_files(source_path=source_path,
delay=delay,
index_delay=index_delay)
cuts = my.open_file_and_return_data(path=cuts_path)
i = 1
my_list_ble[delay[index_delay]] = dict()
if directory == 'ble_wifi_output':
my_list_wifi[delay[index_delay]] = dict()
my_list_total[delay[index_delay]] = dict()
for item in files:
data = my.open_file_and_return_data(path=item)['_mex']
if directory == 'ble_wifi_output':
l_ble, l_wifi, l_total = get_all_value_cuts(dataset=data,
run=i,
cut=cuts)
my_list_ble[delay[index_delay]][i] = l_ble
my_list_wifi[delay[index_delay]][i] = l_wifi
my_list_total[delay[index_delay]][i] = l_total
else:
l_ble = get_all_value_cuts_ble(dataset=data, run=i, cut=cuts)
my_list_ble[delay[index_delay]][i] = l_ble
i += 1
plot(my_list_ble, "BLE")
plot(my_list_wifi, "WiFi")
plot(my_list_total, "BLE - WiFi")
def group_files():
global preprocessing_path
global analysis_path
list_of_files = glob.glob("./../json_file/test_2020_01_30/*.json")
list_of_files.sort()
for i in range(len(list_of_files)):
name = list_of_files[i]
data = my.open_file_and_return_data(path=name)
preprocessing_path = name[2:-5] + "_preprocessing.json"
analysis_path = name[2:-5] + "_analysis.json"
preprocessing(data=data)
time.sleep(1)
def main_2():
my_list = {'delay': list(), 'latency': list(), 'type': list()}
for index_delay in range(len(delay)):
source_path = my.path_media + "json_file/ble_wifi_output/relay_" + str(
relay[index_relay]) + "/" + str(
delay[index_delay]) + "/*_analysis.json"
cuts_path = my.path_media + "json_file/ble_wifi_output/relay_" + str(
relay[index_relay]) + "/x/delay_x_" + str(
delay[index_delay]) + ".json"
files = my.get_grouped_files(source_path=source_path,
delay=delay,
index_delay=index_delay)
cuts = my.open_file_and_return_data(path=cuts_path)
i = 1
for item in files:
data = my.open_file_and_return_data(path=item)
pxs, pys, pzs = get_all_value_2(dataset=data, run=i, cut=cuts)
my_list['delay'].append(pxs)
my_list['latency'].append(pys)
my_list['type'].append(pzs)
i += 1
pxs = list()
pys = list()
pzs = list()
runs = len(my_list['delay'])
for r in range(runs):
item = len(my_list['delay'][r])
for i in range(item):
pxs.append(my_list['delay'][r][i])
pys.append(my_list['latency'][r][i])
pzs.append(my_list['type'][r][i])
dataframe = {'delay': pxs, 'y_data': pys, 'type': pzs}
df = pd.DataFrame(dataframe)
print(df.head())
plot_2(df)
def plot_time(times, filename):
source_path = my.path_media + file_name[3:-5] + "_analysis.json"
data = my.open_file_and_return_data(path=source_path)
pxs = []
pys = []
step = []
info = {
'relay': data['_command']['relay'],
'packets': data['_command']['n_mex'],
'delay': data['_command']['delay']
}
delay = info['delay'] / 1000
my_time = data['_time']
my_time.sort(
key=lambda x: dt.datetime.strptime(x['time'], '%Y-%m-%d %H:%M:%S.%f'))
i = 1
for v in my_time:
# send_time = dt.datetime.strptime(v['time'], '%Y-%m-%d %H:%M:%S.%f')
pxs.append(i)
pys.append((v['delay'] * delay))
i += 1
# if times['ble_wifi_2']['start'] <= send_time <= times['ble_wifi_2']['end_t']:
# step.append('ble_wifi_2')
# elif times['ble_wifi_4']['start'] <= send_time <= times['ble_wifi_2']['end_t']:
# step.append('ble_wifi_4')
df = pd.DataFrame({'k': pxs, 'time': pys})
print(df.head())
sns.lmplot(
x="k",
y='time',
palette='muted',
data=df,
fit_reg=False,
ci=None,
height=5,
aspect=2,
scatter_kws={"s": 5},
)
plt.xlabel("Time change delay (ms)")
plt.ylabel("Delay (s)")
title = "TIME relay_" + str(info['relay']) + ", " + str(
info['packets']) + " packet (1m), delay " + str(info['delay']) + " ms"
plt.title(title)
filename = filename + ".png"
print("\x1b[1;32;40m Saving Graph: {}\x1b[0m".format(filename))
# plt.savefig(filename, dpi=600)
plt.show()
def remove_double():
source_path = my.path_media + file_name[3:-5] + "_analysis.json"
data = my.open_file_and_return_data(path=source_path)
double = False
for k, v in data['_mex'].items():
if len(v) == 7:
double = True
x = list()
for e in v:
if 'ble' in e:
x.append(e)
elif 'type_mex' in e:
if e['type_mex'] == 'S' or e['type_mex'] == 'R':
x.append(e)
data['_mex'][k] = x
if double:
my.save_json_data_elegant(path=analysis_path_2, data=data)
def change_ttl_from_7_to_3(path):
print("- {}".format(change_ttl_from_7_to_3.__name__))
data = my.open_file_and_return_data(code=0, path=path)
mex = data['messages']
i = 0
saving = False
ttl = 7 - data['_command']['relay']
re_ttl = str("P,[0-9]{1,5}," + str(ttl))
replace_ttl = 3 - data['_command']['relay']
for k in mex:
if re.match(re_ttl, k['message_id']):
saving = True
s = k['message_id'].split(',')
new_s = str(s[0] + "," + s[1] + "," + str(replace_ttl))
data['messages'][i]['message_id'] = new_s
i += 1
if saving:
my.save_json_data_2(path=path, data=data)
def main():
if all_test_or_cut:
list_of_files = glob.glob(source_path_2)
else:
list_of_files = glob.glob(source_path)
data_info = dict()
for name in sorted(list_of_files):
data = my.open_file_and_return_data(path=name)
data_info = get_info_from_data(data, data_info)
time.sleep(0.05)
data_details = dict()
for item in delay:
data_details[item] = dict()
for t1 in terms:
data_details[item][t1] = list()
for i in data_info[item]:
statistics = data_info[item][i]['statistic_']
mex = data_info[item][i]['mex_']
data_details[item][terms[0]].append(mex[terms[0]])
data_details[item][terms[1]].append(mex[terms[1]])
data_details[item][terms[2]].append(mex[terms[2]])
data_details[item][terms[3]].append(mex[terms[3]])
data_details[item][terms[4]].append(statistics[terms[4]]['mean'])
data_details[item][terms[5]].append(
statistics['latency'][terms[5]])
data_details[item][terms[6]].append(
statistics['latency'][terms[6]])
data_details[item][terms[7]].append(
statistics['latency'][terms[7]])
data_details[item][terms[8]].append(
statistics['latency'][terms[8]])
data_details[item][terms[9]].append(statistics[terms[9]])
data_details[item][terms[10]].append(statistics[terms[10]])
data_details[item][terms[11]].append(statistics[terms[11]])
save_xlsx(data_details)
def main2():
pxs = []
pys = []
pzs = []
margin_error = []
global index_relay
for index_relay in relay:
source_path_2 = my.path_media + "json_file/relay_" + str(relay[index_relay]) + "/x/delay_XXX_*.json"
list_of_files = glob.glob(source_path_2)
for name in list_of_files:
data = my.open_file_and_return_data(name)
pzs.append(('relay_' + str(data['_command']['relay'])))
pxs.append(data['_command']['delay'])
pys.append(data['summary']['statistic_']['total']['latency']['mean'])
margin_error.append(data['summary']['statistic_']['total']['latency']['m_e'])
dataframe = {'delay': pxs, 'latency': pys, 'type': pzs, 'm_e': margin_error}
df = pd.DataFrame(dataframe)
print(df.head())
#plot_boxplot(df)
# define_base_plot()
plot_with_error(df, 'type', 'latency')
def get_data():
data_details = dict()
for d in delay:
info = {'latency': [], 'pdr': [], 'goodput': []}
path_json_data = my.path_media + "json_file/" + tech + "/relay_" + str(
relay[index_relay]) + "/x/delay_XXX_" + str(
d) + ".json"
data = my.open_file_and_return_data(path=path_json_data)
data_details[d] = dict()
for item in elements:
if tech == 'ble_output':
info['latency'].append(data[item]['statistic_']['latency']['mean'])
info['pdr'].append(data[item]['statistic_']['pdr'])
info['goodput'].append(data[item]['statistic_']['goodput_1'])
elif tech == 'ble_wifi_output':
info['latency'].append(data[item]['statistic_']['total']['latency']['mean'])
info['pdr'].append(data[item]['statistic_']['total']['pdr'])
info['goodput'].append(data[item]['statistic_']['total']['goodput_1'])
else:
raise ValueError('tech incorrect!')
out_latency = my.intervalli_di_confidenza(info['latency'])
# my_confidential_interval_(info['latency'])
out_pdr = my.intervalli_di_confidenza(info['pdr'])
out_goodput = my.intervalli_di_confidenza(info['goodput'])
data_details[d][terms[0]] = out_latency['mean']
data_details[d][terms[1]] = out_latency['m_e']
data_details[d][terms[2]] = out_pdr['mean']
data_details[d][terms[3]] = out_pdr['m_e']
data_details[d][terms[4]] = out_goodput['mean']
data_details[d][terms[5]] = out_goodput['m_e']
return data_details
def call_error_resolution_and_save(path_s):
data = my.open_file_and_return_data(code=0, path=path_1)
data = resolve_errors_preprocessing(data=data)
my.save_json_data_elegant(path=path_s, data=data)
def call_second_analysis_and_save(path_s):
data = my.open_file_and_return_data(code=0, path=path_1)
data, users = second_analysis(data=data)
my.save_json_data_elegant(path=path_s, data=data)
def call_third_analysis_and_save(path_s):
data = my.open_file_and_return_data(code=0, path=path_2)
data = third_analysis(data=data)
my.save_json_data_elegant(path=path_s, data=data)
def call_fourth_analysis_and_save(path_s):
data = my.open_file_and_return_data(code=0, path=path_2)
data = clean_data(data=data, approach="packets") # packets or time
my.save_json_data_elegant(path=path_s, data=data)
def get_data(path):
print("Open file: {}".format(path))
data = my.open_file_and_return_data(code=0, path=path)
return data
def call_preprocessing():
data = my.open_file_and_return_data(path=path)
preprocessing(data=data)
def catalogue_data():
source_path = my.path_media + file_name[3:-5] + "_analysis_2.json"
data = my.open_file_and_return_data(path=source_path)
start_1 = dt.datetime.strptime(data['_status'][0]['time'],
'%Y-%m-%d %H:%M:%S.%f')
end_1 = dt.datetime.strptime(data['_status'][1]['time'],
'%Y-%m-%d %H:%M:%S.%f')
start_2 = dt.datetime.strptime(data['_status'][2]['time'],
'%Y-%m-%d %H:%M:%S.%f')
end_2 = dt.datetime.strptime(data['_status'][3]['time'],
'%Y-%m-%d %H:%M:%S.%f')
start_3 = dt.datetime.strptime(data['_status'][4]['time'],
'%Y-%m-%d %H:%M:%S.%f')
end_3 = dt.datetime.strptime(data['_status'][5]['time'],
'%Y-%m-%d %H:%M:%S.%f')
start_4 = dt.datetime.strptime(data['_status'][6]['time'],
'%Y-%m-%d %H:%M:%S.%f')
end_4 = dt.datetime.strptime(data['_status'][7]['time'],
'%Y-%m-%d %H:%M:%S.%f')
start_5 = dt.datetime.strptime(data['_status'][8]['time'],
'%Y-%m-%d %H:%M:%S.%f')
end_5 = dt.datetime.strptime(data['_status'][9]['time'],
'%Y-%m-%d %H:%M:%S.%f')
pxs = []
pys = []
step = []
cases = {
'ble_1': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_wifi_2': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'wifi_3': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_wifi_4': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_5': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
}
}
times = {
'ble_1': {
'start': start_1,
'end_s': end_1,
'end_t': end_1
},
'ble_wifi_2': {
'start': start_2,
'end_s': end_2,
'end_t': end_2
},
'wifi_3': {
'start': start_3,
'end_s': end_3,
'end_t': end_3
},
'ble_wifi_4': {
'start': start_4,
'end_s': end_4,
'end_t': end_4
},
'ble_5': {
'start': start_5,
'end_s': end_5,
'end_t': end_5
}
}
for k, v in data['_mex'].items():
send_time = dt.datetime.strptime(v[0]['time'], '%Y-%m-%d %H:%M:%S.%f')
length = len(v)
case = ''
string = ''
t = ''
mex_type = list()
if start_1 <= send_time <= end_1:
case = 'ble_1'
mex_type.append('S')
if length == 1:
mex_type.append('L')
elif length == 2:
mex_type.append('E')
mex_type.append('L')
elif length == 3 and 'ble' in v[length - 1]:
mex_type.append('R')
t = 'ble'
string = 'ble_1'
else:
print(case, " -- ", length, " -- ", k)
elif start_2 <= send_time <= end_2:
case = 'ble_wifi_2'
mex_type.append('S')
if length == 1:
mex_type.append('L')
elif length == 2 or length == 4:
mex_type.append('E')
mex_type.append('L')
elif length == 3:
if 'ble' in v[length - 1]:
mex_type.append('R')
t = 'ble'
string = 'ble_2'
else:
mex_type.append('L')
elif length == 5 and 'ble_wifi' in v[length - 1]:
mex_type.append('R')
t = 'wifi'
string = 'wifi_2'
elif length == 6 and 'ble_wifi' in v[length - 1]:
mex_type.append('E')
mex_type.append('R')
t = 'wifi'
string = 'wifi_2'
else:
print(case, " -- ", length, " -- ", k)
def catalogue_data_2():
source_path = my.path_media + file_name[3:-5] + "_analysis_2.json"
data = my.open_file_and_return_data(path=source_path)
pxs = []
pys = []
step = []
increment = data['_command']['n_mex']
start_1 = 1
end_1 = start_1 - 1 + increment
start_2 = end_1 + 1
end_2 = end_1 + increment
start_3 = end_2 + 1
end_3 = end_2 + increment
start_4 = end_3 + 1
end_4 = end_3 + increment
start_5 = end_4 + 1
end_5 = end_4 + increment
cases = {
'ble_1': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_wifi_2': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'wifi_3': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_wifi_4': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
},
'ble_5': {
'S': 0,
'R': 0,
'L': 0,
'E': 0,
'latency': []
}
}
packets_limit = {
'ble_1': {
'start': start_1,
'end_s': end_1,
'end_t': end_1
},
'ble_wifi_2': {
'start': start_2,
'end_s': end_2,
'end_t': end_2
},
'wifi_3': {
'start': start_3,
'end_s': end_3,
'end_t': end_3
},
'ble_wifi_4': {
'start': start_4,
'end_s': end_4,
'end_t': end_4
},
'ble_5': {
'start': start_5,
'end_s': end_5,
'end_t': end_5
}
}
for k, v in data['_mex'].items():
send_time = dt.datetime.strptime(v[0]['time'], '%Y-%m-%d %H:%M:%S.%f')
length = len(v)
case = ''
string = ''
t = ''
mex_type = list()
if start_1 <= int(k) <= end_1:
case = 'ble_1'
mex_type.append('S')
if length == 1:
mex_type.append('L')
elif length == 2:
mex_type.append('E')
mex_type.append('L')
elif length == 3 and 'ble' in v[length - 1]:
mex_type.append('R')
t = 'ble'
string = 'ble_1'
else:
print(case, " -- ", length, " -- ", k)
elif start_2 <= int(k) <= end_2:
case = 'ble_wifi_2'
mex_type.append('S')
if length == 1:
mex_type.append('L')
elif length == 2 or length == 4:
mex_type.append('E')
mex_type.append('L')
elif length == 3:
if 'ble' in v[length - 1]:
mex_type.append('R')
t = 'ble'
string = 'ble_2'
else:
mex_type.append('L')
elif length == 5 and 'ble_wifi' in v[length - 1]:
mex_type.append('R')
t = 'wifi'
string = 'wifi_2'
elif length == 6 and 'ble_wifi' in v[length - 1]:
mex_type.append('E')
mex_type.append('R')
t = 'wifi'
string = 'wifi_2'
else:
print(case, " -- ", length, " -- ", k)
def main_5():
x = dict()
y = list()
z = list()
l_1 = list()
l_2 = list()
if directory == 'ble_output':
raise Exception('wrong - directory- ')
r = 0
for d in range(len(delay)):
path = my.path_media + "json_file/" + directory + "/relay_" + str(
relay[r]) + "/x/delay_XXX_" + str(delay[d]) + ".json"
files = my.get_grouped_files(source_path=path,
delay=delay,
index_delay=d)
for item in files:
data = my.open_file_and_return_data(path=item)
time_ = (data['_command']['delay'])
ble = data['summary']['mex_']['ble']['R']
wifi = data['summary']['mex_']['wifi']['R']
total = data['summary']['mex_']['total']['R']
p_ble = ble * 100 / total
p_wifi = wifi * 100 / total
x[time_] = list()
x[time_].append(p_ble)
z.append('ble')
x[time_].append(p_wifi)
z.append('wifi')
l_1.append(time_)
y.append(p_ble)
l_2.append(100)
dataframe = {'total': l_2, 'ble': y, 'delay': l_1}
df = pd.DataFrame(dataframe)
print(df)
fig_dims = (10, 4)
fig, ax = plt.subplots(figsize=fig_dims)
sns.set_context('notebook')
sns.set_color_codes("muted")
sns.barplot(x='delay', y='total', data=df, label="total", color='b', ax=ax)
sns.set_color_codes("muted")
sns.barplot(x='delay', y='ble', data=df, label="ble", color='y', ax=ax)
sns.despine()
plt.show()
print("--")
dataframe = {
'type': ['ble', 'wifi'],
'50': x[50],
'100': x[100],
'150': x[150],
'200': x[200],
'250': x[250],
'500': x[500],
'1000': x[1000]
}
df = pd.DataFrame(dataframe)
print(df.head())
sns.set_context('notebook')
df.set_index('type').T.plot(kind='bar', stacked=True)
plt.legend(loc='best')
my_point = list()
my_label = list()
delay.reverse()
for i in range(len(delay)):
my_point.append(i + 1)
frequency = 1 / (delay[i] / 1000)
my_label.append(round(frequency, 2))
plt.xticks(my_point, my_label, rotation=30)
plt.xlabel("Frequency (Hz)", fontsize=16)
plt.ylabel("Percentage", fontsize=16)
# plt.title(title)
sns.despine(
) # is a function that removes the spines from the right and upper portion of the plot by default.
plt.show()
def main_4():
x = list()
y = list()
z = list()
dir = ['ble_wifi_output', 'ble_output']
dictionary = dict()
if type_graph == 'latency':
y_label = 'Latency (s)'
title = 'Latency'
name = 'mixed_latency.png'
elif type_graph == 'pdr':
y_label = 'Packet Delivery Ratio'
title = y_label
name = 'mixed_pdr.png'
else:
y_label = 'Goodput (byte/s)'
title = 'Goodput'
name = 'mixed_goodput.png'
for d1 in dir:
if d1 == 'ble_wifi_output':
hue = 'ble_wifi'
else:
hue = 'ble'
dictionary[hue] = dict()
for r in range(len(relay)):
dictionary[hue][r] = {'x': list(), 'y': list()}
for d in range(len(delay)):
path = my.path_media + "json_file/" + d1 + "/relay_" + str(
relay[r]) + "/x/delay_XXX_" + str(delay[d]) + ".json"
files = my.get_grouped_files(source_path=path,
delay=delay,
index_delay=d)
i = 1
for item in files:
data = my.open_file_and_return_data(path=item)
t = hue + ' config_' + str(r)
if hue == 'ble_wifi':
if type_graph == 'latency':
value = data['summary']['statistic_']['total'][
type_graph]['mean']
else:
value = data['summary']['statistic_']['total'][
type_graph]
else:
if type_graph == 'latency':
value = data['summary']['statistic_'][type_graph][
'mean']
else:
value = data['summary']['statistic_'][type_graph]
time_ = convert_time_in_num(data['_command']['delay'])
x.append(time_)
y.append(value)
z.append(t)
dictionary[hue][r]['x'].append(time_)
dictionary[hue][r]['y'].append(value)
i += 1
dataframe = {'delay': x, 'latency': y, 'type': z}
df = pd.DataFrame(dataframe)
# print(df)
print("path: " + my.path_media + "json_file/" + directory + "/last_plot/")
print("name: " + name)
# colors = ['#4878D0', '#EE854A', '#6ACC64', '#D65F5F', '#82C6E2', '#D5BB67']
# sns.set_palette(sns.color_palette(colors))
xs_b_0 = np.linspace(min(dictionary['ble'][0]['x']),
max(dictionary['ble'][0]['x']), 100)
xs_b_1 = np.linspace(min(dictionary['ble'][1]['x']),
max(dictionary['ble'][1]['x']), 100)
xs_b_2 = np.linspace(min(dictionary['ble'][2]['x']),
max(dictionary['ble'][2]['x']), 100)
xs_bw_0 = np.linspace(min(dictionary['ble_wifi'][0]['x']),
max(dictionary['ble_wifi'][0]['x']), 100)
xs_bw_1 = np.linspace(min(dictionary['ble_wifi'][1]['x']),
max(dictionary['ble_wifi'][1]['x']), 100)
xs_bw_2 = np.linspace(min(dictionary['ble_wifi'][2]['x']),
max(dictionary['ble_wifi'][2]['x']), 100)
f_b_0 = sc.interpolate.interp1d(dictionary['ble'][0]['x'],
dictionary['ble'][0]['y'],
kind='linear')
f_b_1 = sc.interpolate.interp1d(dictionary['ble'][1]['x'],
dictionary['ble'][1]['y'],
kind='linear')
f_b_2 = sc.interpolate.interp1d(dictionary['ble'][2]['x'],
dictionary['ble'][2]['y'],
kind='linear')
f_bw_0 = sc.interpolate.interp1d(dictionary['ble_wifi'][0]['x'],
dictionary['ble_wifi'][0]['y'],
kind='linear')
f_bw_1 = sc.interpolate.interp1d(dictionary['ble_wifi'][1]['x'],
dictionary['ble_wifi'][1]['y'],
kind='linear')
f_bw_2 = sc.interpolate.interp1d(dictionary['ble_wifi'][2]['x'],
dictionary['ble_wifi'][2]['y'],
kind='linear')
sns.set_context('notebook')
sns.lmplot(
x='delay',
y='latency',
data=df,
palette='muted',
fit_reg=False,
ci=None,
legend_out=False,
# hue='type',
height=4,
aspect=2,
markers=".",
scatter_kws={"s": 30})
# plot line
plt.plot(xs_b_0, f_b_0(xs_b_0), '-.', color='#D65F5F') # red
plt.plot(xs_b_1, f_b_1(xs_b_1), '-.', color='#956CB4') # purple
plt.plot(xs_b_2, f_b_2(xs_b_2), '-.', color='#8C613C') # brown
plt.plot(xs_bw_0, f_bw_0(xs_bw_0), '--', color='#4878D0') # blue
plt.plot(xs_bw_1, f_bw_1(xs_bw_1), '--', color='#EE854A') # orange
plt.plot(xs_bw_2, f_bw_2(xs_bw_2), '--', color='#6ACC64') # green
# plot point
plt.plot(dictionary['ble'][0]['x'],
dictionary['ble'][0]['y'],
'o',
markersize=6,
color='#D65F5F',
label="ble config_0") # red
plt.plot(dictionary['ble'][1]['x'],
dictionary['ble'][1]['y'],
'o',
markersize=6,
color='#956CB4',
label="ble config_1") # purple
plt.plot(dictionary['ble'][2]['x'],
dictionary['ble'][2]['y'],
'o',
markersize=6,
color='#8C613C',
label="ble confgi_2") # brown
plt.plot(dictionary['ble_wifi'][0]['x'],
dictionary['ble_wifi'][0]['y'],
'D',
markersize=6,
color='#4878D0',
label="ble_wifi config_0") # blue
plt.plot(dictionary['ble_wifi'][1]['x'],
dictionary['ble_wifi'][1]['y'],
'D',
markersize=6,
color='#EE854A',
label="ble_wifi config_1") # orange
plt.plot(dictionary['ble_wifi'][2]['x'],
dictionary['ble_wifi'][2]['y'],
'D',
markersize=6,
color='#6ACC64',
label="ble_wifi config_2") # green
plt.legend(loc='best')
my_point = list()
my_label = list()
delay.reverse()
for i in range(len(delay)):
my_point.append(i + 1)
frequency = 1 / (delay[i] / 1000)
my_label.append(round(frequency, 2))
plt.xticks(my_point, my_label, rotation=30)
plt.xlabel("Frequency (Hz)", fontsize=16)
plt.ylabel(y_label, fontsize=16)
# plt.title(title)
sns.despine(
) # is a function that removes the spines from the right and upper portion of the plot by default.
plt.show()
def main_3():
x = list()
y = list()
z = list()
dictionary = dict()
if directory == 'ble_output':
tech = " - [BLE]"
else:
tech = " - [BLE - WiFi]"
if type_graph == 'latency':
y_label = 'Latency (s)'
title = 'Latency' + tech
name = directory[:-6] + 'latency.png'
elif type_graph == 'pdr':
y_label = 'Packet Delivery Ratio'
title = y_label + tech
name = directory[:-6] + 'pdr.png'
else:
y_label = 'Goodput (byte/s)'
title = 'Goodput' + tech
name = directory[:-6] + 'goodput.png'
for r in range(len(relay)):
dictionary[r] = {'x': list(), 'y': list()}
for d in range(len(delay)):
path = my.path_media + "json_file/" + directory + "/relay_" + str(
relay[r]) + "/x/delay_XXX_" + str(delay[d]) + ".json"
files = my.get_grouped_files(source_path=path,
delay=delay,
index_delay=d)
i = 1
for item in files:
data = my.open_file_and_return_data(path=item)
t = 'config_' + str(int(r + 1))
z.append(t)
time_ = convert_time_in_num(data['_command']['delay'])
x.append(time_)
dictionary[r]['x'].append(time_)
if directory == 'ble_wifi_output':
if type_graph == 'latency':
value = data['summary']['statistic_']['total'][
type_graph]['mean']
else:
value = data['summary']['statistic_']['total'][
type_graph]
else:
if type_graph == 'latency':
value = data['summary']['statistic_'][type_graph][
'mean']
else:
value = data['summary']['statistic_'][type_graph]
y.append(value)
dictionary[r]['y'].append(value)
i += 1
dataframe = {'delay': x, 'y_data': y, 'type': z}
df = pd.DataFrame(dataframe)
print(df.head())
print("path: " + my.path_media + "json_file/" + directory + "/last_plot/")
print("name: " + name)
plot_3(df, dictionary, y_label, title)
plot_x(df, dictionary, y_label, title)
