wiki-se.plil.fr - Contributions [fr]

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T13:18:31Z

Fvallee :

Groupe Vallée-Sellali

== Séance n°1 ==
Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

== Séance n°2 (18/12/2023) ==
Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

== Séance 3 (19/12/2023) ==
Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

== Séance 4 (20/12/2023) ==
Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

== Travail hors des séances et rendu final ==

=== Ajouts ===
Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes). (Utilisation du code annexe GestionData sans la communication TCP pour la création des fichiers)

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%.

Intégration de la bibliothèque libneai.a créée par Nanoedge dans le projet STM et adaptation du code de la STM pour y intégrer l'estimation à partir des données des capteurs. (Annexe app_tof.c)

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace. (entraînement du modèle avec le programme mlpAlgo.py présent en annexe)

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

=== Transmission et stockage des données ===
- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré, par le port série (ap_tof.c disponible en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.
[[Fichier:TerminauxECEAI Vallee.png|vignette|570x570px]]

=== Vidéo ===
Image de l'écran capturé dans la vidéo : [[:Fichier:DemoVideo.mp4|DemoVideo.mp4]]

[[:Fichier:TerminauxECEAI Vallee.png|TerminauxECEAI Vallee.png]][[Fichier:DemoVideo.mp4|vignette]]On constate : Si les données reçues ne contiennent pas 1024 données avant le \n, alors ces données ne sont pas transmises car non exploitables par les modèles de la RPi/VM. On obtient tout de même l'estimation de la STM32.

Comme montré sur la vidéo, on constate que lorsqu'il n'y a aucun mouvement, les estimations sont bonnes.

Pour les trois tests de gauche à droite, les estimations sont bonnes.

Pour les trois tests de droite à gauche, les estimations sont bonnes, à l'exception de la dernière estimation donnée par la RPi et par la VM (vu que les modèles sont les mêmes et qu'ils utilisent les mêmes données à ce moment) : cela est du aux 70% de précision observés lors des tests.

== Annexe ==
Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

=== Codes externes ayant servis à l'entraînement ===
Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>

=== Codes internes à la STM ===
app_tof.c : Code du process. Acquisition des données des 64 capteurs, 16 fois, envoi en temps réel des données et stockage temporaire des données pour faire une estimation avec le modèle interne à la stm32. Une fois les 1024 données récupérées, print d'un \n pour que "serial.readline()" des commandes python se termine.

Envoi de l'estimation après 1024 données.<syntaxhighlight lang="c">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;
int8_t compteur = 0;
uint8_t zones_per_line;

VL53L5A1_RANGING_SENSOR_ReadID(VL53L5A1_DEV_CENTER, &Id);
VL53L5A1_RANGING_SENSOR_GetCapabilities(VL53L5A1_DEV_CENTER, &Cap);

Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET; /* 5 ms < TimingBudget < 100 ms */
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */

uint16_t id_class = 0;
float input_user_buffer[DATA_INPUT_USER * AXIS_NUMBER]; // Buffer of input values
float output_class_buffer[CLASS_NUMBER];
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
enum neai_state error_code = neai_classification_init(knowledge);
if (error_code != NEAI_OK)
{
printf("Erreur lib \n");
}
/* set the profile if different from default one */
VL53L5A1_RANGING_SENSOR_ConfigProfile(VL53L5A1_DEV_CENTER, &Profile);

status = VL53L5A1_RANGING_SENSOR_Start(VL53L5A1_DEV_CENTER, RS_MODE_BLOCKING_CONTINUOUS);

if (status != BSP_ERROR_NONE)
{
printf("VL53L5A1_RANGING_SENSOR_Start failed\n");
while (1);
}

while (1)
{
/* polling mode */
status = VL53L5A1_RANGING_SENSOR_GetDistance(VL53L5A1_DEV_CENTER, &Result);
int sous_buffer[DATA_INPUT_USER];

if (status == BSP_ERROR_NONE)
{
print_result(&Result, sous_buffer);
//afficher_tableau(sous_buffer, DATA_INPUT_USER);
fill_buffer(input_user_buffer, sous_buffer, compteur);

}
if (compteur == 15)
{
//printf("Class number :%d Data user input : %d axis : %d multiply : %d",CLASS_NUMBER, DATA_INPUT_USER, AXIS_NUMBER, AXIS_NUMBER*DATA_INPUT_USER);
neai_classification(input_user_buffer, output_class_buffer, &id_class);
//afficher_tableau(input_user_buffer, DATA_INPUT_USER*AXIS_NUMBER);
printf("\n");
printf("%s\n",id2class[id_class]);
compteur = 0;
}
else
{
compteur++;//printf("Compteur = %d",compteur);
}

if (com_has_data())
{
handle_cmd(get_key());
}

HAL_Delay(POLLING_PERIOD);
}
}

static void print_result(RANGING_SENSOR_Result_t *Result, int sous_buffer[DATA_INPUT_USER])
{
int8_t j;
int8_t k;
int8_t l;
int8_t buffer_position = 0;
int8_t total_values = 0;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;

for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j+k].NumberOfTargets > 0)
{
printf("%d ",(int)Result->ZoneResult[j+k].Distance[l]);
sous_buffer[buffer_position] = (int)Result->ZoneResult[j+k].Distance[l];
buffer_position++;
}
else
printf("%d ", '10');
}
}
}
//printf("total : %d ",total_values);
}
</syntaxhighlight>

=== Codes internes à la Raspberry pi ===
GestionData.py : Lis le port série, stocke les données, effectue une estimation du mouvement, affiche l'estimation provenant de la STM32 et envoie les données brutes à la VM via TCP

COM3 pour les test depuis la machine windows, ACM0 pour l'application finale sur la raspberry

IPV6 de la VM laissée en commentaire<syntaxhighlight lang="python3">
import serial
import datetime
import csv
import socket
import joblib
import requests
import struct

port = 'COM3'#'/dev/ttyACM0'
baudrate = 460800
ser = serial.Serial(port, baudrate)

csv_filename = 'donnees_raspberry.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')
server_address = '2001:861:3541:4260:c69f:9d4:ccf5:7673'#'2001:660:4401:6050:216:3eff:febc:550c'
server_port = 12345
classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]

def DataToTab(ligne, taille_sous_liste=1024):
tableau = [int(nombre) for nombre in ligne.split()]
if (len(tableau)!=taille_sous_liste):
return tableau, 1
return tableau, 0

with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
line_count = 0
client_socket = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
client_socket.connect((server_address, server_port))
try:
while line_count < max_lines:
data = ser.readline().decode('utf-8').strip()
#print("Ligne : ", line_count,"\n")
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
#print(f"{timestamp} - Données lues: {data}")

headers = {'Content-type': 'text/plain'}
body = f"{timestamp} - Données lues: {data}"
tableau, error = DataToTab(data)
if error == 1:
print("Taille de tableau non conforme")
else:
pred = clf.predict([tableau])
print("Classe identifiee sur la Raspberry:", classes[pred[0]])
try:
donnees_brutes = struct.pack('!{}i'.format(len(tableau)), *tableau)
client_socket.sendall(donnees_brutes)
except Exception as e:
print(f"Erreur : {e}")
csv_writer.writerow([data])

classe = ser.readline().decode('utf-8').strip()
print("Classe identifiee par la STM:", classe);
line_count += 1

except KeyboardInterrupt:
pass

finally:
client_socket.close()
ser.close()
</syntaxhighlight>

=== Codes internes à la VM (présents en réalité sur la machine personnelle) ===
server_tcp.py : Ecoute sur le port donné, reçois les données brutes, les stocke, et estime le mouvement effectué<syntaxhighlight lang="python3">
import socket
import struct
import csv
import joblib
import datetime
packet_size = 1024

classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]
csv_filename = 'donnees_recues.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')

def start_tcp_server(ip, port):
with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
server_socket.bind((ip, port))
server_socket.listen(1)
print(f"Serveur tcp en ecoute sur {ip}:{port}")
client_socket, client_address = server_socket.accept()
line_count = 0
try:
while line_count < max_lines:
donnees_brutes = client_socket.recv(packet_size * 4)
liste_entiers = list(struct.unpack('!{}i'.format(packet_size), donnees_brutes))
#print("Recu :", liste_entiers)
csv_writer.writerow(liste_entiers)
pred = clf.predict([liste_entiers])
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
print(f"{timestamp}")
print("Classe identifiee sur la VM:", classes[pred[0]])
line_count+=1
except KeyboardInterrupt:
pass
finally:
client_socket.close

if __name__ == "__main__":
server_ip = '2001:861:5642:4610:46fb:e35c:a75d:2b74'
server_port = 12345
start_tcp_server(server_ip, server_port)
</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T13:17:52Z

Fvallee : Mise en page

Groupe Vallée-Sellali

== Séance n°1 ==
Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

== Séance n°2 (18/12/2023) ==
Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

== Séance 3 (19/12/2023) ==
Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

== Séance 4 (20/12/2023) ==
Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

== Travail hors des séances et rendu final ==

=== Ajouts ===
Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes). (Utilisation du code annexe GestionData sans la communication TCP pour la création des fichiers)

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%.

Intégration de la bibliothèque libneai.a créée par Nanoedge dans le projet STM et adaptation du code de la STM pour y intégrer l'estimation à partir des données des capteurs. (Annexe app_tof.c)

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace. (entraînement du modèle avec le programme mlpAlgo.py présent en annexe)

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

=== Réseau ===
- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré, par le port série (ap_tof.c disponible en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.
[[Fichier:TerminauxECEAI Vallee.png|vignette|570x570px]]

=== Vidéo ===
Image de l'écran capturé dans la vidéo : [[:Fichier:DemoVideo.mp4|DemoVideo.mp4]]

[[:Fichier:TerminauxECEAI Vallee.png|TerminauxECEAI Vallee.png]][[Fichier:DemoVideo.mp4|vignette]]On constate : Si les données reçues ne contiennent pas 1024 données avant le \n, alors ces données ne sont pas transmises car non exploitables par les modèles de la RPi/VM. On obtient tout de même l'estimation de la STM32.

Comme montré sur la vidéo, on constate que lorsqu'il n'y a aucun mouvement, les estimations sont bonnes.

Pour les trois tests de gauche à droite, les estimations sont bonnes.

Pour les trois tests de droite à gauche, les estimations sont bonnes, à l'exception de la dernière estimation donnée par la RPi et par la VM (vu que les modèles sont les mêmes et qu'ils utilisent les mêmes données à ce moment) : cela est du aux 70% de précision observés lors des tests.

== Annexe ==
Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

=== Codes externes ayant servis à l'entraînement ===
Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>

=== Codes internes à la STM ===
app_tof.c : Code du process. Acquisition des données des 64 capteurs, 16 fois, envoi en temps réel des données et stockage temporaire des données pour faire une estimation avec le modèle interne à la stm32. Une fois les 1024 données récupérées, print d'un \n pour que "serial.readline()" des commandes python se termine.

Envoi de l'estimation après 1024 données.<syntaxhighlight lang="c">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;
int8_t compteur = 0;
uint8_t zones_per_line;

VL53L5A1_RANGING_SENSOR_ReadID(VL53L5A1_DEV_CENTER, &Id);
VL53L5A1_RANGING_SENSOR_GetCapabilities(VL53L5A1_DEV_CENTER, &Cap);

Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET; /* 5 ms < TimingBudget < 100 ms */
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */

uint16_t id_class = 0;
float input_user_buffer[DATA_INPUT_USER * AXIS_NUMBER]; // Buffer of input values
float output_class_buffer[CLASS_NUMBER];
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
enum neai_state error_code = neai_classification_init(knowledge);
if (error_code != NEAI_OK)
{
printf("Erreur lib \n");
}
/* set the profile if different from default one */
VL53L5A1_RANGING_SENSOR_ConfigProfile(VL53L5A1_DEV_CENTER, &Profile);

status = VL53L5A1_RANGING_SENSOR_Start(VL53L5A1_DEV_CENTER, RS_MODE_BLOCKING_CONTINUOUS);

if (status != BSP_ERROR_NONE)
{
printf("VL53L5A1_RANGING_SENSOR_Start failed\n");
while (1);
}

while (1)
{
/* polling mode */
status = VL53L5A1_RANGING_SENSOR_GetDistance(VL53L5A1_DEV_CENTER, &Result);
int sous_buffer[DATA_INPUT_USER];

if (status == BSP_ERROR_NONE)
{
print_result(&Result, sous_buffer);
//afficher_tableau(sous_buffer, DATA_INPUT_USER);
fill_buffer(input_user_buffer, sous_buffer, compteur);

}
if (compteur == 15)
{
//printf("Class number :%d Data user input : %d axis : %d multiply : %d",CLASS_NUMBER, DATA_INPUT_USER, AXIS_NUMBER, AXIS_NUMBER*DATA_INPUT_USER);
neai_classification(input_user_buffer, output_class_buffer, &id_class);
//afficher_tableau(input_user_buffer, DATA_INPUT_USER*AXIS_NUMBER);
printf("\n");
printf("%s\n",id2class[id_class]);
compteur = 0;
}
else
{
compteur++;//printf("Compteur = %d",compteur);
}

if (com_has_data())
{
handle_cmd(get_key());
}

HAL_Delay(POLLING_PERIOD);
}
}

static void print_result(RANGING_SENSOR_Result_t *Result, int sous_buffer[DATA_INPUT_USER])
{
int8_t j;
int8_t k;
int8_t l;
int8_t buffer_position = 0;
int8_t total_values = 0;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;

for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j+k].NumberOfTargets > 0)
{
printf("%d ",(int)Result->ZoneResult[j+k].Distance[l]);
sous_buffer[buffer_position] = (int)Result->ZoneResult[j+k].Distance[l];
buffer_position++;
}
else
printf("%d ", '10');
}
}
}
//printf("total : %d ",total_values);
}
</syntaxhighlight>

=== Codes internes à la Raspberry pi ===
GestionData.py : Lis le port série, stocke les données, effectue une estimation du mouvement, affiche l'estimation provenant de la STM32 et envoie les données brutes à la VM via TCP

COM3 pour les test depuis la machine windows, ACM0 pour l'application finale sur la raspberry

IPV6 de la VM laissée en commentaire<syntaxhighlight lang="python3">
import serial
import datetime
import csv
import socket
import joblib
import requests
import struct

port = 'COM3'#'/dev/ttyACM0'
baudrate = 460800
ser = serial.Serial(port, baudrate)

csv_filename = 'donnees_raspberry.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')
server_address = '2001:861:3541:4260:c69f:9d4:ccf5:7673'#'2001:660:4401:6050:216:3eff:febc:550c'
server_port = 12345
classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]

def DataToTab(ligne, taille_sous_liste=1024):
tableau = [int(nombre) for nombre in ligne.split()]
if (len(tableau)!=taille_sous_liste):
return tableau, 1
return tableau, 0

with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
line_count = 0
client_socket = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
client_socket.connect((server_address, server_port))
try:
while line_count < max_lines:
data = ser.readline().decode('utf-8').strip()
#print("Ligne : ", line_count,"\n")
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
#print(f"{timestamp} - Données lues: {data}")

headers = {'Content-type': 'text/plain'}
body = f"{timestamp} - Données lues: {data}"
tableau, error = DataToTab(data)
if error == 1:
print("Taille de tableau non conforme")
else:
pred = clf.predict([tableau])
print("Classe identifiee sur la Raspberry:", classes[pred[0]])
try:
donnees_brutes = struct.pack('!{}i'.format(len(tableau)), *tableau)
client_socket.sendall(donnees_brutes)
except Exception as e:
print(f"Erreur : {e}")
csv_writer.writerow([data])

classe = ser.readline().decode('utf-8').strip()
print("Classe identifiee par la STM:", classe);
line_count += 1

except KeyboardInterrupt:
pass

finally:
client_socket.close()
ser.close()
</syntaxhighlight>

=== Codes internes à la VM (présents en réalité sur la machine personnelle) ===
server_tcp.py : Ecoute sur le port donné, reçois les données brutes, les stocke, et estime le mouvement effectué<syntaxhighlight lang="python3">
import socket
import struct
import csv
import joblib
import datetime
packet_size = 1024

classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]
csv_filename = 'donnees_recues.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')

def start_tcp_server(ip, port):
with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
server_socket.bind((ip, port))
server_socket.listen(1)
print(f"Serveur tcp en ecoute sur {ip}:{port}")
client_socket, client_address = server_socket.accept()
line_count = 0
try:
while line_count < max_lines:
donnees_brutes = client_socket.recv(packet_size * 4)
liste_entiers = list(struct.unpack('!{}i'.format(packet_size), donnees_brutes))
#print("Recu :", liste_entiers)
csv_writer.writerow(liste_entiers)
pred = clf.predict([liste_entiers])
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
print(f"{timestamp}")
print("Classe identifiee sur la VM:", classes[pred[0]])
line_count+=1
except KeyboardInterrupt:
pass
finally:
client_socket.close

if __name__ == "__main__":
server_ip = '2001:861:5642:4610:46fb:e35c:a75d:2b74'
server_port = 12345
start_tcp_server(server_ip, server_port)
</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T13:17:16Z

Fvallee :

Groupe Vallée-Sellali

== Séance n°1 ==
Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

== Séance n°2 (18/12/2023) ==
Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

== Séance 3 (19/12/2023) ==
Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

== Séance 4 (20/12/2023) ==
Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

== Travail hors des séances et rendu final ==

=== Ajouts ===
Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes). (Utilisation du code annexe GestionData sans la communication TCP pour la création des fichiers)

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%.

Intégration de la bibliothèque libneai.a créée par Nanoedge dans le projet STM et adaptation du code de la STM pour y intégrer l'estimation à partir des données des capteurs. (Annexe app_tof.c)

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace. (entraînement du modèle avec le programme mlpAlgo.py présent en annexe)

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

==== Réseau ====
- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré, par le port série (ap_tof.c disponible en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.
[[Fichier:TerminauxECEAI Vallee.png|vignette|570x570px]]

=== Vidéo : ===
Image de l'écran capturé dans la vidéo : [[:Fichier:DemoVideo.mp4|DemoVideo.mp4]]

[[:Fichier:TerminauxECEAI Vallee.png|TerminauxECEAI Vallee.png]][[Fichier:DemoVideo.mp4|vignette]]On constate : Si les données reçues ne contiennent pas 1024 données avant le \n, alors ces données ne sont pas transmises car non exploitables par les modèles de la RPi/VM. On obtient tout de même l'estimation de la STM32.

Comme montré sur la vidéo, on constate que lorsqu'il n'y a aucun mouvement, les estimations sont bonnes.

Pour les trois tests de gauche à droite, les estimations sont bonnes.

Pour les trois tests de droite à gauche, les estimations sont bonnes, à l'exception de la dernière estimation donnée par la RPi et par la VM (vu que les modèles sont les mêmes et qu'ils utilisent les mêmes données à ce moment) : cela est du aux 70% de précision observés lors des tests.

== Annexe ==
Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

=== Codes externes ayant servis à l'entraînement ===
Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>

=== Codes internes à la STM ===
app_tof.c : Code du process. Acquisition des données des 64 capteurs, 16 fois, envoi en temps réel des données et stockage temporaire des données pour faire une estimation avec le modèle interne à la stm32. Une fois les 1024 données récupérées, print d'un \n pour que "serial.readline()" des commandes python se termine.

Envoi de l'estimation après 1024 données.<syntaxhighlight lang="c">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;
int8_t compteur = 0;
uint8_t zones_per_line;

VL53L5A1_RANGING_SENSOR_ReadID(VL53L5A1_DEV_CENTER, &Id);
VL53L5A1_RANGING_SENSOR_GetCapabilities(VL53L5A1_DEV_CENTER, &Cap);

Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET; /* 5 ms < TimingBudget < 100 ms */
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */

uint16_t id_class = 0;
float input_user_buffer[DATA_INPUT_USER * AXIS_NUMBER]; // Buffer of input values
float output_class_buffer[CLASS_NUMBER];
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
enum neai_state error_code = neai_classification_init(knowledge);
if (error_code != NEAI_OK)
{
printf("Erreur lib \n");
}
/* set the profile if different from default one */
VL53L5A1_RANGING_SENSOR_ConfigProfile(VL53L5A1_DEV_CENTER, &Profile);

status = VL53L5A1_RANGING_SENSOR_Start(VL53L5A1_DEV_CENTER, RS_MODE_BLOCKING_CONTINUOUS);

if (status != BSP_ERROR_NONE)
{
printf("VL53L5A1_RANGING_SENSOR_Start failed\n");
while (1);
}

while (1)
{
/* polling mode */
status = VL53L5A1_RANGING_SENSOR_GetDistance(VL53L5A1_DEV_CENTER, &Result);
int sous_buffer[DATA_INPUT_USER];

if (status == BSP_ERROR_NONE)
{
print_result(&Result, sous_buffer);
//afficher_tableau(sous_buffer, DATA_INPUT_USER);
fill_buffer(input_user_buffer, sous_buffer, compteur);

}
if (compteur == 15)
{
//printf("Class number :%d Data user input : %d axis : %d multiply : %d",CLASS_NUMBER, DATA_INPUT_USER, AXIS_NUMBER, AXIS_NUMBER*DATA_INPUT_USER);
neai_classification(input_user_buffer, output_class_buffer, &id_class);
//afficher_tableau(input_user_buffer, DATA_INPUT_USER*AXIS_NUMBER);
printf("\n");
printf("%s\n",id2class[id_class]);
compteur = 0;
}
else
{
compteur++;//printf("Compteur = %d",compteur);
}

if (com_has_data())
{
handle_cmd(get_key());
}

HAL_Delay(POLLING_PERIOD);
}
}

static void print_result(RANGING_SENSOR_Result_t *Result, int sous_buffer[DATA_INPUT_USER])
{
int8_t j;
int8_t k;
int8_t l;
int8_t buffer_position = 0;
int8_t total_values = 0;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;

for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j+k].NumberOfTargets > 0)
{
printf("%d ",(int)Result->ZoneResult[j+k].Distance[l]);
sous_buffer[buffer_position] = (int)Result->ZoneResult[j+k].Distance[l];
buffer_position++;
}
else
printf("%d ", '10');
}
}
}
//printf("total : %d ",total_values);
}
</syntaxhighlight>

=== Codes internes à la Raspberry pi ===
GestionData.py : Lis le port série, stocke les données, effectue une estimation du mouvement, affiche l'estimation provenant de la STM32 et envoie les données brutes à la VM via TCP

COM3 pour les test depuis la machine windows, ACM0 pour l'application finale sur la raspberry

IPV6 de la VM laissée en commentaire<syntaxhighlight lang="python3">
import serial
import datetime
import csv
import socket
import joblib
import requests
import struct

port = 'COM3'#'/dev/ttyACM0'
baudrate = 460800
ser = serial.Serial(port, baudrate)

csv_filename = 'donnees_raspberry.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')
server_address = '2001:861:3541:4260:c69f:9d4:ccf5:7673'#'2001:660:4401:6050:216:3eff:febc:550c'
server_port = 12345
classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]

def DataToTab(ligne, taille_sous_liste=1024):
tableau = [int(nombre) for nombre in ligne.split()]
if (len(tableau)!=taille_sous_liste):
return tableau, 1
return tableau, 0

with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
line_count = 0
client_socket = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
client_socket.connect((server_address, server_port))
try:
while line_count < max_lines:
data = ser.readline().decode('utf-8').strip()
#print("Ligne : ", line_count,"\n")
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
#print(f"{timestamp} - Données lues: {data}")

headers = {'Content-type': 'text/plain'}
body = f"{timestamp} - Données lues: {data}"
tableau, error = DataToTab(data)
if error == 1:
print("Taille de tableau non conforme")
else:
pred = clf.predict([tableau])
print("Classe identifiee sur la Raspberry:", classes[pred[0]])
try:
donnees_brutes = struct.pack('!{}i'.format(len(tableau)), *tableau)
client_socket.sendall(donnees_brutes)
except Exception as e:
print(f"Erreur : {e}")
csv_writer.writerow([data])

classe = ser.readline().decode('utf-8').strip()
print("Classe identifiee par la STM:", classe);
line_count += 1

except KeyboardInterrupt:
pass

finally:
client_socket.close()
ser.close()
</syntaxhighlight>

=== Codes internes à la VM (présents en réalité sur la machine personnelle) ===
server_tcp.py : Ecoute sur le port donné, reçois les données brutes, les stocke, et estime le mouvement effectué<syntaxhighlight lang="python3">
import socket
import struct
import csv
import joblib
import datetime
packet_size = 1024

classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]
csv_filename = 'donnees_recues.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')

def start_tcp_server(ip, port):
with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
server_socket.bind((ip, port))
server_socket.listen(1)
print(f"Serveur tcp en ecoute sur {ip}:{port}")
client_socket, client_address = server_socket.accept()
line_count = 0
try:
while line_count < max_lines:
donnees_brutes = client_socket.recv(packet_size * 4)
liste_entiers = list(struct.unpack('!{}i'.format(packet_size), donnees_brutes))
#print("Recu :", liste_entiers)
csv_writer.writerow(liste_entiers)
pred = clf.predict([liste_entiers])
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
print(f"{timestamp}")
print("Classe identifiee sur la VM:", classes[pred[0]])
line_count+=1
except KeyboardInterrupt:
pass
finally:
client_socket.close

if __name__ == "__main__":
server_ip = '2001:861:5642:4610:46fb:e35c:a75d:2b74'
server_port = 12345
start_tcp_server(server_ip, server_port)
</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T13:15:16Z

Fvallee : Explications Video

Groupe Vallée-Sellali

== Séance n°1: ==
Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

== Séance n°2 (18/12/2023) : ==
Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

== Séance 3 (19/12/2023) : ==
Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

== Séance 4 (20/12/2023) ==
Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

== Travail hors des séances et rendu final : ==
Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes). (Utilisation du code annexe GestionData sans la communication TCP pour la création des fichiers)

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%.

Intégration de la bibliothèque libneai.a créée par Nanoedge dans le projet STM et adaptation du code de la STM pour y intégrer l'estimation à partir des données des capteurs. (Annexe app_tof.c)

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace. (entraînement du modèle avec le programme mlpAlgo.py présent en annexe)

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

==== Réseau : ====
- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré, par le port série (ap_tof.c disponible en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.
[[Fichier:TerminauxECEAI Vallee.png|vignette|570x570px]]

=== Vidéo : ===
Image de l'écran capturé dans la vidéo : [[:Fichier:DemoVideo.mp4|DemoVideo.mp4]]

[[:Fichier:TerminauxECEAI Vallee.png|TerminauxECEAI Vallee.png]][[Fichier:DemoVideo.mp4|vignette]]On constate : Si les données reçues ne contiennent pas 1024 données avant le \n, alors ces données ne sont pas transmises car non exploitables par les modèles de la RPi/VM. On obtient tout de même l'estimation de la STM32.

Comme montré sur la vidéo, on constate que lorsqu'il n'y a aucun mouvement, les estimations sont bonnes.

Pour les trois tests de gauche à droite, les estimations sont bonnes.

Pour les trois tests de droite à gauche, les estimations sont bonnes, à l'exception de la dernière estimation donnée par la RPi et par la VM (vu que les modèles sont les mêmes et qu'ils utilisent les mêmes données à ce moment) : cela est du aux 70% de précision observés lors des tests.

== Annexe ==
Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

=== Codes externes ayant servis à l'entraînement : ===
Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>

=== Codes internes à la STM : ===
app_tof.c : Code du process. Acquisition des données des 64 capteurs, 16 fois, envoi en temps réel des données et stockage temporaire des données pour faire une estimation avec le modèle interne à la stm32. Une fois les 1024 données récupérées, print d'un \n pour que "serial.readline()" des commandes python se termine.

Envoi de l'estimation après 1024 données.<syntaxhighlight lang="c">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;
int8_t compteur = 0;
uint8_t zones_per_line;

VL53L5A1_RANGING_SENSOR_ReadID(VL53L5A1_DEV_CENTER, &Id);
VL53L5A1_RANGING_SENSOR_GetCapabilities(VL53L5A1_DEV_CENTER, &Cap);

Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET; /* 5 ms < TimingBudget < 100 ms */
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */

uint16_t id_class = 0;
float input_user_buffer[DATA_INPUT_USER * AXIS_NUMBER]; // Buffer of input values
float output_class_buffer[CLASS_NUMBER];
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
enum neai_state error_code = neai_classification_init(knowledge);
if (error_code != NEAI_OK)
{
printf("Erreur lib \n");
}
/* set the profile if different from default one */
VL53L5A1_RANGING_SENSOR_ConfigProfile(VL53L5A1_DEV_CENTER, &Profile);

status = VL53L5A1_RANGING_SENSOR_Start(VL53L5A1_DEV_CENTER, RS_MODE_BLOCKING_CONTINUOUS);

if (status != BSP_ERROR_NONE)
{
printf("VL53L5A1_RANGING_SENSOR_Start failed\n");
while (1);
}

while (1)
{
/* polling mode */
status = VL53L5A1_RANGING_SENSOR_GetDistance(VL53L5A1_DEV_CENTER, &Result);
int sous_buffer[DATA_INPUT_USER];

if (status == BSP_ERROR_NONE)
{
print_result(&Result, sous_buffer);
//afficher_tableau(sous_buffer, DATA_INPUT_USER);
fill_buffer(input_user_buffer, sous_buffer, compteur);

}
if (compteur == 15)
{
//printf("Class number :%d Data user input : %d axis : %d multiply : %d",CLASS_NUMBER, DATA_INPUT_USER, AXIS_NUMBER, AXIS_NUMBER*DATA_INPUT_USER);
neai_classification(input_user_buffer, output_class_buffer, &id_class);
//afficher_tableau(input_user_buffer, DATA_INPUT_USER*AXIS_NUMBER);
printf("\n");
printf("%s\n",id2class[id_class]);
compteur = 0;
}
else
{
compteur++;//printf("Compteur = %d",compteur);
}

if (com_has_data())
{
handle_cmd(get_key());
}

HAL_Delay(POLLING_PERIOD);
}
}

static void print_result(RANGING_SENSOR_Result_t *Result, int sous_buffer[DATA_INPUT_USER])
{
int8_t j;
int8_t k;
int8_t l;
int8_t buffer_position = 0;
int8_t total_values = 0;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;

for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j+k].NumberOfTargets > 0)
{
printf("%d ",(int)Result->ZoneResult[j+k].Distance[l]);
sous_buffer[buffer_position] = (int)Result->ZoneResult[j+k].Distance[l];
buffer_position++;
}
else
printf("%d ", '10');
}
}
}
//printf("total : %d ",total_values);
}
</syntaxhighlight>

=== Codes internes à la Raspberry pi : ===
GestionData.py : Lis le port série, stocke les données, effectue une estimation du mouvement, affiche l'estimation provenant de la STM32 et envoie les données brutes à la VM via TCP

COM3 pour les test depuis la machine windows, ACM0 pour l'application finale sur la raspberry

IPV6 de la VM laissée en commentaire<syntaxhighlight lang="python3">
import serial
import datetime
import csv
import socket
import joblib
import requests
import struct

port = 'COM3'#'/dev/ttyACM0'
baudrate = 460800
ser = serial.Serial(port, baudrate)

csv_filename = 'donnees_raspberry.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')
server_address = '2001:861:3541:4260:c69f:9d4:ccf5:7673'#'2001:660:4401:6050:216:3eff:febc:550c'
server_port = 12345
classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]

def DataToTab(ligne, taille_sous_liste=1024):
tableau = [int(nombre) for nombre in ligne.split()]
if (len(tableau)!=taille_sous_liste):
return tableau, 1
return tableau, 0

with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
line_count = 0
client_socket = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
client_socket.connect((server_address, server_port))
try:
while line_count < max_lines:
data = ser.readline().decode('utf-8').strip()
#print("Ligne : ", line_count,"\n")
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
#print(f"{timestamp} - Données lues: {data}")

headers = {'Content-type': 'text/plain'}
body = f"{timestamp} - Données lues: {data}"
tableau, error = DataToTab(data)
if error == 1:
print("Taille de tableau non conforme")
else:
pred = clf.predict([tableau])
print("Classe identifiee sur la Raspberry:", classes[pred[0]])
try:
donnees_brutes = struct.pack('!{}i'.format(len(tableau)), *tableau)
client_socket.sendall(donnees_brutes)
except Exception as e:
print(f"Erreur : {e}")
csv_writer.writerow([data])

classe = ser.readline().decode('utf-8').strip()
print("Classe identifiee par la STM:", classe);
line_count += 1

except KeyboardInterrupt:
pass

finally:
client_socket.close()
ser.close()
</syntaxhighlight>

=== Codes internes à la VM (présents en réalité sur la machine personnelle) : ===
server_tcp.py : Ecoute sur le port donné, reçois les données brutes, les stocke, et estime le mouvement effectué<syntaxhighlight lang="python3">
import socket
import struct
import csv
import joblib
import datetime
packet_size = 1024

classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]
csv_filename = 'donnees_recues.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')

def start_tcp_server(ip, port):
with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
server_socket.bind((ip, port))
server_socket.listen(1)
print(f"Serveur tcp en ecoute sur {ip}:{port}")
client_socket, client_address = server_socket.accept()
line_count = 0
try:
while line_count < max_lines:
donnees_brutes = client_socket.recv(packet_size * 4)
liste_entiers = list(struct.unpack('!{}i'.format(packet_size), donnees_brutes))
#print("Recu :", liste_entiers)
csv_writer.writerow(liste_entiers)
pred = clf.predict([liste_entiers])
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
print(f"{timestamp}")
print("Classe identifiee sur la VM:", classes[pred[0]])
line_count+=1
except KeyboardInterrupt:
pass
finally:
client_socket.close

if __name__ == "__main__":
server_ip = '2001:861:5642:4610:46fb:e35c:a75d:2b74'
server_port = 12345
start_tcp_server(server_ip, server_port)
</syntaxhighlight>

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T13:08:48Z

Fvallee : Video+codes+mise en page

Groupe Vallée-Sellali

== Séance n°1: ==
Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

== Séance n°2 (18/12/2023) : ==
Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

== Séance 3 (19/12/2023) : ==
Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

== Séance 4 (20/12/2023) ==
Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

== Travail hors des séances et rendu final : ==
Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes).

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace.

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

==== Réseau : ====
- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré par le port série (knowledge.h, nanoEdgeAi.h, libneai.a et appTof.c sont disponibles en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.
[[Fichier:TerminauxECEAI Vallee.png|vignette|570x570px]]

=== Vidéo : ===
Image de l'écran capturé dans la vidéo : [[:Fichier:DemoVideo.mp4|DemoVideo.mp4]]

[[:Fichier:TerminauxECEAI Vallee.png|TerminauxECEAI Vallee.png]][[Fichier:DemoVideo.mp4|vignette]]On constate : Si les données reçues ne contiennent pas 1024 données avant le \n, alors ces données ne sont pas transmises car non exploitables par les modèles de la RPi/VM. On obtient tout de même l'estimation de la STM32.

Comme montré sur la vidéo, on constate que lorsqu'il n'y a aucun mouvement, les estimations sont bonnes.

Pour les trois tests de gauche à droite, les estimations sont bonnes.

Pour les trois tests de droite à gauche, les estimations sont bonnes, à l'exception de la dernière estimation donnée par la RPi et par la VM (vu que les modèles sont les mêmes et qu'ils utilisent les mêmes données à ce moment) : cela est du aux 70% de précision observés lors des tests.

== Annexe ==
Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

=== Codes externes ayant servis à l'entraînement : ===
Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>

=== Codes internes à la STM : ===
app_tof.c : Code du process. Acquisition des données des 64 capteurs, 16 fois, envoi en temps réel des données et stockage temporaire des données pour faire une estimation avec le modèle interne à la stm32. Une fois les 1024 données récupérées, print d'un \n pour que "serial.readline()" des commandes python se termine.

Envoi de l'estimation après 1024 données.<syntaxhighlight lang="c">
static void MX_53L5A1_SimpleRanging_Process(void)
{
uint32_t Id;
int8_t compteur = 0;
uint8_t zones_per_line;

VL53L5A1_RANGING_SENSOR_ReadID(VL53L5A1_DEV_CENTER, &Id);
VL53L5A1_RANGING_SENSOR_GetCapabilities(VL53L5A1_DEV_CENTER, &Cap);

Profile.RangingProfile = RS_PROFILE_8x8_CONTINUOUS;
Profile.TimingBudget = TIMING_BUDGET; /* 5 ms < TimingBudget < 100 ms */
Profile.Frequency = RANGING_FREQUENCY; /* Ranging frequency Hz (shall be consistent with TimingBudget value) */
Profile.EnableAmbient = 0; /* Enable: 1, Disable: 0 */
Profile.EnableSignal = 0; /* Enable: 1, Disable: 0 */

uint16_t id_class = 0;
float input_user_buffer[DATA_INPUT_USER * AXIS_NUMBER]; // Buffer of input values
float output_class_buffer[CLASS_NUMBER];
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;
enum neai_state error_code = neai_classification_init(knowledge);
if (error_code != NEAI_OK)
{
printf("Erreur lib \n");
}
/* set the profile if different from default one */
VL53L5A1_RANGING_SENSOR_ConfigProfile(VL53L5A1_DEV_CENTER, &Profile);

status = VL53L5A1_RANGING_SENSOR_Start(VL53L5A1_DEV_CENTER, RS_MODE_BLOCKING_CONTINUOUS);

if (status != BSP_ERROR_NONE)
{
printf("VL53L5A1_RANGING_SENSOR_Start failed\n");
while (1);
}

while (1)
{
/* polling mode */
status = VL53L5A1_RANGING_SENSOR_GetDistance(VL53L5A1_DEV_CENTER, &Result);
int sous_buffer[DATA_INPUT_USER];

if (status == BSP_ERROR_NONE)
{
print_result(&Result, sous_buffer);
//afficher_tableau(sous_buffer, DATA_INPUT_USER);
fill_buffer(input_user_buffer, sous_buffer, compteur);

}
if (compteur == 15)
{
//printf("Class number :%d Data user input : %d axis : %d multiply : %d",CLASS_NUMBER, DATA_INPUT_USER, AXIS_NUMBER, AXIS_NUMBER*DATA_INPUT_USER);
neai_classification(input_user_buffer, output_class_buffer, &id_class);
//afficher_tableau(input_user_buffer, DATA_INPUT_USER*AXIS_NUMBER);
printf("\n");
printf("%s\n",id2class[id_class]);
compteur = 0;
}
else
{
compteur++;//printf("Compteur = %d",compteur);
}

if (com_has_data())
{
handle_cmd(get_key());
}

HAL_Delay(POLLING_PERIOD);
}
}

static void print_result(RANGING_SENSOR_Result_t *Result, int sous_buffer[DATA_INPUT_USER])
{
int8_t j;
int8_t k;
int8_t l;
int8_t buffer_position = 0;
int8_t total_values = 0;
uint8_t zones_per_line;
zones_per_line = ((Profile.RangingProfile == RS_PROFILE_8x8_AUTONOMOUS) ||
(Profile.RangingProfile == RS_PROFILE_8x8_CONTINUOUS)) ? 8 : 4;

for (j = 0; j < Result->NumberOfZones; j += zones_per_line)
{
for (l = 0; l < RANGING_SENSOR_NB_TARGET_PER_ZONE; l++)
{
/* Print distance and status */
for (k = (zones_per_line - 1); k >= 0; k--)
{
if (Result->ZoneResult[j+k].NumberOfTargets > 0)
{
printf("%d ",(int)Result->ZoneResult[j+k].Distance[l]);
sous_buffer[buffer_position] = (int)Result->ZoneResult[j+k].Distance[l];
buffer_position++;
}
else
printf("%d ", '10');
}
}
}
//printf("total : %d ",total_values);
}
</syntaxhighlight>

=== Codes internes à la Raspberry pi : ===
GestionData.py : Lis le port série, stocke les données, effectue une estimation du mouvement, affiche l'estimation provenant de la STM32 et envoie les données brutes à la VM via TCP

COM3 pour les test depuis la machine windows, ACM0 pour l'application finale sur la raspberry

IPV6 de la VM laissée en commentaire<syntaxhighlight lang="python3">
import serial
import datetime
import csv
import socket
import joblib
import requests
import struct

port = 'COM3'#'/dev/ttyACM0'
baudrate = 460800
ser = serial.Serial(port, baudrate)

csv_filename = 'donnees_raspberry.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')
server_address = '2001:861:3541:4260:c69f:9d4:ccf5:7673'#'2001:660:4401:6050:216:3eff:febc:550c'
server_port = 12345
classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]

def DataToTab(ligne, taille_sous_liste=1024):
tableau = [int(nombre) for nombre in ligne.split()]
if (len(tableau)!=taille_sous_liste):
return tableau, 1
return tableau, 0

with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
line_count = 0
client_socket = socket.socket(socket.AF_INET6,socket.SOCK_STREAM)
client_socket.connect((server_address, server_port))
try:
while line_count < max_lines:
data = ser.readline().decode('utf-8').strip()
#print("Ligne : ", line_count,"\n")
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
#print(f"{timestamp} - Données lues: {data}")

headers = {'Content-type': 'text/plain'}
body = f"{timestamp} - Données lues: {data}"
tableau, error = DataToTab(data)
if error == 1:
print("Taille de tableau non conforme")
else:
pred = clf.predict([tableau])
print("Classe identifiee sur la Raspberry:", classes[pred[0]])
try:
donnees_brutes = struct.pack('!{}i'.format(len(tableau)), *tableau)
client_socket.sendall(donnees_brutes)
except Exception as e:
print(f"Erreur : {e}")
csv_writer.writerow([data])

classe = ser.readline().decode('utf-8').strip()
print("Classe identifiee par la STM:", classe);
line_count += 1

except KeyboardInterrupt:
pass

finally:
client_socket.close()
ser.close()
</syntaxhighlight>

=== Codes internes à la VM (présents en réalité sur la machine personnelle) : ===
server_tcp.py : Ecoute sur le port donné, reçois les données brutes, les stocke, et estime le mouvement effectué<syntaxhighlight lang="python3">
import socket
import struct
import csv
import joblib
import datetime
packet_size = 1024

classes = ["Aucune presence", "Mouvement de droite a gauche","Mouvement de gauche a droite"]
csv_filename = 'donnees_recues.txt'
max_lines = 200
clf = joblib.load('modele_mlp.pkl')

def start_tcp_server(ip, port):
with open(csv_filename, 'w', newline='') as csv_file:
csv_writer = csv.writer(csv_file)
server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
server_socket.bind((ip, port))
server_socket.listen(1)
print(f"Serveur tcp en ecoute sur {ip}:{port}")
client_socket, client_address = server_socket.accept()
line_count = 0
try:
while line_count < max_lines:
donnees_brutes = client_socket.recv(packet_size * 4)
liste_entiers = list(struct.unpack('!{}i'.format(packet_size), donnees_brutes))
#print("Recu :", liste_entiers)
csv_writer.writerow(liste_entiers)
pred = clf.predict([liste_entiers])
timestamp = datetime.datetime.now().strftime('%H:%M:%S')
print(f"{timestamp}")
print("Classe identifiee sur la VM:", classes[pred[0]])
line_count+=1
except KeyboardInterrupt:
pass
finally:
client_socket.close

if __name__ == "__main__":
server_ip = '2001:861:5642:4610:46fb:e35c:a75d:2b74'
server_port = 12345
start_tcp_server(server_ip, server_port)
</syntaxhighlight>

Fichier:TerminauxECEAI Vallee.png

2024-01-28T13:03:16Z

Fvallee :

terminaux capturés de la vidéo de démo associée

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T12:47:08Z

Fvallee : Video

Groupe Vallée-Sellali

Séance n°1:

Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe habituel

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

Séance n°2 (18/12/2023) :

Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

Séance 3 (19/12/2023) :

Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

Séance 4 (20/12/2023)

Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

Le choix de main ouverte/main fermée se questionne, on utilise pas l'aspect mouvement que permet les algorithmes.

Les algorithmes donnent un bon résultat avec une précision proche de 70%. La communication entre la VM et la zabeth sur laquelle on teste les fichiers pythons fonctionne.

Du microcontrôleur, on reçoit les données brutes et l'estimation de l'état de la main. Le fichier python sur la zabeth, à destination future de la raspberry, reçoit ces données via le port série, les stocke dans un fichier txt, fait une estimation de l'état de la main, et envoie les données brutes à la VM en utilisant TCP/IP avec l'adresse IPV6 de la VM.

La VM reçoit les données mais ne les traite pas encore.

Travail hors des séances et rendu final :

Extension du programme sur la STM aux 64 capteurs.

Nouveau choix de test qui prend en compte les mouvements.

Création de nouveaux datasets adaptés : lignes de 64 * 16 données, une ligne correspond à une itération du mouvement, environ 170 lignes par datasets pour une prise en compte de plusieurs cas

(passage rapide, passage lent, hauteurs différentes).

Les mouvements sont :

- Mouvement de gauche à droite

- Mouvement de droite à gauche

- Aucune présence

Pour pouvoir tester les modèles résultant de ces datasets, 3 fichiers de tests sont créés contenant chacun une trentaine d'itérations du mouvement.

Avec Nanoedge, entraînement d'un nouveau modèle à destination de la STM. Le modèle le plus efficace avec nos fichiers de tests sont, contrairement aux premières séances, un modèle MLP (multilayer

perceptron). Résultats avec nos fichiers de tests : précision de 90%

En effet, les modèles SVM ne semblent pas adaptés à nos datasets => Adaptation du code python de la raspberry pour utiliser lui aussi un modèle MLP, ce qui est plus efficace.

Modèle résultant avec comme input les fichiers de tests : 70% de précision sur Droite à gauche, 68% de gauche à droite, 100% si aucune présence.

Intégration du code GestionData.py dans la raspberry ainsi que du modèle créé par mlpAlgo.py (uniquement l'output)

Réseau :

- La STM32 envoie les données brutes + l'estimation du mouvement issue de son modèle intégré par le port série (knowledge.h, nanoEdgeAi.h, libneai.a et appTof.c sont disponibles en annexe)

- La Raspberry Pi reçoit ces données brutes, les stocke dans un fichier texte, estime le mouvement effectué, et affiche l'estimation en plus de celle de la STM. Ensuite, les données brutes sont transmises à la VM par TCP/IP en IPV6, à la condition que 1024 données soient présentes à chaque lecture. Si ce n'est pas le cas, les données "corrompues" ne sont pas transmises puisqu'inexploitables. (Voir GestionData.py en annexe)

- La VM reçoit les données par paquet de 1024 entiers, stocke les données dans un fichier txt, et fait une estimation du mouvement en utilisant le même modèle que celui présent dans la raspberry pi.

Lors des tests, nous avons constaté que la communication TCP ne semblait pas permise depuis un ordinateur externe au réseau des zabeths vers la VM : le ping est possible, mais la communication ne semble pas. Nous avons donc fait le choix d'utiliser un ordinateur personnel pour montrer l'efficacité du projet : le fonctionnement est similaire, les données sont envoyées sur la machine personnelle en IPV6.

<nowiki>#</nowiki>Vidéo :
[[Fichier:DemoVideo.mp4|vignette]]

<nowiki>#</nowiki>Annexe

Tous les codes rendus en annexe sont dans leur version finale et ont été utilisés au cours du projet.

Codes externes ayant servis à l'entraînement :

Les fichiers de type data ou test ont été réalisés en lisant le port série et en insérant directement les données dans le fichier texte à condition que les données ne soient pas corrompues.

mlpAlgo.py : programme permettant de générer un modèle utilisant l'algorithme MLP <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_path = 'data_GtoD.txt'
DtoG_path = 'data_DtoG.txt'
GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_path = 'data_rien.txt'
rien_test_path = 'test_rien.txt'

GtoD_train = []
DtoG_train = []
GtoD_target = []
DtoG_target = []
rien_train = []
rien_target = []
test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

# Exemple d'utilisation
GtoD_train, GtoD_target = ReadAndFill(GtoD_path, GtoD_target, 2)
DtoG_train, DtoG_target = ReadAndFill(DtoG_path, DtoG_target, 1)
rien_train, rien_target = ReadAndFill(rien_path, rien_target, 0)
data = GtoD_train + DtoG_train + rien_train
targets = GtoD_target + DtoG_target + rien_target

#Create a svm Classifier
clf = neural_network.MLPClassifier(max_iter=5000000)

#Train the model using the training sets
clf.fit(data, targets)
joblib.dump(clf, 'modele_mlp2.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>mlpPredic.py : Code similaire servant à tester de charger un modèle créé et sauvegardé auparavant <syntaxhighlight lang="python3">
#Import mlp model
from sklearn import neural_network
from sklearn import metrics
import joblib

GtoD_test_path = 'test_GtoD.txt'
DtoG_test_path = 'test_DtoG.txt'
rien_test_path = 'test_rien.txt'

test = []
data = []
targets = []
target_test = []

def ReadAndFill(nom_fichier, target_tab, target_int, taille_sous_liste=1024):
try:
# Ouverture du fichier en mode lecture
with open(nom_fichier, 'r') as fichier:
# Lecture du contenu du fichier ligne par ligne
lignes = fichier.readlines()

# Pour chaque ligne, conversion en liste d'entiers
tableau = [[int(nombre) for nombre in ligne.split()] for ligne in lignes]
tableau_filtre = [sous_liste for sous_liste in tableau if len(sous_liste) == taille_sous_liste]
target_tab = len(tableau_filtre) * [target_int]

return tableau_filtre, target_tab

except FileNotFoundError:
print(f"Le fichier {nom_fichier} n'a pas été trouvé.")
return []
except Exception as e:
print(f"Une erreur s'est produite : {e}")
return []

#Create a svm Classifier
clf = joblib.load('modele_mlp.pkl')

test, target_test = ReadAndFill(GtoD_test_path, target_test, 2)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",GtoD_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(DtoG_test_path, target_test, 1)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",DtoG_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

test, target_test = ReadAndFill(rien_test_path, target_test, 0)

#Predict the response for test dataset
pred = clf.predict(test)
print(pred)
# Model Accuracy: how often is the classifier correct?
print("Fichier de test actuel :",rien_test_path)
print("Accuracy:",metrics.accuracy_score(target_test, pred))

</syntaxhighlight>Codes internes à la STM :

Codes internes à la Raspberry pi :

Codes internes à la VM (présents en réalité sur la machine personnelle) :

Fichier:DemoVideo.mp4

2024-01-28T12:44:43Z

Fvallee :

Test ECEAI par le groupe Florian Vallée/Amine Sellali, SE5 2023/2024

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-28T11:10:03Z

Fvallee : Travail Hors Seance

Atelier SysRes SE5 2023/2024 E8

2024-01-16T17:23:51Z

Fvallee :

'''Cassage de clef WEP d'un point d'accès Wifi'''

Sur Zabeth 8

Afficher les MAC des cracottes :<syntaxhighlight lang="shell" line="1">
aimon -ng start wlan0
airodump-ng --ivs wlan0
</syntaxhighlight>Choix de la cracotte14

BSSID 04:DA:D2:9C:50:5D

wlan0mon absent, bloquant pour la suite

Impossible d'obtenir la clé avec les outputs de :<syntaxhighlight>
airodump-ng -b 04:DA:D2:9C:50:5D -w output wlan0
aircrack-ng -b 04:DA:D2:9C:50:5D output*.cap
</syntaxhighlight>
[[Fichier:Cracotte14.png|vignette|864x864px]]

Fichier:Cracotte14.png

2024-01-16T17:23:18Z

Fvallee :

cracotte

Atelier SysRes SE5 2023/2024 E8

2024-01-16T17:20:47Z

Fvallee : Page créée avec « '''Cassage de clef WEP d'un point d'accès Wifi''' Sur Zabeth 8 Afficher les MAC des cracottes :<syntaxhighlight lang="shell" line="1"> aimon -ng start wlan0 airodump-ng --ivs wlan0 </syntaxhighlight>Choix de la cracotte14 BSSID 04:DA:D2:9C:50:5D wlan0mon absent, bloquant pour la suite Impossible d'obtenir la clé avec les outputs de :<syntaxhighlight> airodump-ng -b 04:DA:D2:9C:50:5D -w output wlan0 aircrack-ng -b 04:DA:D2:9C:50:5D output*.cap </syntaxhigh... »

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2024-01-01T13:00:50Z

Fvallee :

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2023-12-20T13:19:19Z

Fvallee :

Groupe Vallée-Sellali

Séance n°1:

Machine virtuelle créée sur chassiron :

Hostname : ValSel

Distribution : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe : glopglop

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : valsel Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

Séance n°2 (18/12/2023) :

Raspberry connectée au WiFi SE5

Connexion ipv6 possible entre la VM et la raspberry

Données du capteur lues et envoyées au port série

Création d'un programme python client à destination de la raspberry qui : lit le port série, stocke les données reçues, envoie les données reçues en http vers le "serveur" présent sur la VM

Création d'un programme python serveur à destination de la VM qui reçoit et stocke les données

Séance 3 (19/12/2023) :

Création des datasets : main fermée et main ouverte (Une ligne = 16 * 16 données, environ 30 lignes par fichier)

Choix de garder les capteurs en 4x4 pour un compromis vitesse de création des datasets/temps d'entrainement du modèle/efficacité du capteur de mouvement.

Entrainement du modèle avec les datasets sur NanoEdge

Séance 4 (20/12/2023)

Création de nouveaux datasets et de fichiers de tests : (100 lignes de 16 * 16 données)

Création d'un script Python utilisant la bibliothèque sklearn pour implémenter un algorithme de classification SVM, à destination de la Raspberry et de la VM

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2023-12-20T07:11:46Z

Fvallee :

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2023-12-18T16:32:49Z

Fvallee :

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2023-12-18T16:31:41Z

Fvallee :

SE5 ECEAI/eceai 2023/2024/ValleeSellali

2023-12-18T16:26:34Z

Fvallee : Page créée avec « Groupe Vallée-Sellali Séance n°1: Machine virtuelle créée sur chassiron : Hostname : ValSel Distribution : bookworm Stockage : 10G Mémoire vive : 1G Mot de passe : glopglop Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés. Raspberry 4 : Communication via le port série possible Login : pifou Pwd : pasglop STM32F401RE : Nanoedge et IDE installés, conc... »

SE5 ECEAI 2023/2024

2023-12-18T16:25:53Z

Fvallee :

SE5 ECEAI 2023/2024

Groupe Delannoy - Lemaire : [[SE5 ECEAI/eceai 2023/2024/jcie]]

Groupe Rodenburg - Thomas → [[Gabidann|SE5 ECEAI/eceai 2023/2024/gabidann]]

Groupe Halaoui - Farault : [[SE5 ECEAI/eceai 2023/2024/FaraultHalaoui]]

Groupe Godard - Delcourt : [[SE5 ECEAI/eceai 2023/2024/GodardDelcourt]]

Groupe Naudot - Riffaut : [[SE5 ECEAI/eceai_2023/2024/NaudotRiffaut]]

Groupe Amoros - Delaby : [[SE5 ECEAI/eceai 2023/2024/AmorosDelaby]]

Groupe Charleux - Habre : [[SE5 ECEAI/eceai 2023/2024/CharleuxHabre]]

Groupe Balbastre - Simon : [[SE5 ECEAI/eceai 2023/2024/BalbastreSimon]]

Groupe Patrikeev - Mouton : [[SE5 ECEAI/eceai 2023/2024/Patrikeev-Mouton]]

Groupe Brenier - Nguyen : [[SE5 ECEAI/eceai 2023/2024/Brenier-Nguyen]]

Groupe Vallée - Sellali : [[SE5 ECEAI/eceai 2023/2024/ValleeSellali]]

SE5 ECEAI 2023/2024

2023-12-18T16:22:17Z

Fvallee : /* Groupe Vallée-Sellali */

SE5 ECEAI 2023/2024

2023-12-04T16:58:21Z

Fvallee : /*seance1 */

SE5 ECEAI 2023/2024
[[SE5 ECEAI/eceai 2023/2024/jcie]]
== Groupe Patrikeev-Mouton ==
'''Séance n°1:'''

* Une machin virtuelle a été crée sur le serveur chassiron avec la commande :
<syntaxhighlight lang="coffee">
xen-create-image --hostname g19 --force --dist bookworm --size 10G --memory 1G --dir /usr/local/xen --password glopglop --dhcp --bridge bridgeStudents
</syntaxhighlight>La machine virtuelle possède les propriétés suivantes:

Hostname   : g19

Distribution    : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe : glopglop

Les fichier /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list on étés configurés comme demandé dans le sujet.

* La Raspberry Pi 4 a été configurée et connectée au WiFi WIFI_IE_1.

Mot de passe : pasglop

Login : pifou

La communication entre la Raspberry et la machine virtuelle a été vérifiée avec une commande de ping.

* Le STM32F401RE et le capteur de distance (Nucleo-53L5A1):

Les valeurs lues par le capteurs sont renvoyés par le port série du contrôleur STM32 vers le logiciel nanoedge.

== Groupe Vallée-Sellali ==
'''Séance n°1:'''

Machine virtuelle créée sur chassiron :

Hostname   : ValSel

Distribution    : bookworm

Stockage : 10G

Mémoire vive : 1G

Mot de passe : glopglop

Les fichiers /etc/network/interfaces, /etc/resolv.conf et /etc/apt/sources.list ont été modifiés comme demandés.

Raspberry 4 :

Communication via le port série possible

Login : pifou Pwd : pasglop

STM32F401RE : Nanoedge et IDE installés, conception d'un code pour tester le capteur en cours

SE5 système/réseau 2023/2024

2023-10-06T14:58:45Z

Fvallee : /* Répartition des binômes */

= PRA SE5 =

== Menu de la première séance ==

Pour la première séance du 06/10/2023 il vous est demandé d'effectuer individuellement les opérations listées ci-dessous.
* création d'une machine virtuelle sur le serveur <code>capbreton</code> ;
* création d'un conteneur "à la main" sur votre station de travail <code>zabeth</code> :
** créez un conteneur isolé au maximum (sauf pour les utilisateur) avec la méthode décrite en cours,
** création d'un commutateur virtuel privé sur la <code>zabeth</code> dans le réseau IPv4 <code>192.168.68.0/24</code>, l'adresse <code>192.168.68.1</code> est affectée au commutateur lui-même,
** création d'une interface Ethernet virtuelle, une extrémité doit être envoyée dans le conteneur, l'autre dans le commutateur virtuel privé,
** mise en place d'une mascarade sur la <code>zabeth</code>, vérifiez que le conteneur a accès aux mêmes machines que la <code>zabeth</code>.

Par binôme vous devez créer une machine virtuelle mandataire connectée sur le commutateur virtuel SE5 et sur le commutateur virtuel privé des machines virtuelles de services concernées (voir deuxième section du sujet).

Globalement vous devez configurer le routeur principal de la promotion (voir la troisième section du sujet). Pour votre promotion il s'agit du Catalyst 9200 situé en E304. Il faut le connecter en fibre vers le serveur <code>capbreton</code> de la E306 dans le commutateur virtuel SE5 et aussi en fibre vers le local technique SR52 sur un port dans le VLAN 531. Vous pouvez configurer le commutateur via l'utilitaire <code>minicom</code> à partir de la machine <code>zabeth09</code>.

Répartition des élèves pour la première séance :
{| class="wikitable"
! Station de travail !! Elève
|-
| zabeth02 || Elias SIMON
|-
| zabeth03 || Mathis RIFFAUT
|-
| zabeth04 || Dann RODENBURG
|-
| zabeth05 || Benjamin NGUYEN
|-
| zabeth06 || Halaoui mohammed
|-
| zabeth07 || Blgrim Haitam
|-
| zabeth08 || Florian Vallée
|-
| zabeth09 (routeur) || Julien Charleux
|-
| zabeth10 || Amine SELLALI
|-
| zabeth11 || Paul Amoros
|-
| zabeth12 || Maël Delaby
|-
| zabeth13 || Black Baptiste
|-
| zabeth14 || Timothé Brenier
|-
| zabeth15 || Jeanne Delcourt
|-
| zabeth16 || Estelle Godard
|-
| zabeth17 || Jason DELANNOY
|-
| zabeth18 || Chloé Lemaire
|-
| zabeth19 || Gabriel THOMAS
|-
| zabeth20 || Albin MOUTON
|-
| zabeth21 || Prénom Nom
|-
| zabeth22 || Maxime Balbastre
|-
| zabeth26 || Prénom Nom
|-
| zabeth27 || Prénom Nom
|-
| zabeth28 || Prénom Nom
|-
| zabeth30 || Prénom Nom
|-
|}

== Répartition des binômes ==

Concertez-vous pour trouver des noms de machines de services et de machines mandataires dans deux thèmes.

{| class="wikitable"
! Cahier !! Nom machine services
!IP machine services !! Nom de domaine !! Nom machine mandataire
!IP machine mandataires!! Elève
|-
| [[Atelier SysRes SE5 2023/2024 E1 | Cahier n°1]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E2 | Cahier n°2]]
| Elom|| || || || || Elias SIMON
|-
| [[Atelier SysRes SE5 2023/2024 E3 | Cahier n°3]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E4 | Cahier n°4]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E5 | Cahier n°5]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E6 | Cahier n°6]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E7 | Cahier n°7]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E8 | Cahier n°8]]
| Fondor|| || || mushu|| || Florian Vallée
|-
| [[Atelier SysRes SE5 2023/2024 E9 | Cahier n°9]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E10 | Cahier n°10]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E11 | Cahier n°11]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E12 | Cahier n°12]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E13 | Cahier n°13]]
| Bogden|| || || BlancheNeige|| || Black Baptiste
|-
| [[Atelier SysRes SE5 2023/2024 E14 | Cahier n°14]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E15 | Cahier n°15]]
| jiruus|| || || cruella|| || Jeanne Delcourt
|-
| [[Atelier SysRes SE5 2023/2024 E16 | Cahier n°16]]
| exegol|| || || cruella|| || Estelle Godard
|-
| [[Atelier SysRes SE5 2023/2024 E17 | Cahier n°17]]
| Jakku|| || || Jafar|| || Jason DELANNOY
|-
| [[Atelier SysRes SE5 2023/2024 E18 | Cahier n°18]]
| naboo|| || || bouh|| || Chloé Lemaire
|-
| [[Atelier SysRes SE5 2023/2024 E19 | Cahier n°19]]
| geonosis|| || || bouh|| || Gabriel THOMAS
|-
| [[Atelier SysRes SE5 2023/2024 E20 | Cahier n°20]]
| alderaan|| || || Jafar|| || Albin MOUTON
|-
| [[Atelier SysRes SE5 2023/2024 E21 | Cahier n°21]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E22 | Cahier n°22]]
| kashyyyk|| || || mushu|| || Maxime BALBASTRE
|-
| [[Atelier SysRes SE5 2023/2024 E23 | Cahier n°23]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E24 | Cahier n°24]]
| || || || || || Prénom Nom
|-
|}

== Contrôle continu ==

SE5 système/réseau 2023/2024

2023-10-06T14:15:01Z

Fvallee : /* Menu de la première séance */

= PRA SE5 =

== Menu de la première séance ==

Pour la première séance du 06/10/2023 il vous est demandé d'effectuer individuellement les opérations listées ci-dessous.
* création d'une machine virtuelle sur le serveur <code>capbreton</code> ;
* création d'un conteneur "à la main" sur votre station de travail <code>zabeth</code> :
** créez un conteneur isolé au maximum (sauf pour les utilisateur) avec la méthode décrite en cours,
** création d'un commutateur virtuel privé sur la <code>zabeth</code> dans le réseau IPv4 <code>192.168.68.0/24</code>, l'adresse <code>192.168.68.1</code> est affectée au commutateur lui-même,
** création d'une interface Ethernet virtuelle, une extrémité doit être envoyée dans le conteneur, l'autre dans le commutateur virtuel privé,
** mise en place d'une mascarade sur la <code>zabeth</code>, vérifiez que le conteneur a accès aux mêmes machines que la <code>zabeth</code>.

Par binôme vous devez créer une machine virtuelle mandataire connectée sur le commutateur virtuel SE5 et sur le commutateur virtuel privé des machines virtuelles de services concernées (voir deuxième section du sujet).

Globalement vous devez configurer le routeur principal de la promotion (voir la troisième section du sujet). Pour votre promotion il s'agit du Catalyst 9200 situé en E304. Il faut le connecter en fibre vers le serveur <code>capbreton</code> de la E306 dans le commutateur virtuel SE5 et aussi en fibre vers le local technique SR52 sur un port dans le VLAN 531. Vous pouvez configurer le commutateur via l'utilitaire <code>minicom</code> à partir de la machine <code>zabeth09</code>.

Répartition des élèves pour la première séance :
{| class="wikitable"
! Station de travail !! Elève
|-
| zabeth02 || Prénom Nom
|-
| zabeth03 || Mathis RIFFAUT
|-
| zabeth04 || Dann RODENBURG
|-
| zabeth05 || Benjamin NGUYEN
|-
| zabeth06 || Prénom Nom
|-
| zabeth07 || Prénom Nom
|-
| zabeth08 || Florian Vallée
|-
| zabeth09 (routeur) || Julien Charleux
|-
| zabeth10 || Prénom Nom
|-
| zabeth11 || Paul Amoros
|-
| zabeth12 || Maël Delaby
|-
| zabeth13 || Black Baptiste
|-
| zabeth14 || Timothé Brenier
|-
| zabeth15 || Jeanne Delcourt
|-
| zabeth16 || Estelle Godard
|-
| zabeth17 || Jason DELANNOY
|-
| zabeth18 || Chloé Lemaire
|-
| zabeth19 || Gabriel THOMAS
|-
| zabeth20 || Albin MOUTON
|-
| zabeth21 || Prénom Nom
|-
| zabeth22 || Prénom Nom
|-
| zabeth26 || Prénom Nom
|-
| zabeth27 || Prénom Nom
|-
| zabeth28 || Prénom Nom
|-
| zabeth30 || Prénom Nom
|-
|}

== Répartition des binômes ==

Concertez-vous pour trouver des noms de machines de services et de machines mandataires dans deux thèmes.

{| class="wikitable"
! Cahier !! Nom machine services
!IP machine services !! Nom de domaine !! Nom machine mandataire
!IP machine mandataires!! Elève
|-
| [[Atelier SysRes SE5 2023/2024 E1 | Cahier n°1]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E2 | Cahier n°2]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E3 | Cahier n°3]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E4 | Cahier n°4]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E5 | Cahier n°5]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E6 | Cahier n°6]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E7 | Cahier n°7]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E8 | Cahier n°8]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E9 | Cahier n°9]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E10 | Cahier n°10]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E11 | Cahier n°11]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E12 | Cahier n°12]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E13 | Cahier n°13]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E14 | Cahier n°14]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E15 | Cahier n°15]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E16 | Cahier n°16]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E17 | Cahier n°17]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E18 | Cahier n°18]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E19 | Cahier n°19]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E20 | Cahier n°20]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E21 | Cahier n°21]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E22 | Cahier n°22]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E23 | Cahier n°23]]
| || || || || || Prénom Nom
|-
| [[Atelier SysRes SE5 2023/2024 E24 | Cahier n°24]]
| || || || || || Prénom Nom
|-
|}

== Contrôle continu ==