"""
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 - prédictions, affichage, vérification du trafic 
"""
###############################################################################
#LIBRAIRIES UTILES
###############################################################################
import tkinter as tkr;
import time;
import serial;
import pandas as pd
# Réseau de neurones 
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
###############################################################################

###############################################################################
#VARIABLES GLOBALES
###############################################################################
ping_mesured=0; 
rssi_mesured=0;
result=0;
puissance_read = 0;
temp_read = 0;
trame_read = [];
state_ok = 'Stable';
state_attack = 'Perturbé';
pred = 1;
###############################################################################

##############################################################################
#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;
##############################################################################

###############################################################################
#FONCTIONS UTILES
###############################################################################
def Draw_info():   
    #FRAME INFORMATIONS
    infos=tkr.Frame(root,width=1000,height=5000,relief='groove',background='white',bd=3);
    infos.place(x=10,y=10);  
    #DATE - HEURE
    global text;
    text=tkr.Label(infos,text='Contrôle du trafic LoRa\n\n');
    text.config(font=('arial', 20, 'bold'));
    text.config(bg='white', fg='black');
    text.pack();
    global temperature;
    temperature=tkr.Label(infos,text='\n\nTempérature (°C) : '+ str(temp_read));
    temperature.config(font=('arial', 20, 'bold'));
    temperature.config(bg='white', fg='black');
    temperature.pack();
    global ping;
    ping=tkr.Label(infos,text='\n\nPING(ms) : '+ str(ping_mesured));
    ping.config(font=('arial', 20, 'bold'));
    ping.config(bg='white', fg='black');
    ping.pack();
    global rssi;
    rssi=tkr.Label(infos,text='\n\nRSSI(dBm) : '+ str(puissance_read));
    rssi.config(font=('arial', 20, 'bold'));
    rssi.config(bg='white', fg='black');
    rssi.pack();
    global trame;
    trame=tkr.Label(infos,text='\n\nTrame : '+ "".join(map(chr, trame_read)));
    trame.config(font=('arial', 20, 'bold'));
    trame.config(bg='white', fg='black');
    trame.pack(); 
    global etat;
    etat=tkr.Label(infos,text='\n\nEtat du trafic : '+ state_ok);
    etat.config(font=('arial', 20, 'bold'));
    etat.config(bg='white', fg='black');
    etat.pack();
    
###############################################################################
#FONCTION DE PREDICTION APPELEE DANS LE MAIN 
###############################################################################
def predictions(data_eval):
    ###########################################################################
    #ARCHITECTURE DU RESEAU DE NEURONES par le biais de la librairie KERAS
    #ANN 
    ###########################################################################
    #Création du classifieur 
    classifier = Sequential();
    #Couche d'entrée donc avec 2 entrées, PING et DELTA_RSSI
    classifier.add(Dense(input_dim = 2, output_dim = 3, init = 'uniform', activation = 'sigmoid'));
    #Couche cachée
    classifier.add(Dense(output_dim = 3, init = 'uniform', activation = 'sigmoid'));
    #Sortie du réseau de neurones 
    classifier.add(Dense(output_dim = 1, init = 'uniform', activation = 'sigmoid'));
    ###########################################################################
    #LOAD DU TRAINING SET
    ###########################################################################
    json_file=open('C:/Users/Utilisateur/PFE/python/Training/training.json','r');
    loaded_model_json=json_file.read();
    json_file.close();
    loaded_model=model_from_json(loaded_model_json);
    loaded_model.load_weights('C:/Users/Utilisateur/PFE/python/Training/training.h5');
    ###########################################################################
    #REALISER DES PREDICTIONS
    ###########################################################################
    #Normalisation des données 
    #sc = StandardScaler();
    predictions = classifier.predict(data_eval);
    return predictions;
###############################################################################
    
def Refresher():
    #VARIABLES GLOBALES
    global cpt_trame;
    global text;
    global temp;
    global temperature;
    global ping;
    global rssi;
    global trame;
    global etat;
    #RECUPERATION DES DONNEES
    text.configure(text=time.asctime());
    x = ser.readline();
    if(0x46 in x and cpt_trame == 0):
        cpt_trame = cpt_trame + 1;
        temp = time.time();
    if(0x46 in x and cpt_trame >= 1):
        t2 = time.time();
        ping_mesured = (t2-temp)*1000;
        temp = t2;
        cpt_trame = cpt_trame + 1;
        #Lecture de la trame 
        trame_read = x;
        #Récupération de la température
        temp_read = (trame_read[11]-48)*10 + trame_read[12]-48;
        #Récupération de la puissance 
        x = ser.readline();
        puissance_read = (x[1]-48)*10 + x[2]-48;
    #REFRESH DES DONNEES   
    temperature.configure(text='\n\nTempérature (°C) : '+ str(temp_read));
    ping.configure(text='\n\nPING(ms) : '+ str(ping_mesured));
    rssi.configure(text='\n\nRSSI(dBm) : '+ str(puissance_read));
    trame.configure(text='\n\nTrame : '+ "".join(map(chr, trame_read)));
    #PREDICTION
    data_to_pred = pd.read_csv('C:/Users/Utilisateur/PFE/python/datasets/data_to_pred.csv');
    pred = predictions(data_to_pred);
    if(pred==0):
        etat.configure(text='\n\nEtat du trafic : '+ state_ok);
    elif(pred==1):
        etat.configure(text='\n\nEtat du trafic : '+ state_attack);
    root.after(1000, Refresher);#Refresh toutes les secondes

###############################################################################
#AFFICHAGE
###############################################################################
root=tkr.Tk();
Draw_info();
Refresher();
root.mainloop();
###############################################################################