"""
Created on Thu Jan 11 15:22:56 2018
@author: Robin Cavalieri 
IMA5SC - PFE 2018
P32 - Détection automatique de DoS sur réseau LoRa
Main avec méthode des KPPV
"""
###############################################################################
#LIBRAIRIES UTILES
###############################################################################
import time;
import serial;
import numpy as np;
import pandas as pd;
###############################################################################

###############################################################################
#VARIABLES MESUREES
###############################################################################
ping_mesured=0; 
rssi_mesured=0;
result=0;
puissance_read = 0;
temp_read = 0;
trame_read = [];
###############################################################################

##############################################################################
#DEFINITION DE LA LECTURE DE PORT 
##############################################################################
ser = serial.Serial(      
 #Pour Linux
 #port='/dev/ttyACM0',
 #Pour Windows
 port='COM4',
 #Vitesse de communication
 baudrate = 9600,
 #Parité 
 parity=serial.PARITY_NONE,
 #Bit de stop
 stopbits=serial.STOPBITS_ONE,
 #Taille du message 
 bytesize=serial.EIGHTBITS,
 #Out
 timeout=1
)
counter=0;
##############################################################################

###############################################################################
#TRAVAIL PRELIMINAIRE DE TRAITEMENT DES DONNEES D'APPRENTISSAGE
###############################################################################
# Ouverture des bases d'apprentissage
dataset_ping_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_norm.csv');
dataset_ping_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/ping_attack.csv');
dataset_rssi_norm = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_norm.csv');
dataset_rssi_attack = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/rssi_attack.csv');

#Concatenation pour avoir une base de ping et une base de rssi
dataset_ping = np.concatenate((dataset_ping_attack, dataset_ping_norm), axis=0);
dataset_rssi = np.concatenate((dataset_rssi_attack, dataset_rssi_norm), axis=0);

#Récupération des tailles de matrices
[X_ping, Y_ping] = np.shape(dataset_ping);
[X_rssi, Y_rssi] = np.shape(dataset_rssi);
###############################################################################

###############################################################################
#KPPV PING
###############################################################################
def prediction_ping(ping):
    cpt = 0;
    k = 5;
    dataset_ping_temp = np.zeros((X_ping,1));
    #Remplissage des distances euclidiennes 
    for i in range(0, X_ping):
        dataset_ping_temp[i,0] = ((dataset_ping[i,1]-ping)**2)**0.5;   
    #Concatenation avec distances euclidiennes 
    dataset_ping_temp = np.c_[dataset_ping, dataset_ping_temp];
    #Tri
    dataset_ping_temp = dataset_ping_temp[dataset_ping_temp[:,2].argsort()]
    #Checking des k premiers voisins
    print(dataset_ping_temp);
    for j in range(0, k-1): 
        if(dataset_ping_temp[j,0]==1):
            cpt = cpt+1;       
    if(cpt >= (k/2)+1):
        return 1; #Attaque
    else:
        return 0; #RAS
###############################################################################

###############################################################################
#KPPV RSSI
###############################################################################
def prediction_rssi(rssi):
    cpt = 0;
    k = 5;
    dataset_rssi_temp = np.zeros((X_rssi,1));
    #Remplissage des distances euclidiennes 
    for i in range(0, X_rssi):
        dataset_rssi_temp[i,0] = ((dataset_rssi[i,1]-rssi)**2)**0.5;   
    #Concatenation avec distances euclidiennes 
    dataset_rssi_temp = np.c_[dataset_rssi, dataset_rssi_temp];
    #Tri
    dataset_rssi_temp = dataset_rssi_temp[dataset_rssi_temp[:,2].argsort()]
    #Checking des k premiers voisins
    for j in range(0, k-1): 
        if(dataset_rssi_temp[j,0]==1):
            cpt = cpt+1;       
    if(cpt >= (k/2)+1):
        return 1; #Attaque
    else:
        return 0; #RAS
###############################################################################

###############################################################################
#AFFICHAGE 
###############################################################################  
def Recorder():
    global temp;
    global temp_read;
    global ping_mesured;
    global puissance_read;
    global trame_read;
    global cpt_trames;
    global cpt_trames_temp;  
    cpt_trames = 0;
    cpt_trames_temp = 0;
    
    while(1):
        #RECUPERATION DES DONNEES
        x = ser.readline();
        
        if(0x7C in x):
            #Lecture de la trame 
            trame_read = x;         
            #Récupération du compteur de trames
            cpt_trames = (trame_read[15]-48)*100 + (trame_read[16]-48)*10 + (trame_read[17]-48);
        
        if(0x7C in x and cpt_trames == 1):
            temp = time.time();
            
        if(0x7C in x and cpt_trames > 1):
            t2 = time.time();
            ping_mesured = (t2-temp)*1000;
            #Récupération de la température
            temp_read = (trame_read[12]-48)*10 + trame_read[13]-48;
            #Récupération de la puissance 
            x = ser.readline();
            puissance_read = (x[1]-48)*10 + x[2]-48;
            #T2 
            temp = t2;
        
        if(cpt_trames_temp + 1 == cpt_trames):
            #BOOLEEN
            state_ping = prediction_ping(ping_mesured);
            state_rssi = prediction_rssi(puissance_read);
            #AFFICHAGE
            print("\n###############################\n");
            print("TRAME : "+ "".join(map(chr, trame_read))+"\n");
            print("TRAME NUM. : "+str(cpt_trames)+"\n");
            print("TEMPERATURE : "+str(temp_read)+" °C\n");
            print("PUISSANCE : "+str(puissance_read)+" dBm\n");
            print("PING : "+str(ping_mesured)+" ms\n");
            if(state_ping == 0):
                print("PING NORMAL\n");
            elif(state_ping == 1):
                print("PING ATTAQUE\n");
            if(state_rssi == 0):
                print("RSSI NORMAL\n");
            elif(state_rssi == 1):
                print("RSSI ATTAQUE\n");
            print("###############################\n");
    
        cpt_trames_temp = cpt_trames;
###############################################################################

###############################################################################
#MAIN   
###############################################################################
if __name__ == '__main__':   
    Recorder();     
###############################################################################