Blame view

python/main_simple.py 5.7 KB
9a50b3df   rcavalie   premiere version ok
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
  """
  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
  ###############################################################################
  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;
      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[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;
      
          #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("TEMPERATURE : "+str(temp_read)+" °C\n");
          print("PUISSANCE : "+str(puissance_read)+" dBm\n");
          print("PING : "+str(ping_mesured)+" ms\n");
          #pred = 1;
          if(pred==0):
              print("TRAFIC : ATTAQUE\n");
          elif(pred==1):
              print("TRAFIC : RAS\n");
              print("###############################\n");
  ###############################################################################
  
  ###############################################################################
  #MAIN   
  ###############################################################################
  if __name__ == '__main__':   
      Recorder();     
  ###############################################################################