main_simple.py
6.1 KB
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
145
146
147
148
149
150
151
152
153
154
155
156
"""
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():
global temp;
global temp_read;
global ping_mesured;
global puissance_read;
global trame_read;
global cpt_trames;
global cpt_trames_temp;
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;
#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);
if(cpt_trames_temp+1 == cpt_trames):
#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==1):
print("TRAFIC : DANGER\n");
elif(pred==0):
print("TRAFIC : RAS\n");
print("###############################\n");
cpt_trames_temp = cpt_trames;
###############################################################################
###############################################################################
#MAIN
###############################################################################
if __name__ == '__main__':
Recorder();
###############################################################################