"""
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 time;
import serial;
import numpy as np;
# Réseau de neurones 
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
###############################################################################

###############################################################################
#VARIABLES GLOBALES INITIALISATION
###############################################################################
ping_mesured=0; 
rssi_mesured=0;
result=0;
puissance_read = 0;
temp_read = 0;
trame_read = [];
file_name = 'C:/Users/Utilisateur/PFE/python/datasets/data_to_pred.csv';
###############################################################################

##############################################################################
#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;
##############################################################################
    
###############################################################################
#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(32, activation='relu', input_dim=2))
    #Couche de sortie
    classifier.add(Dense(1, activation='sigmoid'))
    ###############################################################################
    #COMPILATION
    ###############################################################################
    # optimizer : algorithme choisi pour trouver le model (le plus puissant)
    # loss : Si deux valeurs en sortie (binairie outcome) : binary_crossentropy
    classifier.compile(optimizer = 'rmsprop', loss = 'binary_crossentropy', metrics = ['accuracy']);
    ###############################################################################
    #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;
###############################################################################

###############################################################################
#AFFICHAGE 
###############################################################################  
def Recorder():
    cpt_trame = 0;
    global temp;
    global temp_read;
    global ping_mesured;
    global puissance_read;
    global trame_read;
    global cpt_trames;
    while(1):
        #RECUPERATION DES DONNEES
        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[12]-48)*10 + trame_read[13]-48;
            #Récupération du compteur de trames
            cpt_trames = (trame_read[15]-48)*100 + (trame_read[16]-48)*10 + (trame_read[17]-48);
            #Récupération de la puissance 
            x = ser.readline();
            puissance_read = (x[1]-48)*10 + x[2]-48;
    
        #SET INPUTS PREDICTION
        data_to_pred =  np.array((ping_mesured, puissance_read),dtype = np.int64); 
        data_to_pred = data_to_pred.reshape((1,2));
        
        #PREDICTION TEMPS REEL
        pred = Predictions(data_to_pred);
        
        #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");
        np.round(pred,0);
        if(pred==0):
            print("TRAFIC : ATTAQUE\n");
        elif(pred==1):
            print("TRAFIC : RAS\n");
        print("###############################\n");
###############################################################################

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