BachelorThesis/BachelorThesis/Software/PyPrecisionGUI/main.py

from reader_interface import ReaderInterface
import numpy as np
from calibration import Calibration
from localization import Localization
from plot_results import Plotting
from moving_average import MovingAverage
from tkinter import *
import time
import socket


"""-----------------------------------GUI Code-------------------------------------------------------------------- """


def calibrate():
    global calibration
    print("-----Started calibration...")
    calibration.new_calibration()


def start_recording():
    global record, recording_array
    recording_array = np.zeros((int(record_length.get()), 19))
    record = True
    print("-----Started recording...")
def save_array():
    global save
    save = True


def calculate_positions():
    localization.scale_factor = float(scale_factor.get())
    localization.k_nearest = k_nearest.get()

    localization.localize_all_samples(filename_localize_in.get(), filename_localize_out.get()) # NORMAL LOCALIZATION
    #localization.localize_averaged_samples(filename_localize_in.get(), filename_localize_out.get()) #AVERAGED LOCALIZATION


def plot_antennas():
    temp_ant_list = ""
    if check_var_all_frames.get() and not check_var_all_mains.get():
        temp_ant_list = "f1, f2, f3, f4, f5, f6, f7, f8"
    if check_var_all_mains.get() and not check_var_all_frames.get():
        temp_ant_list = "m1, m2, m3, m4, m5, m6, m7, m8"
    if check_var_all_frames.get() and check_var_all_mains.get():
        temp_ant_list = "f1, f2, f3, f4, f5, f6, f7, f8, m1, m2, m3, m4, m5, m6, m7, m8"
    if not check_var_all_frames.get() and not check_var_all_mains.get():
        temp_ant_list = antenna_list.get()

    temp_ant_list = temp_ant_list.split(', ')
    print("Antenna plots were made from : recorded_data/", filename_record_out.get(), "| it uses filename_record_out")
    plotting.plot_antennas(filename_record_out.get(), temp_ant_list, float(scale_factor.get()))


def plot_positions():
    plotting.plot_positions(filename_plot_in.get())


# Set up Labelframes
root = Tk()

record_labelframe = LabelFrame(root, text="Record")
record_labelframe.grid(row=0, column=0, sticky=N+E+S+W)

localize = LabelFrame(root, text="Localize")
localize.grid(row=0, column=1, sticky=N+E+S+W)

fingerprint = LabelFrame(root, text="ART")
fingerprint.grid(row=1, column=0, sticky=N+E+S+W)

plot = LabelFrame(root, text="Plot")
plot.grid(row=1, column=1, sticky=N+E+S+W)


# record_labelframeLabelframe
filename_record_out = StringVar(record_labelframe)
filename_record_out.set('current_recording')

record_length = IntVar(record_labelframe)
record_length.set(1000)

label_record_length = Label(record_labelframe, text="Number of samples:")
label_record_length.grid(row=0, column=0, sticky=W)
entry_record_length = Entry(record_labelframe, textvariable=record_length)
entry_record_length.grid(row=0, column=1, sticky=N + E + S + W)

label_filename_record_out = Label(record_labelframe, text="Filename (Out):")
label_filename_record_out.grid(row=1, column=0, sticky=W)
entry_filename_record_out = Entry(record_labelframe, textvariable=filename_record_out)
entry_filename_record_out.grid(row=1, column=1, sticky=N + E + S + W)

button_calibrate = Button(record_labelframe, text="Calibrate", command=calibrate)
button_calibrate.grid(row=2, column=0, sticky=N + E + S + W)

button_record = Button(record_labelframe, text="Record", command=start_recording)
button_record.grid(row=2, column=1, sticky=N + E + S + W)

# Localize Labelframe
filename_localize_in = StringVar(root)
filename_localize_in.set('ART Recordings/Recording_1')

scale_factor = StringVar(plot)
scale_factor.set("0.001")

k_nearest = IntVar(plot)
k_nearest.set(2)

filename_localize_out = StringVar(root)
filename_localize_out.set('current_positions')


label_filename_localize_in = Label(localize, text="Filename (In):")
label_filename_localize_in.grid(row=0, column=0, sticky=W)
emtry_filename_localize_in = Entry(localize, textvariable=filename_localize_in)
emtry_filename_localize_in.grid(row=0, column=1, sticky=N + E + S + W)

label_scale_factor = Label(localize, text="Scale factor:")
label_scale_factor.grid(row=1, column=0, sticky=W)
entry_scale_factor = Entry(localize, textvariable=scale_factor)
entry_scale_factor.grid(row=1, column=1, sticky=N + E + S + W)

label_k_nearest = Label(localize, text="k_nearest:")
label_k_nearest.grid(row=2, column=0, sticky=W)
entry_k_nearest = Entry(localize, textvariable=k_nearest)
entry_k_nearest.grid(row=2, column=1, sticky=N + E + S + W)

label_filename_localize_out = Label(localize, text="Filename (Out):")
label_filename_localize_out.grid(row=3, column=0, sticky=W)
entry_filename_localize_out = Entry(localize, textvariable=filename_localize_out)
entry_filename_localize_out.grid(row=3, column=1, sticky=N + E + S + W)

button_calculate_positions = Button(localize, text="Calculate positions", command=calculate_positions)
button_calculate_positions.grid(row=4, column=0)


# Plot Labelframe
filename_plot_in = StringVar(plot)
filename_plot_in.set('current_positions')

antenna_list = StringVar(plot)
antenna_list.set("f1, f2, m1, m2")

check_var_all_frames = IntVar()
check_var_all_mains = IntVar()

label_filename_plot_in = Label(plot, text="Filename (In):")
label_filename_plot_in.grid(row=0, column=0, sticky=W)
entry_filename_plot_in = Entry(plot, textvariable=filename_plot_in)
entry_filename_plot_in.grid(row=0, column=1, sticky=N + E + S + W)

label_antennas = Label(plot, text="Specific Antenna(s):")
label_antennas.grid(row=1, column=0, sticky = W)
entry_antennas = Entry(plot, textvariable=antenna_list)
entry_antennas.grid(row=1, column=1)

checkbox_all_frames = Checkbutton(plot, variable=check_var_all_frames, text="All Frames", onvalue=1, offvalue=0)
checkbox_all_frames.grid(row=2, column=0)

checkbox_all_mains = Checkbutton(plot, variable=check_var_all_mains, text="All Mains", onvalue=1, offvalue=0)
checkbox_all_mains.grid(row=2, column=1)

button_plot_antennas = Button(plot, text="Plot Antennas", command=plot_antennas)
button_plot_antennas.grid(row=2, column=2)

button_plot_positons = Button(plot, text="Plot Positions", command=plot_positions)
button_plot_positons.grid(row=3, column=0)


# ART Labelframe



""" --------------------- Initializing Parameters--------------------------------------------------------------------"""
# Localization Parameters
moving_average_length = 100
moving_avg = MovingAverage(moving_average_length)
localization_method = 'k-nearest'  # full_table

timer_stream_positions_to_mqtt_client = time.time()

# Recording parameters
recording_index = 0
record = False
recording_array = np.zeros((1000, 19))
#recording_array = []
counter = 0
startTime = time.time()
samples_counter = 1
socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

fingerprinting_table = np.loadtxt("fingerprinting_tables/Julian_1cm_precision_corrected_antenas.csv", delimiter=';')
np.save("fingerprinting_tables/Julian_1cm_precision_corrected_antenas", fingerprinting_table)
print(fingerprinting_table)

def set_reader():
    config = {
        "samples_block_size": 10,
        "resistance": .55,
        "inductance": 20e-6,
        "loadFactor": 1.0,
        "channels": [
            (119000, 0.35),
            (61500, 0.0),
            (50000, 0.0),
            (142000, 0.0)],
        # Channel permutation
        # Raw channels will be arranged in the samples as in this list.
        # Channels correspond to connectors in consecutive pairs (0/1 = A, 2/3 = B, ...).
        # In each pair the lower (even) channel is frame and the higher (odd) channel is main.
        # If you switch antenna connections between ports or have main/frame switched on one
        # port, you will have to reverse that change here to keep the same antenna names in software.
        # THIS PERMUTATION MUST BE 21 ELEMENTS LONG (21 channels in each sample)
        "channelPermutation" :[1, 0, 3, 2, 5, 4,  7,  6,  9,  8,         #config for hmi shelf
                      11, 10, 13, 12, 15, 14,  17,  16, 18, 19,     # in my setup with 8 Antennas, aynthing higher than 15 doesnt matter right?
                      20],
        "numAntennas": 8

    }
    reader = ReaderInterface(resistance=config["resistance"],
                             inductance=config["inductance"],
                             load_factor=config["loadFactor"],
                             num_antennas=config["numAntennas"],
                             channel_permutation=config["channelPermutation"])
    for idx, c in enumerate(config["channels"]):
        reader.setFrequency(idx, c[0])
        if c[1] > 0:  # CHANGED c[1] -> c[0]
            reader.setExciterCurrent(idx, c[1])  # CHANGED
            reader.setExciterEnabled(idx, True)
    reader.setChannel20Switch(3)  # Set channel 20 to current feedback
    reader.enableConfiguration()
    return reader


def process_sample(samples):
    global record, recording_index, recording_array, record_length, filename, counter, \
        startTime, samples_counter, timer_stream_positions_to_mqtt_client
    if time.time() - startTime > 1:
        counter = 0
        startTime = time.time()
    else:
        counter += 1
    for sample in samples:
        #if record:
        #print(len(recording_array))
        rawdata = sample.getRawData()
        rawdata = rawdata[0, :]
        calibrated_sample = calibration.process_sample(rawdata)
        #recording_array.append(rawdata)

        if calibrated_sample is not None:
            averaged_sample = moving_avg.processSample(calibrated_sample)
            #before:
            #frame_antennas = np.abs(np.imag(averaged_sample[0:16:2])) #* -1
            #main_antennas = np.abs(np.imag(averaged_sample[1:16:2])) * -1
            #after:
            frame_antennas = np.imag(averaged_sample[0:16:2])
            main_antennas = np.imag(averaged_sample[1:16:2])

            frames_list = list(frame_antennas)
            mains_list = list(main_antennas)

            # Fixing the polarity of each antenna
            frames_list[0] = frames_list[0] * -1    # frame1
            frames_list[4] = frames_list[4] * -1    # frame5

            #mains_list[2] = mains_list[2] * -1      # main3
            mains_list[4] = mains_list[4] * -1      # main5
            mains_list[5] = mains_list[5] * -1      # main6


            #fv = np.append(frames_list, mains_list)
            pos = [0, 0, 0]
            fv = []
            for s in frames_list:
                fv.append(s)
            for s in mains_list:
                fv.append(s)

            if record:
                if recording_index < (record_length.get()):
                    # pos = localize(fv)

                    recording_array[recording_index, 0:3] = pos
                    recording_array[recording_index, 3:] = fv
                    recording_index += 1
                    print("recording progress=", recording_index)
                    # print("Recording progress : ", round((recording_index / record_length.get()) * 100, 3), "%")
                else:
                    np.save("recorded_data/" + entry_filename_record_out.get(), recording_array)
                    print('-----Finished recording. Saved in: recorded_data/' + entry_filename_record_out.get() + ".npy (shape=",
                          np.shape(recording_array), ")")
                    recording_index = 0
                    record = False
    #else:
        #samples_counter += 1


""" ------------------------ Setting up reader and starting request Data Thread-----------------------------------"""

calibration = Calibration()
reader = set_reader()
request = reader.requestData(process_sample, blockSize=100, blocks=-1)
localization = Localization()
plotting = Plotting()

root.mainloop()